@issuegraph/editor 0.1.0

package/dist/audit/styles.js

@@ -0,0 +1,72 @@
+/**
+ * The audit's structural stylesheet.
+ *
+ * Same contract as the viewer's and the ladder's, and for the same reason: it
+ * carries layout, weight and state, never a value. Every colour and length is a
+ * `var(--ig-…)` the host's theme already resolves, so a second theme keeps
+ * working here. `styles.test.ts` scans these bytes for a literal and for a
+ * token the theme does not define.
+ *
+ * NO TOKENS OF ITS OWN, WHICH IS A REVERSAL WORTH RECORDING. An earlier draft
+ * declared `--ig-audit-bar` and shipped an `auditThemeCss()` to default it. The
+ * failure mode that killed it is the one this package's other stylesheet test
+ * exists to catch: a host that installs the viewer's theme and forgets a second
+ * one gets a `var()` resolving to nothing, and the bar silently does not draw —
+ * "the failure that looks like a styling bug for weeks". Reading the palette's
+ * own gold has no such state, and a host who wants a different attention colour
+ * still has one: target the attribute in their own CSS, which needs no API from
+ * us. Fewer exports is also the safer direction for a package that can add one
+ * later and never take one back.
+ *
+ * THE BAR IS AN INSET BOX SHADOW rather than a border, because a border changes
+ * a row's box and every affected row would shift by its width the moment a
+ * finding appeared. §17d asks for a count that never moves; a rail that jumps
+ * would be the same broken promise one element over.
+ *
+ * SCOPING, THE ONE PLACE THIS DEPARTS FROM ITS SIBLINGS. They scope every
+ * selector under an `.ig-` class because they own the elements they draw. The
+ * bar does not: it lands on a row the VIEWER rendered, and adding a class there
+ * means rewriting a `class` attribute this layer has no business touching. So
+ * it is scoped by {@link AUDIT_SEVERITY_ATTRIBUTE} instead — this package's own
+ * namespaced name, which bounds it to elements a host stamped on purpose.
+ *
+ * There is no transition, no animation and no `@keyframes` here, and there is a
+ * test that says so.
+ */
+import { AUDIT_SEVERITY_ATTRIBUTE } from "./surface.js";
+export const auditStylesheet = `
+.ig-audit {
+  align-items: center;
+  display: inline-flex;
+  font-family: var(--ig-font-ui);
+  font-size: var(--ig-font-size-small);
+  gap: var(--ig-space-tight);
+}
+
+.ig-audit-toggle {
+  align-items: center;
+  background: none;
+  border: 0;
+  color: var(--ig-text-muted);
+  cursor: pointer;
+  display: inline-flex;
+  font: inherit;
+  gap: var(--ig-space-tight);
+  padding: 0;
+}
+
+.ig-audit-toggle[aria-pressed='true'] {
+  color: var(--ig-text);
+}
+
+.ig-audit-count {
+  color: var(--ig-text);
+  font-family: var(--ig-font-mono);
+  font-variant-numeric: tabular-nums;
+}
+
+[${AUDIT_SEVERITY_ATTRIBUTE}] {
+  box-shadow: inset var(--ig-stroke) 0 0 0 var(--ig-edge-serialize-with);
+}
+`;
+//# sourceMappingURL=styles.js.map

package/dist/audit/styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.js","sourceRoot":"","sources":["../../src/audit/styles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAExD,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+B5B,wBAAwB;;;CAG1B,CAAC"}

package/dist/audit/surface.d.ts

