@issuegraph/editor 0.1.0

package/dist/picker/words.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The picker's words. Supplied by the host, never by this package.
+ *
+ * Same contract, and the same reasoning, as
+ * {@link ../reevaluate/words.ts ChangeWords}: the store deliberately stops at
+ * data rather than prose, and a default vocabulary here would take that choice
+ * back one layer down. It is sharper for this surface than for the summary,
+ * because what is being worded is a RELATIONSHIP — "is blocked by" carries a
+ * word order as well as a language, and a package that shipped the phrase would
+ * ship an English clause its consumers could not translate or reverse.
+ *
+ * SO IT IS REQUIRED, NOT DEFAULTED, exactly as `StoreConfig.derive` is: a
+ * default would be a second implementation of something this layer is not
+ * entitled to decide.
+ *
+ * ## One vocabulary, read in two places
+ *
+ * {@link PickerWords.kinds} words both a picker OPTION ("is blocked by", chosen
+ * from a list of five) and the DIRECTION STATEMENT it produces ("#530 is
+ * blocked by #602"). One entry has to read in both positions, which is the same
+ * constraint `ChangeWords.facets` carries for the summary and its chips.
+ *
+ * A host wanting two registers — a short label in the list, a full clause in
+ * the statement — renders {@link ../picker/view.ts PickerView} itself. Nothing
+ * in the default render is load-bearing for that.
+ */
+import type { EdgeKind } from '@issuegraph/store';
+export interface PickerWords {
+    /**
+     * One relational phrase per kind.
+     *
+     * `Record<EdgeKind, string>` rather than a partial map: a kind with no phrase
+     * would render as a bare reference pair, which reads as a DIFFERENT
+     * relationship rather than as a missing label — and mistaking one
+     * relationship for another is the encoding error this surface exists to
+     * prevent. A kind added to the format fails a host's build here, which is
+     * where it can be fixed.
+     */
+    readonly kinds: Readonly<Record<EdgeKind, string>>;
+    /** Names the picker for a screen reader and for a visible heading. */
+    readonly heading: string;
+    /** The control that reverses a directed relationship. */
+    readonly flip: string;
+    /**
+     * Marks the option the edge already carries.
+     *
+     * A word rather than a colour: "which one is it now" is the question the
+     * picker is opened to answer, and a purely visual answer is unavailable to a
+     * screen reader and to a host with a monochrome theme.
+     */
+    readonly current: string;
+}
+//# sourceMappingURL=words.d.ts.map

package/dist/picker/words.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"words.d.ts","sourceRoot":"","sources":["../../src/picker/words.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElD,MAAM,WAAW,WAAW;IAC1B;;;;;;;;;OASG;IACH,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC;IACnD,sEAAsE;IACtE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,yDAAyD;IACzD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B"}

package/dist/picker/words.js

@@ -0,0 +1,28 @@
+/**
+ * The picker's words. Supplied by the host, never by this package.
+ *
+ * Same contract, and the same reasoning, as
+ * {@link ../reevaluate/words.ts ChangeWords}: the store deliberately stops at
+ * data rather than prose, and a default vocabulary here would take that choice
+ * back one layer down. It is sharper for this surface than for the summary,
+ * because what is being worded is a RELATIONSHIP — "is blocked by" carries a
+ * word order as well as a language, and a package that shipped the phrase would
+ * ship an English clause its consumers could not translate or reverse.
+ *
+ * SO IT IS REQUIRED, NOT DEFAULTED, exactly as `StoreConfig.derive` is: a
+ * default would be a second implementation of something this layer is not
+ * entitled to decide.
+ *
+ * ## One vocabulary, read in two places
+ *
+ * {@link PickerWords.kinds} words both a picker OPTION ("is blocked by", chosen
+ * from a list of five) and the DIRECTION STATEMENT it produces ("#530 is
+ * blocked by #602"). One entry has to read in both positions, which is the same
+ * constraint `ChangeWords.facets` carries for the summary and its chips.
+ *
+ * A host wanting two registers — a short label in the list, a full clause in
+ * the statement — renders {@link ../picker/view.ts PickerView} itself. Nothing
+ * in the default render is load-bearing for that.
+ */
+export {};
+//# sourceMappingURL=words.js.map

package/dist/picker/words.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"words.js","sourceRoot":"","sources":["../../src/picker/words.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG"}

package/dist/reevaluate/render.d.ts

@@ -0,0 +1,77 @@
+/**
+ * The re-evaluate surface, as markup: the rail, a summary of what the last edit
+ * did to it, and a delta chip for each row that changed.
+ *
+ * ## It draws nothing inside a row
+ *
+ * The rail is `@issuegraph/viewer`'s linear projection, composed here as a SPEC
+ * rather than as a string — `renderViewer` hands back `scene.root`, so the
+ * viewer's tree nests inside this one and every byte still comes out of
+ * `renderMarkup`. Nothing is concatenated by hand, and no attribute value in
+ * this package is ever escaped by anything but the one renderer.
+ *
+ * That is what makes the design's rule structural instead of asserted:
+ * **unaffected rows are left completely alone** because this package never
+ * touches a row. The rejected alternative — splice chips into the rail's markup
+ * string — would have re-introduced exactly the hand-built escaping surface the
+ * spec grammar exists to remove.
+ *
+ * ## The chips are a KEYED LIST, and this package does not position them
+ *
+ * Said plainly because the earlier wording did not: `data-ig-key` has no
+ * browser behaviour of its own. The chips render as a list beside the rail, and
+ * putting one ON its row needs that row's geometry — which only a mount has,
+ * and this package has no mount. Naming it an overlay while shipping a
+ * normal-flow list claimed a positioning this markup cannot do.
+ *
+ * So the list is built to stand on its own instead: every chip NAMES the row it
+ * describes, which is what lets a reader account for the rows that got no chip.
+ * The key is published for the mount that will position them, and that mount
+ * lands with the change that assembles the workspace — the same boundary the
+ * scale ladder already draws when it defers listener wiring and focus
+ * restoration to whoever owns the mount.
+ *
+ * ## Two rejected alternatives from the design, recorded so they stay rejected
+ *
+ * A before/after side-by-side makes the owner redo the comparison the machine
+ * already did, and doubles the surface at 300 rows. An animated re-sort is
+ * pretty once and unusable in a loop, because rows moving under the cursor mean
+ * the next edit targets the wrong thing. Neither is reachable from here.
+ *
+ * ## Nothing dismisses itself
+ *
+ * There is no timer, and there is no view state. `Store.dismissChange()` is
+ * already the only thing besides the next edit that clears the summary, so this
+ * renders a control publishing `data-ig-command="dismiss-change"` and lets the
+ * store stay the single source of truth. A second copy of "has this been
+ * dismissed" held out here is the drift the command grammar exists to avoid.
+ */
+import { type Theme, type ViewerDocument } from '@issuegraph/viewer';
+import type { OrderChange, OrderStatus } from '@issuegraph/store';
+import type { ChangeWords } from './words.ts';
+import { type ReevaluateView } from './view.ts';
+export interface ReevaluateOptions {
+    /**
+     * The words. Required — see {@link ChangeWords} for why this package will not
+     * invent them.
+     */
+    readonly words: ChangeWords;
+    /** The store's `lastChange`. Absent means no edit has landed to report. */
+    readonly change?: OrderChange | null | undefined;
+    /** The store's `order.status`. `held` greys and labels the rail. */
+    readonly status?: OrderStatus | undefined;
+    readonly theme?: Theme | undefined;
+    /** The selector the theme's custom properties are written onto. */
+    readonly themeSelector?: string | undefined;
+}
+export interface ReevaluateResult {
+    readonly view: ReevaluateView;
+    /** The whole surface: the summary, the chips, and the rail inside one root. */
+    readonly markup: string;
+    /** The viewer's stylesheet, the theme, and this surface's own. Install all. */
+    readonly styles: string;
+    readonly diagnostics: readonly string[];
+}
+/** Render the order, and what the last edit did to it. */
+export declare function renderReevaluate(input: ViewerDocument, options: ReevaluateOptions): ReevaluateResult;
+//# sourceMappingURL=render.d.ts.map

package/dist/reevaluate/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../src/reevaluate/render.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAEH,OAAO,EAEL,KAAK,KAAK,EACV,KAAK,cAAc,EAMpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAa,MAAM,mBAAmB,CAAC;AAE7E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAuC,KAAK,cAAc,EAAkB,MAAM,WAAW,CAAC;AAGrG,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,2EAA2E;IAC3E,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,CAAC;IACjD,oEAAoE;IACpE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC1C,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;IACnC,mEAAmE;IACnE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC7C;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC;AAqJD,0DAA0D;AAC1D,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,cAAc,EACrB,OAAO,EAAE,iBAAiB,GACzB,gBAAgB,CA8ClB"}

package/dist/reevaluate/render.js

@@ -0,0 +1,211 @@
+/**
+ * The re-evaluate surface, as markup: the rail, a summary of what the last edit
+ * did to it, and a delta chip for each row that changed.
+ *
+ * ## It draws nothing inside a row
+ *
+ * The rail is `@issuegraph/viewer`'s linear projection, composed here as a SPEC
+ * rather than as a string — `renderViewer` hands back `scene.root`, so the
+ * viewer's tree nests inside this one and every byte still comes out of
+ * `renderMarkup`. Nothing is concatenated by hand, and no attribute value in
+ * this package is ever escaped by anything but the one renderer.
+ *
+ * That is what makes the design's rule structural instead of asserted:
+ * **unaffected rows are left completely alone** because this package never
+ * touches a row. The rejected alternative — splice chips into the rail's markup
+ * string — would have re-introduced exactly the hand-built escaping surface the
+ * spec grammar exists to remove.
+ *
+ * ## The chips are a KEYED LIST, and this package does not position them
+ *
+ * Said plainly because the earlier wording did not: `data-ig-key` has no
+ * browser behaviour of its own. The chips render as a list beside the rail, and
+ * putting one ON its row needs that row's geometry — which only a mount has,
+ * and this package has no mount. Naming it an overlay while shipping a
+ * normal-flow list claimed a positioning this markup cannot do.
+ *
+ * So the list is built to stand on its own instead: every chip NAMES the row it
+ * describes, which is what lets a reader account for the rows that got no chip.
+ * The key is published for the mount that will position them, and that mount
+ * lands with the change that assembles the workspace — the same boundary the
+ * scale ladder already draws when it defers listener wiring and focus
+ * restoration to whoever owns the mount.
+ *
+ * ## Two rejected alternatives from the design, recorded so they stay rejected
+ *
+ * A before/after side-by-side makes the owner redo the comparison the machine
+ * already did, and doubles the surface at 300 rows. An animated re-sort is
+ * pretty once and unusable in a loop, because rows moving under the cursor mean
+ * the next edit targets the wrong thing. Neither is reachable from here.
+ *
+ * ## Nothing dismisses itself
+ *
+ * There is no timer, and there is no view state. `Store.dismissChange()` is
+ * already the only thing besides the next edit that clears the summary, so this
+ * renders a control publishing `data-ig-command="dismiss-change"` and lets the
+ * store stay the single source of truth. A second copy of "has this been
+ * dismissed" held out here is the drift the command grammar exists to avoid.
+ */
+import { KEY_ATTRIBUTE, element, renderMarkup, renderViewer, resolveTheme, } from '@issuegraph/viewer';
+import { reevaluateView } from "./view.js";
+import { reevaluateStylesheet } from "./styles.js";
+function countWord(count, word) {
+    return [
+        element('span', { class: 'ig-change-count' }, [String(count)]),
+        element('span', { class: 'ig-change-word' }, [word]),
+    ];
+}
+function summarySpec(summary, words) {
+    return element('div', {
+        class: 'ig-change-summary',
+        // Omitted rather than falsified while there is nothing to report: an
+        // element() attribute whose value is `undefined` is not written at all,
+        // and `data-unchanged="false"` would claim an edit landed and moved
+        // nothing when no edit has landed.
+        'data-unchanged': summary === null ? undefined : summary.unchanged ? 'true' : 'false',
+        'data-op': summary?.op,
+        'data-mutation': summary?.mutationId,
+    }, [
+        // THE LIVE REGION IS ALWAYS MOUNTED, AND EMPTY UNTIL THERE IS SOMETHING
+        // TO SAY. A `role="status"` node that is CREATED already carrying its
+        // text is not reliably announced — the region has to exist first and
+        // then have its contents change — so rendering it only alongside a
+        // summary would silently lose the FIRST summary after a load, which is
+        // the one a reader is most likely to be waiting for.
+        //
+        // It is also why the region is this wrapper rather than the content
+        // inside it: an edit that moved something renders a list and one that
+        // moved nothing renders a paragraph, so a role on either would come and
+        // go with the shape. And the dismiss button stays OUTSIDE, or its label
+        // would be re-announced with every summary.
+        //
+        // It is a role, not a timer. Nothing about it expires and the region
+        // stays put until the next edit or an explicit dismissal.
+        element('div', { class: 'ig-change-line', role: 'status' }, summary === null
+            ? []
+            : [
+                // THE ZERO CASE RENDERS, in the summary's own place. An edit that
+                // landed and moved nothing is the finding an owner auditing an
+                // encoding most needs, and drawing nothing for it is the defect
+                // this branch prevents.
+                summary.unchanged
+                    ? element('p', { class: 'ig-change-unchanged' }, [words.unchanged])
+                    : element('ul', { class: 'ig-change-parts' }, summary.parts.map((part) => element('li', { class: 'ig-change-part', 'data-facet': part.facet }, [
+                        ...countWord(part.count, words.facets[part.facet]),
+                    ]))),
+            ]),
+        // ITS OWN CLASS, not the ladder's `.ig-chip`. That class is defined only
+        // in `scale/styles.ts`, so borrowing it would leave this control unstyled
+        // for a host that installs this surface and not that one. Folding the two
+        // chip looks into one rule is the assembling change's call, not this
+        // leaf's — it is the change that first has both on screen at once.
+        //
+        // Absent with no summary: a control that clears nothing is a control that
+        // does nothing, and the region above is what has to persist, not this.
+        summary === null
+            ? null
+            : element('button', { type: 'button', class: 'ig-change-dismiss', 'data-ig-command': 'dismiss-change' }, [words.dismiss]),
+    ]);
+}
+/**
+ * What one issue's delta says, as spans.
+ *
+ * IT NAMES A DIRECTION AND A DISTANCE, NEVER A RANK. `RankMovement.from` and
+ * `.to` are the deriver's 0-BASED positions, while the rail beside them renders
+ * the viewer's 1-BASED ranks — so printing either as a number would put two
+ * different bases side by side and read as an off-by-one. `by` is a distance,
+ * which is basis-independent and safe to print. A host that knows the basis and
+ * wants the endpoints reads them off `view.chips[].deltas`, which carries every
+ * `RankDelta` untouched.
+ */
+function memberSpec(delta, words, named) {
+    return element('span', { class: 'ig-delta-member', 'data-ref': delta.ref }, [
+        // NAMED ONLY WHEN THE NAME ADDS SOMETHING. On a chip whose single member IS
+        // the row, the row key above has already said it and repeating it is noise.
+        // Everywhere else the ref is load-bearing: two members reading
+        // `lead 1 down 1 down` says the row moved twice rather than that a unit of
+        // two each moved down one, and a lone member that is NOT the lead is a
+        // change to an issue the row key does not name at all.
+        named ? element('span', { class: 'ig-delta-ref' }, [delta.ref]) : null,
+        delta.movement === undefined
+            ? null
+            : element('span', {
+                class: 'ig-delta-move',
+                'data-direction': delta.movement.direction,
+                'data-by': delta.movement.by,
+            }, [...countWord(delta.movement.by, words.direction[delta.movement.direction])]),
+        delta.readiness === undefined
+            ? null
+            : element('span', { class: 'ig-delta-readiness', 'data-readiness': delta.readiness }, [
+                words.facets[delta.readiness],
+            ]),
+        delta.presence === undefined
+            ? null
+            : element('span', { class: 'ig-delta-presence', 'data-presence': delta.presence }, [
+                words.facets[delta.presence],
+            ]),
+    ]);
+}
+/**
+ * One ROW's chip — which can speak for more than one issue.
+ *
+ * A `together-with` unit is one row and several refs, so its members are nested
+ * inside a single chip rather than given one each. Each keeps its own
+ * `data-ref`, so a host can still tell which member moved.
+ *
+ * IT NAMES ITS ROW IN TEXT, not only in `KEY_ATTRIBUTE`. Unpositioned, a chip
+ * that carried its key only as an attribute said nothing a reader could see
+ * about WHICH row moved — and the rows that did not move are accounted for
+ * precisely by not being named here. The key is data, not language, so naming
+ * it costs the host no word.
+ */
+function chipSpec(chip, words) {
+    // One member whose ref IS the row: the key names it, so naming it again would
+    // be the only text on the chip that says nothing. Any other shape — several
+    // members, or a lone member the row is not named after — needs each fact
+    // attributed, or the chip reads as one row's facts repeated.
+    const named = chip.deltas.length > 1 || chip.deltas[0]?.ref !== chip.key;
+    return element('li', { class: 'ig-delta-chip', [KEY_ATTRIBUTE]: chip.key }, [
+        element('span', { class: 'ig-delta-key' }, [chip.key]),
+        ...chip.deltas.map((delta) => memberSpec(delta, words, named)),
+    ]);
+}
+/** Render the order, and what the last edit did to it. */
+export function renderReevaluate(input, options) {
+    const status = options.status ?? 'settled';
+    const theme = resolveTheme(options.theme);
+    const rail = renderViewer(input, {
+        projection: 'linear',
+        theme,
+        ...(options.themeSelector === undefined ? {} : { themeSelector: options.themeSelector }),
+    });
+    const view = reevaluateView(options.change, rail.scene, status);
+    const root = element('section', {
+        class: 'ig-reevaluate',
+        // The rail's own state, on the surface that owns the label for it. The
+        // viewer draws the order it was handed; whether that order is the current
+        // one is a fact only the store knows.
+        'data-order': status,
+    }, [
+        // "Write landed, order computing" shows the PREVIOUS order, held still,
+        // greyed one step and EXPLICITLY LABELLED. A stale-but-labelled order
+        // beats a half-computed one, and the rail never shows a rank it is not
+        // sure of — which is why nothing here re-ranks anything: the ranks drawn
+        // are the ones the caller vouched for, and a chip's movement is drawn as
+        // a chip rather than as a rank.
+        view.held ? element('p', { class: 'ig-order-computing' }, [options.words.computing]) : null,
+        summarySpec(view.summary, options.words),
+        view.chips.length === 0
+            ? null
+            : element('ul', { class: 'ig-delta-list' }, view.chips.map((chip) => chipSpec(chip, options.words))),
+        // The viewer's own tree, nested rather than concatenated.
+        rail.scene.root,
+    ]);
+    return {
+        view,
+        markup: renderMarkup(root),
+        styles: `${rail.styles}\n${reevaluateStylesheet}`,
+        diagnostics: [...view.diagnostics, ...rail.diagnostics],
+    };
+}
+//# sourceMappingURL=render.js.map

package/dist/reevaluate/render.js.map

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

package/dist/reevaluate/styles.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The re-evaluate surface's structural stylesheet.
+ *
+ * Same contract as the viewer's and the ladder's: layout, weight and state,
+ * never a value. Every colour, length and font is a `var(--ig-…)` the host's
+ * theme resolves, so a second theme keeps working here too, and
+ * `styles.test.ts` scans these bytes for a literal or an unresolvable token.
+ *
+ * IT ADDS SELECTORS RATHER THAN REDEFINING THEM, with one deliberate exception
+ * that is worth naming: the greyed rail. `.ig-reevaluate[data-order='held']
+ * .ig-viewer` reaches a layer-1 class — but only from INSIDE this surface's own
+ * root, and only for a state layer 1 does not model. The viewer draws the order
+ * it is handed; whether that order is the current one is a fact only the store
+ * knows, so the label and the greying belong to whoever knows it. Nothing here
+ * changes how the rail looks outside this surface.
+ *
+ * There is no transition and no animation, anywhere in this file. The design
+ * rejected the animated re-sort because rows moving under the cursor mean the
+ * next edit targets the wrong thing, and it rejected the toast because the only
+ * evidence the edit worked disappears before it is read. A stylesheet is a
+ * place both could creep back in.
+ */
+export declare const reevaluateStylesheet = "\n.ig-reevaluate {\n  display: flex;\n  flex-direction: column;\n  gap: var(--ig-space);\n  font-family: var(--ig-font-ui);\n  font-size: var(--ig-font-size);\n  line-height: var(--ig-line-height);\n  color: var(--ig-text-body);\n}\n\n/* Greyed one step, and never hidden: a stale order that is labelled is still\n   the most useful thing on the screen.\n\n   A FILTER, NOT A COLOUR, and that is the whole point of this rule. color on\n   the rail greys almost nothing: the viewer's own stylesheet sets color\n   directly on .ig-title, .ig-id and .ig-hold, and carries the stations\n   and badges in background and border-color, none of which inherit at all.\n   A specified value beats an inherited one, so the stale order would have kept\n   its normal palette while this rule looked like it was doing something.\n\n   The enumeration is the trap here, not the oversight: listing the descendants\n   to override is the \"a static rule names one spelling of a capability\"\n   class this repository has already paid for several times over, and it would\n   go stale the first time layer 1 colours something new. filter applies to\n   an element AND its whole subtree whatever properties that subtree sets, so\n   a descendant added later is covered by construction. styles.test.ts pins\n   both halves: that layer 1 really does colour its own descendants, and that\n   this rule is not a bare color. */\n.ig-reevaluate[data-order='held'] .ig-viewer {\n  filter: grayscale(1);\n}\n\n.ig-order-computing {\n  margin: 0;\n  color: var(--ig-text-muted);\n  font-size: var(--ig-font-size-small);\n}\n\n.ig-change-summary {\n  display: flex;\n  gap: var(--ig-space);\n  align-items: baseline;\n  flex-wrap: wrap;\n}\n\n.ig-change-line {\n  display: flex;\n  align-items: baseline;\n}\n\n.ig-change-parts {\n  list-style: none;\n  margin: 0;\n  padding: 0;\n  display: flex;\n  flex-wrap: wrap;\n  /* The blast radius reads as ONE line. The gap is the separator, so no\n     punctuation glyph is baked into the markup \u2014 that would be a second\n     language choice on top of the words themselves. */\n  gap: var(--ig-space);\n}\n\n.ig-change-part {\n  display: flex;\n  gap: var(--ig-space-tight);\n  align-items: baseline;\n}\n\n.ig-change-count {\n  font-family: var(--ig-font-mono);\n  color: var(--ig-text);\n}\n\n.ig-change-word {\n  color: var(--ig-text-body);\n}\n\n.ig-change-unchanged {\n  margin: 0;\n  color: var(--ig-text-body);\n}\n\n.ig-change-dismiss {\n  align-self: flex-start;\n  background: var(--ig-surface-2);\n  color: var(--ig-text-body);\n  border: var(--ig-stroke) solid var(--ig-line);\n  border-radius: var(--ig-radius);\n  padding: var(--ig-space-tight) var(--ig-space);\n  font-family: var(--ig-font-ui);\n  font-size: var(--ig-font-size-small);\n  cursor: pointer;\n}\n\n.ig-change-dismiss:focus-visible {\n  outline: var(--ig-focus-ring) solid var(--ig-focus);\n  outline-offset: var(--ig-space-tight);\n}\n\n.ig-delta-list {\n  list-style: none;\n  margin: 0;\n  padding: 0;\n  display: flex;\n  flex-direction: column;\n  gap: var(--ig-space-tight);\n}\n\n.ig-delta-chip {\n  display: flex;\n  gap: var(--ig-space-tight);\n  align-items: baseline;\n  border: var(--ig-stroke) solid var(--ig-line);\n  border-radius: var(--ig-radius);\n  padding: var(--ig-space-tight);\n  background: var(--ig-surface-2);\n}\n\n.ig-delta-member {\n  display: flex;\n  gap: var(--ig-space-tight);\n  align-items: baseline;\n}\n\n.ig-delta-key,\n.ig-delta-ref {\n  font-family: var(--ig-font-mono);\n  color: var(--ig-text-muted);\n}\n\n/* The count and its word are adjacent spans with no text between them, so\n   without this they render as 2up. Same reason .ig-change-part has one. */\n.ig-delta-move {\n  display: flex;\n  gap: var(--ig-space-tight);\n  align-items: baseline;\n}\n\n.ig-delta-move[data-direction='up'] .ig-change-count {\n  color: var(--ig-station-ready);\n}\n\n.ig-delta-move[data-direction='down'] .ig-change-count {\n  color: var(--ig-text-muted);\n}\n\n.ig-delta-readiness[data-readiness='promoted'] {\n  color: var(--ig-station-ready);\n}\n\n.ig-delta-readiness[data-readiness='newly-held'] {\n  color: var(--ig-station-held);\n}\n\n.ig-delta-presence {\n  color: var(--ig-text-muted);\n}\n";
+//# sourceMappingURL=styles.d.ts.map

package/dist/reevaluate/styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../src/reevaluate/styles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,eAAO,MAAM,oBAAoB,2oIA8JhC,CAAC"}

package/dist/reevaluate/styles.js

@@ -0,0 +1,182 @@
+/**
+ * The re-evaluate surface's structural stylesheet.
+ *
+ * Same contract as the viewer's and the ladder's: layout, weight and state,
+ * never a value. Every colour, length and font is a `var(--ig-…)` the host's
+ * theme resolves, so a second theme keeps working here too, and
+ * `styles.test.ts` scans these bytes for a literal or an unresolvable token.
+ *
+ * IT ADDS SELECTORS RATHER THAN REDEFINING THEM, with one deliberate exception
+ * that is worth naming: the greyed rail. `.ig-reevaluate[data-order='held']
+ * .ig-viewer` reaches a layer-1 class — but only from INSIDE this surface's own
+ * root, and only for a state layer 1 does not model. The viewer draws the order
+ * it is handed; whether that order is the current one is a fact only the store
+ * knows, so the label and the greying belong to whoever knows it. Nothing here
+ * changes how the rail looks outside this surface.
+ *
+ * There is no transition and no animation, anywhere in this file. The design
+ * rejected the animated re-sort because rows moving under the cursor mean the
+ * next edit targets the wrong thing, and it rejected the toast because the only
+ * evidence the edit worked disappears before it is read. A stylesheet is a
+ * place both could creep back in.
+ */
+export const reevaluateStylesheet = `
+.ig-reevaluate {
+  display: flex;
+  flex-direction: column;
+  gap: var(--ig-space);
+  font-family: var(--ig-font-ui);
+  font-size: var(--ig-font-size);
+  line-height: var(--ig-line-height);
+  color: var(--ig-text-body);
+}
+
+/* Greyed one step, and never hidden: a stale order that is labelled is still
+   the most useful thing on the screen.
+
+   A FILTER, NOT A COLOUR, and that is the whole point of this rule. color on
+   the rail greys almost nothing: the viewer's own stylesheet sets color
+   directly on .ig-title, .ig-id and .ig-hold, and carries the stations
+   and badges in background and border-color, none of which inherit at all.
+   A specified value beats an inherited one, so the stale order would have kept
+   its normal palette while this rule looked like it was doing something.
+
+   The enumeration is the trap here, not the oversight: listing the descendants
+   to override is the "a static rule names one spelling of a capability"
+   class this repository has already paid for several times over, and it would
+   go stale the first time layer 1 colours something new. filter applies to
+   an element AND its whole subtree whatever properties that subtree sets, so
+   a descendant added later is covered by construction. styles.test.ts pins
+   both halves: that layer 1 really does colour its own descendants, and that
+   this rule is not a bare color. */
+.ig-reevaluate[data-order='held'] .ig-viewer {
+  filter: grayscale(1);
+}
+
+.ig-order-computing {
+  margin: 0;
+  color: var(--ig-text-muted);
+  font-size: var(--ig-font-size-small);
+}
+
+.ig-change-summary {
+  display: flex;
+  gap: var(--ig-space);
+  align-items: baseline;
+  flex-wrap: wrap;
+}
+
+.ig-change-line {
+  display: flex;
+  align-items: baseline;
+}
+
+.ig-change-parts {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-wrap: wrap;
+  /* The blast radius reads as ONE line. The gap is the separator, so no
+     punctuation glyph is baked into the markup — that would be a second
+     language choice on top of the words themselves. */
+  gap: var(--ig-space);
+}
+
+.ig-change-part {
+  display: flex;
+  gap: var(--ig-space-tight);
+  align-items: baseline;
+}
+
+.ig-change-count {
+  font-family: var(--ig-font-mono);
+  color: var(--ig-text);
+}
+
+.ig-change-word {
+  color: var(--ig-text-body);
+}
+
+.ig-change-unchanged {
+  margin: 0;
+  color: var(--ig-text-body);
+}
+
+.ig-change-dismiss {
+  align-self: flex-start;
+  background: var(--ig-surface-2);
+  color: var(--ig-text-body);
+  border: var(--ig-stroke) solid var(--ig-line);
+  border-radius: var(--ig-radius);
+  padding: var(--ig-space-tight) var(--ig-space);
+  font-family: var(--ig-font-ui);
+  font-size: var(--ig-font-size-small);
+  cursor: pointer;
+}
+
+.ig-change-dismiss:focus-visible {
+  outline: var(--ig-focus-ring) solid var(--ig-focus);
+  outline-offset: var(--ig-space-tight);
+}
+
+.ig-delta-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: var(--ig-space-tight);
+}
+
+.ig-delta-chip {
+  display: flex;
+  gap: var(--ig-space-tight);
+  align-items: baseline;
+  border: var(--ig-stroke) solid var(--ig-line);
+  border-radius: var(--ig-radius);
+  padding: var(--ig-space-tight);
+  background: var(--ig-surface-2);
+}
+
+.ig-delta-member {
+  display: flex;
+  gap: var(--ig-space-tight);
+  align-items: baseline;
+}
+
+.ig-delta-key,
+.ig-delta-ref {
+  font-family: var(--ig-font-mono);
+  color: var(--ig-text-muted);
+}
+
+/* The count and its word are adjacent spans with no text between them, so
+   without this they render as 2up. Same reason .ig-change-part has one. */
+.ig-delta-move {
+  display: flex;
+  gap: var(--ig-space-tight);
+  align-items: baseline;
+}
+
+.ig-delta-move[data-direction='up'] .ig-change-count {
+  color: var(--ig-station-ready);
+}
+
+.ig-delta-move[data-direction='down'] .ig-change-count {
+  color: var(--ig-text-muted);
+}
+
+.ig-delta-readiness[data-readiness='promoted'] {
+  color: var(--ig-station-ready);
+}
+
+.ig-delta-readiness[data-readiness='newly-held'] {
+  color: var(--ig-station-held);
+}
+
+.ig-delta-presence {
+  color: var(--ig-text-muted);
+}
+`;
+//# sourceMappingURL=styles.js.map

package/dist/reevaluate/styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.js","sourceRoot":"","sources":["../../src/reevaluate/styles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,MAAM,CAAC,MAAM,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8JnC,CAAC"}