@issuegraph/editor 0.4.0 → 0.22.1

package/dist/overlay/request.js

@@ -0,0 +1,129 @@
+/**
+ * The one place a write state becomes a position.
+ *
+ * ## What this module is for
+ *
+ * `attachEdgeOverlays` draws everything an overlay can say by reusing the path's
+ * own position — a halo is the path stroked wider, a ghost is the path dashed
+ * differently. What it cannot draw is the half that needs a NEW position: a chip
+ * on the two nodes, a cross beside the terminal, a reason beside the line, and a
+ * conflict's second version on the line's perpendicular. Those travel as
+ * {@link EdgeOverlay.marks}, declared here rather than half-drawn there.
+ *
+ * Layer 1 places them, because it is the layer that computed the layout. This
+ * module is the translation that lets it do so without learning anything: it
+ * turns each declared mark into an {@link EdgeMark} whose vocabulary is
+ * POSITIONAL, so the viewer receives `companion` and never `conflict`.
+ *
+ * ## The mapping is the seam, so it lives on one table
+ *
+ * One entry per mark the grammar can declare, and the table is exhaustive over
+ * that union rather than a switch with a default — a fifth mark added to the
+ * grammar should fail to compile here, not silently stop being drawn. That is
+ * the failure this whole area has had twice: a channel declared in a table and
+ * rendered by nothing.
+ *
+ * ## The words stay on this side
+ *
+ * `writing…` and `✕` are this package's vocabulary — the same strings
+ * `renderOverlayMark` puts in the host-facing slot — and they are handed over as
+ * opaque content. A host that translates translates one vocabulary, and the
+ * viewer never holds a word it could be asked to translate.
+ *
+ * The hue travels as a token NAME, read from the treatment table rather than
+ * copied, so a retheme moves the mark and the stroke together. Where a state has
+ * no hue of its own this asks for NONE, and layer 1 fills in the relationship's.
+ *
+ * That last clause used to say the mark "inherits the relationship's — which is
+ * the same rule the dashed clone follows", and both halves were wrong. A mark is
+ * a SIBLING of the edge, so it inherits the viewer's body text and not the hue
+ * `.ig-edge[data-edge=…]` gives the line; and the dashed clone does not inherit
+ * either — `render.ts` states its stroke inline for exactly that reason, in a
+ * comment about exactly this trap. A `pending-write` chip therefore rendered
+ * grey beside the red line it belonged to.
+ *
+ * So "no tone" is a REQUEST for the kind's hue rather than a decision to have
+ * none, and the layer that owns the relationship vocabulary is the one that
+ * resolves it.
+ */
+import { OVERLAY_TREATMENTS, overlayFor, } from "./grammar.js";
+/**
+ * Where each declared mark goes, and what it says when it gets there.
+ *
+ * `glyph` is `null` for a mark whose whole form is the line — a companion is not
+ * a symbol, it is the relationship drawn a second time.
+ */
+const MARK_PLACEMENTS = Object.freeze({
+    // §17b: "writing… chip on both nodes". Both, not one — an optimistic edit is
+    // in flight at both ends of what it joins, and a single chip reads as a
+    // property of whichever end happened to get it.
+    'node-chip': { placement: 'both-ends', glyph: 'writing…' },
+    // A glyph rather than a word, for the reason the edge vocabulary uses glyphs:
+    // it is the non-colour channel, and it needs no translation. `marks.ts` steps
+    // it clear of the terminal marker rather than over it.
+    'terminal-cross': { placement: 'terminal', glyph: '✕' },
+    // THE SENTENCE IS STILL THE HOST'S. What goes on the canvas is the symbol that
+    // says a reason exists and where it belongs; the reason itself is keyed off
+    // the store's `InvalidCode` in the panel, exactly as `renderOverlayMark`'s
+    // slot does. Putting prose on a canvas would also put it outside the rail that
+    // carries every readable thing about this document.
+    'inline-reason': { placement: 'beside', glyph: '!' },
+    'second-version': { placement: 'companion', glyph: null },
+});
+/**
+ * The marks one overlay asks layer 1 to draw.
+ *
+ * Empty for an overlay with no marks, which is most of them: `selected` declares
+ * none at all, and its halo is drawn from the path's own position.
+ */
+export function marksFor(overlay) {
+    const marks = [];
+    for (const mark of overlay.marks) {
+        const spec = MARK_PLACEMENTS[mark];
+        // THE HUE OF THE STATE THAT DECLARED THIS MARK, not of the overlay as a
+        // whole. An edge can be `selected` and `conflict` at once, and the overlay's
+        // own `line` carries whichever won on precedence — so reading the tone from
+        // there would paint a conflict's companion in the focus colour the moment a
+        // reader clicked it.
+        const owner = overlay.states.find((state) => {
+            // Widened at the read, because each entry's `marks` is a literal tuple —
+            // `selected`'s is empty, so an unwidened `includes` takes `never` and the
+            // lookup does not compile.
+            const declared = OVERLAY_TREATMENTS[state].marks;
+            return declared.includes(mark);
+        });
+        const tone = owner === undefined ? null : OVERLAY_TREATMENTS[owner].hueToken;
+        // NO ACCESSIBLE NAME, and there is no longer a field for one. The canvas is
+        // `aria-hidden`, so nothing inside it can carry a name however it is marked
+        // up — and the state is already announced once, on the edge's own
+        // `aria-label`, by `attachEdgeOverlays`. Saying it twice is what the hidden
+        // canvas exists to prevent.
+        marks.push({ placement: spec.placement, glyph: spec.glyph, tone });
+    }
+    return marks;
+}
+/**
+ * Every overlay's marks, keyed the way layer 1 keys its edges.
+ *
+ * `ProjectedEdge.id` is `edgeIdentity(field, from, to)` — the same string the
+ * viewer publishes on `data-ig-group` — so the two sides agree with no
+ * reconstruction and nothing to keep in step.
+ *
+ * An overlay with no marks is left OUT rather than mapped to an empty list: the
+ * absence of a key and a key with nothing under it should not be two ways of
+ * saying the same thing to a reader of this map.
+ */
+export function edgeMarkRequests(edges) {
+    const requests = new Map();
+    // Folded through `overlayFor`, the same function `attachEdgeOverlays` uses, so
+    // the marks drawn and the states announced cannot come from two readings of
+    // one projection.
+    for (const edge of edges) {
+        const marks = marksFor(overlayFor(edge));
+        if (marks.length === 0)
+            continue;
+        requests.set(edge.id, marks);
+    }
+    return requests;
+}
+//# sourceMappingURL=request.js.map