@@ -0,0 +1,155 @@
+/**
+ * The ambient half of the audit: attention without nagging.
+ *
+ * §17d fixes both what this is and what it may never be. It is a **persistent
+ * header count** that never moves and never animates, a **left-bar** on the
+ * rail rows a finding touches, and an audit **filter**. It is explicitly not a
+ * modal, a toast, a red banner, an animated badge, anything that blocks the
+ * edit loop, or an auto-fix — every finding is a judgment call, so the surface
+ * offers navigation and never a remedy.
+ *
+ * §17a settles the last of those: audit is *"a filter, not a mode — a mode you
+ * must enter is a mode you forget, and encoding errors need to be visible while
+ * you work."* So the count is always drawn, including at zero, and the toggle
+ * narrows what is listed rather than switching the workspace into something
+ * else.
+ *
+ * ## Why the bar is CSS on an attribute rather than a drawn element
+ *
+ * The rows belong to `@issuegraph/viewer`, which stamps `KEY_ATTRIBUTE` on
+ * them. Layer 2 composes layer 1 through its public surface, and the viewer's
+ * markup primitive is deliberately not on it — so an overlay drawn from out
+ * here would have to re-implement HTML escaping, which is duplication with an
+ * injection shape rather than a mirror that merely drifts.
+ *
+ * An attribute plus a stylesheet needs neither. {@link auditRowAttributes}
+ * answers what an affected row carries, `./styles.ts` draws the bar from it,
+ * and the whole exchange is data. It also settles nothing about HOW
+ * overlays attach, which is a separate decision with its own change.
+ *
+ * ## Nothing here renders host text
+ *
+ * The only value that reaches the markup is a COUNT, and a count is a number.
+ * That is a deliberate boundary rather than a happy accident: a finding's
+ * `detail` is prose about issues a host supplied, so drawing it here would put
+ * an escaper in a package whose seam says it may not have one. Findings travel
+ * as data; whatever lists them owns their escaping.
+ *
+ * @see https://github.com/autnmy/issuegraph/blob/main/SPEC.md
+ */
+import type { IssueRef } from '@issuegraph/store';
+import type { AuditClass, AuditFinding, AuditInput, AuditSeverity } from './findings.ts';
+/**
+ * The attribute an affected rail row carries. Its value is the severity that
+ * won the row, so a host can style the four differently without this package
+ * deciding that they should be.
+ */
+export declare const AUDIT_SEVERITY_ATTRIBUTE = "data-ig-audit";
+/** The attribute carrying the persistent count, for a host that reads it back. */
+export declare const AUDIT_COUNT_ATTRIBUTE = "data-ig-audit-count";
+/**
+ * The attribute marking the filter toggle, so a host can bind to it without
+ * matching on a class name that is a styling hook rather than a contract.
+ */
+export declare const AUDIT_FILTER_ATTRIBUTE = "data-ig-audit-filter";
+/** What one affected row is told about itself. */
+export interface AuditRow {
+    readonly ref: IssueRef;
+    /**
+     * The severity of the heaviest finding on this row — `weight` in
+     * {@link AUDIT_CLASS_SPECS}, which exists for exactly this.
+     */
+    readonly severity: AuditSeverity;
+    /** Every class present on the row, in {@link AUDIT_CLASSES} order. */
+    readonly kinds: readonly AuditClass[];
+    /** How many findings name this row. */
+    readonly count: number;
+}
+/**
+ * The two things the ambient surface draws, plus the index they are looked up
+ * through.
+ *
+ * AN IN-PROCESS VALUE, NOT A PAYLOAD — the same distinction
+ * `@issuegraph/viewer` draws between its normalized document and the plain
+ * shape a host sends over a wire. {@link AuditOverlay.rowFor} is a closure, so
+ * this does not serialize; what crosses a boundary is the DOCUMENT, and a
+ * receiver builds its own overlay from it.
+ */
+export interface AuditOverlay {
+    /**
+     * The header count: findings, not affected rows.
+     *
+     * FINDINGS, BECAUSE THAT IS WHAT THE OWNER WORKS THROUGH. One cycle across
+     * six issues is one judgment call, not six, and counting rows would report it
+     * as six pieces of work while the list has one entry.
+     */
+    readonly count: number;
+    /** One entry per affected ref, sorted, so two renders agree. */
+    readonly rows: readonly AuditRow[];
+    /**
+     * The row for a ref, or `undefined` when it is clean.
+     *
+     * A FUNCTION RATHER THAN THE INDEX ITSELF, and the difference is not
+     * cosmetic: `ReadonlyMap` is a TypeScript restriction and nothing more, so
+     * handing out the live `Map` let a JavaScript consumer call `.clear()` on it
+     * — after which the lookups disagreed with `rows`, `findings` and `count`,
+     * which is the inconsistency this whole value exists to prevent. A closure
+     * over a private index cannot be reached at all, and still answers in
+     * constant time, which a scan per row would not.
+     */
+    readonly rowFor: (ref: IssueRef) => AuditRow | undefined;
+    /** The findings themselves, carried through unchanged. */
+    readonly findings: readonly AuditFinding[];
+}
+/**
+ * Project findings onto the two things the ambient surface draws.
+ *
+ * Pure, and a function of the findings alone: it neither re-detects anything
+ * nor reads the document, so the count on screen and the list behind it can
+ * never disagree about what was found.
+ */
+export declare function auditOverlay(input: AuditInput): AuditOverlay;
+/**
+ * What an affected row carries, or an empty record when the row is clean.
+ *
+ * An EMPTY RECORD rather than `undefined`, so a caller spreads the answer
+ * unconditionally and a clean row simply contributes nothing. A caller that
+ * branched would be one `if` away from stamping `undefined` into an attribute,
+ * which reads in the DOM as the string.
+ */
+export declare function auditRowAttributes(overlay: AuditOverlay, ref: IssueRef): Readonly<Record<string, string>>;
+/** Whether the audit filter would keep this row. Clean rows are hidden by it. */
+export declare function auditFilterKeeps(overlay: AuditOverlay, ref: IssueRef): boolean;
+/**
+ * The heaviest row among several refs, or `undefined` when all of them are clean.
+ *
+ * FOR A ROW THAT SPEAKS FOR MORE THAN ONE ISSUE. A `together-with` unit is one
+ * rail row and several refs, so a caller drawing a bar for that row has to pick
+ * which member's severity it shows — and the answer is the heaviest, exactly as
+ * {@link AuditRow.severity} picks the heaviest CLASS within one ref.
+ *
+ * IT LIVES HERE BECAUSE THE WEIGHTS DO. The obvious alternative is for the
+ * caller to rank the rows itself, and the obvious shortcut — take the first
+ * matching entry in `rows` — is wrong in a way that looks right: `rows` is
+ * sorted by `ref`, lexicographically, so "first match" returns whichever member
+ * sorts earliest and a `stale-blocker` on `a` masks a `cycle` on `b`. Ranking
+ * belongs next to the table it ranks by, so no caller holds a second copy of it.
+ */
+export declare function heaviestRow(overlay: AuditOverlay, refs: readonly IssueRef[]): AuditRow | undefined;
+export interface AuditHeaderOptions {
+    /** Whether the filter is currently narrowing the rail. Defaults to `false`. */
+    readonly filtered?: boolean | undefined;
+}
+/**
+ * The persistent header count, as markup.
+ *
+ * ONE CONTROL, ALWAYS PRESENT, ALWAYS THE SAME CLICK — including at zero, which
+ * is why it is neither hidden nor disabled when nothing is found. A control
+ * that appears when there is bad news is a control the eye has to re-find, and
+ * §17d's whole ask is that the audit never demands attention it has not earned.
+ *
+ * A `button` with `aria-pressed`, because a filter toggle is a toggle: it has
+ * two states and a screen reader has to be able to say which one is on.
+ */
+export declare function renderAuditHeader(overlay: AuditOverlay, options?: AuditHeaderOptions): string;
+//# sourceMappingURL=surface.d.ts.map

