@event4u/agent-config 16.4.0 → 17.0.0

package/dist/scripts/_lib/settings_renamed_keys.js

@@ -7,14 +7,26 @@
  * `false` to the shipped default, which is the opposite of accepting the old
  * key — so the two maps stay separate even though both warn once.
  *
- * An entry is dropped one minor after it lands. The new key always wins when
- * one layer carries both: a reader who has already migrated is not overridden
- * by a stale line they forgot to delete.
+ * Release class: A settings key may be removed or renamed in a minor release
+ * only when no consumer project can rely on it — default-neutral and
+ * derivable, proven by a named test; any other removal or rename ships only in
+ * a major, and a renamed key's alias is dropped only in a major. The new key
+ * always wins when one layer carries both: a reader who has already migrated
+ * is not overridden by a stale line they forgot to delete.
  *
  * Its own module rather than more lines in `agent_settings.ts`, which sits
  * three lines under the 1500-line source ceiling — a sixty-line addition there
  * is sixty units of ratchet, and here it is none.
  */
+/**
+ * The release rule for removing or renaming a settings key, as the one string
+ * every statement of it repeats (blocker `what-a-minor-may-remove`, owner
+ * answer (c), 2026-10-14). Exported so the warning below prints it and the
+ * cut names it, rather than each carrying its own paraphrase.
+ */
+export const SETTINGS_REMOVAL_RULE = 'A settings key may be removed or renamed in a minor release only when no consumer project can ' +
+    'rely on it — default-neutral and derivable, proven by a named test; any other removal or rename ' +
+    "ships only in a major, and a renamed key's alias is dropped only in a major.";
 export const RENAMED_KEYS = new Map([
     ['planning.challenge_on_create', 'planning.closure_pass'],
 ]);
@@ -66,8 +78,8 @@ export function applyRenamedKeys(layer) {
         if (_warned.has(oldKey))
             continue;
         _warned.add(oldKey);
-        process.stderr.write(`⚠️  settings: \`${oldKey}\` was renamed to \`${newKey}\`. The old key still ` +
-            `works for one minor; rename it in your .agent-settings.yml.\n`);
+        process.stderr.write(`⚠️  settings: \`${oldKey}\` was renamed to \`${newKey}\`; the old key still works. ` +
+            `${SETTINGS_REMOVAL_RULE} Rename it in your .agent-settings.yml.\n`);
     }
     return layer;
 }

package/dist/scripts/_lib/subagent_native_fields.js

@@ -0,0 +1,35 @@
+/**
+ * Optional subagent-v1 fields → Claude Code native agent frontmatter lines.
+ *
+ * The schema names the host's loading knobs vendor-neutrally; the host
+ * spelling lives here and nowhere else, the way `model_tier` → `model` lives in
+ * `model_tier.ts`. A field is emitted only when the source declares it, so a
+ * definition that sets none of them projects byte-identically to before.
+ *
+ * Two fields are deliberately NOT emitted:
+ *  - `reuse` is read by `_lib/worker_reuse.ts` (condition (g)) off the source
+ *    definition. The host has no per-definition reuse key; writing one would be
+ *    a line the host ignores and a reader might mistake for an enforced switch.
+ *  - `cache_ttl` has no per-definition host key either — the host's TTL knob is
+ *    a settings value.
+ *
+ * `omit_project_instructions` → `omitClaudeMd` drops the instruction hierarchy
+ * for that definition, so a definition setting it relies on its dispatch to
+ * carry the floor and the user's constraints.
+ */
+export function nativeFieldLines(fm) {
+    const out = [];
+    if (typeof fm['effort'] === 'string')
+        out.push(`effort: ${fm['effort']}`);
+    if (typeof fm['max_turns'] === 'number')
+        out.push(`maxTurns: ${fm['max_turns']}`);
+    if (typeof fm['background'] === 'boolean')
+        out.push(`background: ${fm['background']}`);
+    const skills = fm['preload_skills'];
+    if (Array.isArray(skills) && skills.length > 0)
+        out.push(`skills: [${skills.map(String).join(', ')}]`);
+    if (fm['omit_project_instructions'] === true)
+        out.push('omitClaudeMd: true');
+    return out.map((l) => `${l}\n`).join('');
+}
+//# sourceMappingURL=subagent_native_fields.js.map

