@peter.prib/renderengine 0.2.10 → 0.4.0

package/dist/renderengine.umd.js

@@ -19756,14 +19756,19 @@
 
     /**
      * Fruchterman–Reingold: lines pull their ends together, every pair of boxes
-     * pushes apart, cooling over the iterations. Deterministic: it starts from
-     * where the boxes are (boxes on one spot are spread round it first).
+     * pushes apart, cooling over the iterations, all within a frame — a square
+     * round where the boxes were, room for them a grid's worth — so a box with no
+     * lines is not pushed away for ever. Deterministic: it starts from where the
+     * boxes are (boxes on one spot are spread round it first).
      */
     function forceDirected(boxes, edges, gap) {
         const size = Math.max(...boxes.map(b => Math.max(b.width, b.height))) + gap;
         const k = size * 1.2;
         const pos = boxes.map((b, i) => ({ x: b.left + b.width / 2 + (i % 3) * 0.5, y: b.top + b.height / 2 + Math.floor(i / 3) * 0.5 }));
         const index = new Map(boxes.map((b, i) => [b.id, i]));
+        const centre = { x: pos.reduce((t, p) => t + p.x, 0) / pos.length, y: pos.reduce((t, p) => t + p.y, 0) / pos.length };
+        const half = (k * (Math.ceil(Math.sqrt(boxes.length)) + 1)) / 2;
+        const inFrame = (v, c) => Math.min(c + half, Math.max(c - half, v));
         let temperature = size * 2;
         for (let iteration = 0; iteration < 120; iteration++) {
             const shift = pos.map(() => ({ x: 0, y: 0 }));
@@ -19788,8 +19793,8 @@
             for (let i = 0; i < pos.length; i++) {
                 const d = Math.max(1e-9, Math.hypot(shift[i].x, shift[i].y));
                 const step = Math.min(d, temperature);
-                pos[i].x += (shift[i].x / d) * step;
-                pos[i].y += (shift[i].y / d) * step;
+                pos[i].x = inFrame(pos[i].x + (shift[i].x / d) * step, centre.x);
+                pos[i].y = inFrame(pos[i].y + (shift[i].y / d) * step, centre.y);
             }
             temperature *= 0.95;
         }
@@ -24639,6 +24644,8 @@
             this.instance = instance;
             this.model = model;
             this.nodeOptions = nodeOptions;
+            /** A host's live status, `{text, color}` (the editor's elementStatus), or null: drawn as a pill. */
+            this.status = null;
         }
 
         /** State lives on the instance and the model element, not here. @protected */
@@ -24754,6 +24761,27 @@
          * gets no glyph badge (buildNode leaves iconShape unset) but keeps an icon the element sets.
          */
         decorations(ctx) {
+            return [...this._badge(ctx), ...this.statusPill(ctx)];
+        }
+
+        /**
+         * The host's status (`status`), as a small pill inside the box's bottom
+         * right corner: its text, on its colour. Nothing without one.
+         */
+        statusPill({ w, h }) {
+            const text = this.status?.text;
+            if (!text) return [];
+            const label = String(text);
+            const ph = 12, pw = Math.min(w - 6, label.length * 5.5 + 10);
+            const x = w / 2 - pw - 3, y = h / 2 - ph - 3;
+            return [Glyph.group([
+                Glyph.rect(x, y, pw, ph, this.status.color || '#455a64', null, { rx: 6, ry: 6 }),
+                Glyph.text(label, x + pw / 2, y + ph / 2, { fill: '#ffffff', textAnchor: 'middle', verticalAlign: 'middle', fontSize: '8px' }),
+            ], { 'pointer-events': 'none', class: 'element-status' })];
+        }
+
+        /** The type badge (decorations). @private */
+        _badge(ctx) {
             const node = this.node;
             const { w, h } = ctx;
             const fixed = ArchimateElementTemplate.badgeSize(w, h);
@@ -28223,7 +28251,9 @@
      * ModelCheckDialog — a model check's findings (ModelChecker#run), listed:
      * each a button (⚠ a warning, ℹ for a look) that shows what it names
      * (`onReveal`), with what can be done about it beside (`actionsFor`), or
-     * "nothing found". Any editor or part that checks a model shows it this way.
+     * "nothing found". Any editor or part that checks a model shows it this way;
+     * anything else listed to be opened (search results) too, with its own
+     * `title` and `empty` text.
      */
     class ModelCheckDialog {
         /**
@@ -28232,9 +28262,13 @@
          * @param {(finding: Object) => void} [options.onReveal] - Show what a finding names
          * @param {(finding: Object) => Array<{label: string, action: Function}>} [options.actionsFor]
          * @param {Document} [options.document]
+         * @param {string} [options.title] - In place of "Model check: n findings"
+         * @param {string} [options.empty] - What an empty list says
          */
-        constructor({ findings, onReveal = () => {}, actionsFor = () => [], document: doc = globalThis.document }) {
+        constructor({ findings, onReveal = () => {}, actionsFor = () => [], document: doc = globalThis.document, title = null, empty = 'Nothing found: the model passes every check.' }) {
             this.findings = findings;
+            this._title = title;
+            this.empty = empty;
             this.onReveal = onReveal;
             this.actionsFor = actionsFor;
             this.document = doc;
@@ -28242,6 +28276,7 @@
 
         /** The dialog's title: how many findings. */
         get title() {
+            if (this._title) return this._title;
             const n = this.findings.length;
             return `Model check: ${n} finding${n === 1 ? '' : 's'}`;
         }
@@ -28267,7 +28302,7 @@
                             on: { click: () => { dialog?.close(); act.action(); } },
                         })),
                     ],