package/dist/audit/surface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface.d.ts","sourceRoot":"","sources":["../../src/audit/surface.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAGlD,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEzF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,kBAAkB,CAAC;AAExD,kFAAkF;AAClF,eAAO,MAAM,qBAAqB,wBAAwB,CAAC;AAE3D;;;GAGG;AACH,eAAO,MAAM,sBAAsB,yBAAyB,CAAC;AAE7D,kDAAkD;AAClD,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC;IACvB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC,sEAAsE;IACtE,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,CAAC;IACtC,uCAAuC;IACvC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,gEAAgE;IAChE,QAAQ,CAAC,IAAI,EAAE,SAAS,QAAQ,EAAE,CAAC;IACnC;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,QAAQ,KAAK,QAAQ,GAAG,SAAS,CAAC;IACzD,0DAA0D;IAC1D,QAAQ,CAAC,QAAQ,EAAE,SAAS,YAAY,EAAE,CAAC;CAC5C;AAMD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,YAAY,CAmE5D;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,YAAY,EACrB,GAAG,EAAE,QAAQ,GACZ,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAIlC;AAED,iFAAiF;AACjF,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,EAAE,QAAQ,GAAG,OAAO,CAE9E;AAUD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,YAAY,EACrB,IAAI,EAAE,SAAS,QAAQ,EAAE,GACxB,QAAQ,GAAG,SAAS,CAQtB;AAED,MAAM,WAAW,kBAAkB;IACjC,+EAA+E;IAC/E,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACzC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,YAAY,EAAE,OAAO,GAAE,kBAAuB,GAAG,MAAM,CAYjG"}

