@issuegraph/editor 0.4.0 → 0.22.1

package/dist/scale/styles.d.ts

@@ -8,14 +8,20 @@
  * scans these bytes for a literal colour or a fixed length and for a token the
  * theme does not define, so the rule is enforced rather than remembered.
  *
- * IT ADDS SELECTORS RATHER THAN REDEFINING THEM. The refusal, its capsules and
- * their counts already have a look — this file styles only what layer 2
- * introduces: the ladder container, the routes, the search box, the isolated
- * chip and the list it opens.
+ * IT ADDS SELECTORS RATHER THAN REDEFINING THEM, with ONE declared exception.
+ * The refusal and its counts already have a look, so this file styles what
+ * layer 2 introduces: the ladder container, the routes, the search box, the
+ * isolated chip, the list it opens, and §17f's capsule card. The exception is
+ * `.ig-ladder .ig-refusal .ig-list`, which lays layer 1's list out as a board —
+ * declared here because the arrangement is this surface's, and scoped so §16's
+ * single-column list and the ladder's own search matches are untouched. The
+ * capsule CARD is a new class rather than a redefinition of `.ig-capsule` for
+ * the same reason, which is why the list item beside it carries no layer 1
+ * class at all.
  *
  * 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 scaleLadderStylesheet = "\n.ig-ladder {\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-ladder-routes {\n  list-style: none;\n  margin: 0;\n  padding: 0;\n  display: flex;\n  flex-direction: column;\n  gap: var(--ig-space-tight);\n  color: var(--ig-text-muted);\n  font-size: var(--ig-font-size-small);\n}\n\n.ig-ladder-search {\n  display: flex;\n  flex-direction: column;\n  gap: var(--ig-space-tight);\n}\n\n.ig-ladder-search input {\n  background: var(--ig-surface);\n  color: var(--ig-text);\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);\n}\n\n.ig-ladder-search input:focus-visible {\n  outline: var(--ig-focus-ring) solid var(--ig-focus);\n  outline-offset: var(--ig-space-tight);\n}\n\n.ig-ladder-match {\n  display: flex;\n  gap: var(--ig-space-tight);\n  align-items: baseline;\n}\n\n.ig-chip {\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-chip:focus-visible {\n  outline: var(--ig-focus-ring) solid var(--ig-focus);\n  outline-offset: var(--ig-space-tight);\n}\n\n.ig-chip[aria-expanded='true'] {\n  border-color: var(--ig-accent);\n  color: var(--ig-text);\n}\n\n.ig-isolated-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-isolated-list .ig-id {\n  font-family: var(--ig-font-mono);\n  color: var(--ig-text-muted);\n}\n";
