@issuegraph/editor 0.1.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../src/firstpass/render.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAEH,OAAO,EAEL,KAAK,KAAK,EAKX,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAA0B,KAAK,aAAa,EAAiB,MAAM,WAAW,CAAC;AACtF,OAAO,KAAK,EAAiB,UAAU,EAAE,MAAM,YAAY,CAAC;AAE5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,6EAA6E;AAC7E,eAAO,MAAM,gBAAgB,mBAAmB,CAAC;AACjD;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,oBAAoB,CAAC;AACnD,wEAAwE;AACxE,eAAO,MAAM,wBAAwB,qBAAqB,CAAC;AAC3D,kCAAkC;AAClC,eAAO,MAAM,kBAAkB,qBAAqB,CAAC;AACrD,uDAAuD;AACvD,eAAO,MAAM,eAAe,kBAAkB,CAAC;AAE/C,MAAM,WAAW,gBAAgB;IAC/B,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,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,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,gFAAgF;IAChF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;;;;;OAOG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAyHD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,gBAAgB,GAAG,eAAe,CAiD7F"}

package/dist/firstpass/render.js

@@ -0,0 +1,216 @@
+/**
+ * The first-pass queue, as markup.
+ *
+ * ## Drawing a candidate answers nothing
+ *
+ * The property §17e turns on, and the one this file most has to be trusted
+ * with: rendering emits no proposal, wires no listener and dispatches nothing.
+ * It publishes `data-ig-answer` on three buttons and stops. The consent
+ * §17e requires — "it always costs one keystroke" — survives because the
+ * only thing in this package that builds a `Proposal` from a candidate is
+ * `queue.ts`'s `apply` arm, and nothing here calls it.
+ *
+ * `render.test.ts` asserts it from the outside: a rendered candidate produces
+ * no proposal, because there is no return channel on which it could.
+ *
+ * ## Every readable byte comes from the host or from the document
+ *
+ * The same total claim `picker/render.ts` makes, and it is stricter here than
+ * it looks, because the evidence text is host prose flowing through a package
+ * surface. This module never reads it, never truncates it and never summarises
+ * it — it places it, with the evidence `token` beside it as a data attribute so
+ * a host can style a class of reason and a test can assert one without matching
+ * on words.
+ *
+ * ## Progress is drawn as a number the host worded, not a bar
+ *
+ * §17e: "100% encoded is never the goal and the workspace never implies it is."
+ * A progress BAR implies a target by its geometry — an empty tail is a thing
+ * left undone — and no wording can undo that. So the surface publishes the two
+ * counts as attributes and renders the host's sentence, and a host that wants a
+ * bar draws one knowing what it is claiming. `<progress>` is deliberately not
+ * used for the same reason.
+ *
+ * ## It names itself without claiming a heading level
+ *
+ * Same call `picker/render.ts` records: a heading would be a claim about the
+ * HOST's document outline — whether this surface is a section of something, and
+ * at what depth — which a package rendered into an unknown page cannot make.
+ *
+ * That refusal used to be the whole of it, and it left the root `<section>`
+ * with no accessible name at all: a screen-reader user navigating by landmarks
+ * met an unnamed generic region and could not tell it from any other. The
+ * refusal was right and the silence that followed it was not, so the region now
+ * carries an `aria-label` from {@link ./words.ts FirstPassWords} — which names
+ * the surface without asserting anything about where it sits in an outline. A
+ * host that wants it in the outline still wraps it in a heading of its own
+ * choosing.
+ */
+import { element, renderMarkup, resolveTheme, themeCss, } from '@issuegraph/viewer';
+import { firstPassView } from "./view.js";
+import { firstPassStylesheet } from "./styles.js";
+/** The attribute a shell reads to know which answer a control stands for. */
+export const ANSWER_ATTRIBUTE = 'data-ig-answer';
+/**
+ * The attribute on the undo control.
+ *
+ * ITS OWN ATTRIBUTE, not `data-ig-answer="undo"`. {@link ./queue.ts Answer} is
+ * a closed union of three, and undo is not one of them — so a shell reading
+ * `data-ig-answer` and switching over `Answer` would be handed a value outside
+ * the type it was told to expect. `data-ig-command` is the spelling
+ * `picker/render.ts` already uses for a control that is not a choice.
+ */
+export const COMMAND_ATTRIBUTE = 'data-ig-command';
+/** The attribute carrying an evidence item's machine-readable token. */
+export const EVIDENCE_TOKEN_ATTRIBUTE = 'data-ig-evidence';
+/** Answers given, on the root. */
+export const ANSWERED_ATTRIBUTE = 'data-ig-answered';
+/** Candidates found — the denominator, on the root. */
+export const FOUND_ATTRIBUTE = 'data-ig-found';
+/** The three answer controls, in §17e's order. */
+const ANSWER_ORDER = Object.freeze(['apply', 'reject', 'skip']);
+/**
+ * One evidence item.
+ *
+ * The text is the host's sentence, placed verbatim. The token rides beside it
+ * as an attribute rather than in the text, which is what keeps the rendered
+ * prose entirely the host's while leaving the item addressable.
+ */
+function evidenceSpec(item) {
+    return element('li', { class: 'ig-firstpass-evidence-item', [EVIDENCE_TOKEN_ATTRIBUTE]: item.token }, [
+        item.text,
+    ]);
+}
+/**
+ * The proposed relationship, drawn subject · kind · object.
+ *
+ * A DEFAULT WORD ORDER, bypassable exactly as the picker's statement is: the
+ * view model carries the ordered pair and the kind and no order beyond that, so
+ * a host whose language arranges it differently renders the model. The
+ * stylesheet lays it out as a flex row, which is what makes that bypass a
+ * restyle rather than a re-implementation.
+ *
+ * The kind is drawn as its FORMAT SPELLING (`blocked-by`), not as a phrase.
+ * `PickerWords` words the kinds for the picker, and asking a host to word them
+ * a second time here would be two vocabularies free to disagree about one
+ * relationship — while reusing `PickerWords` would couple this surface to a
+ * flow it is not part of. The spelling is the document's own token, so it is
+ * the document's word rather than ours, and it is what the owner will see in
+ * the issue body afterwards.
+ */
+function questionSpec(question, words) {
+    return element('div', { class: 'ig-firstpass-question' }, [
+        element('p', { class: 'ig-firstpass-statement', 'data-ig-kind': question.kind }, [
+            element('span', { class: 'ig-firstpass-ref', 'data-ig-role': 'from' }, [question.subject]),
+            element('span', { class: 'ig-firstpass-kind' }, [question.kind]),
+            element('span', { class: 'ig-firstpass-ref', 'data-ig-role': 'to' }, [question.object]),
+        ]),
+        // NO EVIDENCE IS NO BLOCK, rather than an empty list with a heading. A host
+        // whose detector cannot explain itself says so by sending none
+        // (`candidates.ts`), and drawing a labelled empty container would turn that
+        // into a rendering fault the owner has to interpret.
+        question.evidence.length === 0
+            ? null
+            : element('div', { class: 'ig-firstpass-evidence' }, [
+                element('p', { class: 'ig-firstpass-evidence-label' }, [words.evidence]),
+                element('ul', { class: 'ig-firstpass-evidence-list', 'aria-label': words.evidence }, question.evidence.map(evidenceSpec)),
+            ]),
+    ]);
+}
+/**
+ * The answer controls.
+ *
+ * BUTTONS, and a keyboard-first surface still needs them: §17e's claim is that
+ * the loop is reachable with no pointer, not that a pointer is refused. A
+ * surface with keys and no controls would also be a surface with no discoverable
+ * vocabulary and nothing for assistive technology to name.
+ */
+function answersSpec(words) {
+    return element('div', { class: 'ig-firstpass-answers', role: 'group', 'aria-label': words.answersLabel }, ANSWER_ORDER.map((answer) => element('button', { type: 'button', class: 'ig-firstpass-answer', [ANSWER_ATTRIBUTE]: answer }, [words.answers[answer]])));
+}
+/**
+ * The undo control, drawn whenever there is an answer to withdraw.
+ *
+ * ## It survives the finished state, and that is the point of the rule
+ *
+ * The last answer is the one most in need of taking back — an accidental `Y` on
+ * the final candidate creates the `duplicate-of` §17e says "silently removes
+ * real work from the order", and the queue then has no candidate left to show.
+ * An earlier revision replaced every control with the finished message at that
+ * exact moment, so a reader without a keyboard had no way back from the one
+ * answer that matters most.
+ *
+ * ## One rule, so the pointer and the keyboard cannot disagree
+ *
+ * `keys.ts` gates undo on `canUndo` — anything answered — and deliberately
+ * keeps it live once `hasCandidate` is false. Drawing the control on the same
+ * condition is what makes the two paths the same path. The previous version
+ * disagreed at BOTH edges, in opposite directions: it drew a dead control
+ * before anything was answered, and dropped a live one after the last answer.
+ *
+ * A control that does nothing is worse than no control, which is why this
+ * returns `null` rather than a disabled button: the queue is answered at speed,
+ * and an affordance that is sometimes inert teaches the reader to distrust it.
+ */
+function undoSpec(progress, words) {
+    if (progress.answered === 0)
+        return null;
+    return element('button', { type: 'button', class: 'ig-firstpass-undo', [COMMAND_ATTRIBUTE]: 'undo' }, [words.undo]);
+}
+/** The progress line. The host's sentence over this package's two numbers. */
+function progressSpec(progress, words) {
+    return element('p', { class: 'ig-firstpass-progress' }, [
+        words.progress(progress.answered, progress.found),
+    ]);
+}
+/**
+ * Draw the queue.
+ *
+ * Takes a {@link QueueState} — never a store and never a source. A host hands
+ * the proposal a reduction produced to `Store.propose`, which is the only thing
+ * in the family that dispatches.
+ */
+export function renderFirstPass(state, options) {
+    const view = firstPassView(state);
+    const theme = resolveTheme(options.theme);
+    const { words } = options;
+    const body = (() => {
+        switch (view.state) {
+            case 'asking':
+                return [questionSpec(view.question, words), answersSpec(words), undoSpec(view.progress, words)];
+            case 'finished':
+                // UNDO OUTLIVES THE QUESTIONS. `finished` always carries at least one
+                // answer — a queue that found nothing is `empty` instead — so the
+                // control is always drawn here, which is exactly the case that needs it.
+                return [
+                    element('p', { class: 'ig-firstpass-finished' }, [words.finished]),
+                    undoSpec(view.progress, words),
+                ];
+            case 'empty':
+                // A DIFFERENT SENTENCE FROM `finished`, which is the whole reason the
+                // view model separates them. See `view.ts`.
+                //
+                // NO UNDO, and it needs no test to be sure of it: `empty` means the host
+                // found nothing, and nothing found is nothing that can have been
+                // answered — so `undoSpec` would return `null` here anyway.
+                return [element('p', { class: 'ig-firstpass-empty' }, [words.noCandidates])];
+        }
+    })();
+    const root = element('section', {
+        class: 'ig-firstpass',
+        // NAMED WITHOUT CLAIMING AN OUTLINE POSITION. The heading refusal above
+        // is unchanged — a heading LEVEL is a claim about the host's document
+        // structure — but an unnamed `<section>` is a landmark a screen-reader
+        // user cannot identify, so the region carries the host's own name here.
+        'aria-label': words.label,
+        'data-ig-state': view.state,
+        [ANSWERED_ATTRIBUTE]: String(view.progress.answered),
+        [FOUND_ATTRIBUTE]: String(view.progress.found),
+    }, [...body, progressSpec(view.progress, words)]);
+    return {
+        view,
+        markup: renderMarkup(root),
+        styles: `${themeCss(theme, options.themeSelector ?? ':root')}\n${firstPassStylesheet}`,
+    };
+}
+//# sourceMappingURL=render.js.map