package/dist/audit/surface.js

@@ -0,0 +1,202 @@
+/**
+ * The ambient half of the audit: attention without nagging.
+ *
+ * §17d fixes both what this is and what it may never be. It is a **persistent
+ * header count** that never moves and never animates, a **left-bar** on the
+ * rail rows a finding touches, and an audit **filter**. It is explicitly not a
+ * modal, a toast, a red banner, an animated badge, anything that blocks the
+ * edit loop, or an auto-fix — every finding is a judgment call, so the surface
+ * offers navigation and never a remedy.
+ *
+ * §17a settles the last of those: audit is *"a filter, not a mode — a mode you
+ * must enter is a mode you forget, and encoding errors need to be visible while
+ * you work."* So the count is always drawn, including at zero, and the toggle
+ * narrows what is listed rather than switching the workspace into something
+ * else.
+ *
+ * ## Why the bar is CSS on an attribute rather than a drawn element
+ *
+ * The rows belong to `@issuegraph/viewer`, which stamps `KEY_ATTRIBUTE` on
+ * them. Layer 2 composes layer 1 through its public surface, and the viewer's
+ * markup primitive is deliberately not on it — so an overlay drawn from out
+ * here would have to re-implement HTML escaping, which is duplication with an
+ * injection shape rather than a mirror that merely drifts.
+ *
+ * An attribute plus a stylesheet needs neither. {@link auditRowAttributes}
+ * answers what an affected row carries, `./styles.ts` draws the bar from it,
+ * and the whole exchange is data. It also settles nothing about HOW
+ * overlays attach, which is a separate decision with its own change.
+ *
+ * ## Nothing here renders host text
+ *
+ * The only value that reaches the markup is a COUNT, and a count is a number.
+ * That is a deliberate boundary rather than a happy accident: a finding's
+ * `detail` is prose about issues a host supplied, so drawing it here would put
+ * an escaper in a package whose seam says it may not have one. Findings travel
+ * as data; whatever lists them owns their escaping.
+ *
+ * @see https://github.com/autnmy/issuegraph/blob/main/SPEC.md
+ */
+import { AUDIT_CLASSES, AUDIT_CLASS_SPECS, auditDocument } from "./findings.js";
+/**
+ * The attribute an affected rail row carries. Its value is the severity that
+ * won the row, so a host can style the four differently without this package
+ * deciding that they should be.
+ */
+export const AUDIT_SEVERITY_ATTRIBUTE = 'data-ig-audit';
+/** The attribute carrying the persistent count, for a host that reads it back. */
+export const AUDIT_COUNT_ATTRIBUTE = 'data-ig-audit-count';
+/**
+ * The attribute marking the filter toggle, so a host can bind to it without
+ * matching on a class name that is a styling hook rather than a contract.
+ */
+export const AUDIT_FILTER_ATTRIBUTE = 'data-ig-audit-filter';
+const CLASS_ORDER = new Map(AUDIT_CLASSES.map((kind, index) => [kind, index]));
+/**
+ * Project findings onto the two things the ambient surface draws.
+ *
+ * Pure, and a function of the findings alone: it neither re-detects anything
+ * nor reads the document, so the count on screen and the list behind it can
+ * never disagree about what was found.
+ */
+export function auditOverlay(input) {
+    // IT RUNS THE AUDIT RATHER THAN ACCEPTING ONE. Taking a finding list made
+    // this a public boundary for values TypeScript never checked, and six review
+    // rounds each found a different way for one to be wrong — a mutable array, a
+    // mutable `members`, a `severity` disagreeing with its `kind`, a prototype
+    // key, a ref named twice, a finding naming nobody. That surface is not
+    // enumerable, so it is gone instead of defended: every finding here was built
+    // by the detector, with its invariants established rather than checked.
+    //
+    // The cost is a host that persisted findings must re-audit to draw them. That
+    // is the right way round anyway — the audit is pure and cheap, and a
+    // persisted finding may not describe the document being drawn.
+    const findings = auditDocument(input);
+    // ROWS ARE RAIL ROWS, so only a ref the document carries can have one. A
+    // refusal may name an issue outside a paged document — the detector supports
+    // that on purpose, because filtering findings to the loaded set would drop
+    // them on exactly the issues paging has not reached — but a ROW for such a
+    // ref advertises a rail entry that does not exist, and a consumer iterating
+    // `rows` to filter or navigate would offer an unreachable issue. The finding
+    // and the header count keep it; the row index does not.
+    const carried = new Set(input.document.issues.map((issue) => issue.ref));
+    const byRef = new Map();
+    for (const found of findings) {
+        for (const ref of found.members) {
+            if (!carried.has(ref))
+                continue;
+            const existing = byRef.get(ref);
+            if (existing === undefined) {
+                byRef.set(ref, { kinds: new Set([found.kind]), count: 1 });
+                continue;
+            }
+            existing.kinds.add(found.kind);
+            existing.count += 1;
+        }
+    }
+    const rows = [];
+    for (const [ref, { kinds, count }] of byRef) {
+        const ordered = [...kinds].sort((a, b) => (CLASS_ORDER.get(a) ?? 0) - (CLASS_ORDER.get(b) ?? 0));
+        // The heaviest class speaks for the row. Written as a loop rather than a
+        // seedless `reduce`, which throws on an empty list: a ref only enters the
+        // map by carrying a finding, so the list cannot be empty today — and an
+        // expression whose totality rests on an invariant stated three lines away
+        // is one refactor from a TypeError.
+        let heaviest;
+        for (const kind of ordered) {
+            if (heaviest === undefined || AUDIT_CLASS_SPECS[kind].weight > AUDIT_CLASS_SPECS[heaviest].weight) {
+                heaviest = kind;
+            }
+        }
+        if (heaviest === undefined)
+            continue;
+        rows.push({
+            ref,
+            severity: AUDIT_CLASS_SPECS[heaviest].severity,
+            kinds: Object.freeze(ordered),
+            count,
+        });
+    }
+    rows.sort((a, b) => (a.ref < b.ref ? -1 : a.ref > b.ref ? 1 : 0));
+    const index = new Map(rows.map((row) => [row.ref, row]));
+    return Object.freeze({
+        count: findings.length,
+        rows: Object.freeze(rows.map((row) => Object.freeze(row))),
+        // The index is captured, never exposed — see `rowFor`.
+        rowFor: (ref) => index.get(ref),
+        findings,
+    });
+}
+/**
+ * What an affected row carries, or an empty record when the row is clean.
+ *
+ * An EMPTY RECORD rather than `undefined`, so a caller spreads the answer
+ * unconditionally and a clean row simply contributes nothing. A caller that
+ * branched would be one `if` away from stamping `undefined` into an attribute,
+ * which reads in the DOM as the string.
+ */
+export function auditRowAttributes(overlay, ref) {
+    const row = overlay.rowFor(ref);
+    if (row === undefined)
+        return Object.freeze({});
+    return Object.freeze({ [AUDIT_SEVERITY_ATTRIBUTE]: row.severity });
+}
+/** Whether the audit filter would keep this row. Clean rows are hidden by it. */
+export function auditFilterKeeps(overlay, ref) {
+    return overlay.rowFor(ref) !== undefined;
+}
+/** How heavy a row's worst finding is, from the class table and nothing else. */
+function rowWeight(row) {
+    return row.kinds.reduce((heaviest, kind) => Math.max(heaviest, AUDIT_CLASS_SPECS[kind].weight), Number.NEGATIVE_INFINITY);
+}
+/**
+ * The heaviest row among several refs, or `undefined` when all of them are clean.
+ *
+ * FOR A ROW THAT SPEAKS FOR MORE THAN ONE ISSUE. A `together-with` unit is one
+ * rail row and several refs, so a caller drawing a bar for that row has to pick
+ * which member's severity it shows — and the answer is the heaviest, exactly as
+ * {@link AuditRow.severity} picks the heaviest CLASS within one ref.
+ *
+ * IT LIVES HERE BECAUSE THE WEIGHTS DO. The obvious alternative is for the
+ * caller to rank the rows itself, and the obvious shortcut — take the first
+ * matching entry in `rows` — is wrong in a way that looks right: `rows` is
+ * sorted by `ref`, lexicographically, so "first match" returns whichever member
+ * sorts earliest and a `stale-blocker` on `a` masks a `cycle` on `b`. Ranking
+ * belongs next to the table it ranks by, so no caller holds a second copy of it.
+ */
+export function heaviestRow(overlay, refs) {
+    let heaviest;
+    for (const ref of refs) {
+        const row = overlay.rowFor(ref);
+        if (row === undefined)
+            continue;
+        if (heaviest === undefined || rowWeight(row) > rowWeight(heaviest))
+            heaviest = row;
+    }
+    return heaviest;
+}
+/**
+ * The persistent header count, as markup.
+ *
+ * ONE CONTROL, ALWAYS PRESENT, ALWAYS THE SAME CLICK — including at zero, which
+ * is why it is neither hidden nor disabled when nothing is found. A control
+ * that appears when there is bad news is a control the eye has to re-find, and
+ * §17d's whole ask is that the audit never demands attention it has not earned.
+ *
+ * A `button` with `aria-pressed`, because a filter toggle is a toggle: it has
+ * two states and a screen reader has to be able to say which one is on.
+ */
+export function renderAuditHeader(overlay, options = {}) {
+    const count = String(overlay.count);
+    const pressed = options.filtered === true;
+    return [
+        `<div class="ig-audit" ${AUDIT_COUNT_ATTRIBUTE}="${count}">`,
+        `<button type="button" class="ig-audit-toggle" aria-pressed="${String(pressed)}"`,
+        ` ${AUDIT_FILTER_ATTRIBUTE}>`,
+        `<span class="ig-audit-count">${count}</span>`,
+        `<span class="ig-audit-label">audit</span>`,
+        `</button>`,
+        `</div>`,
+    ].join('');
+}
+//# sourceMappingURL=surface.js.map