+export declare const scaleLadderStylesheet = "\n.ig-ladder {\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-ladder-routes {\n  list-style: none;\n  margin: 0;\n  padding: 0;\n  display: flex;\n  flex-direction: column;\n  gap: var(--ig-space-tight);\n  color: var(--ig-text-muted);\n  font-size: var(--ig-font-size-small);\n}\n\n.ig-ladder-search {\n  display: flex;\n  flex-direction: column;\n  gap: var(--ig-space-tight);\n}\n\n.ig-ladder-search input {\n  background: var(--ig-surface);\n  color: var(--ig-text);\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);\n}\n\n.ig-ladder-search input:focus-visible {\n  outline: var(--ig-focus-ring) solid var(--ig-focus);\n  outline-offset: var(--ig-space-tight);\n}\n\n.ig-ladder-match {\n  display: flex;\n  gap: var(--ig-space-tight);\n  align-items: baseline;\n}\n\n.ig-chip {\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-chip:focus-visible {\n  outline: var(--ig-focus-ring) solid var(--ig-focus);\n  outline-offset: var(--ig-space-tight);\n}\n\n.ig-chip[aria-expanded='true'] {\n  border-color: var(--ig-accent);\n  color: var(--ig-text);\n}\n\n/* THE LIST ITEM IS A GRID CELL AND NOTHING ELSE. It deliberately does not\n   carry .ig-capsule: that is layer 1's own card, and a card inside a card put\n   the stuck tint and the hover on the inner border only. */\n.ig-capsule-cell {\n  display: flex;\n  min-width: 0;\n}\n\n/* FOUR CARDS ACROSS A COLUMN, NOT FOUR ROWS DOWN IT. Frame 17f lays the\n   capsules out as a board, which is what makes the counts comparable at a\n   glance \u2014 the whole reason the count leads. minmax(0, 1fr) rather than a\n   width, because this stylesheet declares no fixed length: a title is arbitrary\n   and auto would let the longest one set every column. Scoped to the ladder's\n   own refusal so \u00A716's single-column list, drawn from the same class in layer\n   1, is untouched. */\n.ig-ladder .ig-refusal .ig-list {\n  display: grid;\n  grid-template-columns: repeat(2, minmax(0, 1fr));\n  gap: var(--ig-space);\n}\n\n/* THE WHOLE CAPSULE IS THE CONTROL, so the button carries the card and the\n   list item carries nothing. A button wrapping a card needs its own alignment\n   and wrapping reset: a user agent centres and nowraps button content, and both\n   are wrong for a four-part card with a title in it. */\n.ig-capsule-enter {\n  display: grid;\n  grid-template-columns: 1fr auto;\n  align-items: start;\n  gap: var(--ig-space-tight) var(--ig-space);\n  width: 100%;\n  height: 100%;\n  text-align: left;\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);\n  font-family: var(--ig-font-ui);\n  font-size: var(--ig-font-size);\n  cursor: pointer;\n}\n\n.ig-capsule-enter:focus-visible {\n  outline: var(--ig-focus-ring) solid var(--ig-focus);\n  outline-offset: var(--ig-space-tight);\n}\n\n.ig-capsule-enter:hover {\n  border-color: var(--ig-accent);\n}\n\n/* THE WHOLE STUCK CARD IS TINTED, as frame 17f draws it \u2014 the badge alone puts\n   the one finding that stops work outright at the size of every other chip on\n   the board. Same hue as the badge inside it, which is blocked-by's, because\n   that is the edge the cycle is made of. */\n.ig-capsule-enter[data-reach='cyclic'] {\n  border-color: var(--ig-edge-blocked-by);\n}\n\n.ig-capsule-enter[data-reach='cyclic'] .ig-capsule-reach {\n  color: var(--ig-edge-blocked-by);\n}\n\n/* THE COUNT LEADS, so it is the one part sized to be read down the board rather\n   than within a card. The --ig-font-size-rank token is the one the theme defines\n   for exactly this \u2014 \"the rank number itself\" \u2014 so a capsule's count and a rail\n   rank are one size by declaration rather than by coincidence. */\n.ig-capsule-size {\n  grid-column: 1;\n  font-family: var(--ig-font-mono);\n  font-size: var(--ig-font-size-rank);\n  font-variant-numeric: tabular-nums;\n  color: var(--ig-text);\n}\n\n/* END-ALIGNED AND CONTENT-WIDTH. A grid item stretches by default, which drew\n   the cycle badge as a full-width bar across the top of the card. The pill is\n   the frame's: the blocked count and the cycle sit in one slot, so they read as\n   one kind of thing rather than as a bordered badge beside bare text. */\n.ig-capsule-load {\n  grid-column: 2;\n  justify-self: end;\n  background: var(--ig-bg);\n  border: var(--ig-stroke) solid var(--ig-line);\n  border-radius: var(--ig-radius);\n  padding: var(--ig-space-micro) var(--ig-space-snug);\n  font-family: var(--ig-font-mono);\n  font-size: var(--ig-font-size-small);\n  font-variant-numeric: tabular-nums;\n  color: var(--ig-text-muted);\n}\n\n/* THE NAME AND THE REACH SPAN BOTH COLUMNS, and the name is the one part\n   allowed to wrap: a title is arbitrary length, and letting it size the grid\n   would make every card on the board a different shape. */\n.ig-capsule-name {\n  grid-column: 1 / -1;\n  color: var(--ig-text);\n  min-width: 0;\n  overflow-wrap: anywhere;\n}\n\n.ig-capsule-reach {\n  grid-column: 1 / -1;\n  color: var(--ig-text-muted);\n  font-size: var(--ig-font-size-small);\n  font-variant-numeric: tabular-nums;\n}\n\n.ig-isolated-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/* A ROW PER ENTRY, WITH A GAP THE MARKUP DOES NOT SUPPLY. The element helper\n   concatenates its children with no whitespace, so the key and the title\n   rendered as one run of text \u2014 #492Audit log pagination. Latent until \u00A717a\n   moved the CONTROL to the rail footer and made this list the thing a reader is\n   sent to, rather than a chip's afterthought. */\n.ig-isolated-list li {\n  display: flex;\n  gap: var(--ig-space-tight);\n  align-items: baseline;\n  min-width: 0;\n}\n\n.ig-isolated-list .ig-id {\n  font-family: var(--ig-font-mono);\n  color: var(--ig-text-muted);\n  flex: none;\n}\n";
 //# sourceMappingURL=styles.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../src/scale/styles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,eAAO,MAAM,qBAAqB,23DAoFjC,CAAC"}
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../src/scale/styles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,eAAO,MAAM,qBAAqB,q3MA+MjC,CAAC"}

package/dist/scale/styles.js

@@ -8,10 +8,16 @@
  * scans these bytes for a literal colour or a fixed length and for a token the
  * theme does not define, so the rule is enforced rather than remembered.
  *
- * IT ADDS SELECTORS RATHER THAN REDEFINING THEM. The refusal, its capsules and
- * their counts already have a look — this file styles only what layer 2
- * introduces: the ladder container, the routes, the search box, the isolated
- * chip and the list it opens.
+ * IT ADDS SELECTORS RATHER THAN REDEFINING THEM, with ONE declared exception.
+ * The refusal and its counts already have a look, so this file styles what
+ * layer 2 introduces: the ladder container, the routes, the search box, the
+ * isolated chip, the list it opens, and §17f's capsule card. The exception is
+ * `.ig-ladder .ig-refusal .ig-list`, which lays layer 1's list out as a board —
+ * declared here because the arrangement is this surface's, and scoped so §16's
+ * single-column list and the ladder's own search matches are untouched. The
+ * capsule CARD is a new class rather than a redefinition of `.ig-capsule` for
+ * the same reason, which is why the list item beside it carries no layer 1
+ * class at all.
  *
  * 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