package/dist/firstpass/render.js.map

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

package/dist/firstpass/styles.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The first pass's structural stylesheet.
+ *
+ * Same contract as the picker's, the ladder's and the overlay's: layout, weight
+ * and state, never a value. Every colour, length and font is a `var(--ig-…)`
+ * the host's theme resolves, and `styles.test.ts` scans these bytes for a
+ * literal colour, a fixed length and a token the theme does not define — so the
+ * rule is enforced rather than remembered.
+ *
+ * IT ADDS SELECTORS RATHER THAN REDEFINING THEM. Nothing here reaches into the
+ * viewer's own classes; this file styles only what the first pass introduces.
+ *
+ * ## The statement is a FLEX ROW, and that is load-bearing
+ *
+ * `render.ts` draws the proposed relationship subject · kind · object and calls
+ * that word order a default a host may bypass. The CSS `order` property
+ * reorders flex children and does nothing to inline text, so laying it out any
+ * other way would make that claim true only in principle — the same reasoning
+ * the picker's stylesheet records, and enforced by the same kind of test.
+ *
+ * ## There is no progress BAR, and its absence is the design
+ *
+ * §17e: "100% encoded is never the goal and the workspace never implies it is."
+ * A bar implies a target by its geometry — an unfilled tail reads as work
+ * outstanding whatever the words beside it say. The progress line is therefore
+ * typographic, and this sheet gives it no track, no fill and no width driven by
+ * the counts. A host that wants a bar draws one knowing what it is claiming.
+ *
+ * ## Every control gets a focus ring
+ *
+ * The queue is keyboard-first, so a control with no `:focus-visible` rule is
+ * unreachable for the reader this surface is built for on any host that resets
+ * the UA outline. Enforced in `styles.test.ts`.
+ */
+export declare const firstPassStylesheet = "\n.ig-firstpass {\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  background: var(--ig-surface);\n  border-radius: var(--ig-radius);\n  padding: var(--ig-space);\n}\n\n.ig-firstpass-question {\n  display: flex;\n  flex-direction: column;\n  gap: var(--ig-space-tight);\n}\n\n.ig-firstpass-statement {\n  display: flex;\n  flex-wrap: wrap;\n  align-items: baseline;\n  gap: var(--ig-space-tight);\n  margin: 0;\n  color: var(--ig-text);\n}\n\n.ig-firstpass-ref {\n  font-family: var(--ig-font-mono);\n}\n\n.ig-firstpass-kind {\n  font-family: var(--ig-font-mono);\n  color: var(--ig-text-muted);\n}\n\n.ig-firstpass-evidence {\n  display: flex;\n  flex-direction: column;\n  gap: var(--ig-space-tight);\n  border-left: var(--ig-stroke) solid var(--ig-line);\n  padding-left: var(--ig-space);\n}\n\n.ig-firstpass-evidence-label {\n  margin: 0;\n  font-size: var(--ig-font-size-small);\n  color: var(--ig-text-muted);\n}\n\n.ig-firstpass-evidence-list {\n  display: flex;\n  flex-direction: column;\n  gap: var(--ig-space-tight);\n  margin: 0;\n  padding: 0;\n  list-style: none;\n}\n\n.ig-firstpass-evidence-item {\n  font-size: var(--ig-font-size-small);\n  color: var(--ig-text-body);\n}\n\n.ig-firstpass-answers {\n  display: flex;\n  flex-wrap: wrap;\n  gap: var(--ig-space-tight);\n}\n\n.ig-firstpass-answer,\n.ig-firstpass-undo {\n  font: inherit;\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}\n\n/* The one answer that writes. Weighted so the irreversible option is the one\n   the eye lands on \u2014 \u00A717e's consent rule is about knowing what you agreed to,\n   and that starts before the keystroke. */\n.ig-firstpass-answer[data-ig-answer='apply'] {\n  border-color: var(--ig-accent);\n}\n\n.ig-firstpass-undo {\n  align-self: flex-start;\n  color: var(--ig-text-muted);\n}\n\n.ig-firstpass-answer:focus-visible,\n.ig-firstpass-undo:focus-visible {\n  outline: var(--ig-focus-ring) solid var(--ig-focus);\n  outline-offset: var(--ig-stroke);\n}\n\n.ig-firstpass-progress {\n  margin: 0;\n  font-size: var(--ig-font-size-small);\n  color: var(--ig-text-muted);\n}\n\n.ig-firstpass-finished,\n.ig-firstpass-empty {\n  margin: 0;\n  color: var(--ig-text);\n}\n";
+//# sourceMappingURL=styles.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../src/firstpass/styles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,eAAO,MAAM,mBAAmB,m9EAgH/B,CAAC"}