package/dist/scripts/_lib/svg_dom.js

@@ -0,0 +1,284 @@
+/**
+ * svg_dom — a dependency-free XML well-formedness parser, and the tree it
+ * builds.
+ *
+ * Step 3.1 of `road-to-svg-review-followups`, amending step 1.1 of
+ * `road-to-svg-with-a-witness`. Review claim C11: a regex cannot prove nesting
+ * or resolve a reference, and the alternatives were all refused for reasons
+ * that still hold — `package.json`'s runtime dependencies carry no XML parser,
+ * `happy-dom` is dev-only, the three vendored tree-sitter grammars are php,
+ * typescript and javascript, and Playwright is absent in a consumer, so the
+ * browser cannot carry a static layer. The remaining option is to write one,
+ * which is what `lint_design_quality` already does for its own surface.
+ *
+ * WHAT IT IS. One scanner over the bytes, producing every node kind an SVG
+ * carries — elements with their attributes, comments, CDATA sections,
+ * processing instructions, DOCTYPEs and text — each with a line and a column,
+ * assembled into a tree with parent links, plus a list of well-formedness
+ * errors.
+ *
+ * TWO SCANNERS, NOT ONE, and this header used to claim otherwise.
+ * `parseElements` in `svg_rules.ts` is an independent scanner over the same
+ * bytes, so the two CAN disagree about what a file contains — finding 3 of the
+ * third completion review of this change found a case where they did, and the
+ * disagreement produced an error-severity false positive. That one is fixed
+ * where it was (the prolog), but the general claim was false and is not
+ * restored: a reader deciding whether a fix here also lands there must check,
+ * not assume. Merging them is a larger change than the finding asked for and
+ * is not attempted under a remediation.
+ *
+ * WHAT IT IS NOT. Not a validating parser, not namespace-aware beyond keeping
+ * the prefix in the name, and it does not expand entities. It reports that a
+ * file is not well-formed; it does not report which schema it violates.
+ *
+ * WHY A FILE THAT IS NOT WELL-FORMED IS A FINDING RATHER THAN A SKIPPED FILE.
+ * A skipped file reads as a clean one in every count that matters, and the
+ * shape this exists to catch — `<g><path></g></path>` — is exactly the shape a
+ * flat element list cannot see: both tags are present, both are spelled
+ * correctly, and the document is nonetheless not a tree.
+ */
+/** 1-based line and column of an offset. Built once per parse. */
+function positions(content) {
+    const starts = [0];
+    for (let i = 0; i < content.length; i += 1) {
+        if (content[i] === '\n')
+            starts.push(i + 1);
+    }
+    return (offset) => {
+        // Binary search for the last line start at or before `offset`.
+        let lo = 0;
+        let hi = starts.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (starts[mid] <= offset)
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        return { line: lo + 1, column: offset - starts[lo] + 1 };
+    };
+}
+/**
+ * End of the tag, honouring quoted attribute values that may contain `>`.
+ *
+ * Exported because `svg_rules.parseElements` scans the same bytes and had its
+ * own byte-identical copy — finding 9 of the third completion review, which
+ * also noted that BOTH copies ship in the per-`.svg`-write hook chunk. Two
+ * scanners is a fact this file's header now states plainly; two copies of
+ * their shared primitives is not a consequence of it.
+ */
+export function tagEnd(content, from) {
+    let quote = null;
+    for (let i = from + 1; i < content.length; i += 1) {
+        const ch = content[i];
+        if (quote !== null) {
+            if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            continue;
+        }
+        if (ch === '>')
+            return i;
+    }
+    return -1;
+}
+/** Attributes of one tag, lowercased keys. Shared with `svg_rules` — see `tagEnd`. */
+export function attrsOf(raw) {
+    const attrs = {};
+    const re = /([A-Za-z_:][\w.:-]*)\s*=\s*("([^"]*)"|'([^']*)')/g;
+    let m;
+    while ((m = re.exec(raw)) !== null) {
+        const key = (m[1] ?? '').toLowerCase();
+        const value = m[3] ?? m[4] ?? '';
+        attrs[key] = value.replace(/&amp;/g, '&');
+    }
+    return attrs;
+}
+/**
+ * Parse one document.
+ *
+ * Never throws: a malformed file produces whatever tree could be built plus
+ * the errors that explain it. A parser that threw would make an unparseable
+ * file indistinguishable from a crash, and the caller's job is to REPORT the
+ * file, not to fall over on it.
+ */
+export function parseDocument(content) {
+    const at = positions(content);
+    const roots = [];
+    const elements = [];
+    const errors = [];
+    const stack = [];
+    const make = (kind, start, name = '', value = '', attrs = {}) => {
+        const { line, column } = at(start);
+        return { kind, name, attrs, line, column, start, value, children: [], parent: null };
+    };
+    const append = (node) => {
+        const parent = stack[stack.length - 1];
+        if (parent === undefined) {
+            roots.push(node);
+        }
+        else {
+            node.parent = parent;
+            parent.children.push(node);
+        }
+    };
+    let i = 0;
+    while (i < content.length) {
+        const lt = content.indexOf('<', i);
+        if (lt === -1) {
+            const rest = content.slice(i);
+            if (rest.trim() !== '')
+                append(make('text', i, '', rest));
+            break;
+        }
+        if (lt > i) {
+            const text = content.slice(i, lt);
+            if (text.trim() !== '')
+                append(make('text', i, '', text));
+        }
+        if (content.startsWith('<!--', lt)) {
+            const end = content.indexOf('-->', lt + 4);
+            if (end === -1) {
+                const p = at(lt);
+                errors.push({ message: 'unterminated comment', line: p.line, column: p.column });
+                append(make('comment', lt, '', content.slice(lt + 4)));
+                break;
+            }
+            append(make('comment', lt, '', content.slice(lt + 4, end)));
+            i = end + 3;
+            continue;
+        }
+        if (content.startsWith('<![CDATA[', lt)) {
+            const end = content.indexOf(']]>', lt + 9);
+            if (end === -1) {
+                const p = at(lt);
+                errors.push({ message: 'unterminated CDATA section', line: p.line, column: p.column });
+                append(make('cdata', lt, '', content.slice(lt + 9)));
+                break;
+            }
+            append(make('cdata', lt, '', content.slice(lt + 9, end)));
+            i = end + 3;
+            continue;
+        }
+        if (content.startsWith('<?', lt)) {
+            const end = content.indexOf('?>', lt + 2);
+            if (end === -1) {
+                // Finding 11 of this change's completion review: this and the
+                // declaration below swallowed the rest of the document into one
+                // node and returned cleanly, so a file ending in
+                // `<?xml version="1.0"` read as WELL-FORMED — a skip, under a
+                // contract whose whole point is that a file which does not
+                // parse is a finding rather than a skipped file.
+                const p = at(lt);
+                errors.push({ message: 'unterminated processing instruction', line: p.line, column: p.column });
+            }
+            const stop = end === -1 ? content.length : end + 2;
+            append(make('pi', lt, '', content.slice(lt + 2, end === -1 ? content.length : end)));
+            i = stop;
+            continue;
+        }
+        if (content.startsWith('<!', lt)) {
+            // A DOCTYPE may carry a bracketed internal subset; it ends after it.
+            const bracket = content.indexOf('[', lt);
+            const close = content.indexOf('>', lt);
+            let stop;
+            if (bracket !== -1 && close !== -1 && bracket < close) {
+                const endBracket = content.indexOf(']', bracket);
+                const after = endBracket === -1 ? close : content.indexOf('>', endBracket);
+                stop = after === -1 ? content.length : after + 1;
+            }
+            else {
+                stop = close === -1 ? content.length : close + 1;
+            }
+            if (close === -1) {
+                const p = at(lt);
+                errors.push({ message: 'unterminated declaration', line: p.line, column: p.column });
+            }
+            append(make('doctype', lt, '', content.slice(lt + 2, Math.max(lt + 2, stop - 1))));
+            i = stop;
+            continue;
+        }
+        const gt = tagEnd(content, lt);
+        if (gt === -1) {
+            const p = at(lt);
+            errors.push({ message: 'unterminated tag', line: p.line, column: p.column });
+            break;
+        }
+        const raw = content.slice(lt, gt + 1);
+        const nameMatch = /^<\/?\s*([A-Za-z_][\w.:-]*)/.exec(raw);
+        if (!nameMatch) {
+            // Finding 11, third case: a `<` that opens something with no legal
+            // element name is malformed markup, not whitespace. Skipping it
+            // silently is the same skip the other two were.
+            const p = at(lt);
+            errors.push({ message: `"${raw.slice(0, 24)}" is not a tag`, line: p.line, column: p.column });
+            i = gt + 1;
+            continue;
+        }
+        const name = (nameMatch[1] ?? '').toLowerCase();
+        const closing = raw.startsWith('</');
+        const selfClosing = raw.endsWith('/>');
+        if (closing) {
+            const open = stack[stack.length - 1];
+            const p = at(lt);
+            if (open === undefined) {
+                errors.push({ message: `closing tag </${name}> with no open element`, line: p.line, column: p.column });
+            }
+            else if (open.name !== name) {
+                // The shape a flat element list cannot see. Reported against
+                // the CLOSING tag, which is where a reader looking at the file
+                // sees the problem.
+                errors.push({
+                    message: `closing tag </${name}> does not match the open <${open.name}> (line ${String(open.line)})`,
+                    line: p.line,
+                    column: p.column,
+                });
+                // Recover by popping to the matching open element WHEN THERE
+                // IS ONE, so a single mistake does not cascade into an error
+                // per remaining tag.
+                //
+                // When there is none, pop NOTHING. Finding 2 of the fourth
+                // completion review: the `else stack.pop()` detached a
+                // perfectly good ancestor to pay for a stray tag that never
+                // opened anything — a file whose `</g>` has no `<g>` lost its
+                // `<svg>` from the stack, so the real `</svg>` at the end then
+                // had no open element and the file collected a SECOND error it
+                // had not earned. Cascading is exactly what this branch exists
+                // to prevent, and the unmatched case was the one where it did
+                // the cascading itself. A closing tag with no match is a stray
+                // tag: report it and carry on.
+                const idx = stack.map((n) => n.name).lastIndexOf(name);
+                if (idx !== -1)
+                    stack.length = idx;
+            }
+            else {
+                stack.pop();
+            }
+            i = gt + 1;
+            continue;
+        }
+        const node = make('element', lt, name, '', attrsOf(raw));
+        append(node);
+        elements.push(node);
+        if (!selfClosing)
+            stack.push(node);
+        i = gt + 1;
+    }
+    for (const unclosed of stack) {
+        errors.push({
+            message: `<${unclosed.name}> is never closed`,
+            line: unclosed.line,
+            column: unclosed.column,
+        });
+    }
+    return { roots, elements, errors };
+}
+// `ancestors` and `documentElement` used to live here. Finding 11 of the third
+// completion review: both were exported, called by nothing, and bundled into
+// the per-`.svg`-write dispatch chunk — own-orphans of this same diff, which
+// `minimal-safe-diff` says the diff that made them removes. `XmlNode.parent`
+// is the primitive either would have been built on and it is still here.
+//# sourceMappingURL=svg_dom.js.map