@@ -88,6 +94,116 @@ export const scaleLadderStylesheet = `
   color: var(--ig-text);
 }
 
+/* THE LIST ITEM IS A GRID CELL AND NOTHING ELSE. It deliberately does not
+   carry .ig-capsule: that is layer 1's own card, and a card inside a card put
+   the stuck tint and the hover on the inner border only. */
+.ig-capsule-cell {
+  display: flex;
+  min-width: 0;
+}
+
+/* FOUR CARDS ACROSS A COLUMN, NOT FOUR ROWS DOWN IT. Frame 17f lays the
+   capsules out as a board, which is what makes the counts comparable at a
+   glance — the whole reason the count leads. minmax(0, 1fr) rather than a
+   width, because this stylesheet declares no fixed length: a title is arbitrary
+   and auto would let the longest one set every column. Scoped to the ladder's
+   own refusal so §16's single-column list, drawn from the same class in layer
+   1, is untouched. */
+.ig-ladder .ig-refusal .ig-list {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: var(--ig-space);
+}
+
+/* THE WHOLE CAPSULE IS THE CONTROL, so the button carries the card and the
+   list item carries nothing. A button wrapping a card needs its own alignment
+   and wrapping reset: a user agent centres and nowraps button content, and both
+   are wrong for a four-part card with a title in it. */
+.ig-capsule-enter {
+  display: grid;
+  grid-template-columns: 1fr auto;
+  align-items: start;
+  gap: var(--ig-space-tight) var(--ig-space);
+  width: 100%;
+  height: 100%;
+  text-align: left;
+  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);
+  font-family: var(--ig-font-ui);
+  font-size: var(--ig-font-size);
+  cursor: pointer;
+}
+
+.ig-capsule-enter:focus-visible {
+  outline: var(--ig-focus-ring) solid var(--ig-focus);
+  outline-offset: var(--ig-space-tight);
+}
+
+.ig-capsule-enter:hover {
+  border-color: var(--ig-accent);
+}
+
+/* THE WHOLE STUCK CARD IS TINTED, as frame 17f draws it — the badge alone puts
+   the one finding that stops work outright at the size of every other chip on
+   the board. Same hue as the badge inside it, which is blocked-by's, because
+   that is the edge the cycle is made of. */
+.ig-capsule-enter[data-reach='cyclic'] {
+  border-color: var(--ig-edge-blocked-by);
+}
+
+.ig-capsule-enter[data-reach='cyclic'] .ig-capsule-reach {
+  color: var(--ig-edge-blocked-by);
+}
+
+/* THE COUNT LEADS, so it is the one part sized to be read down the board rather
+   than within a card. The --ig-font-size-rank token is the one the theme defines
+   for exactly this — "the rank number itself" — so a capsule's count and a rail
+   rank are one size by declaration rather than by coincidence. */
+.ig-capsule-size {
+  grid-column: 1;
+  font-family: var(--ig-font-mono);
+  font-size: var(--ig-font-size-rank);
+  font-variant-numeric: tabular-nums;
+  color: var(--ig-text);
+}
+
+/* END-ALIGNED AND CONTENT-WIDTH. A grid item stretches by default, which drew
+   the cycle badge as a full-width bar across the top of the card. The pill is
+   the frame's: the blocked count and the cycle sit in one slot, so they read as
+   one kind of thing rather than as a bordered badge beside bare text. */
+.ig-capsule-load {
+  grid-column: 2;
+  justify-self: end;
+  background: var(--ig-bg);
+  border: var(--ig-stroke) solid var(--ig-line);
+  border-radius: var(--ig-radius);
+  padding: var(--ig-space-micro) var(--ig-space-snug);
+  font-family: var(--ig-font-mono);
+  font-size: var(--ig-font-size-small);
+  font-variant-numeric: tabular-nums;
+  color: var(--ig-text-muted);
+}
+
+/* THE NAME AND THE REACH SPAN BOTH COLUMNS, and the name is the one part
+   allowed to wrap: a title is arbitrary length, and letting it size the grid
+   would make every card on the board a different shape. */
+.ig-capsule-name {
+  grid-column: 1 / -1;
+  color: var(--ig-text);
+  min-width: 0;
+  overflow-wrap: anywhere;
+}
+
+.ig-capsule-reach {
+  grid-column: 1 / -1;
+  color: var(--ig-text-muted);
+  font-size: var(--ig-font-size-small);
+  font-variant-numeric: tabular-nums;
+}
+
 .ig-isolated-list {
   list-style: none;
   margin: 0;
@@ -97,9 +213,22 @@ export const scaleLadderStylesheet = `
   gap: var(--ig-space-tight);
 }
 
