@issuegraph/editor 0.1.0

package/dist/overlay/render.js

@@ -0,0 +1,439 @@
+/**
+ * The overlay grammar, attached to a viewer scene.
+ *
+ * ## The constraint this module is shaped by
+ *
+ * Layer 2 does not know where an edge is. `index.ts` records the `together-with`
+ * connector as *the one declared crossing* precisely because "only the layer
+ * that computes the layout knows where its endpoints are", and that argument
+ * binds anything that needs a position — an arrowhead, a chip on a node, a
+ * sentence beside a line.
+ *
+ * So this module draws every treatment that can be stated WITHOUT a position,
+ * and declares the rest as marks for whoever owns the layout.
+ *
+ * ## The line, and it was drawn by evidence rather than by taste
+ *
+ * **An overlay that REUSES the path's own position can be drawn here. One that
+ * needs a NEW position cannot.**
+ *
+ * A halo is the path again, stroked wider. A marching or dotted ghost is the
+ * path again, patterned differently. Neither moves, so neither needs to know
+ * where the path goes, and cloning a solved `d` is enough.
+ *
+ * A conflict's second version is the case that looks identical and is not: it
+ * has to sit BESIDE the line, and "beside" is the path's perpendicular — which
+ * cannot be recovered from a `d` this layer does not interpret. Four review
+ * rounds each found a different way that goes wrong: three strokes where a pair
+ * was promised, a companion hidden underneath its twin, a companion that had
+ * lost the relationship's own double-line shape, and finally a vertical offset
+ * sliding ALONG a `together-with` connector that happens to run vertically —
+ * `connectorPath` emits exactly that whenever the two boxes are equal width.
+ *
+ * Each fix was correct and the next round found the next property, because the
+ * missing thing was never a property: it was the geometry. So the companion is
+ * no longer drawn here at all. It travels as the `second-version` mark, placed
+ * by the layer that computed the layout — the same treatment `node-chip`,
+ * `terminal-cross` and `inline-reason` already get, and the same argument
+ * `index.ts` makes for the `together-with` connector living in the viewer.
+ *
+ * What is left genuinely cannot be drawn here: `node-chip` sits on two nodes,
+ * `terminal-cross` and `inline-reason` need the line's end, and
+ * `second-version` needs its perpendicular. Those travel as
+ * {@link EdgeOverlay.marks} for the composer to place, declared rather than
+ * half-drawn here.
+ *
+ * ## How an edge is recognised
+ *
+ * Viewer edge paths publish no per-edge identity — only the `together-with`
+ * connector carries one — so an edge is matched by the accessible name the
+ * viewer gives it: `${from} ${treatment.label} ${to}`.
+ *
+ * The label is read from the viewer's OWN `treatmentFor`, never from a copy, so
+ * a renamed relationship moves both sides at once. What stays local is the
+ * SHAPE of that sentence, and a shape cannot be imported — so `render.test.ts`
+ * pins it with a positive control that attaches to a real rendered scene. If
+ * the viewer restyles its label, that control goes red rather than the overlays
+ * silently ceasing to attach, which is the failure mode worth buying a test.
+ *
+ * Publishing an identity on edge paths would be better and is deliberately NOT
+ * done here: `keyAt` reads `GROUP_ATTRIBUTE` as POINTER identity, so adding one
+ * would change what a click on an edge means. That belongs to the leaf that
+ * owns edge selection, not to a grammar.
+ *
+ * ## Attach to a freshly rendered scene, never to your own output
+ *
+ * The consequence of matching on the accessible name is that overlaying REWRITES
+ * that name — the states are announced there — so an overlaid edge no longer
+ * matches. A host renders a new scene on every state change and attaches to
+ * that, which is the intended shape and is why this is a boundary rather than a
+ * defect.
+ *
+ * Attaching to an already-overlaid scene is out of contract. It fails SAFELY
+ * rather than silently: nothing matches, the scene keeps the overlays it
+ * already had, and every edge is reported in {@link AttachResult.unattached}.
+ * `render.test.ts` pins that, so the behaviour is a decision rather than an
+ * accident. What it must never do is double the announcement, and it does not.
+ *
+ * ## No timer
+ *
+ * The marching dash is a CSS animation, which is what §17b asks for. The rule
+ * is that nothing changes STATE on its own — no `setTimeout`, no `setInterval`,
+ * no self-dismissal. A chip persists until the write settles, and a settled
+ * failure persists until the user acts on it.
+ */
+import { element, resolveTheme, treatmentFor, } from '@issuegraph/viewer';
+import { HALO_OPACITY, STATE_ATTRIBUTE, overlayFor, overlayLabel, } from "./grammar.js";
+/** The class every mark this module adds carries, so a host can find them. */
+export const OVERLAY_CLASS = 'ig-overlay';
+/** The class the viewer puts on an edge path. Matched, never written. */
+const EDGE_CLASS = 'ig-edge';
+/** The class the viewer puts on a terminal marker. NEVER matched — see below. */
+const TERMINAL_CLASS = 'ig-terminal';
+/**
+ * The class the viewer puts on a `together-with` connector.
+ *
+ * A `together-with` relationship is NOT drawn as an edge path — `graph.ts:657`
+ * skips it outright, because it shares a rank rather than ordering anything —
+ * so it is drawn as an enclosure plus this connector. Without matching it, one
+ * of the five relationships could never be overlaid at all: every state on a
+ * `together-with` came back `unattached`.
+ */
+const CONNECTOR_CLASS = 'ig-connector';
+/** The attribute the connector publishes its edge identity on. */
+const GROUP_ATTRIBUTE = 'data-ig-group';
+/** The accessible name the viewer gives an edge, reconstructed from its parts. */
+function edgeName(edge) {
+    return `${edge.from} ${treatmentFor(edge.kind).label} ${edge.to}`;
+}
+function classesOf(attrs) {
+    const value = attrs?.['class'];
+    return typeof value === 'string' ? value.split(' ').filter((name) => name !== '') : [];
+}
+function isEdgePath(spec) {
+    const names = classesOf(spec.attrs);
+    return names.includes(EDGE_CLASS) || names.includes(CONNECTOR_CLASS);
+}
+/**
+ * Which overlay this element carries, if any.
+ *
+ * TWO KEYS, AND IDENTITY IS THE BETTER ONE. Every edge mark publishes
+ * `edgeIdentity(field, from, to)` on `data-ig-group`, and that string IS
+ * `StoredEdge.id` — the same function derives both — so `ProjectedEdge.id`
+ * matches it with no new dependency and no reconstruction.
+ *
+ * THE NAME IS A FALLBACK THAT NO LONGER HAS A KNOWN CALLER, and it is kept
+ * rather than deleted for one reason: this package matches against markup layer
+ * 1 owns, and a viewer that has not yet shipped the identity on ordinary edge
+ * paths still renders against this reader. Deleting it would turn a version
+ * skew into silently unattached overlays instead of a working match.
+ */
+function overlayOn(spec, byIdentity, byName) {
+    const group = spec.attrs?.[GROUP_ATTRIBUTE];
+    if (typeof group === 'string') {
+        const overlay = byIdentity.get(group);
+        if (overlay !== undefined)
+            return { key: group, overlay };
+    }
+    const label = spec.attrs?.['aria-label'];
+    if (typeof label === 'string' && classesOf(spec.attrs).includes(EDGE_CLASS)) {
+        const overlay = byName.get(label);
+        if (overlay !== undefined)
+            return { key: label, overlay };
+    }
+    return null;
+}
+/**
+ * The edge's own path, cloned into an overlay stroke.
+ *
+ * Every geometric attribute is carried across untouched and every identifying
+ * one is dropped: an overlay is decoration, so it must not answer to a name,
+ * take focus, or be read out a second time by a screen reader.
+ */
+function clonePath(spec, overrides) {
+    // `data-ig-group` IS CARRIED, and it is the one identifying attribute that
+    // stays — because dropping it would make a clone a DEAD ZONE over its own
+    // edge. A dash clone is drawn in FRONT of the stroke, so it is what a pointer
+    // lands on; with no identity the viewer's walk climbs past it to the canvas
+    // group and reports a click on the edge as a click on nothing, clearing the
+    // very selection the reader was making. The halo behind it widens the target
+    // for the same edge, which is the same answer either way.
+    // It is a POINTER identity and not a focus one — that separation is exactly
+    // why the viewer publishes decoration on this attribute — so a clone still
+    // takes no tab stop, and `aria-hidden` below still keeps it out of the
+    // accessibility tree.
+    const { class: _class, role: _role, 'aria-label': _label, ...geometry } = spec.attrs ?? {};
+    return {
+        tag: spec.tag,
+        ns: spec.ns,
+        attrs: { ...geometry, 'aria-hidden': 'true', ...overrides },
+    };
+}
+/**
+ * The marks that can be drawn from the edge's own path, and nothing else.
+ *
+ * Order matters and is drawn back-to-front: the halo sits BEHIND the edge so it
+ * reads as a glow around the line rather than a second line over it, and the
+ * dash and the conflict's second version sit in front.
+ */
+function overlayMarks(spec, overlay, edge, theme) {
+    const behind = [];
+    const front = [];
+    // EVERY CLONE INHERITS THE TREATMENT, rather than the edge getting it and the
+    // clones being re-specified one property at a time. Six of this PR's review
+    // findings were one class — a clone that did not inherit the hue, the
+    // opacity, the dash, the stroke count or the position of the thing it was
+    // cloned from — and each was fixed on its own until the shape of the mistake
+    // was visible. Deriving it once is what stops the seventh.
+    const inherited = overlay.line?.opacity === null || overlay.line?.opacity === undefined
+        ? {}
+        : { opacity: overlay.line.opacity };
+    if (overlay.halo) {
+        behind.push(clonePath(spec, {
+            ...inherited,
+            class: `${OVERLAY_CLASS} ig-overlay-halo`,
+            // From the grammar, never from the stylesheet — see `HALO_OPACITY`.
+            opacity: HALO_OPACITY,
+            // Widened from the theme's own stroke rather than from a literal, so a
+            // host thickening its lines keeps the halo proportionate to them.
+            'stroke-width': theme.metrics['--ig-stroke'] * 3,
+            'stroke-dasharray': null,
+        }));
+    }
+    const line = overlay.line;
+    if (line !== null && line.dash !== null) {
+        // EVERY dash the table declares, not just the marching one. `invalid` asks
+        // for `dotted` and an earlier draft drew only `marching`, so the dotted
+        // ghost silently never appeared — the table declared a shape channel that
+        // nothing rendered, which is a field that lies rather than a missing case.
+        //
+        // Drawn on a CLONE so the kind's own dash survives underneath: the pattern
+        // is one of the four channels the type identity rests on, and writing
+        // `stroke-dasharray` onto the edge itself would spend it.
+        front.push(clonePath(spec, {
+            ...inherited,
+            class: `${OVERLAY_CLASS} ig-overlay-dash ig-overlay-${line.dash}`,
+            // THE HUE HAS TO BE STATED. The clone drops `class`, so it is no longer
+            // `.ig-edge` and the viewer's `.ig-edge[data-edge=…]` hue rules stop
+            // applying to it — a `currentColor` stroke then resolved to the
+            // inherited body-text grey and painted OVER the edge, collapsing the
+            // hue channel exactly while a write was pending.
+            //
+            // The state's own hue where it has one (a refusal is red), and the
+            // RELATIONSHIP's hue where it does not (a pending write is still a
+            // `blocked-by`). Both are read from their owning table — the viewer's
+            // `treatmentFor` for the kind — never copied.
+            stroke: `var(${line.hueToken ?? treatmentFor(edge.kind).hueToken})`,
+            'stroke-dasharray': null,
+        }));
+    }
+    return { behind, front };
+}
+/**
+ * The attributes the overlay writes onto the edge's own path.
+ *
+ * The name is rebuilt from `base` — the edge's own reconstructed name — rather
+ * than read back off the element. Reading the element makes the function
+ * accumulate: attaching twice produced `… — writing — writing`, because the
+ * second pass took the first pass's output as its starting point. Deriving it
+ * from the edge every time makes a second attach a no-op, which is what a
+ * caller re-rendering on every state change will do.
+ */
+function edgeAttributes(base, overlay) {
+    const opacity = overlay.line?.opacity;
+    return {
+        [STATE_ATTRIBUTE]: overlay.attribute,
+        // Re-announced, so a reader who cannot see the halo or the ghost still
+        // learns the edge is selected, writing, or refused.
+        'aria-label': overlayLabel(base, overlay),
+        // The table is the single source for this number; the stylesheet
+        // deliberately carries no opacity rule for a state.
+        ...(opacity === null || opacity === undefined ? {} : { opacity }),
+    };
+}
+/**
+ * Walk a spec tree, overlaying every edge an overlay was supplied for.
+ *
+ * Rebuilt rather than mutated: an `ElementSpec` is `readonly` throughout, and a
+ * scene that changed under a host holding a previous one would defeat exactly
+ * the memoisation the viewer canonicalises its state order to enable.
+ */
+function overlayTree(spec, context) {
+    const children = spec.children ?? [];
+    const next = [];
+    for (const child of children) {
+        if (typeof child === 'string') {
+            next.push(child);
+            continue;
+        }
+        // THE TERMINAL IS NEVER TOUCHED, and this is the line that keeps the four
+        // redundant channels alive. An overlay adds marks beside the type's own
+        // dash, terminal, glyph and hue; it never stands in for one. `failed`'s ✕
+        // travels as a MARK for the composer to add beside the terminal, which is
+        // why there is no branch here that would draw over it.
+        if (classesOf(child.attrs).includes(TERMINAL_CLASS)) {
+            next.push(child);
+            continue;
+        }
+        if (!isEdgePath(child)) {
+            next.push(overlayTree(child, context));
+            continue;
+        }
+        // AN EDGE THIS MODULE HAS ALREADY OVERLAID IS NOT OVERLAID AGAIN, and this
+        // is a DELIBERATE refusal now rather than a side effect of the match key.
+        //
+        // It used to be one. The overlay rewrites `aria-label`, and the accessible
+        // name was the ONLY key an ordinary edge path could be matched by — so a
+        // second pass fell through and the scene survived by accident. Edge paths
+        // publish `data-ig-group` now, and an identity is not rewritten by
+        // decoration, so that accident is gone: a second pass would have matched
+        // again and drawn a second halo behind the first.
+        //
+        // Attaching to this module's own output stays OUT of contract — a host
+        // renders a fresh scene and attaches to that. What this pins is that going
+        // out of contract is REPORTED rather than silently corrupting: the element
+        // is left exactly as it is and its key never reaches `attached`, so the
+        // overlay comes back in `unattached` where a host or a test can see it.
+        if (child.attrs?.[STATE_ATTRIBUTE] !== undefined && child.attrs[STATE_ATTRIBUTE] !== null) {
+            next.push(child);
+            continue;
+        }
+        const match = overlayOn(child, context.byIdentity, context.byName);
+        if (match === null || match.overlay.states.length === 0) {
+            next.push(child);
+            continue;
+        }
+        const edge = context.edgeOf.get(match.key);
+        if (edge === undefined) {
+            next.push(child);
+            continue;
+        }
+        context.attached.add(match.key);
+        // PER STROKE, NOT PER EDGE — and this is the class fix, not a preference.
+        //
+        // `serialize-with` is drawn as TWO `.ig-edge` paths, and an earlier
+        // revision drew the stroke-derived marks ONCE for the pair. That is what
+        // produced a single-stroke conflict companion beside a double-stroke
+        // original, and it would have produced a halo around one of two parallel
+        // lines next. Every mark built here is CLONED FROM A STROKE, so it belongs
+        // to that stroke: clone them all and the kind's shape survives for free
+        // instead of being re-derived for each new case.
+        //
+        // The marks that are genuinely per-edge — the chips, the ✕, the reason —
+        // are not built here at all. They need a position this layer does not have,
+        // so they travel as declared marks and are placed once by the composer.
+        const { behind, front } = overlayMarks(child, match.overlay, edge, context.theme);
+        next.push(...behind, { ...child, attrs: { ...child.attrs, ...edgeAttributes(edgeName(edge), match.overlay) } }, ...front);
+    }
+    return { ...spec, children: next };
+}
+/**
+ * Overlay a scene's edges with the states their projection carries.
+ *
+ * Takes `ProjectedEdge`s rather than resolved overlays because an edge's kind
+ * and endpoints are what identify it in the scene, and asking a caller to hand
+ * those over separately is asking it to keep two things in step.
+ */
+export function attachEdgeOverlays(scene, edges, options = {}) {
+    const theme = resolveTheme(options.theme);
+    const overlays = edges.map(overlayFor);
+    const byIdentity = new Map();
+    const byName = new Map();
+    const edgeOf = new Map();
+    for (const [index, overlay] of overlays.entries()) {
+        const edge = edges[index];
+        if (edge === undefined || overlay.states.length === 0)
+            continue;
+        byIdentity.set(edge.id, overlay);
+        edgeOf.set(edge.id, edge);
+        const name = edgeName(edge);
+        byName.set(name, overlay);
+        edgeOf.set(name, edge);
+    }
+    const attached = new Set();
+    const context = {
+        byIdentity,
+        byName,
+        edgeOf,
+        attached,
+        theme,
+    };
+    const root = overlayTree(scene.root, context);
+    // REPORTED, NOT DROPPED. An overlay whose edge the scene does not draw is
+    // ordinary — the graph projection has a node budget and falls back to
+    // clusters — but it is also what a broken match looks like, and the two must
+    // not be indistinguishable. A host can surface it; a test can pin it.
+    //
+    // Either key counts: a `together-with` is only ever drawn as a connector, so
+    // it matches by identity and never by name.
+    const unattached = overlays.filter((overlay, index) => {
+        const edge = edges[index];
+        if (edge === undefined || overlay.states.length === 0)
+            return false;
+        return !attached.has(edge.id) && !attached.has(edgeName(edge));
+    });
+    return { scene: { ...scene, root }, overlays, unattached };
+}
+/**
+ * The `writing…`, `retry` and reason marks, as controls a host can dispatch.
+ *
+ * Positioned by whoever calls it — see the module note. It renders the control,
+ * publishing what it does as data on `data-ig-overlay`, the same contract
+ * `scale/render.ts` established: layer 2 publishes the control, and the mount
+ * that owns the state wires it.
+ *
+ * The reason mark carries the store's `InvalidCode` and NO sentence. A host
+ * keys its own message off the code, for the same reason `change.ts` ships
+ * counts rather than prose.
+ */
+export function renderOverlayMark(overlay, mark, reasonCode) {
+    switch (mark) {
+        case 'node-chip':
+            return element('span', { class: `${OVERLAY_CLASS} ig-overlay-chip`, 'data-ig-overlay': 'writing' }, 
+            // The one word this package renders, and it is a STATE name rather than
+            // a message — the same thing `grammar.ts` already announces to a screen
+            // reader, so a host that translates translates one vocabulary.
+            ['writing…']);
+        case 'terminal-cross':
+            return element('span', {
+                class: `${OVERLAY_CLASS} ig-overlay-cross`,
+                'data-ig-overlay': 'failed',
+                role: 'img',
+                'aria-label': 'failed',
+            }, 
+            // THE GLYPH IS THE MARK. An earlier draft returned this span EMPTY,
+            // carrying colour and typography and no shape — so `failed` lost the
+            // one cue that separates it from `invalid` without colour, which is the
+            // whole reason a terminal mark is drawn rather than a hue changed.
+            //
+            // A glyph rather than a word, for the same reason the viewer's edge
+            // vocabulary uses ⊘ ⇄ ⧉ ≡ ⑃: it is the non-colour channel, and it needs
+            // no translation.
+            ['✕']);
+        case 'inline-reason':
+            // A SLOT, NOT A GLYPH — and the distinction is deliberate rather than an
+            // oversight of the same class as the empty ✕ above. This element is
+            // EMPTY because the sentence is the host's: the package publishes the
+            // store's stable `InvalidCode` and the host keys its own message off it,
+            // exactly as `change.ts` ships counts rather than prose. `data-ig-slot`
+            // says so out loud, so an empty element here reads as intended rather
+            // than as the bug it looked like one case up.
+            return element('span', {
+                class: `${OVERLAY_CLASS} ig-overlay-reason`,
+                'data-ig-overlay': 'reason',
+                'data-ig-slot': 'reason',
+                'data-ig-code': reasonCode ?? null,
+            });
+        case 'second-version':
+            // Also a slot. The held version is DRAWN by `attachEdgeOverlays` as the
+            // companion stroke; what a host adds here is whatever labels or offers to
+            // act on it — view-diff, retry-on-latest, discard-mine. Never a merge.
+            return element('span', {
+                class: `${OVERLAY_CLASS} ig-overlay-held`,
+                'data-ig-overlay': 'conflict',
+                'data-ig-slot': 'held-version',
+                'aria-label': overlayLabel('', overlay).trim(),
+            });
+    }
+}
+//# sourceMappingURL=render.js.map