package/dist/firstpass/styles.js

@@ -0,0 +1,148 @@
+/**
+ * The first pass's structural stylesheet.
+ *
+ * Same contract as the picker's, the ladder's and the overlay's: layout, weight
+ * and state, never a value. Every colour, length and font is a `var(--ig-…)`
+ * the host's theme resolves, and `styles.test.ts` scans these bytes for a
+ * literal colour, a fixed length and a token the theme does not define — so the
+ * rule is enforced rather than remembered.
+ *
+ * IT ADDS SELECTORS RATHER THAN REDEFINING THEM. Nothing here reaches into the
+ * viewer's own classes; this file styles only what the first pass introduces.
+ *
+ * ## The statement is a FLEX ROW, and that is load-bearing
+ *
+ * `render.ts` draws the proposed relationship subject · kind · object and calls
+ * that word order a default a host may bypass. The CSS `order` property
+ * reorders flex children and does nothing to inline text, so laying it out any
+ * other way would make that claim true only in principle — the same reasoning
+ * the picker's stylesheet records, and enforced by the same kind of test.
+ *
+ * ## There is no progress BAR, and its absence is the design
+ *
+ * §17e: "100% encoded is never the goal and the workspace never implies it is."
+ * A bar implies a target by its geometry — an unfilled tail reads as work
+ * outstanding whatever the words beside it say. The progress line is therefore
+ * typographic, and this sheet gives it no track, no fill and no width driven by
+ * the counts. A host that wants a bar draws one knowing what it is claiming.
+ *
+ * ## Every control gets a focus ring
+ *
+ * The queue is keyboard-first, so a control with no `:focus-visible` rule is
+ * unreachable for the reader this surface is built for on any host that resets
+ * the UA outline. Enforced in `styles.test.ts`.
+ */
+export const firstPassStylesheet = `
+.ig-firstpass {
+  display: flex;
+  flex-direction: column;
+  gap: var(--ig-space);
+  font-family: var(--ig-font-ui);
+  font-size: var(--ig-font-size);
+  line-height: var(--ig-line-height);
+  color: var(--ig-text-body);
+  background: var(--ig-surface);
+  border-radius: var(--ig-radius);
+  padding: var(--ig-space);
+}
+
+.ig-firstpass-question {
+  display: flex;
+  flex-direction: column;
+  gap: var(--ig-space-tight);
+}
+
+.ig-firstpass-statement {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  gap: var(--ig-space-tight);
+  margin: 0;
+  color: var(--ig-text);
+}
+
+.ig-firstpass-ref {
+  font-family: var(--ig-font-mono);
+}
+
+.ig-firstpass-kind {
+  font-family: var(--ig-font-mono);
+  color: var(--ig-text-muted);
+}
+
+.ig-firstpass-evidence {
+  display: flex;
+  flex-direction: column;
+  gap: var(--ig-space-tight);
+  border-left: var(--ig-stroke) solid var(--ig-line);
+  padding-left: var(--ig-space);
+}
+
+.ig-firstpass-evidence-label {
+  margin: 0;
+  font-size: var(--ig-font-size-small);
+  color: var(--ig-text-muted);
+}
+
+.ig-firstpass-evidence-list {
+  display: flex;
+  flex-direction: column;
+  gap: var(--ig-space-tight);
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.ig-firstpass-evidence-item {
+  font-size: var(--ig-font-size-small);
+  color: var(--ig-text-body);
+}
+
+.ig-firstpass-answers {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--ig-space-tight);
+}
+
+.ig-firstpass-answer,
+.ig-firstpass-undo {
+  font: inherit;
+  color: var(--ig-text);
+  background: var(--ig-surface-2);
+  border: var(--ig-stroke) solid var(--ig-line);
+  border-radius: var(--ig-radius);
+  padding: var(--ig-space-tight) var(--ig-space);
+  cursor: pointer;
+}
+
+/* The one answer that writes. Weighted so the irreversible option is the one
+   the eye lands on — §17e's consent rule is about knowing what you agreed to,
+   and that starts before the keystroke. */
+.ig-firstpass-answer[data-ig-answer='apply'] {
+  border-color: var(--ig-accent);
+}
+
+.ig-firstpass-undo {
+  align-self: flex-start;
+  color: var(--ig-text-muted);
+}
+
+.ig-firstpass-answer:focus-visible,
+.ig-firstpass-undo:focus-visible {
+  outline: var(--ig-focus-ring) solid var(--ig-focus);
+  outline-offset: var(--ig-stroke);
+}
+
+.ig-firstpass-progress {
+  margin: 0;
+  font-size: var(--ig-font-size-small);
+  color: var(--ig-text-muted);
+}
+
+.ig-firstpass-finished,
+.ig-firstpass-empty {
+  margin: 0;
+  color: var(--ig-text);
+}
+`;
+//# sourceMappingURL=styles.js.map