+/* A ROW PER ENTRY, WITH A GAP THE MARKUP DOES NOT SUPPLY. The element helper
+   concatenates its children with no whitespace, so the key and the title
+   rendered as one run of text — #492Audit log pagination. Latent until §17a
+   moved the CONTROL to the rail footer and made this list the thing a reader is
+   sent to, rather than a chip's afterthought. */
+.ig-isolated-list li {
+  display: flex;
+  gap: var(--ig-space-tight);
+  align-items: baseline;
+  min-width: 0;
+}
+
 .ig-isolated-list .ig-id {
   font-family: var(--ig-font-mono);
   color: var(--ig-text-muted);
+  flex: none;
 }
 `;
 //# sourceMappingURL=styles.js.map

package/dist/scale/styles.js.map

@@ -1 +1 @@
-{"version":3,"file":"styles.js","sourceRoot":"","sources":["../../src/scale/styles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,CAAC,MAAM,qBAAqB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoFpC,CAAC"}
+{"version":3,"file":"styles.js","sourceRoot":"","sources":["../../src/scale/styles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,MAAM,CAAC,MAAM,qBAAqB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+MpC,CAAC"}

package/dist/workspace/chrome.d.ts

@@ -17,5 +17,5 @@
  * that imports CSS cannot be loaded by a bare Node runtime, and a string needs
  * no bundler.
  */
-export declare const mountStylesheet = "\n.ig-mount {\n  position: relative;\n  height: 100%;\n  min-height: 0;\n}\n\n.ig-mount > .ig-workspace {\n  /* THE FLOATING CHOOSER'S BOX. A canvas drop places the kind chooser inside\n     the workspace root, so a host that scopes its theme to that root still\n     resolves the chooser's tokens; the root is the positioning box for it. */\n  position: relative;\n  height: 100%;\n  box-sizing: border-box;\n}\n\n.ig-mount[data-dragging='true'] {\n  cursor: grabbing;\n  user-select: none;\n}\n\n.ig-chrome {\n  padding: var(--ig-space-tight) var(--ig-space);\n  border-top: var(--ig-stroke) solid var(--ig-line);\n  display: flex;\n  flex-direction: column;\n  gap: var(--ig-space-tight);\n  font-family: var(--ig-font-ui);\n  font-size: var(--ig-font-size-small);\n  line-height: var(--ig-line-height);\n  color: var(--ig-text-body);\n}\n\n.ig-chrome-sentence {\n  margin: 0;\n  font-family: var(--ig-font-mono);\n  color: var(--ig-text);\n}\n\n.ig-chrome-button {\n  font: inherit;\n  font-size: var(--ig-font-size-small);\n  color: var(--ig-text);\n  background: var(--ig-surface-2);\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  cursor: pointer;\n  text-align: left;\n}\n\n.ig-chrome-button:hover {\n  border-color: var(--ig-accent);\n}\n\n.ig-chrome-button:focus-visible {\n  outline: var(--ig-focus-ring) solid var(--ig-focus);\n  outline-offset: var(--ig-space-tight);\n}\n\n.ig-chrome-quiet {\n  background: none;\n  color: var(--ig-text-muted);\n}\n\n.ig-chrome-danger {\n  color: var(--ig-state-failed);\n  border-color: var(--ig-state-failed);\n}\n\n.ig-chrome-input {\n  font: inherit;\n  font-size: var(--ig-font-size-small);\n  color: var(--ig-text);\n  background: var(--ig-surface-2);\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  width: 100%;\n  box-sizing: border-box;\n}\n\n.ig-chrome-input:focus-visible {\n  outline: var(--ig-focus-ring) solid var(--ig-focus);\n  outline-offset: var(--ig-space-tight);\n}\n\n.ig-chrome-kinds {\n  display: flex;\n  flex-direction: column;\n  gap: var(--ig-space-tight);\n}\n\n/* EACH KIND CARRIES ITS HUE ON THE LEFT, the same hue the viewer draws the\n   edge in, so the chooser and the canvas name a relationship the same way. */\n.ig-chrome-kinds .ig-chrome-button {\n  border-left: var(--ig-terminal-width) solid var(--ig-line);\n}\n\n.ig-chrome-kinds [data-edge='blocked-by'] {\n  border-left-color: var(--ig-edge-blocked-by);\n}\n\n.ig-chrome-kinds [data-edge='serialize-with'] {\n  border-left-color: var(--ig-edge-serialize-with);\n}\n\n.ig-chrome-kinds [data-edge='together-with'] {\n  border-left-color: var(--ig-edge-together-with);\n}\n\n.ig-chrome-kinds [data-edge='duplicate-of'] {\n  border-left-color: var(--ig-edge-duplicate-of);\n}\n\n.ig-chrome-kinds [data-edge='decomposed-from'] {\n  border-left-color: var(--ig-edge-decomposed-from);\n}\n\n.ig-chrome-matches {\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-chrome-match {\n  width: 100%;\n}\n\n.ig-chrome-search,\n.ig-chrome-chooser {\n  display: flex;\n  flex-direction: column;\n  gap: var(--ig-space-tight);\n}\n\n/* PLACED BY THE MOUNT, at the drop point `pickerPlacement` chose: `left` and\n   `top` are written inline on the element, so this rule carries the box and\n   nothing about where it sits. */\n.ig-chrome-floating {\n  position: absolute;\n  width: calc(var(--ig-char-width) * 40);\n  padding: var(--ig-space-tight) var(--ig-space);\n  background: var(--ig-surface-2);\n  border: var(--ig-stroke) solid var(--ig-accent);\n  border-radius: var(--ig-radius);\n  z-index: 2;\n}\n\n.ig-chrome-keys {\n  margin: 0;\n  font-size: var(--ig-font-size-small);\n  color: var(--ig-text-muted);\n}\n";
+export declare const mountStylesheet = "\n.ig-mount {\n  position: relative;\n  height: 100%;\n  min-height: 0;\n}\n\n.ig-mount > .ig-workspace {\n  /* THE FLOATING CHOOSER'S BOX. A canvas drop places the kind chooser inside\n     the workspace root, so a host that scopes its theme to that root still\n     resolves the chooser's tokens; the root is the positioning box for it. */\n  position: relative;\n  height: 100%;\n  box-sizing: border-box;\n}\n\n.ig-mount[data-dragging='true'] {\n  cursor: grabbing;\n  user-select: none;\n}\n\n.ig-chrome {\n  padding: var(--ig-space-tight) var(--ig-space);\n  border-top: var(--ig-stroke) solid var(--ig-line);\n  display: flex;\n  flex-direction: column;\n  gap: var(--ig-space-tight);\n  font-family: var(--ig-font-ui);\n  font-size: var(--ig-font-size-small);\n  line-height: var(--ig-line-height);\n  color: var(--ig-text-body);\n}\n\n.ig-chrome-sentence {\n  margin: 0;\n  font-family: var(--ig-font-mono);\n  color: var(--ig-text);\n}\n\n.ig-chrome-button {\n  font: inherit;\n  font-size: var(--ig-font-size-small);\n  color: var(--ig-text);\n  background: var(--ig-surface-2);\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  cursor: pointer;\n  text-align: left;\n}\n\n.ig-chrome-button:hover {\n  border-color: var(--ig-accent);\n}\n\n.ig-chrome-button:focus-visible {\n  outline: var(--ig-focus-ring) solid var(--ig-focus);\n  outline-offset: var(--ig-space-tight);\n}\n\n.ig-chrome-quiet {\n  background: none;\n  color: var(--ig-text-muted);\n}\n\n.ig-chrome-danger {\n  color: var(--ig-state-failed);\n  border-color: var(--ig-state-failed);\n}\n\n.ig-chrome-input {\n  font: inherit;\n  font-size: var(--ig-font-size-small);\n  color: var(--ig-text);\n  background: var(--ig-surface-2);\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  width: 100%;\n  box-sizing: border-box;\n}\n\n.ig-chrome-input:focus-visible {\n  outline: var(--ig-focus-ring) solid var(--ig-focus);\n  outline-offset: var(--ig-space-tight);\n}\n\n.ig-chrome-kinds {\n  display: flex;\n  flex-direction: column;\n  gap: var(--ig-space-tight);\n}\n\n/* EACH KIND CARRIES ITS HUE ON THE LEFT, the same hue the viewer draws the\n   edge in, so the chooser and the canvas name a relationship the same way. */\n.ig-chrome-kinds .ig-chrome-button {\n  border-left: var(--ig-terminal-width) solid var(--ig-line);\n}\n\n.ig-chrome-kinds [data-edge='blocked-by'] {\n  border-left-color: var(--ig-edge-blocked-by);\n}\n\n.ig-chrome-kinds [data-edge='serialize-with'] {\n  border-left-color: var(--ig-edge-serialize-with);\n}\n\n.ig-chrome-kinds [data-edge='together-with'] {\n  border-left-color: var(--ig-edge-together-with);\n}\n\n.ig-chrome-kinds [data-edge='duplicate-of'] {\n  border-left-color: var(--ig-edge-duplicate-of);\n}\n\n.ig-chrome-kinds [data-edge='decomposed-from'] {\n  border-left-color: var(--ig-edge-decomposed-from);\n}\n\n.ig-chrome-matches {\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-chrome-match {\n  width: 100%;\n}\n\n.ig-chrome-search,\n.ig-chrome-chooser {\n  display: flex;\n  flex-direction: column;\n  gap: var(--ig-space-tight);\n}\n\n/* PLACED BY THE MOUNT, at the drop point `pickerPlacement` chose: `left` and\n   `top` are written inline on the element, so this rule carries the box and\n   nothing about where it sits. */\n.ig-chrome-floating {\n  position: absolute;\n  width: calc(var(--ig-char-width) * 40);\n  padding: var(--ig-space-tight) var(--ig-space);\n  background: var(--ig-surface-2);\n  border: var(--ig-stroke) solid var(--ig-accent);\n  border-radius: var(--ig-radius);\n  z-index: 2;\n}\n\n.ig-chrome-keys {\n  margin: 0;\n  font-size: var(--ig-font-size-small);\n  color: var(--ig-text-muted);\n}\n\n/* THE FIRST PASS COVERS THE WORKSPACE. \u00A717e is a review queue rather than a\n   fourth column, so it is drawn over the three zones instead of beside them.\n   Placed against the workspace root, which is this sheet's positioning box. */\n.ig-firstpass-overlay {\n  position: absolute;\n  inset: 0;\n  z-index: 3;\n  display: flex;\n  flex-direction: column;\n  align-items: center;\n  /* START-SAFE, NOT CENTRED. Evidence is host prose of no fixed length, and a\n     short workspace makes any panel too tall \u2014 centring overflow puts the\n     question above the container's own origin, where no scroll can reach it.\n     Laid out from the top and centred by the panel's own auto margins, which\n     collapse the moment there is not enough room. */\n  justify-content: flex-start;\n  overflow: auto;\n  gap: var(--ig-space);\n  padding: var(--ig-space-loose);\n  box-sizing: border-box;\n  background: var(--ig-bg);\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/* A CONTAINER THAT TAKES FOCUS NEEDS A RING. The wrapper is focused on open and\n   after every answer, so without one a sighted keyboard user cannot see where\n   they are on the surface built for them. */\n.ig-firstpass-overlay:focus-visible {\n  outline: var(--ig-focus-ring) solid var(--ig-focus);\n  outline-offset: calc(var(--ig-stroke) * -1);\n}\n\n.ig-firstpass-panel {\n  width: 100%;\n  max-width: calc(var(--ig-char-width) * 72);\n  /* Centres while it fits, and starts at the top the moment it does not. */\n  margin-block: auto;\n}\n\n/* The scanning and failed sentences. Both are the host's words. */\n.ig-firstpass-note {\n  margin: 0;\n  color: var(--ig-text-muted);\n}\n";
 //# sourceMappingURL=chrome.d.ts.map

package/dist/workspace/chrome.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chrome.d.ts","sourceRoot":"","sources":["../../src/workspace/chrome.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,eAAO,MAAM,eAAe,40HA6J3B,CAAC"}
+{"version":3,"file":"chrome.d.ts","sourceRoot":"","sources":["../../src/workspace/chrome.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,eAAO,MAAM,eAAe,ijLA6M3B,CAAC"}

package/dist/workspace/chrome.js

@@ -174,5 +174,53 @@ export const mountStylesheet = `
   font-size: var(--ig-font-size-small);
   color: var(--ig-text-muted);
 }
