@issuegraph/editor 0.1.0

package/dist/audit/findings.d.ts

@@ -0,0 +1,225 @@
+/**
+ * The audit: four findings about an encoding, as a pure detector over one
+ * document.
+ *
+ * Design §17d names exactly four, and they are not variations on one theme —
+ * each says something different about how much of the encoding can be trusted:
+ *
+ *     cycle               nothing in the component can EVER be ready
+ *     stale blocker       bookkeeping; a closed blocker already satisfies readiness
+ *     dead duplicate ref  the issue is out of the order and nothing tracks its work
+ *     encoding refused    its edges are incomplete, and it looks merely unencoded
+ *
+ * THE FOURTH IS THE ONE THAT IS EASY TO DROP, and it is the reason this module
+ * takes more than a document. It is not a relationship finding — it is the
+ * ABSENCE of readable relationships, and §17e is explicit that most issues
+ * legitimately have none. Without it, an issue whose declaration the reader
+ * refused is indistinguishable from an issue that declares nothing, which is an
+ * absence rendered as a value in the one place somebody is auditing for
+ * encoding accuracy. A parsed document cannot carry it: a refusal is a fact
+ * about the raw body, and by the time a document exists the body is gone. So
+ * the host states it, from the reader's own answer.
+ *
+ * NOTHING HERE FIXES ANYTHING. Every finding is a judgment call — a stale
+ * blocker may be deliberate history — so the detector reports and the surface
+ * navigates. `auto-fix` appears nowhere in this package, deliberately.
+ *
+ * @see https://github.com/autnmy/issuegraph/blob/main/SPEC.md
+ */
+import type { GraphDocument, IssueRef } from '@issuegraph/store';
+/**
+ * The four classes, in the order §17d states them — which is also the order
+ * findings are reported in, so a list is stable between runs.
+ */
+export declare const AUDIT_CLASSES: readonly ["cycle", "stale-blocker", "dead-duplicate-ref", "encoding-refused"];
+export type AuditClass = (typeof AUDIT_CLASSES)[number];
+/**
+ * How much a finding costs, in the design's own words rather than a number.
+ *
+ * Named rather than ranked because the four are not points on one scale: a
+ * cycle stops the work, a dead duplicate ref hides work that looks handled, and
+ * those are different harms. {@link AUDIT_CLASS_SPECS} carries the one ordering
+ * anything needs — which finding wins a row that has several.
+ */
+export type AuditSeverity = 
+/** The only finding that stops work outright: no member can ever be ready. */
+'blocks-work'
+/** The issue is excluded from the order while nothing tracks its work. */
+ | 'dangerous'
+/** Closed blockers satisfy readiness; clearing is bookkeeping. */
+ | 'misleading'
+/** Until it parses the issue has no edges at all. */
+ | 'blocks-own-edges';
+/** What is true of a class, for every finding in it. */
+export interface AuditClassSpec {
+    readonly severity: AuditSeverity;
+    /**
+     * Which finding speaks for a row carrying several. Higher wins.
+     *
+     * A ROW ORDERING, NOT A SEVERITY ORDERING. `severity` stays a name because
+     * the four harms are not commensurable; this number exists only because one
+     * issue can carry two findings and the left-bar has one row to say it on.
+     */
+    readonly weight: number;
+    /**
+     * Whether the finding may be kept as deliberate history.
+     *
+     * TRUE ON `stale-blocker` AND NOTHING ELSE (§17d). A closed blocker is often
+     * a record of what a piece of work waited for, and clearing it destroys that;
+     * none of the other three is ever something to keep. Stated as data on the
+     * class so the affordance cannot be offered by a render site that decides for
+     * itself.
+     */
+    readonly keepAsHistory: boolean;
+}
+/**
+ * The class table. A total record, so adding a class to {@link AUDIT_CLASSES}
+ * is a compile error until this states what it costs — which is what stops a
+ * fifth finding arriving with its severity chosen wherever it is first drawn.
+ */
+export declare const AUDIT_CLASS_SPECS: Readonly<{
+    readonly cycle: Readonly<{
+        severity: "blocks-work";
+        weight: 3;
+        keepAsHistory: false;
+    }>;
+    readonly 'dead-duplicate-ref': Readonly<{
+        severity: "dangerous";
+        weight: 2;
+        keepAsHistory: false;
+    }>;
+    readonly 'encoding-refused': Readonly<{
+        severity: "blocks-own-edges";
+        weight: 1;
+        keepAsHistory: false;
+    }>;
+    readonly 'stale-blocker': Readonly<{
+        severity: "misleading";
+        weight: 0;
+        keepAsHistory: true;
+    }>;
+}>;
+/** One finding. Severity travels ON it, never looked up at the render site. */
+/**
+ * One finding.
+ *
+ * `severity` and `keepAsHistory` are FIELDS, because the design asks for them
+ * to be — *"severity is data on the finding, not a colour chosen at the render
+ * site"* — but they are never a caller's to choose. They are read off the class
+ * table where a finding is built, so the table is the single source and a
+ * finding whose severity disagrees with its class cannot be constructed.
+ *
+ * NOTHING ELSE CONSTRUCTS ONE. Every finding in existence comes from this
+ * module's own builder, which reads both fields off the table — so there is no
+ * disagreement to refuse, from TypeScript or anywhere else. An earlier revision
+ * accepted findings from a caller and tried to enforce the relationship in the
+ * TYPE instead; that needs either a cast, which this repository forbids, or a
+ * four-row builder table, and it still could not reach a value deserialized
+ * from a wire. Removing the boundary was cheaper than either.
+ */
+export interface AuditFinding {
+    readonly kind: AuditClass;
+    readonly severity: AuditSeverity;
+    readonly keepAsHistory: boolean;
+    /**
+     * Every issue the finding is about: a SET, sorted, with no ref twice. A cycle
+     * names its whole component; the other three name one issue, or the two ends
+     * of the edge that produced them.
+     *
+     * Both properties are established where a finding is built, not merely
+     * expected — the row grammar counts an entry per member, so a repeated ref
+     * would report one finding as two.
+     */
+    readonly members: readonly IssueRef[];
+    /** What the reader can be told, in one sentence. Never parsed, never a code. */
+    readonly detail: string;
+}
+/**
+ * An issue whose declaration the reader refused.
+ *
+ * The `diagnostic` is the reader's own words when the host has them — this
+ * package never produces one, because it never sees a body.
+ */
+export interface EncodingRefusal {
+    readonly ref: IssueRef;
+    readonly diagnostic?: string | undefined;
+}
+/**
+ * The two answers the audit needs from a reader, and does not compute.
+ *
+ * THE PORT, AND THE WHOLE REASON THIS MODULE WALKS NOTHING. Both fields come
+ * straight off `buildModel(...)` in `@issuegraph/reader`: `cycles` is
+ * `Model.cycles`, `duplicateCanonical` is `Model.duplicateCanonical`. A second
+ * implementation of either here would be the mirror whose input space drifts,
+ * and both would drift in specific, checkable ways rather than hypothetical
+ * ones — see each field.
+ *
+ * IT IS THE READER'S ANSWER SPECIFICALLY, NOT `@issuegraph/derive`'s
+ * `wouldCycleOnBlockedBy`, AND THAT DISTINCTION IS THE WHOLE POINT. That
+ * function is a PRE-WRITE GUARD, and its documented divergences all lean the
+ * fail-safe way for a write that is about to happen: it spans closed nodes, and
+ * it does NOT exempt a together unit's internal `blocked-by` edges. Refusing
+ * too much is the recoverable direction before a write — a human can decline
+ * the refusal — and it is exactly the wrong direction for a statement about
+ * what a backlog IS. §6.6 says so in as many words: internal edges *"stay
+ * advisory... they would make every group carrying its own ordering read as
+ * stuck"*. Interpreting the write guard as an edge-on-cycle test therefore
+ * reports a `blocks-work` finding for every ordinary together group that
+ * carries its own ordering.
+ *
+ * REQUIRED, never defaulted. Both classes that rest on this are the ones that
+ * matter most — the finding that stops work, and the finding that hides work —
+ * so a host with no reader must not quietly receive a thinner audit and read it
+ * as a complete one. That is the same absence-rendered-as-a-value the fourth
+ * class exists to refuse, arriving through this module's own front door.
+ */
+export interface AuditGraph {
+    /**
+     * `Model.cycles` — the `blocked-by` cycles among OPEN nodes (§6.6), each as
+     * sorted keys, contracted over schedulable units with internal edges dropped.
+     *
+     * Every rule in that sentence is one this module would otherwise have to
+     * restate, and §6.6 calls a reader that skips the contraction non-conforming.
+     */
+    readonly cycles: readonly (readonly IssueRef[])[];
+    /**
+     * `Model.duplicateCanonical` — the TRANSITIVE §4.3.3 canonical for a ref, or
+     * `null` when the ref is already canonical.
+     *
+     * Transitive is the load-bearing word. With `a duplicate-of b`, `b
+     * duplicate-of c` and `c` closed, the reader excludes BOTH `a` and `b` from
+     * the order — so both are dead references, and a test against each edge's
+     * immediate target sees only `b`, because `b` itself is open. The same
+     * resolution applies to a `blocked-by` naming a duplicate, which §4.3.3 reads
+     * as naming its canonical.
+     */
+    readonly duplicateCanonical: (ref: IssueRef) => IssueRef | null;
+}
+export interface AuditInput {
+    readonly document: GraphDocument;
+    /**
+     * See {@link AuditGraph}. Required, and stated in the STORE's own ref
+     * spelling — the host builds the model, so the host owns the translation
+     * between a store reference (opaque, never parsed) and a model key
+     * (normalised against a home repo, §4.2). That is the right side of the seam
+     * for it: the host is the only party holding both.
+     */
+    readonly graph: AuditGraph;
+    /**
+     * Refs the reader refused, from the host's own parse. Absent means the host
+     * has nothing to report, which is not the same claim as "every issue parsed"
+     * — but it is the only claim a caller who omits it has made, so the class
+     * simply yields no findings.
+     */
+    readonly encodingRefused?: readonly EncodingRefusal[] | undefined;
+}
+/**
+ * Every finding in one document, in {@link AUDIT_CLASSES} order.
+ *
+ * Pure and total: it reads the document it was given, asks the probe, and
+ * touches nothing else. A malformed or partial document yields fewer findings
+ * rather than an exception — an audit that throws on the data it is auditing is
+ * worse than one that reports what it can see.
+ */
+export declare function auditDocument(input: AuditInput): readonly AuditFinding[];
+//# sourceMappingURL=findings.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"findings.d.ts","sourceRoot":"","sources":["../../src/audit/findings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAc,MAAM,mBAAmB,CAAC;AAE7E;;;GAGG;AACH,eAAO,MAAM,aAAa,+EAKf,CAAC;AAEZ,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAExD;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa;AACvB,8EAA8E;AAC5E,aAAa;AACf,0EAA0E;GACxE,WAAW;AACb,kEAAkE;GAChE,YAAY;AACd,qDAAqD;GACnD,kBAAkB,CAAC;AAEvB,wDAAwD;AACxD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;;;;;;OAQG;IACH,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;CACjC;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;EASoC,CAAC;AAGnE,+EAA+E;AAC/E;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC;;;;;;;;OAQG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,QAAQ,EAAE,CAAC;IACtC,gFAAgF;IAChF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC;IACvB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,SAAS,QAAQ,EAAE,CAAC,EAAE,CAAC;IAClD;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,kBAAkB,EAAE,CAAC,GAAG,EAAE,QAAQ,KAAK,QAAQ,GAAG,IAAI,CAAC;CACjE;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B;;;;;OAKG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,CAAC;CACnE;AAsZD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,YAAY,EAAE,CAUxE"}