package/dist/overlay/render.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.js","sourceRoot":"","sources":["../../src/overlay/render.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG;AAGH,OAAO,EAML,OAAO,EACP,YAAY,EACZ,YAAY,GACb,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,YAAY,EACZ,eAAe,EAEf,UAAU,EACV,YAAY,GACb,MAAM,cAAc,CAAC;AAEtB,8EAA8E;AAC9E,MAAM,CAAC,MAAM,aAAa,GAAG,YAAY,CAAC;AAE1C,yEAAyE;AACzE,MAAM,UAAU,GAAG,SAAS,CAAC;AAE7B,iFAAiF;AACjF,MAAM,cAAc,GAAG,aAAa,CAAC;AAErC;;;;;;;;GAQG;AACH,MAAM,eAAe,GAAG,cAAc,CAAC;AAEvC,kEAAkE;AAClE,MAAM,eAAe,GAAG,eAAe,CAAC;AAkBxC,kFAAkF;AAClF,SAAS,QAAQ,CAAC,IAAmB;IACnC,OAAO,GAAG,IAAI,CAAC,IAAI,IAAI,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,EAAE,EAAE,CAAC;AACpE,CAAC;AAED,SAAS,SAAS,CAAC,KAAsD;IACvE,MAAM,KAAK,GAAG,KAAK,EAAE,CAAC,OAAO,CAAC,CAAC;IAC/B,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AACzF,CAAC;AAED,SAAS,UAAU,CAAC,IAAiB;IACnC,MAAM,KAAK,GAAG,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACpC,OAAO,KAAK,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC;AACvE,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAS,SAAS,CAChB,IAAiB,EACjB,UAA4C,EAC5C,MAAwC;IAExC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,eAAe,CAAC,CAAC;IAC5C,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACtC,IAAI,OAAO,KAAK,SAAS;YAAE,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;IAC5D,CAAC;IACD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,YAAY,CAAC,CAAC;IACzC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;QAC5E,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAClC,IAAI,OAAO,KAAK,SAAS;YAAE,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;IAC5D,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;GAMG;AACH,SAAS,SAAS,CAAC,IAAiB,EAAE,SAA8C;IAClF,2EAA2E;IAC3E,0EAA0E;IAC1E,8EAA8E;IAC9E,4EAA4E;IAC5E,4EAA4E;IAC5E,6EAA6E;IAC7E,0DAA0D;IAC1D,4EAA4E;IAC5E,2EAA2E;IAC3E,uEAAuE;IACvE,sBAAsB;IACtB,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,QAAQ,EAAE,GAAG,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC;IAC3F,OAAO;QACL,GAAG,EAAE,IAAI,CAAC,GAAG;QACb,EAAE,EAAE,IAAI,CAAC,EAAE;QACX,KAAK,EAAE,EAAE,GAAG,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE;KAC5D,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,SAAS,YAAY,CACnB,IAAiB,EACjB,OAAoB,EACpB,IAAmB,EACnB,KAAY;IAEZ,MAAM,MAAM,GAAkB,EAAE,CAAC;IACjC,MAAM,KAAK,GAAkB,EAAE,CAAC;IAEhC,8EAA8E;IAC9E,4EAA4E;IAC5E,sEAAsE;IACtE,0EAA0E;IAC1E,6EAA6E;IAC7E,2DAA2D;IAC3D,MAAM,SAAS,GACb,OAAO,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,IAAI,OAAO,CAAC,IAAI,EAAE,OAAO,KAAK,SAAS;QACnE,CAAC,CAAC,EAAE;QACJ,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;IAExC,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;QACjB,MAAM,CAAC,IAAI,CACT,SAAS,CAAC,IAAI,EAAE;YACd,GAAG,SAAS;YACZ,KAAK,EAAE,GAAG,aAAa,kBAAkB;YACzC,oEAAoE;YACpE,OAAO,EAAE,YAAY;YACrB,uEAAuE;YACvE,kEAAkE;YAClE,cAAc,EAAE,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,CAAC;YAChD,kBAAkB,EAAE,IAAI;SACzB,CAAC,CACH,CAAC;IACJ,CAAC;IAED,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAC1B,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;QACxC,2EAA2E;QAC3E,wEAAwE;QACxE,0EAA0E;QAC1E,2EAA2E;QAC3E,EAAE;QACF,2EAA2E;QAC3E,sEAAsE;QACtE,0DAA0D;QAC1D,KAAK,CAAC,IAAI,CACR,SAAS,CAAC,IAAI,EAAE;YACd,GAAG,SAAS;YACZ,KAAK,EAAE,GAAG,aAAa,+BAA+B,IAAI,CAAC,IAAI,EAAE;YACjE,wEAAwE;YACxE,qEAAqE;YACrE,gEAAgE;YAChE,qEAAqE;YACrE,iDAAiD;YACjD,EAAE;YACF,mEAAmE;YACnE,mEAAmE;YACnE,sEAAsE;YACtE,8CAA8C;YAC9C,MAAM,EAAE,OAAO,IAAI,CAAC,QAAQ,IAAI,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,QAAQ,GAAG;YACnE,kBAAkB,EAAE,IAAI;SACzB,CAAC,CACH,CAAC;IACJ,CAAC;IAED,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;AAC3B,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,cAAc,CAAC,IAAY,EAAE,OAAoB;IACxD,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC;IACtC,OAAO;QACL,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC,SAAS;QACpC,uEAAuE;QACvE,oDAAoD;QACpD,YAAY,EAAE,YAAY,CAAC,IAAI,EAAE,OAAO,CAAC;QACzC,iEAAiE;QACjE,oDAAoD;QACpD,GAAG,CAAC,OAAO,KAAK,IAAI,IAAI,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC;KAClE,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,SAAS,WAAW,CAClB,IAAiB,EACjB,OAAuB;IAEvB,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,IAAI,EAAE,CAAC;IACrC,MAAM,IAAI,GAAgB,EAAE,CAAC;IAE7B,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;QAC7B,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC9B,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACjB,SAAS;QACX,CAAC;QAED,0EAA0E;QAC1E,wEAAwE;QACxE,0EAA0E;QAC1E,0EAA0E;QAC1E,uDAAuD;QACvD,IAAI,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC;YACpD,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACjB,SAAS;QACX,CAAC;QAED,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;YACvB,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC;YACvC,SAAS;QACX,CAAC;QAED,2EAA2E;QAC3E,0EAA0E;QAC1E,EAAE;QACF,2EAA2E;QAC3E,yEAAyE;QACzE,0EAA0E;QAC1E,mEAAmE;QACnE,yEAAyE;QACzE,kDAAkD;QAClD,EAAE;QACF,uEAAuE;QACvE,2EAA2E;QAC3E,2EAA2E;QAC3E,wEAAwE;QACxE,wEAAwE;QACxE,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC,eAAe,CAAC,KAAK,SAAS,IAAI,KAAK,CAAC,KAAK,CAAC,eAAe,CAAC,KAAK,IAAI,EAAE,CAAC;YAC1F,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACjB,SAAS;QACX,CAAC;QAED,MAAM,KAAK,GAAG,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,UAAU,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;QACnE,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACxD,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACjB,SAAS;QACX,CAAC;QAED,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC3C,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACjB,SAAS;QACX,CAAC;QACD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAEhC,0EAA0E;QAC1E,EAAE;QACF,oEAAoE;QACpE,yEAAyE;QACzE,qEAAqE;QACrE,yEAAyE;QACzE,2EAA2E;QAC3E,wEAAwE;QACxE,iDAAiD;QACjD,EAAE;QACF,yEAAyE;QACzE,4EAA4E;QAC5E,wEAAwE;QACxE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,YAAY,CAAC,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;QAElF,IAAI,CAAC,IAAI,CACP,GAAG,MAAM,EACT,EAAE,GAAG,KAAK,EAAE,KAAK,EAAE,EAAE,GAAG,KAAK,CAAC,KAAK,EAAE,GAAG,cAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,EAAE,EAAE,EACzF,GAAG,KAAK,CACT,CAAC;IACJ,CAAC;IAED,OAAO,EAAE,GAAG,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;AACrC,CAAC;AAYD;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAChC,KAAY,EACZ,KAA+B,EAC/B,UAA0B,EAAE;IAE5B,MAAM,KAAK,GAAG,YAAY,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAC1C,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAEvC,MAAM,UAAU,GAAG,IAAI,GAAG,EAAuB,CAAC;IAClD,MAAM,MAAM,GAAG,IAAI,GAAG,EAAuB,CAAC;IAC9C,MAAM,MAAM,GAAG,IAAI,GAAG,EAAyB,CAAC;IAChD,KAAK,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAC;QAClD,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;QAC1B,IAAI,IAAI,KAAK,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC;YAAE,SAAS;QAChE,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;QACjC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;QAC1B,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;QAC5B,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QAC1B,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACzB,CAAC;IAED,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAU,CAAC;IACnC,MAAM,OAAO,GAAmB;QAC9B,UAAU;QACV,MAAM;QACN,MAAM;QACN,QAAQ;QACR,KAAK;KACN,CAAC;IACF,MAAM,IAAI,GAAG,WAAW,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAE9C,0EAA0E;IAC1E,sEAAsE;IACtE,6EAA6E;IAC7E,sEAAsE;IACtE,EAAE;IACF,6EAA6E;IAC7E,4CAA4C;IAC5C,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE;QACpD,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;QAC1B,IAAI,IAAI,KAAK,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;QACpE,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;IACjE,CAAC,CAAC,CAAC;IAEH,OAAO,EAAE,KAAK,EAAE,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC;AAC7D,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,iBAAiB,CAC/B,OAAoB,EACpB,IAAkC,EAClC,UAAmB;IAEnB,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,WAAW;YACd,OAAO,OAAO,CACZ,MAAM,EACN,EAAE,KAAK,EAAE,GAAG,aAAa,kBAAkB,EAAE,iBAAiB,EAAE,SAAS,EAAE;YAC3E,wEAAwE;YACxE,wEAAwE;YACxE,+DAA+D;YAC/D,CAAC,UAAU,CAAC,CACb,CAAC;QACJ,KAAK,gBAAgB;YACnB,OAAO,OAAO,CACZ,MAAM,EACN;gBACE,KAAK,EAAE,GAAG,aAAa,mBAAmB;gBAC1C,iBAAiB,EAAE,QAAQ;gBAC3B,IAAI,EAAE,KAAK;gBACX,YAAY,EAAE,QAAQ;aACvB;YACD,oEAAoE;YACpE,qEAAqE;YACrE,wEAAwE;YACxE,mEAAmE;YACnE,EAAE;YACF,oEAAoE;YACpE,wEAAwE;YACxE,kBAAkB;YAClB,CAAC,GAAG,CAAC,CACN,CAAC;QACJ,KAAK,eAAe;YAClB,yEAAyE;YACzE,oEAAoE;YACpE,sEAAsE;YACtE,yEAAyE;YACzE,wEAAwE;YACxE,sEAAsE;YACtE,8CAA8C;YAC9C,OAAO,OAAO,CAAC,MAAM,EAAE;gBACrB,KAAK,EAAE,GAAG,aAAa,oBAAoB;gBAC3C,iBAAiB,EAAE,QAAQ;gBAC3B,cAAc,EAAE,QAAQ;gBACxB,cAAc,EAAE,UAAU,IAAI,IAAI;aACnC,CAAC,CAAC;QACL,KAAK,gBAAgB;YACnB,wEAAwE;YACxE,0EAA0E;YAC1E,uEAAuE;YACvE,OAAO,OAAO,CAAC,MAAM,EAAE;gBACrB,KAAK,EAAE,GAAG,aAAa,kBAAkB;gBACzC,iBAAiB,EAAE,UAAU;gBAC7B,cAAc,EAAE,cAAc;gBAC9B,YAAY,EAAE,YAAY,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC,IAAI,EAAE;aAC/C,CAAC,CAAC;IACP,CAAC;AACH,CAAC"}