package/dist/overlay/request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.js","sourceRoot":"","sources":["../../src/overlay/request.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAKH,OAAO,EAGL,kBAAkB,EAClB,UAAU,GACX,MAAM,cAAc,CAAC;AAEtB;;;;;GAKG;AACH,MAAM,eAAe,GAEjB,MAAM,CAAC,MAAM,CAAC;IAChB,6EAA6E;IAC7E,wEAAwE;IACxE,gDAAgD;IAChD,WAAW,EAAE,EAAE,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,UAAU,EAAE;IAC1D,8EAA8E;IAC9E,8EAA8E;IAC9E,uDAAuD;IACvD,gBAAgB,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,GAAG,EAAE;IACvD,+EAA+E;IAC/E,4EAA4E;IAC5E,2EAA2E;IAC3E,+EAA+E;IAC/E,oDAAoD;IACpD,eAAe,EAAE,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,EAAE;IACpD,gBAAgB,EAAE,EAAE,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,IAAI,EAAE;CAC1D,CAAC,CAAC;AAEH;;;;;GAKG;AACH,MAAM,UAAU,QAAQ,CAAC,OAAoB;IAC3C,MAAM,KAAK,GAAe,EAAE,CAAC;IAE7B,KAAK,MAAM,IAAI,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;QACjC,MAAM,IAAI,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;QACnC,wEAAwE;QACxE,6EAA6E;QAC7E,4EAA4E;QAC5E,4EAA4E;QAC5E,qBAAqB;QACrB,MAAM,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;YAC1C,yEAAyE;YACzE,0EAA0E;YAC1E,2BAA2B;YAC3B,MAAM,QAAQ,GAA2B,kBAAkB,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC;YACzE,OAAO,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QACjC,CAAC,CAAC,CAAC;QACH,MAAM,IAAI,GAAG,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC;QAC7E,4EAA4E;QAC5E,4EAA4E;QAC5E,kEAAkE;QAClE,4EAA4E;QAC5E,4BAA4B;QAC5B,KAAK,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;IACrE,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,gBAAgB,CAC9B,KAA+B;IAE/B,MAAM,QAAQ,GAAG,IAAI,GAAG,EAA+B,CAAC;IACxD,+EAA+E;IAC/E,4EAA4E;IAC5E,kBAAkB;IAClB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,KAAK,GAAG,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC;QACzC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;YAAE,SAAS;QACjC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;IAC/B,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/overlay/styles.d.ts

@@ -37,5 +37,5 @@
  * 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";