-                })) : [{ text: 'Nothing found: the model passes every check.' }],
+                })) : [{ text: this.empty }],
             }, this.document);
             dialog = new FormDialog({
                 title: this.title,
@@ -33184,8 +33219,12 @@
          *   elements (null cancels). Without it the first of KIND_PREFERENCE that is allowed is used.
          * @param {(nodeOptions: Object) => void} [options.onNodeOptionsChange] - The ⚙ Settings menu changed
          *   the version or distinct shapes (the host may need to redraw more than the canvas, e.g. a palette)
+         * @param {(element: Object) => ({text: string, color?: string}|null)} [options.elementStatus] - A host's
+         *   live status for an element (a component's lifecycle state), drawn on its boxes
+         * @param {(element: Object) => Array<Object>} [options.elementMenuExtras] - A host's menu items for an
+         *   element (its transitions), at the end of a box's right-click menu
          */
-        constructor({ view, model, nodeOptions = {}, chooseKind = null, onNodeOptionsChange = null, templateMenu = null, customViewpoints = [], settingsManager = null, ...options }) {
+        constructor({ view, model, nodeOptions = {}, chooseKind = null, onNodeOptionsChange = null, templateMenu = null, customViewpoints = [], settingsManager = null, elementStatus = null, elementMenuExtras = null, ...options }) {
             super({ ...options, templates: new Map(), edges: new Map(), history: view.history, arrangement: view.arrangement });
             this.view = view;
             this.model = model;
@@ -33198,6 +33237,9 @@
             this.settingsManager = settingsManager;
             /** Canvas templates (a CanvasTemplateMenu): placed on the canvas, saved from its shapes. */
             this.templateMenu = templateMenu;
+            /** A host's live status per element, drawn on its boxes, and its menu items per element. */
+            this.elementStatus = elementStatus;
+            this.elementMenuExtras = elementMenuExtras;
             this.addDropHandler({
                 accepts: (dt) => Array.from(dt.types).includes(ARCHIMATE_TYPE_MIME),
                 drop: (dt, point) => this.addElement(dt.getData(ARCHIMATE_TYPE_MIME), point),
@@ -33235,6 +33277,7 @@
                 ...(missing.length ? [{ label: `Add Missing Relationships (${missing.length})`, action: () => this.addMissingRelationships(elementId) }] : []),
                 ...hintMenuItems(this.view, elementId, { onChange: () => this.render() }),
                 ...(items.length ? [{ label: 'Save as template', items }] : []),
+                ...(element && this.elementMenuExtras ? this.elementMenuExtras(element) ?? [] : []),
             ];
         }
 
@@ -33459,7 +33502,11 @@
                 templates.set(inst.id, existing?.instance === inst ? existing
                     : new ArchimateElementTemplate(inst, model, { nodeOptions: this.nodeOptions }));
             }
-            for (const t of templates.values()) t.nodeOptions = this.nodeOptions;
+            for (const t of templates.values()) {
+                t.nodeOptions = this.nodeOptions;
+                // Asked afresh at every sync: a host's status is live, not part of the model.
+                t.status = this.elementStatus ? this.elementStatus(t.instance.resolve(model)) ?? null : null;
+            }
             // The view's groups (Archi groups: model folders with bounds on this view).
             for (const folder of view.placedFolders) {
                 const existing = this.templates.get(folder.id);
@@ -33958,6 +34005,9 @@
         /** Whether files in this format can be imported (opened) as well as exported. A subclass that only exports says no. */
         get imports() { return true; }
 
+        /** Whether a model can be exported in this format. A subclass that only reads (another tool's export) says no. */
+        get exports() { return true; }
+
         /** True when import takes the file's bytes (a zip archive), else its text. */
         get readsBytes() { return false; }
 
@@ -34017,7 +34067,7 @@
         const choose = chooseFile ?? ((accept) => pickFile(accept, doc()));
         const tell = report ?? ((message) => (doc().defaultView ?? globalThis).alert(message));
         const groups = formats.map(format => [
-            only !== 'import' && enabled(format, 'export') && { label: only ? format.label : `Export ${format.label}`, action: () => save(format.export(model()), format.fileName) },
+            only !== 'import' && format.exports !== false && enabled(format, 'export') && { label: only ? format.label : `Export ${format.label}`, action: () => save(format.export(model()), format.fileName) },
             only !== 'export' && format.imports && enabled(format, 'import') && {
                 label: only ? `${format.label}…` : `Import ${format.label}…`,
                 action: () => importFile(format, { choose, onImport, report: tell }),
@@ -41279,6 +41329,29 @@
             return this.entities.find(e => e.id === id) ?? null;
         }
 
+        /** An entity by id, else by name (any case), or null. */
+        named(text) {
+            const s = String(text ?? '').trim();
+            return this.entity(s) ?? this.entities.find(e => String(e.name ?? '').toLowerCase() === s.toLowerCase()) ?? null;
+        }
+
+        /**
+         * What a foreign key's `references` names: `{ entity, column }` (column
+         * null when it names the table alone), or null. `table` or `table.column`,
+         * the table by id or name; a table's own name may hold dots (a
+         * schema-qualified `sales.customer`), so the whole text is tried as a
+         * table first, then what is before its last dot, the rest its column.
+         */
+        resolveReference(ref) {
+            const text = String(ref ?? '').trim();
+            if (!text) return null;
+            const whole = this.named(text);
+            if (whole) return { entity: whole, column: null };
+            const dot = text.lastIndexOf('.');
+            const entity = dot > 0 ? this.named(text.slice(0, dot)) : null;
+            return entity ? { entity, column: text.slice(dot + 1).trim() || null } : null;
+        }
+
         /** Add an entity (its id unique at this level). */
         addEntity(entity) {
             if (!entity?.id) throw new TypeError('An entity needs an id');
@@ -41719,17 +41792,13 @@
         foreignKeys() {
             return ATTRIBUTED.flatMap(level => {
                 const schema = this.model.level(level);
-                const find = (ref) => {
-                    const [name] = String(ref).split('.');
-                    return schema.entity(name) ?? schema.entities.find(e => e.name.toLowerCase() === name.trim().toLowerCase()) ?? null;
-                };
                 const related = (a, b) => schema.relationships.some(r => (r.source === a && r.target === b) || (r.source === b && r.target === a));
                 return schema.entities.flatMap(e => (e.attributes ?? []).filter(a => a.isFK).flatMap(a => {
                     if (!a.references) {
                         return schema.relationships.some(r => r.source === e.id || r.target === e.id) ? []
                             : [this._entity(level, e, 'foreign-key-unrelated', 'info', `"${e.name}.${a.name}" is a foreign key, but "${e.name}" has no relationship`)];
                     }
-                    const target = find(a.references);
+                    const target = schema.resolveReference(a.references)?.entity;
                     if (!target) return [this._entity(level, e, 'reference-missing', 'warning', `"${e.name}.${a.name}" references "${a.references}", which is not at the ${level} level`)];
                     return related(e.id, target.id) ? []
                         : [this._entity(level, e, 'foreign-key-without-relationship', 'warning', `"${e.name}.${a.name}" references "${target.name}", but they have no relationship`)];
@@ -42003,50 +42072,211 @@
         }
     }
 
-    /**
-     * DataModelEditCommand — one edit of a DataModel (an entity, an attribute, a
-     * relationship, a delete) as one undo step: run, it makes the change and keeps
-     * the model as it was before and after (DataModel#toJSON); undone or redone, it
-     * puts the model back as it was (DataModel#restore). Any change to a model is
-     * undoable this way, whatever it touches.
-     */
-    class DataModelEditCommand extends Command {
-        /** A model edit is no edit on one view: undoing it shows no other. */
-        viewId = null;
-
-        /**
-         * @param {DataModel} model
-         * @param {string} label - What the undo menu calls it ('Edit Customer')
-         * @param {(model: DataModel) => *} change - Makes the change
-         */
-        constructor(model, label, change) {
-            super(label);
-            this.model = model;
-            this.change = change;
-            this.before = null;
-            this.after = null;
-        }
-
-        execute() {
-            if (this.after) {
-                this.model.restore(this.after);
-            } else {
-                this.before = DataModelEditCommand.snapshot(this.model);
-                this.result = this.change(this.model);
-                this.after = DataModelEditCommand.snapshot(this.model);
-            }
-            this.model.edited();
-        }
-
-        undo() {
-            this.model.restore(this.before);
-            this.model.edited();
-        }
-
-        /** The model as it is, a copy nothing later changes (its toJSON shares some arrays). */
-        static snapshot(model) {
-            return JSON.parse(JSON.stringify(model.toJSON()));
-        }
+    /**
+     * ModelEditCommand — one edit of an EditableModel (a data model's entity, a
+     * requirements model's story, a delete) as one undo step: run, it makes the
+     * change and keeps the model as it was before and after (its toJSON); undone
+     * or redone, it puts the model back as it was (its restore). Any change to a
+     * model is undoable this way, whatever it touches.
+     */
+    class ModelEditCommand extends Command {
+        /** A model edit is no edit on one view: undoing it shows no other. */
+        viewId = null;
+
+        /**
+         * @param {EditableModel} model
+         * @param {string} label - What the undo menu calls it ('Edit Customer')
+         * @param {(model: EditableModel) => *} change - Makes the change
+         */
+        constructor(model, label, change) {
+            super(label);
+            this.model = model;
+            this.change = change;
+            this.before = null;
+            this.after = null;
+        }
+
+        execute() {
+            if (this.after) {
+                this.model.restore(this.after);
+            } else {
+                this.before = ModelEditCommand.snapshot(this.model);
+                this.result = this.change(this.model);
+                this.after = ModelEditCommand.snapshot(this.model);
+            }
+            this.model.edited();
+        }
+
+        undo() {
+            this.model.restore(this.before);
+            this.model.edited();
+        }
+
+        /** The model as it is, a copy nothing later changes (its toJSON may share arrays). */
+        static snapshot(model) {
+            return JSON.parse(JSON.stringify(model.toJSON()));
+        }
+    }
+
+    /**
+     * EditableModel — base of a model edited as a whole rather than view by view
+     * (DataModel, RequirementsModel; a ViewSetModel keeps its views' histories
+     * its own way). What a part needs of any model it edits, keeps and merges:
+     *
+     * - a name;
+     * - whether it changed since it was saved (`edited()`, `markSaved()`,
+     *   `isDirty()`, `onEdit(fn)`), so a part shows it, keeps it and asks before
+     *   it is lost;
+     * - an undo history, every edit one step on it (`editCommand(label, change)`:
+     *   the model before and after, as its toJSON, put back by `restore`);
+     * - how it differs from another of its kind (`compareWith`, over the
+     *   subclass's `comparedKinds()`), which merges the other's into it.
+     *
+     * A subclass gives `toJSON()`, its constructor reading that back, and
+     * `static STATE`: the fields `restore` puts back.
+     */
+    class EditableModel {
+        /** The fields a snapshot puts back (restore). A subclass lists its own, `name` among them. */
+        static STATE = Object.freeze(['name']);
+
+        /** @param {{name?: string}} [spec] */
+        constructor(spec = {}) {
+            if (new.target === EditableModel) throw new TypeError('EditableModel is abstract — subclass it');
+            /** What the model is called. */
+            this.name = spec.name ?? '';
+            this._version = 0;
+            this._saved = 0;
+            this._editListeners = [];
+        }
+
+        /** The kinds it is compared on and merged by (ComparedKind), in the order a merge brings them. None here. */
+        comparedKinds() {
+            return [];
+        }
+
+        /** How this model differs from another (ModelComparison), which can merge the other's into it. */
+        compareWith(other) {
+            return new ModelComparison(this, other);
+        }
+
+        /** Its undo history: a merge is one step on it. */
+        get history() {
+            return (this._history ??= new CommandHistory());
+        }
+
+        /** A change made as one undo step (ModelEditCommand), not yet run. */
+        editCommand(label, change) {
+            return new ModelEditCommand(this, label, change);
+        }
+
+        /** Put the model back as a snapshot (its toJSON) says: the fields its class lists (STATE). */
+        restore(json) {
+            const back = new this.constructor(JSON.parse(JSON.stringify(json)));
+            for (const key of this.constructor.STATE) this[key] = back[key];
+        }
+
+        // ===== Changed since saved =====
+
+        /** Something changed: listeners hear of it. */
+        edited() {
+            this._version++;
+            this._emitEdit();
+        }
+
+        /** This state is the saved one (a file opened or saved). */
+        markSaved() {
+            this._saved = this._version;
+            this._emitEdit();
+        }
+
+        /** Whether it changed since markSaved. */
+        isDirty() {
+            return this._version !== this._saved;
+        }
+
+        /** Call `fn(model)` after every change (and markSaved). Returns an unsubscribe function. */
+        onEdit(fn) {
+            this._editListeners.push(fn);
+            return () => { this._editListeners = this._editListeners.filter(l => l !== fn); };
+        }
+
+        /** @private */
+        _emitEdit() {
+            for (const fn of this._editListeners) fn(this);
+        }
+
+        /** An id made from `name`, unlike any of `taken`'s ids ('customer', 'customer-2'). */
+        _freshId(name, taken) {
+            const base = String(name ?? 'item').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'item';
+            let id = base;
+            for (let n = 2; taken.some(t => t.id === id); n++) id = `${base}-${n}`;
+            return id;
+        }
+
+        /** The model as plain JSON, read back by its constructor. @abstract */
+        toJSON() {
+            throw new Error(`${this.constructor.name} must implement toJSON()`);
+        }
+    }
+
+    /**
+     * Benchmark — what a model is measured by, so a change to it (a proposal, a
+     * merge) says whether it made the model better. Each measure:
+     * `{ key, label, value, better: 'lower'|'higher', format?: 'count'|'share'|'score' }`
+     * (a share is 0..1; a value of null is not measured yet).
+     *
+     * Every model with a checker is measured by its findings — warnings counted
+     * apart (`Benchmark.findings`); a model with more to say gives its own
+     * `benchmark()` (a data model its Scorecard, a requirements model how many
+     * stories say when they are done and trace to something), starting from those.
+     */
+    class Benchmark {
+        /** A model's measures: its own benchmark(), else its checker's findings, else none. */
+        static of(model) {
+            if (typeof model?.benchmark === 'function') return model.benchmark();
+            return Benchmark.findings(model);
+        }
+
+        /** The check's warnings and all its findings, each fewer the better. */
+        static findings(model) {
+            if (typeof model?.checker !== 'function') return [];
+            const found = model.checker().run();
+            return [
+                { key: 'warnings', label: 'Check warnings', value: found.filter(f => f.severity === 'warning').length, better: 'lower', format: 'count' },
+                { key: 'findings', label: 'Check findings', value: found.length, better: 'lower', format: 'count' },
+            ];
+        }
+
+        /**
+         * Two models' measures side by side, matched by key: `{key, label, format,
+         * before, after, change}` — change 'better', 'worse', 'same', or null when
+         * either is not measured.
+         */
+        static compare(before, after) {
+            const then = new Map(before.map(m => [m.key, m]));
+            return after.filter(m => then.has(m.key)).map(m => {
+                const was = then.get(m.key).value, now = m.value;
+                const change = was == null || now == null ? null
+                    : was === now ? 'same'
+                        : (now < was) === (m.better === 'lower') ? 'better' : 'worse';
+                return { key: m.key, label: m.label, format: m.format ?? 'count', before: was, after: now, change };
+            });
+        }
+
+        /** A measure's value as it reads ('3', '50%', '72 of 100', '—'). */
+        static format(value, format = 'count') {
+            if (value == null) return '—';
+            if (format === 'share') return `${Math.round(value * 100)}%`;
+            if (format === 'score') return `${value} of 100`;
+            return String(value);
+        }
+
+        /** A comparison in a line: "Check findings 7 → 3 (better); …" — what did not change left out unless nothing did. */
+        static text(rows) {
+            const moved = rows.filter(r => r.change !== 'same');
+            const shown = moved.length ? moved : rows;
+            return shown.map(r => `${r.label} ${Benchmark.format(r.before, r.format)} → ${Benchmark.format(r.after, r.format)}${r.change && r.change !== 'same' ? ` (${r.change})` : ''}`).join('; ');
+        }
     }
 
     /** Words that stay small inside a title. */
@@ -42700,8 +42930,42 @@
         }
     }
 
+    /** A plain copy of JSON-shaped data. */
+    const copy$2 = (value) => (value === undefined ? undefined : JSON.parse(JSON.stringify(value)));
+
+    /** A list of a model's held in an array (`list(model)`), each by an id; bring puts a copy in place or adds it. */
+    class ListCompared extends ComparedKind {
+        constructor() {
+            super();
+            if (new.target === ListCompared) throw new TypeError('ListCompared is abstract — subclass it');
+        }
+
+        /** The array the model holds them in. @abstract */
+        list(model) { throw new Error(`${this.constructor.name} must implement list()`); }
+
+        items(model) { return this.list(model); }
+        get(model, id) { return this.items(model).find(item => this.idOf(item) === id) ?? null; }
+
+        /** Put a copy of `item` at its place (in place of the one with its id, else last); undone, as it was. */
+        bring(model, item) {
+            const list = this.list(model);
+            const twin = this.copyOf(item);
+            const at = list.findIndex(x => this.idOf(x) === this.idOf(item));
+            if (at < 0) {
+                list.push(twin);
+                return () => { const i = list.indexOf(twin); if (i >= 0) list.splice(i, 1); };
+            }
+            const old = list[at];
+            list[at] = twin;
+            return () => { const i = list.indexOf(twin); if (i >= 0) list[i] = old; };
+        }
+
+        /** A copy to put in the other model. */
+        copyOf(item) { return copy$2(item); }
+    }
+
     /** A plain copy of JSON-shaped data. */
-    const copy = (value) => (value === undefined ? undefined : JSON.parse(JSON.stringify(value)));
+    const copy$1 = (value) => (value === undefined ? undefined : JSON.parse(JSON.stringify(value)));
 
     /**
      * The kinds two DataModels are compared on and merged by (ModelComparison,
@@ -42711,37 +42975,6 @@
      * two models alike but for where their boxes are, are alike.
      */
 
-    /** A list of a model's held in an array (`list(model)`), each by an id; bring puts a copy in place or adds it. */
-    class ListCompared extends ComparedKind {
-        constructor() {
-            super();
-            if (new.target === ListCompared) throw new TypeError('ListCompared is abstract — subclass it');
-        }
-
-        /** The array the model holds them in. @abstract */
-        list(model) { throw new Error(`${this.constructor.name} must implement list()`); }
-
-        items(model) { return this.list(model); }
-        get(model, id) { return this.items(model).find(item => this.idOf(item) === id) ?? null; }
-
-        /** Put a copy of `item` at its place (in place of the one with its id, else last); undone, as it was. */
-        bring(model, item) {
-            const list = this.list(model);
-            const twin = this.copyOf(item);
-            const at = list.findIndex(x => this.idOf(x) === this.idOf(item));
-            if (at < 0) {
-                list.push(twin);
-                return () => { const i = list.indexOf(twin); if (i >= 0) list.splice(i, 1); };
-            }
-            const old = list[at];
-            list[at] = twin;
-            return () => { const i = list.indexOf(twin); if (i >= 0) list[i] = old; };
-        }
-
-        /** A copy to put in the other model. */
-        copyOf(item) { return copy(item); }
-    }
-
     /** One level's entities: compared on all but where they are drawn. */
     class LevelEntitiesCompared extends ListCompared {
         constructor(level) {
@@ -42755,7 +42988,7 @@
 
         content(entity) {
             const { x, y, ...rest } = entity;
-            return copy(rest);
+            return copy$1(rest);
         }
     }
 
@@ -42774,7 +43007,7 @@
         list(model) { return model.level(this.level).relationships; }
         idOf(r) { return r.id ?? `${r.source}->${r.target}${r.name ? `:${r.name}` : ''}`; }
         nameOf(r) { return `${r.source} ${r.name || '→'} ${r.target}`; }
-        content(r) { return copy(r); }
+        content(r) { return copy$1(r); }
         requires(r) { return [[`${this.level}-entity`, r.source], [`${this.level}-entity`, r.target]]; }
     }
 
@@ -42801,8 +43034,8 @@
 
     /** Perspectives and contexts are classes; their JSON is what counts, and a copy is one made from it. */
     class ModelPartsCompared extends ListCompared {
-        content(item) { return copy(item.toJSON()); }
-        copyOf(item) { return new item.constructor(copy(item.toJSON())); }
+        content(item) { return copy$1(item.toJSON()); }
+        copyOf(item) { return new item.constructor(copy$1(item.toJSON())); }
     }
 
     class ContextsCompared extends ModelPartsCompared {
@@ -42844,11 +43077,13 @@
      * (`{ entities, relationships }`, as dataModelDiagram takes them), is read as
      * three levels mapped one to one.
      *
-     * It knows whether it changed since it was saved (`edited()`, `markSaved()`,
-     * `isDirty()`, `onEdit(fn)`), as a ViewSetModel does, so a part can show it,
-     * keep it and ask before it is lost.
+     * What any model a part edits has — whether it changed since saved, its undo
+     * history, compare and merge — is EditableModel's.
      */
-    class DataModel {
+    class DataModel extends EditableModel {
+        /** What a snapshot puts back (EditableModel#restore). */
+        static STATE = Object.freeze(['name', 'levels', 'mappings', 'mappingLayout', 'noteLayout', 'perspectives', 'contexts', 'dataTypes', 'namingStandard', 'classificationScheme', 'scorecard']);
+
         /** The levels, outermost first. */
         static LEVELS = LEVELS;
 
@@ -42932,11 +43167,7 @@
          * @param {string} [spec.name] - What the model is called
          */
         constructor(spec = {}) {
-            /** What the model is called. */
-            this.name = spec.name ?? '';
-            this._version = 0;
-            this._saved = 0;
-            this._editListeners = [];
+            super(spec);
             const { levels, mappings = [], mappingLayout = {}, noteLayout = {} } = spec.levels ? spec : DataModel.levelsFromCombined(spec);
             this.levels = Object.fromEntries(LEVELS.map(level => [level, new LevelSchema(level, levels?.[level] ?? {})]));
             this.mappings = LEVELS.slice(1).map((to, i) => {
@@ -42963,6 +43194,14 @@
             return new ModelScorecard(this);
         }
 
+        /** What it is measured by (Benchmark): its check's findings, and its Scorecard total. */
+        benchmark() {
+            return [
+                ...Benchmark.findings(this),
+                { key: 'scorecard', label: 'Scorecard', value: this.scored().total().score, better: 'higher', format: 'score' },
+            ];
+        }
+
         /** Keep a reviewer's scores and the weights (ModelScorecard.specFrom's), as one undo step. */
         scorecardCommand(spec) {
             return this.editCommand('Score the model', (model) => {
@@ -43010,46 +43249,6 @@
             ];
         }
 
-        /** How this model differs from another (ModelComparison), which can merge the other's into it. */
-        compareWith(other) {
-            return new ModelComparison(this, other);
-        }
-
-        /** Its undo history: a merge is one step on it. */
-        get history() {
-            return (this._history ??= new CommandHistory());
-        }
-
-        // ===== Changed since saved =====
-
-        /** Something changed (a perspective or context, a box or note moved): listeners hear of it. */
-        edited() {
-            this._version++;
-            this._emitEdit();
-        }
-
-        /** This state is the saved one (a file opened or saved). */
-        markSaved() {
-            this._saved = this._version;
-            this._emitEdit();
-        }
-
-        /** Whether it changed since markSaved. */
-        isDirty() {
-            return this._version !== this._saved;
-        }
-
-        /** Call `fn(model)` after every change (and markSaved). Returns an unsubscribe function. */
-        onEdit(fn) {
-            this._editListeners.push(fn);
-            return () => { this._editListeners = this._editListeners.filter(l => l !== fn); };
-        }
-
-        /** @private */
-        _emitEdit() {
-            for (const fn of this._editListeners) fn(this);
-        }
-
         /** A level's schema (LevelSchema). */
         level(name) {
             const schema = this.levels[name];
@@ -43265,13 +43464,7 @@
 
         // ===== Perspectives and contexts of one's own =====
 
-        // ===== Editing what a level holds (each a DataModelEditCommand: one undo step) =====
-
-        /** Put the model back as a snapshot says (DataModelEditCommand): its levels, mappings, layout, perspectives, contexts, data types. */
-        restore(json) {
-            const back = new DataModel(JSON.parse(JSON.stringify(json)));
-            for (const key of ['name', 'levels', 'mappings', 'mappingLayout', 'noteLayout', 'perspectives', 'contexts', 'dataTypes', 'namingStandard', 'classificationScheme', 'scorecard']) this[key] = back[key];
-        }
+        // ===== Editing what a level holds (each an editCommand: one undo step) =====
 
         /** Set how its data is classified (a ClassificationScheme spec), as one undo step. */
         classificationSchemeCommand(spec) {
@@ -43287,11 +43480,6 @@
             });
         }
 
-        /** A change made as one undo step. */
-        editCommand(label, change) {
-            return new DataModelEditCommand(this, label, change);
-        }
-
         /**
          * Add an entity at a level (`id` null: one made from its name) or change
          * one (what the spec leaves out, where it is drawn among it, kept).
@@ -43643,13 +43831,6 @@
         }
 
         /** An id from a name, not yet among `taken`. @private */
-        _freshId(name, taken) {
-            const base = String(name ?? 'item').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'item';
-            let id = base;
-            for (let n = 2; taken.some(t => t.id === id); n++) id = `${base}-${n}`;
-            return id;
-        }
-
         toJSON() {
             return {
                 name: this.name,
@@ -44671,6 +44852,15 @@
             return /^[a-z_][a-z0-9_]*$/.test(s) && !RESERVED.has(s) ? s : `"${s.replace(/"/g, '""')}"`;
         }
 
+        /**
+         * A table's name as SQL takes it: a schema-qualified one (`sales.customer`)
+         * each part as name() has it, so it names the table in its schema rather
+         * than one table called "sales.customer".
+         */
+        static tableName(text) {
+            return String(text).split('.').map(SqlDdl.name).join('.');
+        }
+
         /** A text as an SQL string literal. */
         static literal(text) {
             return `'${String(text).replace(/'/g, "''")}'`;
@@ -44680,11 +44870,7 @@
         write(model) {
             const schema = model.level('physical');
             const tables = schema.entities;
-            const find = (ref) => {
-                const [table, column] = String(ref).split('.').map(s => s.trim());
-                const target = schema.entity(table) ?? tables.find(t => t.name.toLowerCase() === table.toLowerCase());
-                return target ? { target, column } : null;
-            };
+            const table = SqlDdl.tableName;
             const out = [`-- ${model.name || 'Data model'}: the physical level, ${tables.length} table${tables.length === 1 ? '' : 's'}`, ''];
             for (const t of tables) {
                 const columns = t.attributes ?? [];
@@ -44694,28 +44880,28 @@
                     ...(keys.length ? [`    PRIMARY KEY (${keys.join(', ')})`] : []),
                     ...columns.filter(c => c.isUnique && !c.isPK).map(c => `    UNIQUE (${SqlDdl.name(c.name)})`),
                 ];
-                out.push(`CREATE TABLE ${SqlDdl.name(t.name)} (`, lines.join(',\n'), ');', '');
+                out.push(`CREATE TABLE ${table(t.name)} (`, lines.join(',\n'), ');', '');
             }
             for (const t of tables) {
                 for (const c of (t.attributes ?? []).filter(a => a.isFK && a.references)) {
-                    const ref = find(c.references);
+                    const ref = schema.resolveReference(c.references);
                     if (!ref) {
                         out.push(`-- ${t.name}.${c.name} references ${c.references}, which is not a table here`);
                         continue;
                     }
-                    const theirs = ref.column ? [ref.column] : (ref.target.attributes ?? []).filter(a => a.isPK).map(a => a.name);
+                    const theirs = ref.column ? [ref.column] : (ref.entity.attributes ?? []).filter(a => a.isPK).map(a => a.name);
                     if (!theirs.length) {
-                        out.push(`-- ${t.name}.${c.name} references ${ref.target.name}, which has no primary key`);
+                        out.push(`-- ${t.name}.${c.name} references ${ref.entity.name}, which has no primary key`);
                         continue;
                     }
-                    out.push(`ALTER TABLE ${SqlDdl.name(t.name)} ADD CONSTRAINT ${SqlDdl.name(`fk_${t.name}_${c.name}`.toLowerCase().replace(/[^a-z0-9_]+/g, '_'))}`
-                        + ` FOREIGN KEY (${SqlDdl.name(c.name)}) REFERENCES ${SqlDdl.name(ref.target.name)} (${theirs.map(SqlDdl.name).join(', ')});`);
+                    out.push(`ALTER TABLE ${table(t.name)} ADD CONSTRAINT ${SqlDdl.name(`fk_${t.name}_${c.name}`.toLowerCase().replace(/[^a-z0-9_]+/g, '_'))}`
+                        + ` FOREIGN KEY (${SqlDdl.name(c.name)}) REFERENCES ${table(ref.entity.name)} (${theirs.map(SqlDdl.name).join(', ')});`);
                 }
             }
             if (this.comments) {
                 const notes = tables.flatMap(t => [
-                    ...(t.description ? [`COMMENT ON TABLE ${SqlDdl.name(t.name)} IS ${SqlDdl.literal(t.description)};`] : []),
-                    ...(t.attributes ?? []).filter(c => c.description).map(c => `COMMENT ON COLUMN ${SqlDdl.name(t.name)}.${SqlDdl.name(c.name)} IS ${SqlDdl.literal(c.description)};`),
+                    ...(t.description ? [`COMMENT ON TABLE ${table(t.name)} IS ${SqlDdl.literal(t.description)};`] : []),
+                    ...(t.attributes ?? []).filter(c => c.description).map(c => `COMMENT ON COLUMN ${table(t.name)}.${SqlDdl.name(c.name)} IS ${SqlDdl.literal(c.description)};`),
                 ]);
                 if (notes.length) out.push('', ...notes);
             }
@@ -44744,6 +44930,853 @@
         }
     }
 
+    /**
+     * The kinds two RequirementsModels are compared on and merged by
+     * (ModelComparison): epics, releases, then stories, in the order a merge
+     * brings them — a story needs its epic and its release.
+     */
+
+    class EpicsCompared extends ListCompared {
+        get key() { return 'epic'; }
+        get label() { return 'Epics'; }
+        list(model) { return model.epics; }
+        content(epic) { return { ...epic }; }
+    }
+
+    class ReleasesCompared extends ListCompared {
+        get key() { return 'release'; }
+        get label() { return 'Releases'; }
+        list(model) { return model.releases; }
+        content(release) { return { ...release }; }
+    }
+
+    /** Stories: compared on everything, where they sit in the list aside. */
+    class StoriesCompared extends ListCompared {
+        get key() { return 'story'; }
+        get label() { return 'Stories'; }
+        list(model) { return model.stories; }
+        content(story) { return JSON.parse(JSON.stringify(story)); }
+
+        requires(story) {
+            return [...(story.epic ? [['epic', story.epic]] : []), ...(story.release ? [['release', story.release]] : [])];
+        }
+    }
+
+    /**
+     * RequirementsChecker — what a requirements model is missing, as a team
+     * reviewing a backlog would say it: a story with no acceptance criteria
+     * (nothing to say when it is done), one that says neither who wants it nor
+     * what (no "As a … I want …"), one that traces to nothing (nothing realises
+     * it), one under no epic, an epic with no stories, two stories of one name.
+     *
+     * With `resolve(trace)` — the host's way to find what a trace names in its
+     * other models (true, false, or undefined when it cannot tell) — a trace to
+     * something that is not there is found too.
+     *
+     * Findings name a story or an epic (`kind`), as ModelChecker's do.
+     */
+    class RequirementsChecker extends ModelChecker {
+        /**
+         * @param {RequirementsModel} model
+         * @param {{resolve?: (trace: Object) => (boolean|undefined)}} [options]
+         */
+        constructor(model, { resolve = null } = {}) {
+            super(model);
+            this.resolve = resolve;
+        }
+
+        checks() {
+            return [this.noCriteria, this.noNarrative, this.untraced, this.brokenTraces, this.noEpic, this.emptyEpics, this.sameNames];
+        }
+
+        /** @private */
+        _story(story, code, severity, message) {
+            return { code, severity, kind: 'story', ids: [story.id], message };
+        }
+
+        noCriteria() {
+            return this.model.stories.filter(s => !s.criteria.length)
+                .map(s => this._story(s, 'story-no-criteria', 'warning', `"${s.name}" has no acceptance criteria: nothing says when it is done`));
+        }
+
+        noNarrative() {
+            return this.model.stories.filter(s => !s.want && !s.description)
+                .map(s => this._story(s, 'story-no-narrative', 'info', `"${s.name}" says neither who wants it nor what (As a … I want … so that …)`));
+        }
+
+        untraced() {
+            return this.model.stories.filter(s => !s.traces.length)
+                .map(s => this._story(s, 'story-untraced', 'info', `"${s.name}" traces to nothing that realises it`));
+        }
+
+        brokenTraces() {
+            if (!this.resolve) return [];
+            return this.model.stories.flatMap(s => s.traces.filter(t => this.resolve(t) === false)
+                .map(t => this._story(s, 'trace-missing', 'warning', `"${s.name}" traces to ${t.kind} "${t.name || t.ref}", which is not there`)));
+        }
+
+        noEpic() {
+            if (!this.model.epics.length) return [];
+            return this.model.stories.filter(s => !this.model.epic(s.epic))
+                .map(s => this._story(s, 'story-no-epic', 'info', `"${s.name}" is under no epic`));
+        }
+
+        emptyEpics() {
+            return this.model.epics.filter(e => !this.model.storiesOf(e.id).length)
+                .map(e => ({ code: 'epic-empty', severity: 'info', kind: 'epic', ids: [e.id], message: `Epic "${e.name}" has no stories` }));
+        }
+
+        sameNames() {
+            const byName = new Map();
+            for (const s of this.model.stories) {
+                const key = s.name.trim().toLowerCase();
+                if (key) byName.set(key, [...(byName.get(key) ?? []), s]);
+            }
+            return [...byName.values()].filter(list => list.length > 1)
+                .map(list => ({ code: 'story-duplicate', severity: 'warning', kind: 'story', ids: list.map(s => s.id), message: `${list.length} stories are called "${list[0].name}"` }));
+        }
+    }
+
+    /** A plain copy of JSON-shaped data. */
+    const copy = (value) => JSON.parse(JSON.stringify(value));
+
+    /**
+     * What a story can trace to, and what its trace is called: ArchiMate's
+     * motivation and implementation elements, any other element of an
+     * architecture, and a data model's concepts, entities and tables — so a trace
+     * runs epic → story → requirement → component → entity → table. A trace's
+     * `kind` is any string; these are the ones offered.
+     */
+    const TRACE_KINDS = Object.freeze([
+        ['requirement', 'Requirement (ArchiMate)'],
+        ['work-package', 'Work package (ArchiMate)'],
+        ['element', 'Architecture element'],
+        ['concept', 'Data concept'],
+        ['entity', 'Data entity'],
+        ['table', 'Table'],
+    ]);
+
+    /** Where a story is in its life, in order; a status is any string, these are offered. */
+    const STATUSES = Object.freeze(['To do', 'In progress', 'Done']);
+
+    /**
+     * RequirementsModel — what a system is to do, as an agile team writes it:
+     * **epics** (large outcomes), the **stories** that deliver them ("As a … I
+     * want … so that …"), each with its **acceptance criteria**, sliced into
+     * **releases**; and **traces** from a story to what realises it in the other
+     * models (TRACE_KINDS: an ArchiMate requirement or work package, an element,
+     * a data concept, entity or table — `{kind, ref, name?, model?}`, `ref` that
+     * model's id).
+     *
+     * Read as a **story map** (`storyMap()`): epics across in order, releases
+     * down, each cell the stories of that epic in that release; stories with no
+     * epic or no release have a column and a row of their own. `coverage()` and
+     * the checker (RequirementsChecker) say what is missing — a story with no
+     * acceptance criteria, nothing realising it — the numbers a bench measures.
+     *
+     * Spec (its toJSON): `{ name?, epics: [{id, name, description?}], releases:
+     * [{id, name}], stories: [{id, name, epic?, release?, as?, want?, soThat?,
+     * description?, criteria: [{id, text}], status?, priority?, points?, labels?,
+     * source?: {system, key, url?}, traces: [{kind, ref, name?, model?}]}] }`.
+     * Ids are made from names when not given. Every edit is a command (one undo
+     * step); compare and merge, and changed-since-saved, are EditableModel's.
+     */
+    class RequirementsModel extends EditableModel {
+        static STATE = Object.freeze(['name', 'epics', 'releases', 'stories']);
+
+        static TRACE_KINDS = TRACE_KINDS;
+
+        static STATUSES = STATUSES;
+
+        /** A story map's column for stories with no epic, and its row for those in no release. */
+        static NO_EPIC = '';
+        static NO_RELEASE = '';
+
+        constructor(spec = {}) {
+            super(spec);
+            this.epics = [];
+            this.releases = [];
+            this.stories = [];
+            for (const e of spec.epics ?? []) this.epics.push(this._epic(e));
+            for (const r of spec.releases ?? []) this.releases.push(this._release(r));
+            for (const s of spec.stories ?? []) this.stories.push(this._story(s));
+        }
+
+        // ===== Reading =====
+
+        epic(id) { return this.epics.find(e => e.id === id) ?? null; }
+        release(id) { return this.releases.find(r => r.id === id) ?? null; }
+        story(id) { return this.stories.find(s => s.id === id) ?? null; }
+
+        /** The stories of an epic (NO_EPIC: of none), in order; with `release`, only those in it (NO_RELEASE: in none). */
+        storiesOf(epicId, release) {
+            return this.stories.filter(s => (s.epic || '') === (epicId || '')
+                && (release === undefined || (s.release || '') === (release || '')));
+        }
+
+        /** The story's sentence: "As a … I want … so that …", from what it has. */
+        static narrative(story) {
+            return [story.as && `As ${/^(a|an|the)\b/i.test(story.as) ? '' : 'a '}${story.as}`, story.want && `I want ${story.want}`, story.soThat && `so that ${story.soThat}`]
+                .filter(Boolean).join(', ');
+        }
+
+        /**
+         * The story map: `columns` the epics in order (then NO_EPIC, if any story
+         * has none), `rows` the releases in order (then NO_RELEASE, if any story is
+         * in none, or there are no releases), and `cell(epicId, releaseId)` the
+         * stories there, in order.
+         */
+        storyMap() {
+            const columns = [...this.epics.map(e => ({ id: e.id, name: e.name, epic: e }))];
+            if (this.stories.some(s => !this.epic(s.epic))) columns.push({ id: RequirementsModel.NO_EPIC, name: 'No epic', epic: null });
+            const rows = this.releases.map(r => ({ id: r.id, name: r.name, release: r }));
+            if (!rows.length || this.stories.some(s => !this.release(s.release))) rows.push({ id: RequirementsModel.NO_RELEASE, name: this.releases.length ? 'Not planned' : 'Stories', release: null });
+            const epicOf = (s) => (this.epic(s.epic) ? s.epic : RequirementsModel.NO_EPIC);
+            const releaseOf = (s) => (this.release(s.release) ? s.release : RequirementsModel.NO_RELEASE);
+            return {
+                columns, rows,
+                cell: (epicId, releaseId) => this.stories.filter(s => epicOf(s) === epicId && releaseOf(s) === releaseId),
+            };
+        }
+
+        /** The stories that trace to `ref` (with `kind`, only traces of that kind): what a change to it touches. */
+        tracingTo(ref, kind) {
+            return this.stories.filter(s => s.traces.some(t => t.ref === ref && (!kind || t.kind === kind)));
+        }
+
+        /**
+         * How complete it is, as numbers to measure by: stories, how many have
+         * acceptance criteria, how many trace to something, epics with no stories,
+         * and each as a share (0..1; 1 with nothing to count).
+         */
+        coverage() {
+            const stories = this.stories.length;
+            const withCriteria = this.stories.filter(s => s.criteria.length).length;
+            const traced = this.stories.filter(s => s.traces.length).length;
+            const emptyEpics = this.epics.filter(e => !this.storiesOf(e.id).length).length;
+            const share = (n, of) => (of ? n / of : 1);
+            return {
+                stories, withCriteria, traced, epics: this.epics.length, emptyEpics,
+                criteriaShare: share(withCriteria, stories), traceShare: share(traced, stories),
+            };
+        }
+
+        /** What it is measured by (Benchmark): its check's findings, and how many stories say when they are done and trace to something. */
+        benchmark() {
+            const c = this.coverage();
+            return [
+                ...Benchmark.findings(this),
+                { key: 'criteria', label: 'Stories with acceptance criteria', value: c.criteriaShare, better: 'higher', format: 'share' },
+                { key: 'traced', label: 'Stories traced', value: c.traceShare, better: 'higher', format: 'share' },
+            ];
+        }
+
+        /** Its checks (RequirementsChecker). */
+        checker(options) {
+            return new RequirementsChecker(this, options);
+        }
+
+        comparedKinds() {
+            return [new EpicsCompared(), new ReleasesCompared(), new StoriesCompared()];
+        }
+
+        // ===== Editing (each an editCommand: one undo step) =====
+
+        /** Add an epic (`id` null) or change one. The command's result is the epic. */
+        saveEpicCommand(id, spec) {
+            return this.editCommand(id ? `Edit epic ${spec.name ?? id}` : `New epic ${spec.name ?? ''}`.trim(), (model) => {
+                if (!id) { const epic = model._epic(spec); model.epics.push(epic); return epic; }
+                const epic = model.epic(id);
+                if (epic) Object.assign(epic, model._epic({ ...epic, ...spec, id }));
+                return epic;
+            });
+        }
+
+        /** Remove an epic; its stories stay, with no epic. */
+        removeEpicCommand(id) {
+            return this.editCommand(`Remove epic ${this.epic(id)?.name ?? id}`, (model) => {
+                model.epics = model.epics.filter(e => e.id !== id);
+                for (const s of model.stories) if (s.epic === id) s.epic = '';
+            });
+        }
+
+        /** Add a release (`id` null) or rename one. */
+        saveReleaseCommand(id, spec) {
+            return this.editCommand(id ? `Edit release ${spec.name ?? id}` : `New release ${spec.name ?? ''}`.trim(), (model) => {
+                if (!id) { const release = model._release(spec); model.releases.push(release); return release; }
+                const release = model.release(id);
+                if (release) Object.assign(release, model._release({ ...release, ...spec, id }));
+                return release;
+            });
+        }
+
+        /** Remove a release; its stories stay, planned in none. */
+        removeReleaseCommand(id) {
+            return this.editCommand(`Remove release ${this.release(id)?.name ?? id}`, (model) => {
+                model.releases = model.releases.filter(r => r.id !== id);
+                for (const s of model.stories) if (s.release === id) s.release = '';
+            });
+        }
+
+        /** Add a story (`id` null) or change one — what the spec leaves out kept. The command's result is the story. */
+        saveStoryCommand(id, spec) {
+            return this.editCommand(id ? `Edit ${spec.name ?? this.story(id)?.name ?? id}` : `New story ${spec.name ?? ''}`.trim(), (model) => {
+                if (!id) { const story = model._story(spec); model.stories.push(story); return story; }
+                const at = model.stories.findIndex(s => s.id === id);
+                if (at < 0) return null;
+                model.stories[at] = model._story({ ...model.stories[at], ...spec, id });
+                return model.stories[at];
+            });
+        }
+
+        removeStoryCommand(id) {
+            return this.editCommand(`Remove ${this.story(id)?.name ?? id}`, (model) => {
+                model.stories = model.stories.filter(s => s.id !== id);
+            });
+        }
+
+        /**
+         * Move a story on the map: to an epic and a release (NO_EPIC, NO_RELEASE:
+         * none), before another story there (`before`; none: last).
+         */
+        moveStoryCommand(id, { epic, release, before = null }) {
+            return this.editCommand(`Move ${this.story(id)?.name ?? id}`, (model) => {
+                const story = model.story(id);
+                if (!story || before === id) return;
+                if (epic !== undefined) story.epic = epic || '';
+                if (release !== undefined) story.release = release || '';
+                model.stories.splice(model.stories.indexOf(story), 1);
+                const at = before ? model.stories.findIndex(s => s.id === before) : -1;
+                model.stories.splice(at < 0 ? model.stories.length : at, 0, story);
+            });
+        }
+
+        /** Trace a story to something that realises it (`{kind, ref, name?, model?}`); once per kind and ref. */
+        traceCommand(storyId, trace) {
+            return this.editCommand(`Trace ${this.story(storyId)?.name ?? storyId} to ${trace.name || trace.ref}`, (model) => {
+                const story = model.story(storyId);
+                if (!story || story.traces.some(t => t.kind === trace.kind && t.ref === trace.ref)) return;
+                story.traces.push(RequirementsModel._trace(trace));
+            });
+        }
+
+        /** Remove a story's trace to `ref` (of `kind`, if given). */
+        untraceCommand(storyId, ref, kind) {
+            return this.editCommand(`Remove the trace of ${this.story(storyId)?.name ?? storyId}`, (model) => {
+                const story = model.story(storyId);
+                if (story) story.traces = story.traces.filter(t => !(t.ref === ref && (!kind || t.kind === kind)));
+            });
+        }
+
+        /**
+         * Bring epics, releases and stories in (an import): one undo step. One with
+         * the id of one there replaces it; the rest are added.
+         */
+        bringCommand({ epics = [], releases = [], stories = [] }, label = 'Import') {
+            return this.editCommand(label, (model) => {
+                const put = (list, item) => {
+                    const at = list.findIndex(x => x.id === item.id);
+                    if (at < 0) list.push(item); else list[at] = item;
+                };
+                for (const e of epics) put(model.epics, model._epic(e));
+                for (const r of releases) put(model.releases, model._release(r));
+                for (const s of stories) put(model.stories, model._story(s));
+            });
+        }
+
+        // ===== Its parts, read from a spec =====
+
+        /** @private */
+        _epic({ id, name = '', description = '', source } = {}) {
+            return {
+                id: id ?? this._freshId(name || 'epic', this.epics), name, description,
+                ...(source && { source: copy(source) }),
+            };
+        }
+
+        /** @private */
+        _release({ id, name = '' } = {}) {
+            return { id: id ?? this._freshId(name || 'release', this.releases), name };
+        }
+
+        /** @private */
+        _story(spec = {}) {
+            const { id, name = '', epic = '', release = '', as = '', want = '', soThat = '', description = '', status = '', priority = '', points = null, labels = [], source, criteria = [], traces = [] } = spec;
+            const story = {
+                id: id ?? this._freshId(name || 'story', this.stories), name, epic: epic ?? '', release: release ?? '',
+                as, want, soThat, description, status, priority,
+                points: Number.isFinite(Number(points)) && points !== null && points !== '' ? Number(points) : null,
+                labels: [...labels],
+                criteria: [],
+                traces: traces.map(t => RequirementsModel._trace(t)),
+                ...(source && { source: copy(source) }),
+            };
+            // A new criterion is numbered past every id the story's criteria have, so none is given twice.
+            const given = new Set(criteria.map(c => (typeof c === 'object' && c?.id) || null).filter(Boolean));
+            let n = 0;
+            const fresh = () => { let id; do id = `${story.id}-ac${++n}`; while (given.has(id)); given.add(id); return id; };
+            for (const c of criteria) {
+                const text = typeof c === 'string' ? c : c?.text;
+                if (!String(text ?? '').trim()) continue;
+                story.criteria.push({ id: (typeof c === 'object' && c.id) || fresh(), text: String(text).trim() });
+            }
+            return story;
+        }
+
+        /** @private */
+        static _trace({ kind = 'element', ref, name = '', model = '' } = {}) {
+            return { kind, ref: String(ref ?? ''), ...(name && { name }), ...(model && { model }) };
+        }
+
+        toJSON() {
+            return {
+                name: this.name,
+                epics: copy(this.epics),
+                releases: copy(this.releases),
+                stories: copy(this.stories),
+            };
+        }
+    }
+
+    /**
+     * RequirementsFileFormat — a requirements model as a file
+     * (`.requirements.json`): its epics, releases and stories
+     * (RequirementsModel#toJSON), read back by `new RequirementsModel(json)`.
+     */
+    class RequirementsFileFormat extends ModelFileFormat {
+        get label() { return '.requirements.json'; }
+        get accept() { return '.requirements.json,.json'; }
+        get fileName() { return 'model.requirements.json'; }
+        get featureName() { return 'Requirements'; }
+
+        /** JSON with a requirements model's shape: stories, or epics. */
+        recognizes(text) {
+            try {
+                const json = JSON.parse(text);
+                return !!json && typeof json === 'object' && (Array.isArray(json.stories) || Array.isArray(json.epics));
+            } catch {
+                return false;
+            }
+        }
+
+        export(model) {
+            return { data: JSON.stringify(model.toJSON(), null, 2), mimeType: 'application/json' };
+        }
+
+        import(text) {
+            return new RequirementsModel(JSON.parse(text));
+        }
+    }
+
+    /**
+     * Where each tracker's export keeps what a story needs: per tracker, the
+     * column names (CSV) each field may be under, first found wins; which issue
+     * types are epics; how its list fields are separated. One definition per
+     * tracker — the CSV and the JSON readers both map onto these fields. A host
+     * gives its own (a custom field's column) through `new TrackerExport({ columns })`.
+     */
+    const TRACKERS = Object.freeze({
+        jira: {
+            label: 'Jira',
+            // Columns only its exports have, to tell it by.
+            marks: ['Issue key', 'Issue Type'],
+            columns: {
+                key: ['Issue key', 'Key'], id: ['Issue id'], type: ['Issue Type'], title: ['Summary'],
+                description: ['Description'], parent: ['Parent', 'Parent id', 'Parent key', 'Custom field (Epic Link)', 'Epic Link'],
+                status: ['Status'], priority: ['Priority'],
+                points: ['Custom field (Story Points)', 'Story Points', 'Custom field (Story point estimate)', 'Story point estimate'],
+                release: ['Fix Version/s', 'Fix versions', 'Sprint'], labels: ['Labels'],
+                criteria: ['Custom field (Acceptance Criteria)', 'Acceptance Criteria'], url: [],
+            },
+            epicTypes: ['Epic'], skipTypes: ['Sub-task', 'Subtask'], labelSeparator: /[\s,]+/,
+        },
+        azure: {
+            label: 'Azure DevOps',
+            marks: ['Work Item Type'],
+            columns: {
+                key: ['ID'], id: ['ID'], type: ['Work Item Type'], title: ['Title', 'Title 1', 'Title 2', 'Title 3'],
+                description: ['Description'], parent: ['Parent'], status: ['State'], priority: ['Priority'],
+                points: ['Story Points', 'Effort', 'Size'], release: ['Iteration Path'], labels: ['Tags'],
+                criteria: ['Acceptance Criteria'], url: [],
+            },
+            epicTypes: ['Epic', 'Feature'], skipTypes: ['Task'], labelSeparator: /\s*;\s*/,
+        },
+        gitlab: {
+            label: 'GitLab',
+            marks: ['Issue ID', 'URL'],
+            columns: {
+                key: ['Issue ID', 'IID'], id: ['Issue ID', 'IID'], type: [], title: ['Title'], description: ['Description'],
+                parent: ['Epic ID'], parentName: ['Epic Title'], status: ['State'], priority: [], points: ['Weight'],
+                release: ['Milestone'], labels: ['Labels'], criteria: [], url: ['URL'],
+            },
+            epicTypes: [], skipTypes: [], labelSeparator: /\s*,\s*/,
+        },
+    });
+
+    /**
+     * Where Jira's JSON keeps what has no field of its own: custom fields, by key.
+     * Jira Cloud's "Story point estimate" is customfield_10016 unless a site
+     * changed it; a host names its own (`columns: { points: ['customfield_10026'] }`).
+     */
+    const JIRA_FIELDS = Object.freeze({
+        points: ['story_points', 'storyPoints', 'customfield_10016'],
+        criteria: ['acceptanceCriteria'],
+    });
+
+    /** Text with HTML in it (Azure DevOps keeps descriptions as HTML) as lines of plain text. */
+    function plainText(value) {
+        if (value == null) return '';
+        if (typeof value === 'object') return documentText(value);
+        return String(value)
+            .replace(/<\s*(br|\/p|\/div|\/li|\/h\d)\s*\/?>/gi, '\n').replace(/<\s*li[^>]*>/gi, '- ')
+            .replace(/<[^>]+>/g, '')
+            .replace(/&nbsp;/g, ' ').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, '&')
+            .replace(/\r\n?/g, '\n').replace(/\n{3,}/g, '\n\n').trim();
+    }
+
+    /** Jira Cloud's description, a document of nodes, as text: each paragraph and list item a line. */
+    function documentText(node) {
+        if (!node || typeof node !== 'object') return '';
+        if (node.type === 'text') return node.text ?? '';
+        const inner = (node.content ?? []).map(documentText).join('');
+        return ['paragraph', 'heading', 'listItem', 'codeBlock'].includes(node.type) ? `${node.type === 'listItem' ? '- ' : ''}${inner.trim()}\n` : inner;
+    }
+
+    /** The lines of a list: "- x", "* x", "1. x", "• x", "[ ] x" — each item a line, its marker gone. */
+    function listItems(text) {
+        return String(text ?? '').split('\n')
+            .map(line => line.replace(/^\s*(?:[-*•+]|\d+[.)]|\[[ xX]?\])\s+/, '').trim())
+            .filter(Boolean);
+    }
+
+    /**
+     * Acceptance criteria in a story's text: the lines under an "Acceptance
+     * criteria" heading, else its Given/When/Then scenarios (one each), else none.
+     * @returns {{criteria: Array<string>, rest: string}} - and the text without them
+     */
+    function criteriaFrom(text) {
+        const s = plainText(text);
+        const heading = /^\s*(?:#+\s*|\*\*)?acceptance criteria\b[^\n]*\n/im.exec(s);
+        if (heading) {
+            const after = s.slice(heading.index + heading[0].length);
+            const end = after.search(/\n\s*\n\s*(?:#+\s|\*\*|[A-Z][^\n:]{0,40}:\s*\n)/);
+            const block = end < 0 ? after : after.slice(0, end);
+            return { criteria: listItems(block), rest: (s.slice(0, heading.index) + (end < 0 ? '' : after.slice(end))).replace(/\n{3,}/g, '\n\n').trim() };
+        }
+        const scenarios = [];
+        let current = null;
+        for (const line of s.split('\n')) {
+            const t = line.replace(/^\s*(?:[-*•]\s+)?/, '').trim();
+            if (/^given\b/i.test(t)) { current = [t]; scenarios.push(current); } else if (current && /^(when|then|and|but)\b/i.test(t)) current.push(t); else current = null;
+        }
+        if (scenarios.length) return { criteria: scenarios.map(lines => lines.join(' ')), rest: s.split('\n').filter(l => !/^\s*(?:[-*•]\s+)?(given|when|then|and|but)\b/i.test(l)).join('\n').trim() };
+        return { criteria: [], rest: s };
+    }
+
+    /** A field that holds only acceptance criteria: as criteriaFrom reads them, else each of its lines one. */
+    function criteriaField(text) {
+        const found = criteriaFrom(text).criteria;
+        return found.length ? found : listItems(plainText(text));
+    }
+
+    /** "As a <who>, I want <what> so that <why>" in a text: its three parts (empty where it says nothing). */
+    function narrativeFrom(text) {
+        const m = /\bas an?\s+([^,\n]+?)\s*,?\s+i\s+(?:want|need|would like)\s+([^\n]+?)(?:\s*,?\s+so\s+that\s+([^\n]+?))?\s*(?:[.\n]|$)/i.exec(plainText(text));
+        return m ? { as: m[1].trim(), want: m[2].trim(), soThat: (m[3] ?? '').trim() } : { as: '', want: '', soThat: '' };
+    }
+
+    /** A text without its "As a … I want …" line: what is left to describe the story, once its sentence is read (narrativeFrom). */
+    function withoutNarrative(text) {
+        return String(text ?? '').replace(/^\s*\**\s*as an?\s[^\n]*\bi\s+(want|need|would like)\b[^\n]*\n?/im, '').trim();
+    }
+
+    /**
+     * TrackerExport — epics and stories from what an issue tracker exports: Jira,
+     * Azure DevOps or GitLab (TRACKERS), as CSV or as their API's JSON. An issue
+     * of an epic type becomes an epic (GitLab's epics are named by their issues'
+     * Epic ID and title); the rest become stories under their parent epic, with
+     * their status, priority, points, labels and release (fix version, iteration
+     * or milestone). Acceptance criteria come from their own field, else from
+     * the description (criteriaFrom); "As a … I want … so that …" from the
+     * description or the title (narrativeFrom). Each keeps where it came from
+     * (`source: {system, key, url?}`), and its id is the tracker's key, so
+     * reading a newer export over a model replaces what it had.
+     *
+     * `read(text)` gives a RequirementsModel spec (`{epics, releases, stories}`).
+     */
+    class TrackerExport {
+        /**
+         * @param {Object} [options]
+         * @param {string} [options.tracker] - 'jira', 'azure', 'gitlab' (default: told from the export)
+         * @param {Object<string, Array<string>>} [options.columns] - Column names to look in first, by field (in Jira's JSON, field keys)
+         */
+        constructor({ tracker = null, columns = {} } = {}) {
+            this.tracker = tracker;
+            this.columns = columns;
+        }
+
+        /** What a tracker is called ('Jira'). */
+        static label(tracker) {
+            return TRACKERS[tracker]?.label ?? 'Tracker';
+        }
+
+        /** Which tracker an export's columns (or JSON) are from, or null. */
+        static detect(text) {
+            const json = TrackerExport._json(text);
+            if (json) {
+                if (Array.isArray(json.issues) && json.issues[0]?.fields) return 'jira';
+                if (Array.isArray(json.value ?? json.workItems) && (json.value ?? json.workItems)[0]?.fields) return 'azure';
+                if (Array.isArray(json) && json[0] && 'iid' in json[0]) return 'gitlab';
+                return null;
+            }
+            const { columns } = parseCsvTable(text);
+            const has = new Set(columns.map(c => c.toLowerCase()));
+            const found = Object.entries(TRACKERS).find(([, t]) => t.marks.every(m => has.has(m.toLowerCase())));
+            return found?.[0] ?? null;
+        }
+
+        /** @private */
+        static _json(text) {
+            const s = String(text ?? '').trim();
+            if (!s.startsWith('{') && !s.startsWith('[')) return null;
+            try { return JSON.parse(s); } catch { return null; }
+        }
+
+        /**
+         * The export as a requirements model's spec.
+         * @returns {{epics: Array, releases: Array, stories: Array, tracker: string|null}}
+         */
+        read(text) {
+            const tracker = this.tracker ?? TrackerExport.detect(text) ?? 'jira';
+            const def = TRACKERS[tracker];
+            if (!def) throw new Error(`Unknown tracker: "${tracker}"`);
+            const json = TrackerExport._json(text);
+            const issues = json ? this._fromJson(tracker, json) : this._fromCsv(def, text);
+            return { ...this._model(tracker, def, issues), tracker };
+        }
+
+        /** CSV rows as issues: each field from the first of its columns there. @private */
+        _fromCsv(def, text) {
+            const { columns, rows } = parseCsvTable(text);
+            const lower = new Map(columns.map(c => [c.toLowerCase(), c]));
+            const columnOf = (field) => [...(this.columns[field] ?? []), ...(def.columns[field] ?? [])].map(c => lower.get(c.toLowerCase())).find(Boolean);
+            const fields = Object.keys({ ...def.columns, ...this.columns, parentName: [] });
+            const at = Object.fromEntries(fields.map(f => [f, columnOf(f)]));
+            return rows.map(row => Object.fromEntries(fields.map(f => [f, at[f] ? row[at[f]] : ''])));
+        }
+
+        /** An API's JSON as issues, in the CSV's fields. @private */
+        _fromJson(tracker, json) {
+            if (tracker === 'jira') {
+                return (json.issues ?? []).map(({ key, id, fields: f = {} }) => {
+                    const custom = (names) => Object.entries(f).find(([k]) => names.some(n => k.toLowerCase().includes(n)))?.[1];
+                    // A field the host named (its custom field's key), else Jira Cloud's usual one.
+                    const field = (name) => [...(this.columns[name] ?? []), ...(JIRA_FIELDS[name] ?? [])].map(k => f[k]).find(v => v != null && v !== '');
+                    return {
+                        key, id: String(id ?? ''), type: f.issuetype?.name ?? '', title: f.summary ?? '', description: f.description ?? '',
+                        parent: f.parent?.key ?? f.parent?.id ?? '', status: f.status?.name ?? '', priority: f.priority?.name ?? '',
+                        points: field('points') ?? custom(['storypoint', 'story_point']) ?? '',
+                        release: (f.fixVersions ?? [])[0]?.name ?? '', labels: (f.labels ?? []).join(' '),
+                        criteria: field('criteria') ?? custom(['acceptance']) ?? '', url: '',
+                    };
+                });
+            }
+            if (tracker === 'azure') {
+                return (json.value ?? json.workItems ?? []).map(({ id, fields: f = {}, url }) => ({
+                    key: String(id), id: String(id), type: f['System.WorkItemType'] ?? '', title: f['System.Title'] ?? '',
+                    description: f['System.Description'] ?? '', parent: String(f['System.Parent'] ?? ''), status: f['System.State'] ?? '',
+                    priority: String(f['Microsoft.VSTS.Common.Priority'] ?? ''),
+                    points: f['Microsoft.VSTS.Scheduling.StoryPoints'] ?? f['Microsoft.VSTS.Scheduling.Effort'] ?? '',
+                    release: f['System.IterationPath'] ?? '', labels: f['System.Tags'] ?? '',
+                    criteria: f['Microsoft.VSTS.Common.AcceptanceCriteria'] ?? '', url: url ?? '',
+                }));
+            }
+            return (Array.isArray(json) ? json : []).map(i => ({
+                key: String(i.iid ?? i.id), id: String(i.iid ?? i.id), type: '', title: i.title ?? '', description: i.description ?? '',
+                parent: String(i.epic?.id ?? i.epic_iid ?? ''), parentName: i.epic?.title ?? '', status: i.state ?? '', priority: '',
+                points: i.weight ?? '', release: i.milestone?.title ?? '', labels: (i.labels ?? []).map(l => l.name ?? l).join(','),
+                criteria: '', url: i.web_url ?? '',
+            }));
+        }
+
+        /** Issues as epics, releases and stories. @private */
+        _model(tracker, def, issues) {
+            const is = (list, type) => list.some(t => t.toLowerCase() === String(type ?? '').trim().toLowerCase());
+            const keyOf = new Map();   // an issue's id or key → its key (Jira's CSV names a parent by its id)
+            for (const i of issues) for (const k of [i.key, i.id]) if (k) keyOf.set(String(k), String(i.key || i.id));
+            const source = (i, key) => ({ system: tracker, key, ...(i.url && { url: i.url }) });
+
+            const epics = new Map();
+            for (const i of issues) {
+                if (!is(def.epicTypes, i.type)) continue;
+                const key = String(i.key || i.id);
+                epics.set(key, { id: key, name: plainText(i.title), description: plainText(i.description), source: source(i, key) });
+            }
+            const releases = new Map();
+            const stories = [];
+            for (const i of issues) {
+                if (is(def.epicTypes, i.type) || is(def.skipTypes, i.type) || !String(i.title ?? '').trim()) continue;
+                const key = String(i.key || i.id);
+                const parent = i.parent ? keyOf.get(String(i.parent)) ?? String(i.parent) : '';
+                if (parent && !epics.has(parent) && i.parentName) epics.set(parent, { id: parent, name: plainText(i.parentName), description: '', source: { system: tracker, key: parent } });
+                const release = plainText(i.release);
+                if (release && !releases.has(release)) releases.set(release, { id: release, name: release.split(/[\\/]/).pop() });
+                const own = criteriaField(i.criteria);
+                const inText = own.length ? { criteria: [], rest: plainText(i.description) } : criteriaFrom(i.description);
+                const said = narrativeFrom(i.description);
+                const { as, want, soThat } = said.want ? said : narrativeFrom(i.title);
+                stories.push({
+                    id: key, name: plainText(i.title), epic: parent, release,
+                    as, want, soThat, description: said.want ? withoutNarrative(inText.rest) : inText.rest,
+                    criteria: own.length ? own : inText.criteria,
+                    status: plainText(i.status), priority: plainText(i.priority), points: i.points === '' ? null : i.points,
+                    labels: String(i.labels ?? '').split(def.labelSeparator).map(l => l.trim()).filter(Boolean),
+                    source: source(i, key), traces: [],
+                });
+            }
+            // A story whose parent is no epic here (a story's sub-item, an epic not exported) is under none.
+            for (const s of stories) if (s.epic && !epics.has(s.epic)) s.epic = '';
+            return { epics: [...epics.values()], releases: [...releases.values()], stories };
+        }
+    }
+
+    /**
+     * Storyboard — epics and stories from a storyboard or requirements document
+     * written in Markdown (or plain text with Markdown headings), as teams keep
+     * them beside or before a tracker:
+     *
+     * - a heading that says "Epic" (`## Epic: Checkout`) is an epic, one that says
+     *   "Story" (`### Story: Pay by card`) a story; otherwise the document's one
+     *   title (`#`) is its name, the next level down are epics and the level
+     *   below that stories;
+     * - under an epic, a list item that reads "As a … I want …" is a story too;
+     * - under a story, "As a … I want … so that …" is its narrative, the list
+     *   under "Acceptance criteria" (or its Given/When/Then lines) its criteria,
+     *   and the rest its description — a picture (`![caption](file)`) kept there
+     *   by its caption.
+     *
+     * `read(text)` gives a RequirementsModel spec (`{name, epics, stories}`); ids
+     * are made from names (prefix: `prefix`, so two storyboards read into one
+     * model stay apart).
+     */
+    class Storyboard {
+        /** @param {{prefix?: string}} [options] */
+        constructor({ prefix = '' } = {}) {
+            this.prefix = prefix;
+        }
+
+        read(text) {
+            const lines = String(text ?? '').replace(/\r\n?/g, '\n').split('\n');
+            const headings = lines.map((line, at) => ({ at, m: /^(#{1,6})\s+(.*?)\s*#*\s*$/.exec(line) })).filter(h => h.m)
+                .map(({ at, m }) => ({ at, level: m[1].length, text: m[2].trim() }));
+            const kindOf = (h) => (/^epic\b/i.test(h.text) ? 'epic' : /^(user\s+)?story\b/i.test(h.text) || /\bas an?\s+\S/i.test(h.text) ? 'story' : null);
+            const top = Math.min(...headings.map(h => h.level));
+            const tops = headings.filter(h => h.level === top);
+            // One top heading, a title (#), names the document; its children are the epics.
+            const named = top === 1 && tops.length === 1 && !kindOf(tops[0]) && headings.length > 1;
+            const epicLevel = named ? top + 1 : top;
+            const strip = (t) => t.replace(/^(epic|(user\s+)?story)\s*[:\-–—]?\s*/i, '').trim();
+
+            const epics = [], stories = [];
+            const ids = new Set();
+            const idFor = (name, kind) => {
+                const base = `${this.prefix}${String(name).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || kind}`;
+                let id = base;
+                for (let n = 2; ids.has(id); n++) id = `${base}-${n}`;
+                ids.add(id);
+                return id;
+            };
+            const bodyOf = (h, i) => lines.slice(h.at + 1, headings[i + 1]?.at ?? lines.length).join('\n');
+            let epic = null;
+            headings.forEach((h, i) => {
+                if (named && h === tops[0]) return;
+                const kind = kindOf(h) ?? (h.level === epicLevel ? 'epic' : h.level === epicLevel + 1 ? 'story' : null);
+                const body = bodyOf(h, i);
+                if (kind === 'epic') {
+                    epic = { id: idFor(strip(h.text), 'epic'), name: strip(h.text), description: '' };
+                    epics.push(epic);
+                    const listed = this._listedStories(body);
+                    epic.description = listed.rest;
+                    for (const s of listed.stories) stories.push({ ...s, id: idFor(s.name, 'story'), epic: epic.id });
+                } else if (kind === 'story') {
+                    stories.push({ ...this._story(strip(h.text), body), id: idFor(strip(h.text), 'story'), epic: epic?.id ?? '' });
+                }
+            });
+            if (!headings.length || (!epics.length && !stories.length)) {
+                for (const s of this._listedStories(lines.join('\n')).stories) stories.push({ ...s, id: idFor(s.name, 'story') });
+            }
+            return { name: named ? tops[0].text : '', epics, stories };
+        }
+
+        /** A story from its heading and what is under it. @private */
+        _story(name, body) {
+            const pictures = [...body.matchAll(/!\[([^\]]*)\]\([^)]*\)/g)].map(m => m[1]).filter(Boolean);
+            const text = body.replace(/!\[([^\]]*)\]\([^)]*\)/g, '').trim();
+            const said = narrativeFrom(text);
+            const { as, want, soThat } = said.want ? said : narrativeFrom(name);
+            const { criteria, rest } = criteriaFrom(text);
+            const description = [withoutNarrative(rest), ...pictures.map(c => `Picture: ${c}`)].filter(Boolean).join('\n');
+            return { name, as, want, soThat, description, criteria };
+        }
+
+        /** "As a … I want …" list items: stories; the rest of the text, kept. @private */
+        _listedStories(body) {
+            const stories = [];
+            const rest = [];
+            for (const line of body.split('\n')) {
+                const item = /^\s*(?:[-*•+]|\d+[.)])\s+(.*)$/.exec(line);
+                const said = item && narrativeFrom(item[1]);
+                if (said?.want) stories.push({ name: said.want.replace(/^to\s+/i, '').replace(/^./, c => c.toUpperCase()), ...said, description: '', criteria: [] });
+                else rest.push(line);
+            }
+            return { stories, rest: rest.join('\n').trim() };
+        }
+    }
+
+    /**
+     * The files a requirements model is read from that another tool wrote — they
+     * import only: a tracker's export (TrackerExport: Jira, Azure DevOps,
+     * GitLab, CSV or JSON) and a storyboard (Storyboard: Markdown). Each reads
+     * the file as a new model; `spec(text)` is what it holds, for a part that
+     * brings it into the model open (RequirementsModel#bringCommand).
+     */
+    class RequirementsImportFormat extends ModelFileFormat {
+        get exports() { return false; }
+
+        /** What the file holds, as a RequirementsModel spec. @abstract */
+        spec(text) { throw new Error(`${this.constructor.name} must implement spec()`); }
+
+        import(text) {
+            return new RequirementsModel(this.spec(text));
+        }
+    }
+
+    class TrackerExportFileFormat extends RequirementsImportFormat {
+        get label() { return 'Tracker export (Jira, Azure DevOps, GitLab)'; }
+        get accept() { return '.csv,.json'; }
+        get featureName() { return 'TrackerExport'; }
+
+        /** A CSV or JSON export one of the trackers wrote. */
+        recognizes(text) {
+            return !!TrackerExport.detect(text);
+        }
+
+        spec(text) {
+            const { tracker, ...spec } = new TrackerExport().read(text);
+            return { name: `${TrackerExport.label(tracker)} export`, ...spec };
+        }
+    }
+
+    class StoryboardFileFormat extends RequirementsImportFormat {
+        get label() { return 'Storyboard (Markdown)'; }
+        get accept() { return '.md,.markdown,.txt'; }
+        get featureName() { return 'Storyboard'; }
+
+        spec(text) {
+            return new Storyboard().read(text);
+        }
+    }
+
     /**
      * propertiesDialog — the "Show/Edit Properties" dialog, as a shipped feature.
      *
@@ -47655,6 +48688,7 @@
     exports.AttributedLevel = AttributedLevel;
     exports.BackgroundCommand = BackgroundCommand;
     exports.BackgroundGroup = BackgroundGroup;
+    exports.Benchmark = Benchmark;
     exports.BianActionTerm = BianActionTerm;
     exports.BianFunctionalPattern = BianFunctionalPattern;
     exports.BianLandscapeReader = BianLandscapeReader;
@@ -47732,6 +48766,7 @@
     exports.EditHintCommand = EditHintCommand;
     exports.EditPropertyCommand = EditPropertyCommand;
     exports.EditViewItemCommand = EditViewItemCommand;
+    exports.EditableModel = EditableModel;
     exports.EditorShell = EditorShell;
     exports.ElementFilterRule = ElementFilterRule;
     exports.ElementInstance = ElementInstance;
@@ -47776,6 +48811,7 @@
     exports.Mat4 = Mat4;
     exports.MeasuredCategory = MeasuredCategory;
     exports.MenuBar = MenuBar;
+    exports.ModelEditCommand = ModelEditCommand;
     exports.ModelFileFormat = ModelFileFormat;
     exports.ModelScorecard = ModelScorecard;
     exports.ModelTree = ModelTree;
@@ -47810,6 +48846,9 @@
     exports.RemoveLineCommand = RemoveLineCommand;
     exports.RenderEngine = RenderEngine;
     exports.ReorderCommand = ReorderCommand;
+    exports.RequirementsChecker = RequirementsChecker;
+    exports.RequirementsFileFormat = RequirementsFileFormat;
+    exports.RequirementsModel = RequirementsModel;
     exports.ResizeCommand = ResizeCommand;
     exports.RotateCommand = RotateCommand;
     exports.RoundedRectangleTemplate = RoundedRectangleTemplate;
@@ -47826,8 +48865,11 @@
     exports.SqlDdlFileFormat = SqlDdlFileFormat;
     exports.StadiumTemplate = StadiumTemplate;
     exports.StarTemplate = StarTemplate;
+    exports.Storyboard = Storyboard;
+    exports.StoryboardFileFormat = StoryboardFileFormat;
     exports.StructuredType = StructuredType;
     exports.SwimlaneTemplate = SwimlaneTemplate;
+    exports.TRACKERS = TRACKERS;
     exports.TREE_LAYERS = TREE_LAYERS;
     exports.TREE_MODE_CATALOG = TREE_MODE_CATALOG;
     exports.Template = Template;
@@ -47841,6 +48883,8 @@
     exports.ToolbarSelect = ToolbarSelect;
     exports.ToolbarSeparator = ToolbarSeparator;
     exports.ToolbarText = ToolbarText;
+    exports.TrackerExport = TrackerExport;
+    exports.TrackerExportFileFormat = TrackerExportFileFormat;
     exports.TrapezoidTemplate = TrapezoidTemplate;
     exports.TreeModeRegistry = TreeModeRegistry;
     exports.TriangleTemplate = TriangleTemplate;