package/dist/overlay/styles.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The overlay's structural stylesheet.
+ *
+ * Same contract as the ladder's and the viewer's: layout, weight and state,
+ * never a value. Every colour, length and duration here is a `var(--ig-…)` the
+ * host's theme resolves, so a second theme keeps working on the surfaces layer
+ * 2 adds. `styles.test.ts` scans these bytes for a literal colour, a fixed
+ * length and a token the theme does not define.
+ *
+ * IT DECLARES NO OPACITY AT ALL. `grammar.ts` is the single source for every
+ * alpha this package applies, and `render.ts` writes each onto its element —
+ * so there is deliberately no `opacity` rule here, for a state OR for a mark.
+ *
+ * That rule was written for the state opacities and then broken by the halo,
+ * which was styled here at 0.35 because it is not a state. The composited
+ * contrast check reads the grammar, so the one alpha it could not see was the
+ * one that failed the 3:1 bar. `styles.test.ts` now enforces the rule instead
+ * of stating it. A rule would be a
+ * second copy of a number, and the two would drift the first time one was
+ * tuned. What CSS owns is what CSS can express and the table cannot: the halo's
+ * stroke, the marching animation, and the hue each state paints with.
+ *
+ * IT SELECTS ONLY WHAT THIS PACKAGE ADDS. In particular it never selects
+ * `.ig-terminal`: the terminal marker is one of the four redundant channels the
+ * edge's type identity rests on, and a rule here could occlude it as surely as
+ * a mark could. The four survive because nothing in this file reaches them.
+ *
+ * ## The marching dash, and why it is not a timer
+ *
+ * `pending-write` animates `stroke-dashoffset`, which is the design's "marching
+ * dash". Nothing about it changes STATE: the animation runs while the edge is
+ * pending and stops when the projection stops saying so. A chip that dismissed
+ * itself would be the banned thing, and there is none.
+ *
+ * It is written under `prefers-reduced-motion` guard, because a reader who has
+ * asked for less motion still needs to know a write is in flight — the opacity
+ * and the dash pattern carry that on their own, so the movement is what drops
+ * rather than the signal.
+ */
+export declare const edgeOverlayStylesheet = "\n.ig-overlay {\n  pointer-events: none;\n}\n\n.ig-overlay-halo {\n  fill: none;\n  stroke: var(--ig-focus);\n  stroke-linecap: round;\n}\n\n/* The stroke is set per element from the treatment table \u2014 a state's own hue\n   where it has one, the relationship's where it does not \u2014 for the same reason\n   the viewer sets its dash per element: one source for a channel. */\n.ig-overlay-dash {\n  fill: none;\n}\n\n.ig-overlay-marching {\n  stroke-dasharray: 4 4;\n  animation: ig-overlay-march 1s linear infinite;\n}\n\n.ig-overlay-dotted {\n  stroke-dasharray: 1 3;\n}\n\n@keyframes ig-overlay-march {\n  to {\n    stroke-dashoffset: -8;\n  }\n}\n\n@media (prefers-reduced-motion: reduce) {\n  .ig-overlay-marching {\n    animation: none;\n  }\n}\n\n/* NOT prefixed with the edge class. A together-with relationship is drawn as a\n   connector rather than an edge path, so an edge-anchored rule left one of the\n   five relationships unstyled in every state. Only an overlaid element carries\n   the attribute at all, so the bare selector reaches exactly the intended set.\n   (No backticks in here: this is inside a template literal, and one ends it.) */\n[data-ig-state~='invalid'] {\n  stroke: var(--ig-state-invalid);\n}\n\n[data-ig-state~='failed'] {\n  stroke: var(--ig-state-failed);\n}\n\n[data-ig-state~='conflict'] {\n  stroke: var(--ig-state-conflict);\n}\n\n.ig-overlay-chip {\n  background: var(--ig-surface-2);\n  color: var(--ig-text-muted);\n  border: var(--ig-stroke) solid var(--ig-line);\n  border-radius: var(--ig-radius);\n  padding: var(--ig-space-tight);\n  font-family: var(--ig-font-ui);\n  font-size: var(--ig-font-size-small);\n}\n\n.ig-overlay-cross {\n  color: var(--ig-state-failed);\n  font-family: var(--ig-font-ui);\n  font-size: var(--ig-font-size);\n}\n\n.ig-overlay-reason {\n  color: var(--ig-state-invalid);\n  font-family: var(--ig-font-ui);\n  font-size: var(--ig-font-size-small);\n}\n\n.ig-overlay-held {\n  color: var(--ig-state-conflict);\n  font-family: var(--ig-font-ui);\n  font-size: var(--ig-font-size-small);\n}\n";
+//# sourceMappingURL=styles.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../src/overlay/styles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,eAAO,MAAM,qBAAqB,6hEAmFjC,CAAC"}