package/dist/firstpass/styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.js","sourceRoot":"","sources":["../../src/firstpass/styles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,MAAM,CAAC,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgHlC,CAAC"}

package/dist/firstpass/view.d.ts

@@ -0,0 +1,82 @@
+/**
+ * The queue as a view model: one question, its evidence, and where you are.
+ *
+ * Everything a shell needs to draw the first pass, and nothing about how. Same
+ * split `picker/view.ts` and `reevaluate/view.ts` keep — the model is
+ * exhaustively testable on a runtime with no DOM, and `render.ts` is left with
+ * nothing to get wrong except markup.
+ *
+ * ## The three states are a union, not a candidate plus two flags
+ *
+ * A queue is showing a question, or it has finished, or the host found nothing
+ * to ask about. Modelled as one nullable candidate beside a `finished` boolean,
+ * two of the four combinations would be unreachable and a renderer would still
+ * have to answer for them. As a union each state carries exactly the fields it
+ * has, and §17e's insistence that an empty queue and a completed queue read
+ * DIFFERENTLY becomes something the type enforces rather than something a
+ * renderer remembers.
+ *
+ * ## Progress rides on every state
+ *
+ * Including `finished` — an owner who just answered the last question wants to
+ * see the 64 they answered, not a bare congratulation. And including `empty`,
+ * where it is honestly zero of zero: §17e's rule is that the denominator is
+ * candidates found, and a host that found none has a denominator, not a missing
+ * one.
+ */
+import type { Candidate } from './candidates.ts';
+import { type QueueProgress, type QueueState } from './queue.ts';
+/**
+ * The question on screen.
+ *
+ * It restates the candidate's own fields rather than nesting it, so a renderer
+ * reads `view.subject` instead of `view.candidate.from` — and so the ordered
+ * pair is named for what it MEANS in the sentence being asked. Nothing here
+ * chooses a word order; that is `render.ts`'s default and a host may bypass it,
+ * exactly as the picker's statement is bypassable.
+ */
+export interface FirstPassQuestion {
+    readonly candidate: Candidate;
+    /** The issue the proposed relationship starts from. */
+    readonly subject: string;
+    /** The issue it points at. */
+    readonly object: string;
+    /** Which relationship is proposed. */
+    readonly kind: string;
+    /** Why the host proposed it. May be empty — see `candidates.ts`. */
+    readonly evidence: readonly {
+        readonly token: string;
+        readonly text: string;
+    }[];
+}
+/**
+ * What the surface is showing.
+ *
+ * `asking` carries the question; the other two carry none, because there is
+ * none. A discriminated union so a renderer's switch is exhaustive and a fourth
+ * state — were the design ever to grow one — is a compile error rather than a
+ * blank panel.
+ */
+export type FirstPassView = {
+    readonly state: 'asking';
+    readonly question: FirstPassQuestion;
+    readonly progress: QueueProgress;
+} | {
+    readonly state: 'finished';
+    readonly progress: QueueProgress;
+} | {
+    readonly state: 'empty';
+    readonly progress: QueueProgress;
+};
+/**
+ * The view for a queue. Total and pure.
+ *
+ * `empty` is decided by the DENOMINATOR rather than by the cursor, which is the
+ * one subtlety here: a queue of zero candidates is finished the moment it
+ * opens, so a test on `finished` alone would report the misconfigured-detector
+ * case as a completed first pass. §17e's two facts stay separate because the
+ * question asked to tell them apart is "did the host find anything?", not "is
+ * there anything left?".
+ */
+export declare function firstPassView(state: QueueState): FirstPassView;
+//# sourceMappingURL=view.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"view.d.ts","sourceRoot":"","sources":["../../src/firstpass/view.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,UAAU,EAAmC,MAAM,YAAY,CAAC;AAElG;;;;;;;;GAQG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,uDAAuD;IACvD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,8BAA8B;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,sCAAsC;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,EAAE,SAAS;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACjF;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAA;CAAE,GACpG;IAAE,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAA;CAAE,GAChE;IAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAA;CAAE,CAAC;AAElE;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,CAqB9D"}