+
+/* THE FIRST PASS COVERS THE WORKSPACE. §17e is a review queue rather than a
+   fourth column, so it is drawn over the three zones instead of beside them.
+   Placed against the workspace root, which is this sheet's positioning box. */
+.ig-firstpass-overlay {
+  position: absolute;
+  inset: 0;
+  z-index: 3;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  /* START-SAFE, NOT CENTRED. Evidence is host prose of no fixed length, and a
+     short workspace makes any panel too tall — centring overflow puts the
+     question above the container's own origin, where no scroll can reach it.
+     Laid out from the top and centred by the panel's own auto margins, which
+     collapse the moment there is not enough room. */
+  justify-content: flex-start;
+  overflow: auto;
+  gap: var(--ig-space);
+  padding: var(--ig-space-loose);
+  box-sizing: border-box;
+  background: var(--ig-bg);
+  font-family: var(--ig-font-ui);
+  font-size: var(--ig-font-size);
+  line-height: var(--ig-line-height);
+  color: var(--ig-text-body);
+}
+
+/* A CONTAINER THAT TAKES FOCUS NEEDS A RING. The wrapper is focused on open and
+   after every answer, so without one a sighted keyboard user cannot see where
+   they are on the surface built for them. */
+.ig-firstpass-overlay:focus-visible {
+  outline: var(--ig-focus-ring) solid var(--ig-focus);
+  outline-offset: calc(var(--ig-stroke) * -1);
+}
+
+.ig-firstpass-panel {
+  width: 100%;
+  max-width: calc(var(--ig-char-width) * 72);
+  /* Centres while it fits, and starts at the top the moment it does not. */
+  margin-block: auto;
+}
+
+/* The scanning and failed sentences. Both are the host's words. */
+.ig-firstpass-note {
+  margin: 0;
+  color: var(--ig-text-muted);
+}
 `;
 //# sourceMappingURL=chrome.js.map

package/dist/workspace/chrome.js.map

@@ -1 +1 @@
-{"version":3,"file":"chrome.js","sourceRoot":"","sources":["../../src/workspace/chrome.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6J9B,CAAC"}
+{"version":3,"file":"chrome.js","sourceRoot":"","sources":["../../src/workspace/chrome.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6M9B,CAAC"}

package/dist/workspace/firstpass.d.ts

@@ -0,0 +1,166 @@
+/**
+ * The first pass as a slice of the workspace's state — no DOM, no promises.
+ *
+ * `firstpass/queue.ts` is the review loop itself and knows nothing about being
+ * opened or closed; `firstpass/candidates.ts` declares a port whose one method
+ * is asynchronous by construction. Between them sits a lifecycle nobody owned:
+ * the surface is shut, then a scan is out, then a queue is up, and a scan can
+ * fail. That lifecycle is this file, in the shape `selectionReducer`,
+ * `scaleReducer` and `createReducer` already use here — so `host.ts` composes a
+ * fourth reducer rather than growing a fourth set of rules.
+ *
+ * ## The phase is a union, and `decided` sits outside it
+ *
+ * Everything the phase carries belongs to one phase only, so it is a
+ * discriminated union for the reason `firstpass/view.ts` records about its own
+ * three states: the impossible combinations stop existing.
+ *
+ * {@link FirstPassState.decided} is deliberately NOT in the union, because it
+ * is the one fact that has to outlive every phase. See below.
+ *
+ * ## A re-open re-scans, and `decided` is what makes that honest
+ *
+ * Closing drops the queue rather than resuming it: a queue held across a close
+ * carries a candidate set taken before the writes the reader just made, so it
+ * would go on asking about relationships that now exist.
+ *
+ * But a re-scan on its own would re-ask every question the reader already
+ * answered — `queue.ts` defines `reject` as "no, this is not a relationship.
+ * Answered, and gone", and a host's `findCandidates` is never told what was
+ * decided, so it cannot filter them out on the reader's behalf. Forty rejections
+ * would come back on the next open, which is a worse outcome than the resume
+ * this refuses and defeats §17e's "first pass has an end" across sessions.
+ *
+ * So the decided ids ride outside the phase and filter the next scan.
+ *
+ * **`skip` is not decided, and that is the design rather than an omission.**
+ * §17e's `S` is "not now", and `queue.ts` ships `skippedCandidates` precisely
+ * because "the deferred set is the thing a second pass is built from". A skipped
+ * candidate coming back in the next pass is what deferring it meant.
+ *
+ * ## Scans carry a generation, or the newest answer can lose
+ *
+ * A reader who closes during a slow scan and opens again has two scans in
+ * flight. Discriminating on the phase alone cannot tell their answers apart, so
+ * the STALE set — taken before the reader's writes — would open the queue while
+ * the fresh one arrived on `open` and was dropped. That is the exact failure the
+ * re-scan rule exists to prevent, arriving through the door the rule opened.
+ *
+ * {@link FirstPassState.scan} is a monotonic counter. Every scan is issued under
+ * it, every answer carries the number it was issued under, and an answer whose
+ * number is not the current one is dropped.
+ */
+import type { Candidate, CandidateId } from '../firstpass/candidates.ts';
+import { type QueueCommand, type QueueResult, type QueueState } from '../firstpass/queue.ts';
+/** What the surface is doing. Exactly one of these, always. */
+export type FirstPassPhase = 
+/** Shut. The header's entry is the only way in. */
+{
+    readonly kind: 'closed';
+}
+/** A scan is out. The generation is {@link FirstPassState.scan}. */
+ | {
+    readonly kind: 'scanning';
+}
+/**
+ * The host's scan rejected.
+ *
+ * ITS OWN PHASE rather than an empty queue: `empty` means the host found
+ * nothing to encode, which is a claim about the backlog that a failed scan
+ * does not license — the vacuity `firstpass/view.ts` separates its own two
+ * end states to avoid. And its own phase rather than a silent return to
+ * `closed`, which made a broken port indistinguishable from a dead button.
+ *
+ * It carries no payload: the reason is the host's and this package does not
+ * read it. A shell draws its own sentence and its own way out.
+ */
+ | {
+    readonly kind: 'failed';
+} | {
+    readonly kind: 'open';
+    readonly queue: QueueState;
+};
+export interface FirstPassState {
+    readonly phase: FirstPassPhase;
+    /**
+     * The candidates DECIDED in this state's lifetime — `apply` and `reject`.
+     *
+     * Filters the next scan, so a re-open does not re-ask a decided question. Held
+     * as ids rather than candidates because that is what a scan can be compared
+     * against, and because {@link CandidateId} is the identity the HOST minted:
+     * `firstpass/candidates.ts` is explicit that two findings about the same pair
+     * are not necessarily the same finding, so nothing here derives an identity of
+     * its own.
+     */
+    readonly decided: readonly CandidateId[];
+    /** The generation the newest scan was issued under. Monotonic. */
+    readonly scan: number;
+}
+export declare const INITIAL_FIRST_PASS: FirstPassState;
+/**
+ * One act on the surface.
+ *
+ * `candidates` and `scan-failed` are the two answers a scan can have, and both
+ * carry the generation they were issued under — see the module header.
+ */
+export type FirstPassCommand = {
+    readonly kind: 'open';
+} | {
+    readonly kind: 'candidates';
+    readonly scan: number;
+    readonly candidates: readonly Candidate[];
+} | {
+    readonly kind: 'scan-failed';
+    readonly scan: number;
+} | {
+    readonly kind: 'queue';
+    readonly command: QueueCommand;
+} | {
+    readonly kind: 'close';
+}
+/**
+ * Close, and forget the decisions too.
+ *
+ * A DIFFERENT SCANNER IS A DIFFERENT FIRST PASS. {@link CandidateId} is
+ * opaque and host-minted, and `candidates.ts` promises only that it is stable
+ * for a queue's life — so two independently written detectors may reuse the
+ * same id for entirely different findings. Carrying one scanner's decisions
+ * into another's scan would silently drop the next detector's question on an
+ * id collision, which is the one failure a first pass cannot afford: a
+ * question nobody was asked looks exactly like a question already answered.
+ */
+ | {
+    readonly kind: 'reset';
+};
+export interface FirstPassOutcome {
+    readonly state: FirstPassState;
+    /**
+     * The queue transition, when one happened.
+     *
+     * Passed through UNCHANGED rather than interpreted: `QueueResult` already
+     * carries the proposal an `apply` stands for and the answer an `undo` took
+     * back, and re-deriving either here would be a second opinion about what the
+     * queue just did.
+     */
+    readonly result: QueueResult | null;
+    /**
+     * The generation of a scan the caller must now run, or `null`.
+     *
+     * REPORTED RATHER THAN PERFORMED, because `findCandidates` returns a promise
+     * and this reducer is pure. The caller runs the scan and sends the answer back
+     * as `candidates` or `scan-failed` carrying this number.
+     */
+    readonly scanning: number | null;
+}
+/**
+ * Apply one command. Total, pure, and never mutates what it is given.
+ *
+ * Every arm guards on the phase, and a command that does not belong to the
+ * current phase changes nothing — the same call `queueReducer` makes about
+ * answering a finished queue, and for the same reason: these arrive from a
+ * reader going fast and from a promise settling late, so neither is an error.
+ */
+export declare function firstPassReducer(state: FirstPassState, command: FirstPassCommand): FirstPassOutcome;
+/** The queue on screen, or `null` when none is. For a shell deciding what to draw. */
+export declare function openQueueOf(state: FirstPassState): QueueState | null;
+//# sourceMappingURL=firstpass.d.ts.map

package/dist/workspace/firstpass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"firstpass.d.ts","sourceRoot":"","sources":["../../src/workspace/firstpass.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,UAAU,EAGhB,MAAM,uBAAuB,CAAC;AAE/B,+DAA+D;AAC/D,MAAM,MAAM,cAAc;AACxB,mDAAmD;AACjD;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE;AAC7B,oEAAoE;GAClE;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAAE;AAC/B;;;;;;;;;;;GAWG;GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAC3B;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;CAAE,CAAC;AAE1D,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B;;;;;;;;;OASG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;IACzC,kEAAkE;IAClE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,eAAO,MAAM,kBAAkB,EAAE,cAI/B,CAAC;AAEH;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GACxB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACzB;IACE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;CAC3C,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACvD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;CAAE,GAC1D;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE;AAC5B;;;;;;;;;;GAUG;GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAE/B,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B;;;;;;;OAOG;IACH,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC;IACpC;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC;AAgCD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,cAAc,EACrB,OAAO,EAAE,gBAAgB,GACxB,gBAAgB,CAiDlB;AAED,sFAAsF;AACtF,wBAAgB,WAAW,CAAC,KAAK,EAAE,cAAc,GAAG,UAAU,GAAG,IAAI,CAEpE"}

package/dist/workspace/firstpass.js

@@ -0,0 +1,151 @@
+/**
+ * The first pass as a slice of the workspace's state — no DOM, no promises.
+ *
+ * `firstpass/queue.ts` is the review loop itself and knows nothing about being
+ * opened or closed; `firstpass/candidates.ts` declares a port whose one method
+ * is asynchronous by construction. Between them sits a lifecycle nobody owned:
+ * the surface is shut, then a scan is out, then a queue is up, and a scan can
+ * fail. That lifecycle is this file, in the shape `selectionReducer`,
+ * `scaleReducer` and `createReducer` already use here — so `host.ts` composes a
+ * fourth reducer rather than growing a fourth set of rules.
+ *
+ * ## The phase is a union, and `decided` sits outside it
+ *
+ * Everything the phase carries belongs to one phase only, so it is a
+ * discriminated union for the reason `firstpass/view.ts` records about its own
+ * three states: the impossible combinations stop existing.
+ *
+ * {@link FirstPassState.decided} is deliberately NOT in the union, because it
+ * is the one fact that has to outlive every phase. See below.
+ *
+ * ## A re-open re-scans, and `decided` is what makes that honest
+ *
+ * Closing drops the queue rather than resuming it: a queue held across a close
+ * carries a candidate set taken before the writes the reader just made, so it
+ * would go on asking about relationships that now exist.
+ *
+ * But a re-scan on its own would re-ask every question the reader already
+ * answered — `queue.ts` defines `reject` as "no, this is not a relationship.
+ * Answered, and gone", and a host's `findCandidates` is never told what was
+ * decided, so it cannot filter them out on the reader's behalf. Forty rejections
+ * would come back on the next open, which is a worse outcome than the resume
+ * this refuses and defeats §17e's "first pass has an end" across sessions.
+ *
+ * So the decided ids ride outside the phase and filter the next scan.
+ *
+ * **`skip` is not decided, and that is the design rather than an omission.**
+ * §17e's `S` is "not now", and `queue.ts` ships `skippedCandidates` precisely
+ * because "the deferred set is the thing a second pass is built from". A skipped
+ * candidate coming back in the next pass is what deferring it meant.
+ *
+ * ## Scans carry a generation, or the newest answer can lose
+ *
+ * A reader who closes during a slow scan and opens again has two scans in
+ * flight. Discriminating on the phase alone cannot tell their answers apart, so
+ * the STALE set — taken before the reader's writes — would open the queue while
+ * the fresh one arrived on `open` and was dropped. That is the exact failure the
+ * re-scan rule exists to prevent, arriving through the door the rule opened.
+ *
+ * {@link FirstPassState.scan} is a monotonic counter. Every scan is issued under
+ * it, every answer carries the number it was issued under, and an answer whose
+ * number is not the current one is dropped.
+ */
+import { openQueue, queueReducer, } from "../firstpass/queue.js";
+export const INITIAL_FIRST_PASS = Object.freeze({
+    phase: Object.freeze({ kind: 'closed' }),
+    decided: Object.freeze([]),
+    scan: 0,
+});
+function still(state) {
+    return { state, result: null, scanning: null };
+}
+/**
+ * The decided set after one queue transition.
+ *
+ * An added `apply` or `reject` joins it; an `undo` takes its candidate back out.
+ * Neither case can collide with an id carried in from an earlier pass, because
+ * the queue was built by filtering those ids out — so the set stays a set
+ * without this function ever having to ask which pass an id came from.
+ */
+function decidedAfter(decided, before, after) {
+    if (after.answers.length > before.answers.length) {
+        const given = after.answers[after.answers.length - 1];
+        if (given === undefined || given.answer === 'skip')
+            return decided;
+        return [...decided, given.candidate.id];
+    }
+    if (after.answers.length < before.answers.length) {
+        const taken = before.answers[before.answers.length - 1];
+        if (taken === undefined || taken.answer === 'skip')
+            return decided;
+        return decided.filter((id) => id !== taken.candidate.id);
+    }
+    return decided;
+}
+/**
+ * Apply one command. Total, pure, and never mutates what it is given.
+ *
+ * Every arm guards on the phase, and a command that does not belong to the
+ * current phase changes nothing — the same call `queueReducer` makes about
+ * answering a finished queue, and for the same reason: these arrive from a
+ * reader going fast and from a promise settling late, so neither is an error.
+ */
+export function firstPassReducer(state, command) {
+    switch (command.kind) {
+        case 'open': {
+            // ONLY FROM `closed`. A second press while a scan is out must not issue a
+            // second scan, and neither `open` nor `failed` is re-openable in place:
+            // both draw a way out, and the way back in is through `closed`.
+            if (state.phase.kind !== 'closed')
+                return still(state);
+            const scan = state.scan + 1;
+            return {
+                state: { ...state, phase: { kind: 'scanning' }, scan },
+                result: null,
+                scanning: scan,
+            };
+        }
+        case 'candidates': {
+            if (state.phase.kind !== 'scanning' || command.scan !== state.scan)
+                return still(state);
+            const decided = new Set(state.decided);
+            // THE DECIDED ARE DROPPED BEFORE THE QUEUE IS BUILT, not hidden after, so
+            // the denominator §17e bounds progress by counts what is actually being
+            // asked. A queue of five that silently skips four would report "0 of 5".
+            const fresh = command.candidates.filter((candidate) => !decided.has(candidate.id));
+            return still({ ...state, phase: { kind: 'open', queue: openQueue(fresh) } });
+        }
+        case 'scan-failed': {
+            if (state.phase.kind !== 'scanning' || command.scan !== state.scan)
+                return still(state);
+            return still({ ...state, phase: { kind: 'failed' } });
+        }
+        case 'queue': {
+            if (state.phase.kind !== 'open')
+                return still(state);
+            const before = state.phase.queue;
+            const result = queueReducer(before, command.command);
+            return {
+                state: {
+                    ...state,
+                    phase: { kind: 'open', queue: result.state },
+                    decided: decidedAfter(state.decided, before, result.state),
+                },
+                result,
+                scanning: null,
+            };
+        }
+        case 'close':
+            // THE QUEUE GOES, `decided` STAYS. See the module header: dropping the
+            // queue is what keeps a re-open fresh, and keeping the decisions is what
+            // keeps it from re-asking. That holds for the SAME scanner; see `reset`.
+            return still({ ...state, phase: { kind: 'closed' } });
+        case 'reset':
+            return still({ ...state, phase: { kind: 'closed' }, decided: [] });
+    }
+}
+/** The queue on screen, or `null` when none is. For a shell deciding what to draw. */
+export function openQueueOf(state) {
+    return state.phase.kind === 'open' ? state.phase.queue : null;
+}
+//# sourceMappingURL=firstpass.js.map

package/dist/workspace/firstpass.js.map

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