package/dist/scripts/_lib/svg_filled_counter.js

@@ -0,0 +1,285 @@
+/**
+ * `svg-structure-filled-counter` — step 3.2 of `road-to-type-with-a-witness`.
+ *
+ * A letter with a counter (o, e, a, B, 8) or an O-ring mark is one path with an
+ * outer and an inner contour. Under `fill-rule="nonzero"`, the default, the
+ * counter stays open only when the inner contour winds the OTHER way: a
+ * same-direction inner contour adds to the winding number and the counter
+ * paints. Measured on the repo's Chromium: two same-direction circles of radius
+ * 250 and 160 painted 196,282 px, the ring they should be 115,940.
+ *
+ * The check flattens each subpath to a polygon, sums the winding signs of the
+ * subpaths that contain a subpath's every vertex, and reports the subpath when
+ * that sum is nonzero and shares its own sign — it sits in a painted region and
+ * deepens it instead of cutting it out. It is advisory (decision A8): `warning`, never `error`, until
+ * the false-positive census of step 3.3 says otherwise.
+ *
+ * Limits, stated rather than guessed around: a transform does not change a
+ * winding sign unless it mirrors, and a mirror flips both contours alike, so
+ * transforms are ignored; `fill-rule` set from a stylesheet selector is not
+ * read — an attribute or inline style, on the path or an ancestor, is.
+ */
+import { tokenisePath } from './svg_geometry.js';
+const CURVE_STEPS = 12;
+const MAX_SUBPATHS = 400;
+function styleProp(el, prop) {
+    const direct = el.attrs[prop];
+    if (direct !== undefined)
+        return direct.trim();
+    const m = new RegExp(`(?:^|;)\\s*${prop}\\s*:\\s*([^;]+)`, 'i').exec(el.attrs['style'] ?? '');
+    return m?.[1]?.trim();
+}
+function arcPoints(from, args) {
+    const [rxIn, ryIn, rotDeg, large, sweep, x, y] = args;
+    const [x1, y1] = from;
+    let rx = Math.abs(rxIn);
+    let ry = Math.abs(ryIn);
+    if (rx === 0 || ry === 0 || (x1 === x && y1 === y))
+        return [[x, y]];
+    const phi = (rotDeg * Math.PI) / 180;
+    const cos = Math.cos(phi);
+    const sin = Math.sin(phi);
+    const dx = (x1 - x) / 2;
+    const dy = (y1 - y) / 2;
+    const xp = cos * dx + sin * dy;
+    const yp = -sin * dx + cos * dy;
+    const lambda = (xp * xp) / (rx * rx) + (yp * yp) / (ry * ry);
+    if (lambda > 1) {
+        rx *= Math.sqrt(lambda);
+        ry *= Math.sqrt(lambda);
+    }
+    const num = rx * rx * ry * ry - rx * rx * yp * yp - ry * ry * xp * xp;
+    const den = rx * rx * yp * yp + ry * ry * xp * xp;
+    const coef = (large === sweep ? -1 : 1) * Math.sqrt(Math.max(0, num / den));
+    const cxp = (coef * rx * yp) / ry;
+    const cyp = (-coef * ry * xp) / rx;
+    const cx = cos * cxp - sin * cyp + (x1 + x) / 2;
+    const cy = sin * cxp + cos * cyp + (y1 + y) / 2;
+    const angle = (ux, uy, vx, vy) => {
+        const a = Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy);
+        return a;
+    };
+    const t1 = angle(1, 0, (xp - cxp) / rx, (yp - cyp) / ry);
+    let dt = angle((xp - cxp) / rx, (yp - cyp) / ry, (-xp - cxp) / rx, (-yp - cyp) / ry);
+    if (!sweep && dt > 0)
+        dt -= 2 * Math.PI;
+    if (sweep && dt < 0)
+        dt += 2 * Math.PI;
+    const out = [];
+    for (let k = 1; k <= CURVE_STEPS; k++) {
+        const t = t1 + (dt * k) / CURVE_STEPS;
+        const ex = rx * Math.cos(t);
+        const ey = ry * Math.sin(t);
+        out.push([cos * ex - sin * ey + cx, sin * ex + cos * ey + cy]);
+    }
+    return out;
+}
+function bezier(p0, p1, p2, p3) {
+    const out = [];
+    for (let k = 1; k <= CURVE_STEPS; k++) {
+        const t = k / CURVE_STEPS;
+        const u = 1 - t;
+        out.push([
+            u * u * u * p0[0] + 3 * u * u * t * p1[0] + 3 * u * t * t * p2[0] + t * t * t * p3[0],
+            u * u * u * p0[1] + 3 * u * u * t * p1[1] + 3 * u * t * t * p2[1] + t * t * t * p3[1],
+        ]);
+    }
+    return out;
+}
+/** Each subpath of `d` as a flattened polygon, or `null` when `d` does not parse. */
+export function subpathPolygons(d) {
+    const tokens = tokenisePath(d);
+    if (tokens === null)
+        return null;
+    const ARGS = { m: 2, l: 2, t: 2, h: 1, v: 1, c: 6, s: 4, q: 4, a: 7, z: 0 };
+    const polys = [];
+    let poly = [];
+    let cur = [0, 0];
+    let start = [0, 0];
+    let lastCtrl = null;
+    let lastQuad = null;
+    let i = 0;
+    let cmd = '';
+    const flush = () => {
+        if (poly.length >= 3)
+            polys.push(poly);
+        poly = [];
+    };
+    while (i < tokens.length) {
+        const tok = tokens[i];
+        if (/^[a-zA-Z]$/.test(tok)) {
+            cmd = tok;
+            i += 1;
+            if (cmd.toLowerCase() === 'z') {
+                cur = start;
+                lastCtrl = lastQuad = null;
+                flush();
+                continue;
+            }
+            if (i >= tokens.length)
+                break;
+            continue;
+        }
+        const lower = cmd.toLowerCase();
+        const n = ARGS[lower];
+        if (n === undefined || n === 0)
+            return null;
+        const a = tokens.slice(i, i + n).map(Number);
+        if (a.length < n || a.some((v) => !Number.isFinite(v)))
+            return null;
+        i += n;
+        const rel = cmd !== cmd.toUpperCase();
+        const ox = rel ? cur[0] : 0;
+        const oy = rel ? cur[1] : 0;
+        const at = (k) => [a[k] + ox, a[k + 1] + oy];
+        let next = cur;
+        let pts = [];
+        let ctrl = null;
+        let quad = null;
+        switch (lower) {
+            case 'm':
+                flush();
+                next = at(0);
+                start = next;
+                pts = [next];
+                // Further pairs after a moveto are implicit linetos.
+                cmd = rel ? 'l' : 'L';
+                break;
+            case 'l':
+                next = at(0);
+                pts = [next];
+                break;
+            case 'h':
+                next = [a[0] + ox, cur[1]];
+                pts = [next];
+                break;
+            case 'v':
+                next = [cur[0], a[0] + oy];
+                pts = [next];
+                break;
+            case 'c':
+                ctrl = at(2);
+                next = at(4);
+                pts = bezier(cur, at(0), ctrl, next);
+                break;
+            case 's': {
+                const c1 = lastCtrl ? [2 * cur[0] - lastCtrl[0], 2 * cur[1] - lastCtrl[1]] : cur;
+                ctrl = at(0);
+                next = at(2);
+                pts = bezier(cur, c1, ctrl, next);
+                break;
+            }
+            case 'q':
+            case 't': {
+                const q = lower === 'q' ? at(0) : lastQuad ? [2 * cur[0] - lastQuad[0], 2 * cur[1] - lastQuad[1]] : cur;
+                next = lower === 'q' ? at(2) : at(0);
+                quad = q;
+                const c1 = [cur[0] + (2 / 3) * (q[0] - cur[0]), cur[1] + (2 / 3) * (q[1] - cur[1])];
+                const c2 = [next[0] + (2 / 3) * (q[0] - next[0]), next[1] + (2 / 3) * (q[1] - next[1])];
+                pts = bezier(cur, c1, c2, next);
+                break;
+            }
+            case 'a':
+                next = [a[5] + ox, a[6] + oy];
+                pts = arcPoints(cur, [a[0], a[1], a[2], a[3], a[4], next[0], next[1]]);
+                break;
+        }
+        poly.push(...pts);
+        cur = next;
+        lastCtrl = ctrl;
+        lastQuad = quad;
+        if (polys.length > MAX_SUBPATHS)
+            return polys;
+    }
+    flush();
+    return polys;
+}
+function signedArea(poly) {
+    let s = 0;
+    for (let k = 0; k < poly.length; k++) {
+        const [x1, y1] = poly[k];
+        const [x2, y2] = poly[(k + 1) % poly.length];
+        s += x1 * y2 - x2 * y1;
+    }
+    return s / 2;
+}
+function inside(pt, poly) {
+    let hit = false;
+    for (let k = 0, j = poly.length - 1; k < poly.length; j = k++) {
+        const [xi, yi] = poly[k];
+        const [xj, yj] = poly[j];
+        if (yi > pt[1] !== yj > pt[1] && pt[0] < ((xj - xi) * (pt[1] - yi)) / (yj - yi) + xi)
+            hit = !hit;
+    }
+    return hit;
+}
+/**
+ * Every `<path>` painted under `nonzero` whose subpath sits in a painted region
+ * of the same path and winds with it. One entry per inner subpath; `outer` is
+ * the smallest subpath containing it.
+ */
+export function filledCounters(elements) {
+    const out = [];
+    // The fill rule and fill each element inherits, by an open-element stack.
+    const stack = [];
+    for (const el of elements) {
+        if (el.closing) {
+            const at = stack.map((s) => s.name).lastIndexOf(el.name);
+            if (at >= 0)
+                stack.length = at;
+            continue;
+        }
+        const parent = stack[stack.length - 1];
+        const rule = styleProp(el, 'fill-rule') ?? parent?.rule;
+        const fill = styleProp(el, 'fill') ?? parent?.fill;
+        if (!el.selfClosing)
+            stack.push({ name: el.name, rule, fill });
+        if (el.name !== 'path')
+            continue;
+        if ((rule ?? 'nonzero').toLowerCase() === 'evenodd' || (fill ?? '').toLowerCase() === 'none')
+            continue;
+        const polys = subpathPolygons(el.attrs['d'] ?? '');
+        if (polys === null || polys.length < 2 || polys.length > MAX_SUBPATHS)
+            continue;
+        const areas = polys.map(signedArea);
+        for (let inner = 0; inner < polys.length; inner++) {
+            const ia = areas[inner];
+            if (Math.abs(ia) < 1e-9)
+                continue;
+            // The winding number around the inner contour, from every subpath
+            // that contains it — not from one outer, or an island inside a
+            // counter reads as a filled counter.
+            let around = 0;
+            let nearest = -1;
+            for (let outer = 0; outer < polys.length; outer++) {
+                if (outer === inner)
+                    continue;
+                const oa = areas[outer];
+                if (Math.abs(oa) <= Math.abs(ia))
+                    continue;
+                const op = polys[outer];
+                if (!polys[inner].every((p) => inside(p, op)))
+                    continue;
+                around += Math.sign(oa);
+                if (nearest < 0 || Math.abs(oa) < Math.abs(areas[nearest]))
+                    nearest = outer;
+            }
+            if (around !== 0 && Math.sign(around) === Math.sign(ia)) {
+                out.push({ element: el, inner: inner + 1, outer: nearest + 1 });
+            }
+        }
+    }
+    return out;
+}
+/** The rule as `scanSvg` runs it: one advisory finding per filled counter. */
+export function ruleFilledCounter(elements, file) {
+    return filledCounters(elements).map((c) => ({
+        rule: 'svg-structure-filled-counter',
+        file,
+        line: c.element.line,
+        snippet: `<path> subpath ${c.inner} sits inside subpath ${c.outer} with the same winding under nonzero, so ` +
+            'the counter paints — wind the inner contour the other way, or declare fill-rule="evenodd"',
+        severity: 'warning',
+    }));
+}
+//# sourceMappingURL=svg_filled_counter.js.map