package/dist/overlay/styles.js

@@ -0,0 +1,124 @@
+/**
+ * The overlay's structural stylesheet.
+ *
+ * Same contract as the ladder's and the viewer's: layout, weight and state,
+ * never a value. Every colour, length and duration here is a `var(--ig-…)` the
+ * host's theme resolves, so a second theme keeps working on the surfaces layer
+ * 2 adds. `styles.test.ts` scans these bytes for a literal colour, a fixed
+ * length and a token the theme does not define.
+ *
+ * IT DECLARES NO OPACITY AT ALL. `grammar.ts` is the single source for every
+ * alpha this package applies, and `render.ts` writes each onto its element —
+ * so there is deliberately no `opacity` rule here, for a state OR for a mark.
+ *
+ * That rule was written for the state opacities and then broken by the halo,
+ * which was styled here at 0.35 because it is not a state. The composited
+ * contrast check reads the grammar, so the one alpha it could not see was the
+ * one that failed the 3:1 bar. `styles.test.ts` now enforces the rule instead
+ * of stating it. A rule would be a
+ * second copy of a number, and the two would drift the first time one was
+ * tuned. What CSS owns is what CSS can express and the table cannot: the halo's
+ * stroke, the marching animation, and the hue each state paints with.
+ *
+ * IT SELECTS ONLY WHAT THIS PACKAGE ADDS. In particular it never selects
+ * `.ig-terminal`: the terminal marker is one of the four redundant channels the
+ * edge's type identity rests on, and a rule here could occlude it as surely as
+ * a mark could. The four survive because nothing in this file reaches them.
+ *
+ * ## The marching dash, and why it is not a timer
+ *
+ * `pending-write` animates `stroke-dashoffset`, which is the design's "marching
+ * dash". Nothing about it changes STATE: the animation runs while the edge is
+ * pending and stops when the projection stops saying so. A chip that dismissed
+ * itself would be the banned thing, and there is none.
+ *
+ * It is written under `prefers-reduced-motion` guard, because a reader who has
+ * asked for less motion still needs to know a write is in flight — the opacity
+ * and the dash pattern carry that on their own, so the movement is what drops
+ * rather than the signal.
+ */
+export const edgeOverlayStylesheet = `
+.ig-overlay {
+  pointer-events: none;
+}
+
+.ig-overlay-halo {
+  fill: none;
+  stroke: var(--ig-focus);
+  stroke-linecap: round;
+}
+
+/* The stroke is set per element from the treatment table — a state's own hue
+   where it has one, the relationship's where it does not — for the same reason
+   the viewer sets its dash per element: one source for a channel. */
+.ig-overlay-dash {
+  fill: none;
+}
+
+.ig-overlay-marching {
+  stroke-dasharray: 4 4;
+  animation: ig-overlay-march 1s linear infinite;
+}
+
+.ig-overlay-dotted {
+  stroke-dasharray: 1 3;
+}
+
+@keyframes ig-overlay-march {
+  to {
+    stroke-dashoffset: -8;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .ig-overlay-marching {
+    animation: none;
+  }
+}
+
+/* NOT prefixed with the edge class. A together-with relationship is drawn as a
+   connector rather than an edge path, so an edge-anchored rule left one of the
+   five relationships unstyled in every state. Only an overlaid element carries
+   the attribute at all, so the bare selector reaches exactly the intended set.
+   (No backticks in here: this is inside a template literal, and one ends it.) */
+[data-ig-state~='invalid'] {
+  stroke: var(--ig-state-invalid);
+}
+
+[data-ig-state~='failed'] {
+  stroke: var(--ig-state-failed);
+}
+
+[data-ig-state~='conflict'] {
+  stroke: var(--ig-state-conflict);
+}
+
+.ig-overlay-chip {
+  background: var(--ig-surface-2);
+  color: var(--ig-text-muted);
+  border: var(--ig-stroke) solid var(--ig-line);
+  border-radius: var(--ig-radius);
+  padding: var(--ig-space-tight);
+  font-family: var(--ig-font-ui);
+  font-size: var(--ig-font-size-small);
+}
+
+.ig-overlay-cross {
+  color: var(--ig-state-failed);
+  font-family: var(--ig-font-ui);
+  font-size: var(--ig-font-size);
+}
+
+.ig-overlay-reason {
+  color: var(--ig-state-invalid);
+  font-family: var(--ig-font-ui);
+  font-size: var(--ig-font-size-small);
+}
+
+.ig-overlay-held {
+  color: var(--ig-state-conflict);
+  font-family: var(--ig-font-ui);
+  font-size: var(--ig-font-size-small);
+}
+`;
+//# sourceMappingURL=styles.js.map

package/dist/overlay/styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.js","sourceRoot":"","sources":["../../src/overlay/styles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,MAAM,CAAC,MAAM,qBAAqB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmFpC,CAAC"}