package/dist/firstpass/view.js

@@ -0,0 +1,60 @@
+/**
+ * The queue as a view model: one question, its evidence, and where you are.
+ *
+ * Everything a shell needs to draw the first pass, and nothing about how. Same
+ * split `picker/view.ts` and `reevaluate/view.ts` keep — the model is
+ * exhaustively testable on a runtime with no DOM, and `render.ts` is left with
+ * nothing to get wrong except markup.
+ *
+ * ## The three states are a union, not a candidate plus two flags
+ *
+ * A queue is showing a question, or it has finished, or the host found nothing
+ * to ask about. Modelled as one nullable candidate beside a `finished` boolean,
+ * two of the four combinations would be unreachable and a renderer would still
+ * have to answer for them. As a union each state carries exactly the fields it
+ * has, and §17e's insistence that an empty queue and a completed queue read
+ * DIFFERENTLY becomes something the type enforces rather than something a
+ * renderer remembers.
+ *
+ * ## Progress rides on every state
+ *
+ * Including `finished` — an owner who just answered the last question wants to
+ * see the 64 they answered, not a bare congratulation. And including `empty`,
+ * where it is honestly zero of zero: §17e's rule is that the denominator is
+ * candidates found, and a host that found none has a denominator, not a missing
+ * one.
+ */
+import { currentCandidate, queueProgress } from "./queue.js";
+/**
+ * The view for a queue. Total and pure.
+ *
+ * `empty` is decided by the DENOMINATOR rather than by the cursor, which is the
+ * one subtlety here: a queue of zero candidates is finished the moment it
+ * opens, so a test on `finished` alone would report the misconfigured-detector
+ * case as a completed first pass. §17e's two facts stay separate because the
+ * question asked to tell them apart is "did the host find anything?", not "is
+ * there anything left?".
+ */
+export function firstPassView(state) {
+    const progress = queueProgress(state);
+    if (progress.found === 0)
+        return { state: 'empty', progress };
+    const candidate = currentCandidate(state);
+    if (candidate === null)
+        return { state: 'finished', progress };
+    return {
+        state: 'asking',
+        progress,
+        question: {
+            candidate,
+            subject: candidate.from,
+            object: candidate.to,
+            kind: candidate.kind,
+            // COPIED RATHER THAN PASSED THROUGH, so the view model is a plain value a
+            // host can serialise, compare or snapshot without carrying a reference
+            // into the candidate set it came from.
+            evidence: candidate.evidence.map((item) => ({ token: item.token, text: item.text })),
+        },
+    };
+}
+//# sourceMappingURL=view.js.map

package/dist/firstpass/view.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"view.js","sourceRoot":"","sources":["../../src/firstpass/view.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAGH,OAAO,EAAuC,gBAAgB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAoClG;;;;;;;;;GASG;AACH,MAAM,UAAU,aAAa,CAAC,KAAiB;IAC7C,MAAM,QAAQ,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;IACtC,IAAI,QAAQ,CAAC,KAAK,KAAK,CAAC;QAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC;IAE9D,MAAM,SAAS,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC;IAC1C,IAAI,SAAS,KAAK,IAAI;QAAE,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC;IAE/D,OAAO;QACL,KAAK,EAAE,QAAQ;QACf,QAAQ;QACR,QAAQ,EAAE;YACR,SAAS;YACT,OAAO,EAAE,SAAS,CAAC,IAAI;YACvB,MAAM,EAAE,SAAS,CAAC,EAAE;YACpB,IAAI,EAAE,SAAS,CAAC,IAAI;YACpB,0EAA0E;YAC1E,uEAAuE;YACvE,uCAAuC;YACvC,QAAQ,EAAE,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;SACrF;KACF,CAAC;AACJ,CAAC"}