package/dist/audit/findings.js

@@ -0,0 +1,348 @@
+/**
+ * The audit: four findings about an encoding, as a pure detector over one
+ * document.
+ *
+ * Design §17d names exactly four, and they are not variations on one theme —
+ * each says something different about how much of the encoding can be trusted:
+ *
+ *     cycle               nothing in the component can EVER be ready
+ *     stale blocker       bookkeeping; a closed blocker already satisfies readiness
+ *     dead duplicate ref  the issue is out of the order and nothing tracks its work
+ *     encoding refused    its edges are incomplete, and it looks merely unencoded
+ *
+ * THE FOURTH IS THE ONE THAT IS EASY TO DROP, and it is the reason this module
+ * takes more than a document. It is not a relationship finding — it is the
+ * ABSENCE of readable relationships, and §17e is explicit that most issues
+ * legitimately have none. Without it, an issue whose declaration the reader
+ * refused is indistinguishable from an issue that declares nothing, which is an
+ * absence rendered as a value in the one place somebody is auditing for
+ * encoding accuracy. A parsed document cannot carry it: a refusal is a fact
+ * about the raw body, and by the time a document exists the body is gone. So
+ * the host states it, from the reader's own answer.
+ *
+ * NOTHING HERE FIXES ANYTHING. Every finding is a judgment call — a stale
+ * blocker may be deliberate history — so the detector reports and the surface
+ * navigates. `auto-fix` appears nowhere in this package, deliberately.
+ *
+ * @see https://github.com/autnmy/issuegraph/blob/main/SPEC.md
+ */
+/**
+ * The four classes, in the order §17d states them — which is also the order
+ * findings are reported in, so a list is stable between runs.
+ */
+export const AUDIT_CLASSES = Object.freeze([
+    'cycle',
+    'stale-blocker',
+    'dead-duplicate-ref',
+    'encoding-refused',
+]);
+/**
+ * The class table. A total record, so adding a class to {@link AUDIT_CLASSES}
+ * is a compile error until this states what it costs — which is what stops a
+ * fifth finding arriving with its severity chosen wherever it is first drawn.
+ */
+export const AUDIT_CLASS_SPECS = Object.freeze({
+    cycle: Object.freeze({ severity: 'blocks-work', weight: 3, keepAsHistory: false }),
+    'dead-duplicate-ref': Object.freeze({ severity: 'dangerous', weight: 2, keepAsHistory: false }),
+    'encoding-refused': Object.freeze({
+        severity: 'blocks-own-edges',
+        weight: 1,
+        keepAsHistory: false,
+    }),
+    'stale-blocker': Object.freeze({ severity: 'misleading', weight: 0, keepAsHistory: true }),
+});
+/**
+ * Every ref the document carries, whatever its state.
+ *
+ * IT STANDS IN FOR THE READER'S `referenceable` SET, which is what decides
+ * whether a reference resolves through a `duplicate-of` at all. That set holds
+ * FULL nodes only — a declarer-only node is added to the key map and
+ * explicitly "does not become referenceable" — because a weak node may add
+ * constraints and may never satisfy one. A host builds both this document and
+ * the model from the same issues, so the refs it carries are exactly the full
+ * nodes; anything else it knows about arrives as a declarer.
+ *
+ * WHERE THE PROXY IS WRONG IT IS WRONG SAFELY: it can only ever be NARROWER
+ * than `referenceable`, so a target it does not carry goes unresolved and the
+ * finding is withheld. That is the same direction the stale-blocker class
+ * already takes for an absent declarer, and the opposite of the failure it
+ * replaces.
+ */
+function carriedRefs(document) {
+    return new Set(document.issues.map((issue) => issue.ref));
+}
+/** The refs the document holds as OPEN issues. Absence here means UNKNOWN. */
+function openRefs(document) {
+    const open = new Set();
+    for (const issue of document.issues) {
+        if (issue.state === 'open')
+            open.add(issue.ref);
+    }
+    return open;
+}
+/** Whether the document holds this ref as a CLOSED issue. */
+function closedRefs(document) {
+    const closed = new Set();
+    for (const issue of document.issues) {
+        if (issue.state === 'closed')
+            closed.add(issue.ref);
+    }
+    return closed;
+}
+/** Lexicographic on the sorted member lists, so a finding list is stable. */
+function compareMembers(a, b) {
+    for (let index = 0; index < Math.min(a.length, b.length); index += 1) {
+        const left = a[index];
+        const right = b[index];
+        if (left !== right)
+            return left < right ? -1 : 1;
+    }
+    return a.length - b.length;
+}
+/**
+ * A finding with nothing left aliased to anyone else's object.
+ *
+ * BOTH LEVELS, AND THAT IS THE WHOLE POINT. `Object.freeze` is shallow, and
+ * `readonly AuditFinding[]` accepts a MUTABLE array of MUTABLE objects — so
+ * freezing the outer value leaves both the finding and its `members` writable
+ * through the caller's own reference, and a later push changes what a consumer
+ * already rendered. Fixing one level at a time just moves the aliasing down,
+ * and `members` is the last level there is: every other field is a primitive.
+ *
+ * Exported so {@link ../surface.ts auditOverlay} normalizes what it is HANDED
+ * by the same rule this module applies to what it BUILDS. Two spellings of
+ * "settled" is how the two come to disagree.
+ */
+/**
+ * A finding, with every invariant established by construction.
+ *
+ * THERE IS NO LONGER A BOUNDARY HERE TO DEFEND, AND THAT IS THE CHANGE. This
+ * function used to be reachable with a caller's own object, so it grew a
+ * validator: a class lookup that a prototype key could satisfy, a members list
+ * that might not be an array, a `severity` that might disagree with `kind`, a
+ * members list carrying a ref twice, then one carrying none. Six review rounds,
+ * each a different way for a value TypeScript never checked to be wrong, and
+ * two claims of closure that were premature because the surface is not
+ * enumerable.
+ *
+ * So the boundary was removed rather than hardened a seventh time:
+ * {@link ../surface.ts auditOverlay} now derives its findings by running the
+ * audit instead of accepting a list, and every finding in existence comes from
+ * here. What were runtime defences are invariants again:
+ *
+ *     kind            a literal from AUDIT_CLASSES, at four call sites
+ *     severity        read from the table, never passed in
+ *     keepAsHistory   read from the table, never passed in
+ *     members         a sorted set, non-empty
+ *     detail          built here
+ *
+ * `members` is still normalized rather than assumed, because the detectors
+ * build it from document data — a self-blocking edge really does hand this
+ * `['a', 'a']`. Non-empty is asserted rather than filtered: a finding naming
+ * nobody would add to the header count while giving a reader nothing to open,
+ * and no detector can produce one, so silence would hide a defect rather than
+ * tolerate an input.
+ */
+function finding(kind, members, detail) {
+    const spec = AUDIT_CLASS_SPECS[kind];
+    // A SORTED SET. Sorting is what makes two runs over one document produce
+    // equal findings; deduplication matters because the row grammar counts one
+    // entry per member, and a self-blocking edge hands this the same ref twice.
+    const named = Object.freeze([...new Set(members)].sort());
+    if (named.length === 0)
+        throw new Error(`unreachable: a ${kind} finding names no issues`);
+    return Object.freeze({
+        kind,
+        severity: spec.severity,
+        keepAsHistory: spec.keepAsHistory,
+        members: named,
+        detail,
+    });
+}
+function edgesOfKind(document, kind) {
+    return document.edges.filter((edge) => edge.kind === kind);
+}
+/**
+ * The two classes that read this ask about an edge; the other two do not, and
+ * deliberately keep none of it. §6.6 already restricts cycles to open nodes,
+ * and an encoding refusal is a fact about a DECLARATION — which the model reads
+ * from closed nodes too, so a closed issue's unreadable `duplicate-of` still
+ * misroutes live edges.
+ */
+function verdictFor(edge, closed, open, carried, refused, graph, 
+// WHICH END'S CANONICAL DECIDES THE ANSWER. A stale blocker asks where the
+// TARGET's work went; a dead duplicate ref asks where the DECLARER's did.
+resolveFrom) {
+    // THE TWO ENDS RESOLVE UNDER DIFFERENT RULES, because the reader applies its
+    // referenceability gate in exactly one of the two places:
+    //
+    //  - A RELATIONSHIP TARGET is canonicalized only when it is REFERENCEABLE.
+    //    `duplicateCanonical` answers for any key the model holds, the
+    //    declarer-only tier included, but a weak node is not referenceable — it
+    //    may add constraints and may never satisfy one. Asking unconditionally
+    //    turned an unresolvable blocker, which the reader treats as BLOCKING,
+    //    into a discharged one.
+    //  - A DECLARER'S OWN CHAIN carries no such gate. `duplicateCanonicalOf`
+    //    starts from the key map, which holds weak nodes too, and the gate inside
+    //    it applies to the NEXT hop. So an absent declarer's chain resolves, and
+    //    gating it discarded the transitive answer the dead-duplicate class is
+    //    built on — the very case that class deliberately reports on an unknown
+    //    declarer.
+    const effective = resolveFrom === 'to'
+        ? ((carried.has(edge.to) ? graph.duplicateCanonical(edge.to) : null) ?? edge.to)
+        : (graph.duplicateCanonical(edge.from) ?? edge.to);
+    return {
+        effective,
+        effectiveClosed: closed.has(effective),
+        // THE TARGET SIDE ONLY, and the scope is load-bearing rather than
+        // incidental. What a refusal costs is knowledge of where the edge POINTS:
+        // the unreadable declaration is the one that might have redirected the
+        // chain. The DECLARER's own refusal says nothing about whether the issue on
+        // the other end is closed, so suppressing on it would hide a true finding —
+        // measured, by this package's own all-four-classes fixture, which went to
+        // three the moment that leg was added.
+        knowable: !refused.has(edge.to) && !refused.has(effective),
+        declarerLive: !closed.has(edge.from),
+        declarerOpen: open.has(edge.from),
+        declarerEdgesRead: graph.duplicateCanonical(edge.from) === null,
+    };
+}
+/**
+ * The reader's stuck groups, one finding each.
+ *
+ * A PASS-THROUGH, AND DELIBERATELY SO. §6.6's answer already carries every rule
+ * that makes it correct — open nodes only, contracted over schedulable units,
+ * internal `blocked-by` edges dropped as advisory — and each of those is a rule
+ * this module would otherwise restate and eventually disagree with. What is
+ * left here is presentation: sorting, and the sentence.
+ *
+ * An empty group is skipped rather than drawn: a finding naming nobody would
+ * add to the header count while giving a reader nothing to navigate to.
+ */
+function cycleFindings(graph) {
+    return graph.cycles
+        .filter((members) => members.length > 0)
+        .map((members) => [...members].sort())
+        .sort((a, b) => compareMembers(a, b))
+        .map((members) => finding('cycle', members, `${members.join(' · ')} form a blocked-by cycle; no member can ever become ready`));
+}
+/**
+ * A `blocked-by` whose EFFECTIVE target is closed.
+ *
+ * EFFECTIVE, because §4.3.3 makes an edge naming a duplicate name its canonical
+ * instead — so a blocker that is itself a duplicate of a closed issue is a
+ * stale blocker, and testing the immediate target alone misses it.
+ *
+ * "LONG-closed" IS NOT AVAILABLE HERE and the shortfall is stated rather than
+ * approximated: a document carries no timestamp, so how long ago a blocker
+ * closed is not a fact this layer holds. Every closed blocker is reported
+ * instead — the safe direction for a finding whose whole severity is
+ * `misleading`, and the one a host can narrow with a date it does have.
+ *
+ * A TARGET THE DOCUMENT DOES NOT HOLD IS NOT REPORTED. It is unknown, not
+ * closed, and reporting it would state as bookkeeping what is really a paging
+ * boundary.
+ */
+function staleBlockerFindings(document, graph, refused) {
+    const closed = closedRefs(document);
+    const open = openRefs(document);
+    const carried = carriedRefs(document);
+    const findings = [];
+    for (const edge of edgesOfKind(document, 'blocked-by')) {
+        const verdict = verdictFor(edge, closed, open, carried, refused, graph, 'to');
+        // PROVABLY OPEN, not merely not-closed — see `declarerOpen`.
+        if (!verdict.declarerOpen || !verdict.knowable || !verdict.effectiveClosed)
+            continue;
+        // A blocked-by written on a DUPLICATE is not read by the model at all, so
+        // it holds nothing and there is no readiness for a closed target to have
+        // satisfied. `dead-duplicate-ref` deliberately does not consult this — see
+        // the field.
+        if (!verdict.declarerEdgesRead)
+            continue;
+        const effective = verdict.effective;
+        const via = effective === edge.to ? '' : ` (via ${edge.to}, which duplicates it)`;
+        findings.push(finding('stale-blocker', [edge.from, edge.to].sort(), `${edge.from} is blocked-by ${effective}${via}, which is closed; readiness is already satisfied`));
+    }
+    return findings.sort((a, b) => compareMembers(a.members, b.members));
+}
+/**
+ * A `duplicate-of` whose TRANSITIVE canonical is closed.
+ *
+ * The dangerous one: §4.3.3 excludes a duplicate from the order entirely, so
+ * with the canonical closed the work is tracked by nothing at all while the
+ * backlog reads as though it were handled.
+ *
+ * TRANSITIVE IS WHAT MAKES IT COMPLETE. In a chain — `a duplicate-of b`, `b
+ * duplicate-of c`, `c` closed — the reader excludes both `a` and `b`, so both
+ * references are dead. Testing each edge's immediate target reports `b` and
+ * misses `a`, because `b` is open: the miss is silent, and it is a miss in the
+ * one class whose whole point is work that looks handled and is not.
+ *
+ * The fallback to the immediate target covers a chain the model could not
+ * resolve, where `duplicateCanonical` answers `null`. Reporting on what the
+ * edge itself names is the fail-safe direction for a `dangerous` class.
+ */
+function deadDuplicateFindings(document, graph, refused) {
+    const closed = closedRefs(document);
+    const open = openRefs(document);
+    const carried = carriedRefs(document);
+    const findings = [];
+    for (const edge of edgesOfKind(document, 'duplicate-of')) {
+        const verdict = verdictFor(edge, closed, open, carried, refused, graph, 'from');
+        // NOT provably closed, which deliberately admits an unknown declarer — see
+        // `declarerLive`, and the asymmetry with the stale-blocker case above.
+        if (!verdict.declarerLive || !verdict.knowable || !verdict.effectiveClosed)
+            continue;
+        const canonical = verdict.effective;
+        const via = canonical === edge.to ? '' : ` (through ${edge.to})`;
+        findings.push(finding('dead-duplicate-ref', [edge.from, edge.to].sort(), `${edge.from} is duplicate-of ${canonical}${via}, which is closed; its work is excluded from the order and tracked nowhere`));
+    }
+    return findings.sort((a, b) => compareMembers(a.members, b.members));
+}
+/**
+ * The refusals the host reported.
+ *
+ * NOT FILTERED TO THE DOCUMENT. A refused declaration is a fact the host
+ * asserted about an issue it read, and dropping the ones the document does not
+ * carry would silently discard findings on exactly the issues a paging boundary
+ * has not reached yet. The row overlay simply has no row to mark for those,
+ * which is a presentation consequence rather than a reason to lose the finding.
+ *
+ * Deduplicated by ref, first occurrence winning — the model's own rule for a
+ * repeated key, kept here so a host that reports one issue twice does not get
+ * two identical findings.
+ */
+function encodingRefusedFindings(refusals) {
+    const seen = new Set();
+    const findings = [];
+    for (const refusal of refusals) {
+        if (seen.has(refusal.ref))
+            continue;
+        seen.add(refusal.ref);
+        const because = refusal.diagnostic === undefined || refusal.diagnostic === ''
+            ? ''
+            : `: ${refusal.diagnostic}`;
+        findings.push(finding('encoding-refused', [refusal.ref], `${refusal.ref} declares relationships the reader refused${because}; the edges it declares are incomplete and cannot be trusted until it parses`));
+    }
+    return findings.sort((a, b) => compareMembers(a.members, b.members));
+}
+/**
+ * Every finding in one document, in {@link AUDIT_CLASSES} order.
+ *
+ * Pure and total: it reads the document it was given, asks the probe, and
+ * touches nothing else. A malformed or partial document yields fewer findings
+ * rather than an exception — an audit that throws on the data it is auditing is
+ * worse than one that reports what it can see.
+ */
+export function auditDocument(input) {
+    const { document, graph } = input;
+    const refusals = input.encodingRefused ?? [];
+    const refused = new Set(refusals.map((refusal) => refusal.ref));
+    return Object.freeze([
+        ...cycleFindings(graph),
+        ...staleBlockerFindings(document, graph, refused),
+        ...deadDuplicateFindings(document, graph, refused),
+        ...encodingRefusedFindings(refusals),
+    ]);
+}
+//# sourceMappingURL=findings.js.map

package/dist/audit/findings.js.map

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

package/dist/audit/styles.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+export declare const auditStylesheet = "\n.ig-audit {\n  align-items: center;\n  display: inline-flex;\n  font-family: var(--ig-font-ui);\n  font-size: var(--ig-font-size-small);\n  gap: var(--ig-space-tight);\n}\n\n.ig-audit-toggle {\n  align-items: center;\n  background: none;\n  border: 0;\n  color: var(--ig-text-muted);\n  cursor: pointer;\n  display: inline-flex;\n  font: inherit;\n  gap: var(--ig-space-tight);\n  padding: 0;\n}\n\n.ig-audit-toggle[aria-pressed='true'] {\n  color: var(--ig-text);\n}\n\n.ig-audit-count {\n  color: var(--ig-text);\n  font-family: var(--ig-font-mono);\n  font-variant-numeric: tabular-nums;\n}\n\n[data-ig-audit] {\n  box-shadow: inset var(--ig-stroke) 0 0 0 var(--ig-edge-serialize-with);\n}\n";
+//# sourceMappingURL=styles.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../src/audit/styles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAIH,eAAO,MAAM,eAAe,6rBAkC3B,CAAC"}