+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/* QUALIFIED, AND THE QUALIFICATION IS THE WHOLE RULE \u2014 it is what makes these\n   three declarations apply at all.\n\n   They used to be bare, and the comment here explained why: a together-with was\n   drawn as a CONNECTOR rather than an edge path, so an edge-anchored rule left\n   one of the five relationships unstyled. Both halves of that have since stopped\n   being true, and nothing noticed either.\n\n   The connector is gone \u2014 layer 1's section-16 pass draws a together unit as ONE\n   card with its members listed inside, so the relationship's whole drawn form is\n   its badge, and the badge rules below are what reach it.\n\n   And the bare selector never painted an edge. A drawn path carries BOTH the edge\n   class with its kind attribute, which the viewer hues at specificity (0,2,0), and\n   the state attribute, which at (0,1,0) loses to it \u2014 and specificity beats source\n   order, so concatenating this sheet last changed nothing. Measured in a browser:\n   a conflicted blocked-by edge computed the relationship's own red, never the\n   state's gold.\n\n   So the bare rules matched exactly two kinds of element and were dead on both.\n   On a path they lost the cascade; on a badge they set a stroke, which a span has\n   no use for.\n\n   invalid was the only state that looked right, and by accident: it is the one\n   settled state carrying a dash, so render.ts builds a CLONE for it, and a clone\n   drops its class \u2014 which is precisely why that file sets the stroke inline on\n   one. The states that build no clone had nothing to fall back on, which is why\n   failed rendered identically to invalid, and conflict identically to a settled\n   edge.\n\n   The kind attribute is carried by every drawn path and by nothing else, so adding\n   it reaches (0,3,0) and wins OUTRIGHT rather than by tying and being placed later.\n   A tie would work today and would break the first time a host reordered the\n   sheets \u2014 and this rule has already failed silently once.\n\n   (No backticks in here: this is inside a template literal, and one ends it.) */\n.ig-edge[data-edge][data-ig-state~='invalid'] {\n  stroke: var(--ig-state-invalid);\n}\n\n.ig-edge[data-edge][data-ig-state~='failed'] {\n  stroke: var(--ig-state-failed);\n}\n\n.ig-edge[data-edge][data-ig-state~='conflict'] {\n  stroke: var(--ig-state-conflict);\n}\n\n/* A BADGE IS NOT A STROKE, AND SOME RELATIONSHIPS ARE ONLY A BADGE.\n   together-with is drawn as no line at all \u2014 it shares a rank rather than\n   ordering anything, and layer 1 draws the unit as one card with its members\n   listed inside \u2014 so the chip that names it is its entire representation. The\n   marks this module clones from a stroke cannot be cloned from a span, and the\n   stroke rules above paint a property a span does not have: an in-flight or\n   refused together-edge therefore read exactly like a settled one, with the\n   state visible only to a screen reader.\n\n   So a chip states the state with what a chip HAS: its border and its ink.\n   Every state the drawn edge distinguishes, distinguished here too \u2014 including\n   the two that have no hue of their own, where a stroke uses a ghost or a halo\n   and a chip uses a dash and the focus ring. */\n.ig-badge[data-ig-state~='invalid'] {\n  border-color: var(--ig-state-invalid);\n  color: var(--ig-state-invalid);\n}\n\n.ig-badge[data-ig-state~='failed'] {\n  border-color: var(--ig-state-failed);\n  color: var(--ig-state-failed);\n}\n\n.ig-badge[data-ig-state~='conflict'] {\n  border-color: var(--ig-state-conflict);\n  color: var(--ig-state-conflict);\n}\n\n/* Pending is the state with no hue: the drawn edge says it with a dashed ghost,\n   and a chip says it with a dashed border of its own. */\n.ig-badge[data-ig-state~='pending-write'] {\n  border-style: dashed;\n}\n\n/* Selected is the focus ring's meaning, and the theme says so where it declares\n   the token \u2014 selected is deliberately not an edit-state hue. */\n.ig-badge[data-ig-state~='selected'] {\n  box-shadow: 0 0 0 var(--ig-stroke) var(--ig-focus);\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

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

package/dist/overlay/styles.js

@@ -76,23 +76,94 @@ export const edgeOverlayStylesheet = `
   }
 }
 
-/* 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.
+/* QUALIFIED, AND THE QUALIFICATION IS THE WHOLE RULE — it is what makes these
+   three declarations apply at all.
+
+   They used to be bare, and the comment here explained why: a together-with was
+   drawn as a CONNECTOR rather than an edge path, so an edge-anchored rule left
+   one of the five relationships unstyled. Both halves of that have since stopped
+   being true, and nothing noticed either.
+
+   The connector is gone — layer 1's section-16 pass draws a together unit as ONE
+   card with its members listed inside, so the relationship's whole drawn form is
+   its badge, and the badge rules below are what reach it.
+
+   And the bare selector never painted an edge. A drawn path carries BOTH the edge
+   class with its kind attribute, which the viewer hues at specificity (0,2,0), and
+   the state attribute, which at (0,1,0) loses to it — and specificity beats source
+   order, so concatenating this sheet last changed nothing. Measured in a browser:
+   a conflicted blocked-by edge computed the relationship's own red, never the
+   state's gold.
+
+   So the bare rules matched exactly two kinds of element and were dead on both.
+   On a path they lost the cascade; on a badge they set a stroke, which a span has
+   no use for.
+
+   invalid was the only state that looked right, and by accident: it is the one
+   settled state carrying a dash, so render.ts builds a CLONE for it, and a clone
+   drops its class — which is precisely why that file sets the stroke inline on
+   one. The states that build no clone had nothing to fall back on, which is why
+   failed rendered identically to invalid, and conflict identically to a settled
+   edge.
+
+   The kind attribute is carried by every drawn path and by nothing else, so adding
+   it reaches (0,3,0) and wins OUTRIGHT rather than by tying and being placed later.
+   A tie would work today and would break the first time a host reordered the
+   sheets — and this rule has already failed silently once.
+
    (No backticks in here: this is inside a template literal, and one ends it.) */
-[data-ig-state~='invalid'] {
+.ig-edge[data-edge][data-ig-state~='invalid'] {
   stroke: var(--ig-state-invalid);
 }
 
-[data-ig-state~='failed'] {
+.ig-edge[data-edge][data-ig-state~='failed'] {
   stroke: var(--ig-state-failed);
 }
 
-[data-ig-state~='conflict'] {
+.ig-edge[data-edge][data-ig-state~='conflict'] {
   stroke: var(--ig-state-conflict);
 }
 
+/* A BADGE IS NOT A STROKE, AND SOME RELATIONSHIPS ARE ONLY A BADGE.
+   together-with is drawn as no line at all — it shares a rank rather than
+   ordering anything, and layer 1 draws the unit as one card with its members
+   listed inside — so the chip that names it is its entire representation. The
+   marks this module clones from a stroke cannot be cloned from a span, and the
+   stroke rules above paint a property a span does not have: an in-flight or
+   refused together-edge therefore read exactly like a settled one, with the
+   state visible only to a screen reader.
+
+   So a chip states the state with what a chip HAS: its border and its ink.
+   Every state the drawn edge distinguishes, distinguished here too — including
+   the two that have no hue of their own, where a stroke uses a ghost or a halo
+   and a chip uses a dash and the focus ring. */
+.ig-badge[data-ig-state~='invalid'] {
+  border-color: var(--ig-state-invalid);
+  color: var(--ig-state-invalid);
+}
+
+.ig-badge[data-ig-state~='failed'] {
+  border-color: var(--ig-state-failed);
+  color: var(--ig-state-failed);
+}
+
+.ig-badge[data-ig-state~='conflict'] {
+  border-color: var(--ig-state-conflict);
+  color: var(--ig-state-conflict);
+}
+
+/* Pending is the state with no hue: the drawn edge says it with a dashed ghost,
+   and a chip says it with a dashed border of its own. */
+.ig-badge[data-ig-state~='pending-write'] {
+  border-style: dashed;
+}
+
+/* Selected is the focus ring's meaning, and the theme says so where it declares
+   the token — selected is deliberately not an edit-state hue. */
+.ig-badge[data-ig-state~='selected'] {
+  box-shadow: 0 0 0 var(--ig-stroke) var(--ig-focus);
+}
+
 .ig-overlay-chip {
   background: var(--ig-surface-2);
   color: var(--ig-text-muted);

package/dist/overlay/styles.js.map

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

package/dist/picker/render.d.ts

@@ -1,5 +1,21 @@
 /**
- * The type picker, the direction statement and the flip control, as markup.
+ * The type picker — the five kinds an edge can be retyped to — as markup.
+ *
+ * ## The direction statement and the flip are NOT here, and once were
+ *
+ * §17b's direction card belongs to the panel that has an edge selected, and
+ * `renderWorkspace` draws it: the relationship row already states the pair and
+ * the kind, and the flip sits at the end of that row where frame 17b draws it.
+ * They lived here because this surface landed first, and a picker composed into
+ * that panel then drew a second statement and a second flip one element from
+ * the first — which is the encoding ambiguity §17b exists to remove, produced by
+ * the surface meant to remove it.
+ *
+ * {@link ./view.ts PickerView} still carries `direction` and `flip`: they are
+ * the MODEL, `reduceHost` builds its proposal from them, and a host that wants
+ * another arrangement renders them itself — `PickerView` carries the ordered
+ * pair and the kind and no word order beyond that, which is what makes such a
+ * host cheap. What moved is the drawing, not the answer.
  *
  * ## Every readable byte comes from the host or from the document
  *
@@ -9,24 +25,18 @@
  * being worded here is a RELATIONSHIP, so a phrase written in would be an
  * English clause in the one place the design says a reader most often gets the
  * encoding wrong. `render.test.ts` enforces it by asserting that every text node
- * is either a {@link ./words.ts PickerWords} entry or an issue reference — a
- * total claim rather than a spot check, so a word added later fails rather than
- * slipping in.
- *
- * ## The default word order is a DEFAULT
+ * is a {@link ./words.ts PickerWords} entry — a total claim rather than a spot
+ * check, so a word added later fails rather than slipping in.
  *
- * The statement is drawn subject · phrase · object, which is a word order and
- * therefore a presentation choice this layer is not entitled to impose. It is
- * offered as the ordinary case and bypassed the same way the re-evaluate
- * summary's is: {@link ./view.ts PickerView} carries the ordered pair and the
- * kind and no order beyond that, so a host that needs another arrangement
- * renders the view model. Nothing here is load-bearing for it.
+ * IT NO LONGER ADMITS AN ISSUE REFERENCE EITHER, and the tightening is the
+ * statement leaving rather than a decision: the two references this surface
+ * used to draw were the statement's. A list of KINDS naming an ISSUE would now
+ * itself be the finding.
  *
  * ## It publishes commands and wires nothing
  *
- * `data-ig-command="retype"` with a `data-ig-kind`, and
- * `data-ig-command="flip"`. Listener wiring, focus and dispatch belong to the
- * mount, exactly as the scale ladder and the re-evaluate surface already defer
+ * `data-ig-command="retype"` with a `data-ig-kind`. Listener wiring, focus and
+ * dispatch belong to the mount, exactly as the scale ladder and the re-evaluate surface already defer
  * them — and the proposal each command stands for is on the view model, so a
  * mount reads it rather than reconstructing it from attributes.
  *
@@ -54,7 +64,7 @@ export interface PickerOptions {
 }
 export interface PickerResult {
     readonly view: PickerView;
-    /** The picker, the statement and the flip control, under one root. */
+    /** The kind list, under one root. */
     readonly markup: string;
     /**
      * The theme and this surface's own stylesheet. Install both.

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

@@ -1 +1 @@
-{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../src/picker/render.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,EAEL,KAAK,KAAK,EAKX,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAE/D,OAAO,EAA4C,KAAK,UAAU,EAAc,MAAM,WAAW,CAAC;AAElG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,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,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,sEAAsE;IACtE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;;;;;;;OASG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC;AAiDD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,aAAa,EACvB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,aAAa,GACrB,YAAY,CAiCd"}
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../src/picker/render.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH,OAAO,EAEL,KAAK,KAAK,EAKX,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAE/D,OAAO,EAAmB,KAAK,UAAU,EAAc,MAAM,WAAW,CAAC;AAEzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,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,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,qCAAqC;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;;;;;;;OASG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC;AAkCD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,aAAa,EACvB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,aAAa,GACrB,YAAY,CAsBd"}

package/dist/picker/render.js

@@ -1,5 +1,21 @@
 /**
- * The type picker, the direction statement and the flip control, as markup.
+ * The type picker — the five kinds an edge can be retyped to — as markup.
+ *
+ * ## The direction statement and the flip are NOT here, and once were
+ *
+ * §17b's direction card belongs to the panel that has an edge selected, and
+ * `renderWorkspace` draws it: the relationship row already states the pair and
+ * the kind, and the flip sits at the end of that row where frame 17b draws it.
+ * They lived here because this surface landed first, and a picker composed into
+ * that panel then drew a second statement and a second flip one element from
+ * the first — which is the encoding ambiguity §17b exists to remove, produced by
+ * the surface meant to remove it.
+ *
+ * {@link ./view.ts PickerView} still carries `direction` and `flip`: they are
+ * the MODEL, `reduceHost` builds its proposal from them, and a host that wants
+ * another arrangement renders them itself — `PickerView` carries the ordered
+ * pair and the kind and no word order beyond that, which is what makes such a
+ * host cheap. What moved is the drawing, not the answer.
  *
  * ## Every readable byte comes from the host or from the document
  *
@@ -9,24 +25,18 @@
  * being worded here is a RELATIONSHIP, so a phrase written in would be an
  * English clause in the one place the design says a reader most often gets the
  * encoding wrong. `render.test.ts` enforces it by asserting that every text node
- * is either a {@link ./words.ts PickerWords} entry or an issue reference — a
- * total claim rather than a spot check, so a word added later fails rather than
- * slipping in.
+ * is a {@link ./words.ts PickerWords} entry — a total claim rather than a spot
+ * check, so a word added later fails rather than slipping in.
  *
- * ## The default word order is a DEFAULT
- *
- * The statement is drawn subject · phrase · object, which is a word order and
- * therefore a presentation choice this layer is not entitled to impose. It is
- * offered as the ordinary case and bypassed the same way the re-evaluate
- * summary's is: {@link ./view.ts PickerView} carries the ordered pair and the
- * kind and no order beyond that, so a host that needs another arrangement
- * renders the view model. Nothing here is load-bearing for it.
+ * IT NO LONGER ADMITS AN ISSUE REFERENCE EITHER, and the tightening is the
+ * statement leaving rather than a decision: the two references this surface
+ * used to draw were the statement's. A list of KINDS naming an ISSUE would now
+ * itself be the finding.
  *
  * ## It publishes commands and wires nothing
  *
- * `data-ig-command="retype"` with a `data-ig-kind`, and
- * `data-ig-command="flip"`. Listener wiring, focus and dispatch belong to the
- * mount, exactly as the scale ladder and the re-evaluate surface already defer
+ * `data-ig-command="retype"` with a `data-ig-kind`. Listener wiring, focus and
+ * dispatch belong to the mount, exactly as the scale ladder and the re-evaluate surface already defer
  * them — and the proposal each command stands for is on the view model, so a
  * mount reads it rather than reconstructing it from attributes.
  *
@@ -64,20 +74,6 @@ function optionSpec(option, words) {
         ]),
     ]);
 }
-/**
- * The direction statement.
- *
- * The two references are the DOCUMENT's, not this package's words, and each
- * carries the role it plays so a host can restyle or reorder them without
- * parsing the sentence back apart.
- */
-function directionSpec(direction, words) {
-    return element('p', { class: 'ig-picker-direction', 'data-ig-kind': direction.kind }, [
-        element('span', { class: 'ig-picker-ref', 'data-ig-role': 'from' }, [direction.from]),
-        element('span', { class: 'ig-picker-phrase' }, [words.kinds[direction.kind]]),
-        element('span', { class: 'ig-picker-ref', 'data-ig-role': 'to' }, [direction.to]),
-    ]);
-}
 /**
  * The picker for one existing edge.
  *
@@ -94,13 +90,6 @@ export function renderPicker(document, edgeId, options) {
         view.options.length === 0
             ? null
             : element('ul', { class: 'ig-picker-kinds', 'aria-label': words.heading }, view.options.map((option) => optionSpec(option, words))),
-        // Symmetric kinds render NEITHER of the next two. The absence is the
-        // finding: a control to reverse a relationship that carries no direction
-        // would claim the format says something it does not.
-        view.direction === null ? null : directionSpec(view.direction, words),
-        view.flip === null
-            ? null
-            : element('button', { type: 'button', class: 'ig-picker-flip', 'data-ig-command': 'flip' }, [words.flip]),
     ]);
     return {
         view,

package/dist/picker/render.js.map

@@ -1 +1 @@
-{"version":3,"file":"render.js","sourceRoot":"","sources":["../../src/picker/render.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"render.js","sourceRoot":"","sources":["../../src/picker/render.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH,OAAO,EAGL,OAAO,EACP,YAAY,EACZ,YAAY,EACZ,QAAQ,GACT,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAAoC,UAAU,EAAE,MAAM,WAAW,CAAC;AACzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAgC/C,gFAAgF;AAChF,SAAS,UAAU,CAAC,MAAkB,EAAE,KAAkB;IACxD,OAAO,OAAO,CACZ,IAAI,EACJ;QACE,KAAK,EAAE,gBAAgB;QACvB,cAAc,EAAE,MAAM,CAAC,IAAI;QAC3B,eAAe,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO;QACnD,cAAc,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO;KAClD,EACD;QACE,OAAO,CACL,QAAQ,EACR;YACE,IAAI,EAAE,QAAQ;YACd,KAAK,EAAE,kBAAkB;YACzB,iBAAiB,EAAE,QAAQ;YAC3B,cAAc,EAAE,MAAM,CAAC,IAAI;YAC3B,oEAAoE;YACpE,kEAAkE;YAClE,kEAAkE;YAClE,cAAc,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO;SAClD,EACD;YACE,OAAO,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,kBAAkB,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;YAC1E,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,mBAAmB,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI;SACzF,CACF;KACF,CACF,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAC1B,QAAuB,EACvB,MAAc,EACd,OAAsB;IAEtB,MAAM,IAAI,GAAG,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAC1C,MAAM,KAAK,GAAG,YAAY,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAC1C,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC;IAE1B,MAAM,IAAI,GAAG,OAAO,CAAC,SAAS,EAAE,EAAE,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,IAAI,CAAC,MAAM,EAAE,EAAE;QACnF,OAAO,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,mBAAmB,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC7D,IAAI,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC;YACvB,CAAC,CAAC,IAAI;YACN,CAAC,CAAC,OAAO,CACL,IAAI,EACJ,EAAE,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,KAAK,CAAC,OAAO,EAAE,EACzD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CACxD;KACN,CAAC,CAAC;IAEH,OAAO;QACL,IAAI;QACJ,MAAM,EAAE,YAAY,CAAC,IAAI,CAAC;QAC1B,MAAM,EAAE,GAAG,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,aAAa,IAAI,OAAO,CAAC,KAAK,gBAAgB,EAAE;QACnF,WAAW,EAAE,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC;KACnC,CAAC;AACJ,CAAC"}

package/dist/picker/styles.d.ts

@@ -10,17 +10,17 @@
  * IT ADDS SELECTORS RATHER THAN REDEFINING THEM. Nothing here reaches into the
  * viewer's own classes; this file styles only what the picker introduces.
  *
- * ## The statement is laid out as a FLEX ROW, and that is load-bearing
+ * ## §17b's direction statement is no longer styled here
  *
- * render.ts draws the statement subject, phrase, object, and calls that word
- * order a default a host may bypass. A flex row is what makes the bypass cheap:
- * the CSS order property reorders flex children, so a host whose language puts
- * the relationship elsewhere restyles rather than re-implements. Laying it out
- * as inline text would have made the claim in render.ts true only in principle.
+ * This sheet once laid the statement out as a flex row so a host could reorder
+ * it with the CSS order property. The statement is `renderWorkspace`'s
+ * relationship row now — see `picker/render.ts`'s header for why — and its
+ * layout went with it, to `workspace/styles.ts`. Nothing here draws a
+ * relationship any more; this sheet styles the kind list and nothing else.
  *
  * Shipped as a string for the same reason the viewer's is: an entry that
  * imports CSS cannot be loaded by a bare Node runtime, and a string needs no
  * bundler.
  */
-export declare const pickerStylesheet = "\n.ig-picker {\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.ig-picker-heading {\n  margin: 0;\n  font-weight: normal;\n  font-size: var(--ig-font-size-small);\n  color: var(--ig-text-muted);\n}\n\n.ig-picker-kinds {\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-picker-choice {\n  display: flex;\n  align-items: baseline;\n  gap: var(--ig-space-tight);\n  width: 100%;\n  text-align: left;\n  background: var(--ig-surface);\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);\n  font-family: inherit;\n  font-size: inherit;\n  line-height: inherit;\n}\n\n.ig-picker-choice:focus-visible,\n.ig-picker-flip:focus-visible {\n  outline: var(--ig-focus-ring) solid var(--ig-focus);\n  outline-offset: var(--ig-stroke);\n}\n\n/* The kind the edge already carries. Marked on the ROW rather than on the\n   button, so a host restyling the control keeps the distinction. */\n.ig-picker-kind[data-current='true'] .ig-picker-choice {\n  background: var(--ig-surface-2);\n  border-color: var(--ig-accent);\n  color: var(--ig-text);\n}\n\n.ig-picker-current {\n  margin-left: auto;\n  font-size: var(--ig-font-size-small);\n  color: var(--ig-text-muted);\n}\n\n/* Wraps rather than truncates: a qualified reference is long, and a statement\n   whose object is cut off says something other than what the format holds. */\n.ig-picker-direction {\n  margin: 0;\n  display: flex;\n  flex-wrap: wrap;\n  align-items: baseline;\n  gap: var(--ig-space-tight);\n  color: var(--ig-text-body);\n}\n\n.ig-picker-ref {\n  font-family: var(--ig-font-mono);\n  color: var(--ig-accent);\n}\n\n.ig-picker-flip {\n  align-self: flex-start;\n  background: var(--ig-surface);\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);\n  font-family: inherit;\n  font-size: var(--ig-font-size-small);\n  line-height: inherit;\n}\n";
+export declare const pickerStylesheet = "\n.ig-picker {\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.ig-picker-heading {\n  margin: 0;\n  font-weight: normal;\n  font-size: var(--ig-font-size-small);\n  color: var(--ig-text-muted);\n}\n\n.ig-picker-kinds {\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-picker-choice {\n  display: flex;\n  align-items: baseline;\n  gap: var(--ig-space-tight);\n  width: 100%;\n  text-align: left;\n  background: var(--ig-surface);\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);\n  font-family: inherit;\n  font-size: inherit;\n  line-height: inherit;\n}\n\n.ig-picker-choice:focus-visible {\n  outline: var(--ig-focus-ring) solid var(--ig-focus);\n  outline-offset: var(--ig-stroke);\n}\n\n/* The kind the edge already carries. Marked on the ROW rather than on the\n   button, so a host restyling the control keeps the distinction. */\n.ig-picker-kind[data-current='true'] .ig-picker-choice {\n  background: var(--ig-surface-2);\n  border-color: var(--ig-accent);\n  color: var(--ig-text);\n}\n\n.ig-picker-current {\n  margin-left: auto;\n  font-size: var(--ig-font-size-small);\n  color: var(--ig-text-muted);\n}\n";
 //# sourceMappingURL=styles.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../src/picker/styles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,eAAO,MAAM,gBAAgB,ktEA0F5B,CAAC"}
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../src/picker/styles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,eAAO,MAAM,gBAAgB,y8CA6D5B,CAAC"}

package/dist/picker/styles.js

@@ -10,13 +10,13 @@
  * IT ADDS SELECTORS RATHER THAN REDEFINING THEM. Nothing here reaches into the
  * viewer's own classes; this file styles only what the picker introduces.
  *
- * ## The statement is laid out as a FLEX ROW, and that is load-bearing
+ * ## §17b's direction statement is no longer styled here
  *
- * render.ts draws the statement subject, phrase, object, and calls that word
- * order a default a host may bypass. A flex row is what makes the bypass cheap:
- * the CSS order property reorders flex children, so a host whose language puts
- * the relationship elsewhere restyles rather than re-implements. Laying it out
- * as inline text would have made the claim in render.ts true only in principle.
+ * This sheet once laid the statement out as a flex row so a host could reorder
+ * it with the CSS order property. The statement is `renderWorkspace`'s
+ * relationship row now — see `picker/render.ts`'s header for why — and its
+ * layout went with it, to `workspace/styles.ts`. Nothing here draws a
+ * relationship any more; this sheet styles the kind list and nothing else.
  *
  * Shipped as a string for the same reason the viewer's is: an entry that
  * imports CSS cannot be loaded by a bare Node runtime, and a string needs no
@@ -65,8 +65,7 @@ export const pickerStylesheet = `
   line-height: inherit;
 }
 