package/dist/audit/surface.js.map

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

package/dist/create/draft.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Creating an edge, as the one thing all three paths do.
+ *
+ * §17b asks for three **equivalent** create paths — canvas, inspector and
+ * keyboard — and is explicit that they are equivalent rather than a primary
+ * path with two shortcuts. The inspector is "the only path when the target
+ * isn't on canvas", and at any real size most targets are off canvas (§17f:
+ * the canvas is a *local* instrument), so a design where drag is the real path
+ * and the other two are conveniences is a design that stops working at the
+ * size it was built for.
+ *
+ * ## Equivalence is a property of the SHAPE, not a promise a test keeps
+ *
+ * The three paths gather the same three facts in different orders:
+ *
+ *     canvas      source → target → kind      (drag, then the picker at the drop)
+ *     inspector   source → kind   → target    ("+ add" → type → issue search)
+ *     keyboard    source → kind   → target    (`R` → `1`–`5` → search → `⏎`)
+ *
+ * So a draft modelled as a SEQUENCE would need three sequences, and "equivalent"
+ * would mean three implementations that agree today. This models it as a SET of
+ * gathered facts instead: three slots, each filled by its own command, in any
+ * order, and the proposal is emitted on whichever transition completes the set.
+ * Order-independence stops being a thing to verify and becomes a thing that
+ * cannot be otherwise — there is one emitter, and none of the three paths is
+ * spelled out here at all.
+ *
+ * That is also why the draft carries no path identity. A `source` filled by a
+ * drag and one filled by `R` are the same fact, and a field recording which
+ * arrived would be the difference between the paths growing back — every reader
+ * of it a place where one path could start behaving unlike the others. What
+ * genuinely differs between them is where the picker is DRAWN, which is
+ * geometry and lives in {@link ./placement.ts}, not state.
+ *
+ * ## One user act, one `Proposal`
+ *
+ * The same rule `picker/view.ts` keeps for retype and flip. `@issuegraph/store`
+ * closed the operation set at four so that one act is one round trip and one
+ * undo entry, and a create that emitted twice — or that emitted a delete plus a
+ * create — would undo the property the store went out of its way to model.
+ *
+ * ## Validity is the store's, and stays there
+ *
+ * A self-edge, a duplicate edge, an unknown issue: `structuralRefusal` owns all
+ * of them and answers with an `InvalidCode`. This module proposes; it does not
+ * adjudicate. `picker/view.ts` made the same call for `unchanged-kind` and
+ * recorded why — a second validity rule out here is a second place for the
+ * answer to drift, and the surface a refusal is drawn on already exists.
+ */
+import type { EdgeKind, IssueRef, Proposal } from '@issuegraph/store';
+/**
+ * The facts gathered so far. Three slots, filled in any order.
+ *
+ * `null` means "not yet gathered", which is distinct from any legal value of
+ * either field — an issue reference is a non-empty string and a kind is one of
+ * five — so no sentinel collides with real data.
+ */
+export interface CreateDraft {
+    /** The issue the relationship is being created FROM. */
+    readonly source: IssueRef | null;
+    /** The issue it is being created TO. */
+    readonly target: IssueRef | null;
+    /** Which relationship. `null` until the type picker has answered. */
+    readonly kind: EdgeKind | null;
+}
+/** Nothing gathered. The state before a create starts and after one emits. */
+export declare const IDLE_CREATE_DRAFT: CreateDraft;
+/**
+ * One fact arriving, from whichever path gathered it.
+ *
+ * `begin` is deliberately not "set source": it starts a NEW relationship, so it
+ * clears whatever a previous, abandoned draft had gathered. Restarting from a
+ * different issue while a half-built draft is open is ordinary — the reader
+ * changes their mind about the subject — and carrying the old target into it
+ * would create an edge nobody asked for out of two halves of two intentions.
+ */
+export type CreateCommand = {
+    readonly kind: 'begin';
+    readonly source: IssueRef;
+} | {
+    readonly kind: 'target';
+    readonly ref: IssueRef;
+} | {
+    readonly kind: 'type';
+    readonly edgeKind: EdgeKind;
+} | {
+    readonly kind: 'cancel';
+};
+/**
+ * The next draft, and the proposal this transition emitted.
+ *
+ * `proposal` is `null` on every transition but the completing one. Same shape
+ * as the viewer's `NavigationResult` — next state plus the one thing the shell
+ * should do — because it is the same job, and a host already reducing one can
+ * reduce the other without learning a second protocol.
+ */
+export interface CreateResult {
+    readonly draft: CreateDraft;
+    readonly proposal: Proposal | null;
+}
+/**
+ * Apply one command. Total, pure, and never mutates what it is given.
+ *
+ * AN EXHAUSTIVE SWITCH OVER A DISCRIMINATED UNION — the shape `scaleReducer`
+ * already uses here and the one branching form `AGENTS.md`'s boundary rule
+ * leaves open. Adding a command without a case fails the build rather than
+ * silently returning the draft unchanged.
+ *
+ * The direction a create lands with is the gather order: `from` is the source,
+ * `to` is the target. Nothing here infers it. §17b's rule is that direction is
+ * STATED rather than guessed, and it is — by the picker, after the edit lands,
+ * with a flip beside it, which is one act from correct. That is the same
+ * reasoning `picker/view.ts` records for retyping across the directed/symmetric
+ * split, and it is why this module does not ask about directedness at all: a
+ * symmetric kind keeps the pair too, precisely so an editor knows which issue
+ * carries the field.
+ */
+export declare function createReducer(draft: CreateDraft, command: CreateCommand): CreateResult;
+//# sourceMappingURL=draft.d.ts.map

package/dist/create/draft.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"draft.d.ts","sourceRoot":"","sources":["../../src/create/draft.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAEtE;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,wDAAwD;IACxD,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI,CAAC;IACjC,wCAAwC;IACxC,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI,CAAC;IACjC,qEAAqE;IACrE,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAAC;CAChC;AAED,8EAA8E;AAC9E,eAAO,MAAM,iBAAiB,EAAE,WAI9B,CAAC;AAEH;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAA;CAAE,GACrD;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAA;CAAE,GACnD;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;CAAE,GACtD;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC;AAEhC;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;CACpC;AAqBD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,GAAG,YAAY,CAmCtF"}