-.ig-picker-choice:focus-visible,
-.ig-picker-flip:focus-visible {
+.ig-picker-choice:focus-visible {
   outline: var(--ig-focus-ring) solid var(--ig-focus);
   outline-offset: var(--ig-stroke);
 }
@@ -84,33 +83,5 @@ export const pickerStylesheet = `
   font-size: var(--ig-font-size-small);
   color: var(--ig-text-muted);
 }
-
-/* Wraps rather than truncates: a qualified reference is long, and a statement
-   whose object is cut off says something other than what the format holds. */
-.ig-picker-direction {
-  margin: 0;
-  display: flex;
-  flex-wrap: wrap;
-  align-items: baseline;
-  gap: var(--ig-space-tight);
-  color: var(--ig-text-body);
-}
-
-.ig-picker-ref {
-  font-family: var(--ig-font-mono);
-  color: var(--ig-accent);
-}
-
-.ig-picker-flip {
-  align-self: flex-start;
-  background: var(--ig-surface);
-  color: var(--ig-text-body);
-  border: var(--ig-stroke) solid var(--ig-line);
-  border-radius: var(--ig-radius);
-  padding: var(--ig-space-tight);
-  font-family: inherit;
-  font-size: var(--ig-font-size-small);
-  line-height: inherit;
-}
 `;
 //# sourceMappingURL=styles.js.map

package/dist/picker/styles.js.map

@@ -1 +1 @@
-{"version":3,"file":"styles.js","sourceRoot":"","sources":["../../src/picker/styles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,CAAC,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0F/B,CAAC"}
+{"version":3,"file":"styles.js","sourceRoot":"","sources":["../../src/picker/styles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,CAAC,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6D/B,CAAC"}

package/dist/picker/view.d.ts

@@ -50,11 +50,12 @@
  * The rejected shape was a per-option PREVIEW: every option carrying the
  * statement it would produce, so the direction is chosen at the same moment as
  * the kind. It was rejected because it doubles what the picker says in order to
- * pre-empt a case the surface already answers — the retype lands, the picker
+ * pre-empt a case the surface already answers — the retype lands, this model
  * re-derives from the new document, and the direction is then STATED with a
  * flip beside it, one act from correct. §17b's rule is that direction is stated
- * rather than inferred, and it is stated. Revisit this if the flip turns out to
- * be reached often enough to be the real cost.
+ * rather than inferred, and it is stated: on `renderWorkspace`'s relationship
+ * row, which is where both the statement and the flip are drawn. Revisit this
+ * if the flip turns out to be reached often enough to be the real cost.
  *
  * ## It writes no words and holds no state
  *
@@ -72,7 +73,10 @@ import { type EdgeId, type EdgeKind, type GraphDocument, type IssueRef, type Pro
  * The kind travels with them because a pair alone cannot be worded.
  *
  * There is deliberately no `text`. A host renders "#530 is blocked by #602" in
- * its own language and its own word order; see {@link ./words.ts PickerWords}.
+ * its own language and its own word order — and no shipped surface words one
+ * from this shape any more: `renderWorkspace`'s row states the direction from
+ * layer 1's `EDGE_TREATMENTS`, and this pair is here for the hosts that draw
+ * their own.
  */
 export interface DirectionStatement {
     readonly kind: EdgeKind;

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

@@ -1 +1 @@
-{"version":3,"file":"view.d.ts","sourceRoot":"","sources":["../../src/picker/view.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AAGH,OAAO,EACL,KAAK,MAAM,EACX,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,QAAQ,EAEd,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;;GASG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC;CACvB;AAED,oCAAoC;AACpC,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,8DAA8D;IAC9D,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,wEAAwE;IACxE,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,CAAC;IACtC,gFAAgF;IAChF,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;CAC7B;AAED,MAAM,WAAW,UAAU;IACzB,uEAAuE;IACvE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;IACxC,mEAAmE;IACnE,QAAQ,CAAC,SAAS,EAAE,kBAAkB,GAAG,IAAI,CAAC;IAC9C,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC;AAkBD;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU,CAwB9E"}
+{"version":3,"file":"view.d.ts","sourceRoot":"","sources":["../../src/picker/view.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AAGH,OAAO,EACL,KAAK,MAAM,EACX,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,QAAQ,EAEd,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC;CACvB;AAED,oCAAoC;AACpC,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,8DAA8D;IAC9D,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,wEAAwE;IACxE,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,CAAC;IACtC,gFAAgF;IAChF,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;CAC7B;AAED,MAAM,WAAW,UAAU;IACzB,uEAAuE;IACvE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;IACxC,mEAAmE;IACnE,QAAQ,CAAC,SAAS,EAAE,kBAAkB,GAAG,IAAI,CAAC;IAC9C,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC;AAkBD;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU,CAwB9E"}

package/dist/picker/view.js

@@ -50,11 +50,12 @@
  * The rejected shape was a per-option PREVIEW: every option carrying the
  * statement it would produce, so the direction is chosen at the same moment as
  * the kind. It was rejected because it doubles what the picker says in order to
- * pre-empt a case the surface already answers — the retype lands, the picker
+ * pre-empt a case the surface already answers — the retype lands, this model
  * re-derives from the new document, and the direction is then STATED with a
  * flip beside it, one act from correct. §17b's rule is that direction is stated
- * rather than inferred, and it is stated. Revisit this if the flip turns out to
- * be reached often enough to be the real cost.
+ * rather than inferred, and it is stated: on `renderWorkspace`'s relationship
+ * row, which is where both the statement and the flip are drawn. Revisit this
+ * if the flip turns out to be reached often enough to be the real cost.
  *
  * ## It writes no words and holds no state
  *