tosijs-floorplan 0.3.0 → 0.4.0

package/README.md

@@ -88,6 +88,8 @@ One flat record per wired element. Producers may add fields beyond these —
 | `required` | `boolean` | the field is required |
 | `disabled` | `boolean` | disabled right now |
 | `contentEditable` | `boolean` | an editable region — treated as an input field |
+| `interactive` | `boolean` | the producer's **assertion** that this element can be acted on — for producers that cannot introspect handlers (React delegates at a root; vanilla `addEventListener` is not enumerable from page script). Asserting is truth-telling; fabricating `on` to unlock the styling would be a lie in the payload. A binding framework never needs it |
+| `editable` | `boolean` | the producer's assertion that text goes in here — the DOM-side counterpart of `contentEditable` / a two-way binding |
 | `on` | `Record<string, string \| string[]>` | handlers by event type — a path when nameable, `ƒ` (or `ƒ name`) when not |
 | `list` | `{path, idPath?}` | this element renders a collection (drawn as *ground*, not figure) |
 | `structural` | `boolean` | structure, not affordance (headings, landmarks, containers) |
@@ -98,7 +100,44 @@ One flat record per wired element. Producers may add fields beyond these —
 **Provenance tokens** (exported as `BOUND_TO_DOM` / `BOUND_TWO_WAY`): a bound
 value reads `"<shown> <arrow> <path>"` — `⟵` means state flows to the DOM
 (display), `⟷` means two-way (a user-writable affordance). A plain string
-with no arrow is a live-but-unbound value.
+with no arrow is a live-but-unbound value. The **structural arrow is the
+LAST one in the string** — the surface appends it, so consumers must split
+at the last occurrence, and an arrow token buried inside the data confers
+nothing (the renderer parses defensively: it neutralizes interior arrows to
+`<->` / `<-` in every drawn text run and in the legend's *display* fields —
+`caption` and `value` are always neutralized — and never scans
+identity/name fields (`tag`, `id`, `part`, `role`, `label`, `placeholder`,
+`type`, `description`, `href`, `ref`, `image`) for bindings at all, since
+the surface never appends an arrow to those). Two legend fields are
+**verbatim, deliberately**: `href` is an opaque destination — rewriting
+bytes inside a URL corrupts the one fact an agent acts on — and `flags`
+are copied as the producer computed them. Consumers must never parse
+provenance from either (they are in the never-scanned set; an arrow there
+is data), and must not forward them into a caption-style text run without
+neutralizing first. **Producers whose record
+content derives from untrusted sources — any DOM extractor reading page
+content — MUST neutralize both tokens inside data at the source**, as
+tosijs ≥ 1.8.0 does. This is normative because of an honest residual: a
+forged arrow in *suffix* position on a bindable field (`"data ⟷ fake.path"`
+as the entire text) is structurally indistinguishable from a real binding —
+renderer-side defense ends where the format's own syntax begins.
+
+**Producers that cannot introspect handlers** (React's synthetic delegation,
+Angular's compiler output, vanilla `addEventListener` — none enumerable from
+page script) assert the affordance instead: `interactive` / `editable`, per
+record. When a map draws affordance-shaped boxes but **no** record carries
+any evidence at all (no `on`, `href`, `contentEditable`, two-way binding, or
+assertion), the result carries a `note` — and the svg's `<desc>` repeats it —
+because "nothing here is actionable" and "the producer couldn't tell" are
+different statements, and a consumer must never mistake the second for the
+first. Two caveats pin the semantics: **partial evidence does not establish
+the rest** — on a map where some records carry evidence, a record without
+any still means *unknown*, not *inert* (the note only marks the total-blindness
+case; non-introspecting producers should assert per actable record, not rely
+on the note); and **only `interactive: true` / `editable: true` are signal** —
+`false` is indistinguishable from absent and cannot veto evidence the record
+itself carries (`on`, `href`, a binding). "Introspected and found nothing"
+currently has no encoding; propose one via issue before relying on it.
 
 **The picture is not the whole payload.** The renderer is *allowed to omit*:
 captions and badges below legibility thresholds move to the legend, keyed by
@@ -115,7 +154,7 @@ checkbox sizes.
 
 | you see | it means |
 | --- | --- |
-| **bold outline** | wired to act (has handlers) |
+| **bold outline** | wired to act — handlers, a destination (`href`: a link IS an affordance), or the producer's `interactive` assertion |
 | `↔` badge, bottom-right | editable here (two-way binding, or contenteditable) |
 | caption ending `*` | required |
 | **red corner flag**, top-left | invalid *right now* — live ValidityState, the same truth `:invalid` styles |
@@ -133,14 +172,20 @@ checkbox sizes.
 | footer strip: "N elements with details in legend" | the image's confession that it isn't the whole map — fetch `schematic().legend` (a machine-readable `<desc>` says the same) |
 
 The target-size audit honours WCAG 2.5.8's **inline exception** as far as
-pure geometry can: a link *with text* is presumed sized by its text and is
-exempt (flagging prose links would fire on every paragraph — a check that
-cries wolf gets ignored, taking the real findings with it). An icon link —
-an `<a>` wrapping an `<svg>`, no text — stays flagged. A producer with DOM
-access can compute the exception *properly* (computed display + parent text
-nodes) and ship the finding via `flags`; a producer flag whose `kind`
-mentions `target` **supersedes** the built-in audit, so the two never
-double-mark.
+pure geometry can: a link is exempt when it has text **and its box is wider
+than tall** — the shape text layout produces (flagging prose links would
+fire on every paragraph — a check that cries wolf gets ignored, taking the
+real findings with it). Icon links stay flagged: an `<a>` wrapping an
+`<svg>` with no text, and equally a **square** icon link that happens to
+carry a label or a glyph — a 16×16 box was not sized by its text, whatever
+the text is (the text-only rule exempted exactly the header-row-of-icons
+case the check was built for; haltija's issue #2 caught it). A producer
+with DOM access computes the exception *properly* (computed display +
+parent text nodes) and ships the finding via `flags` — that is the
+**intended path** for DOM producers; a producer flag whose `kind` mentions
+`target` **supersedes** the built-in audit, so the two never double-mark.
+Both rules are exported (`isInteractive`, `targetSizeFinding`) so audits
+share this implementation instead of keeping a drifting copy.
 
 Captions tell the truth in priority order: a held **value** wins (as
 `label: value` when both are known), an empty control falls back to its
@@ -154,8 +199,10 @@ geometry genuinely runs out.
 
 | export | what |
 | --- | --- |
-| `schematic(description, options?)` | the renderer's primary form — returns `{ svg, legend }`: the drawing plus the metadata it could not legibly carry (cramped/truncated/undersized records), keyed by index/ref. **Pair every raster with its legend.** |
+| `schematic(description, options?)` | the renderer's primary form — returns `{ svg, legend, note? }`: the drawing, the metadata it could not legibly carry (cramped/truncated/undersized records, keyed by index/ref), and — when no record carries affordance evidence — the note saying so. **Pair every raster with its legend.** |
 | `schematicSVG(description, options?)` | `schematic().svg` — the string-only form; each `<g>` carries `data-record="<i>"` linking back to `description.wiring[i]` (the image as index) |
+| `isInteractive(record)` | "can I act here?" — the single implementation (handlers, `href`, `contentEditable`, a structural two-way binding, or the producer's assertion; ground never). Exported so audits consume it instead of keeping a drifting copy |
+| `targetSizeFinding(record, targetSize?)` | the WCAG 2.5.8 rule with the settled exemptions (toggles, text-sized links, producer-flag supersession) — the measured legend fact, or `null` |
 | `rasterizeSVG(svg, {scale})` | SVG → PNG Blob for vision encoders (browser canvas; under bun/node use `@resvg/resvg-js` — rasterize at 2× so labels OCR cleanly) |
 | `boundsOf(element)` | an element's page-coordinate bounds — the natural `within` argument |
 | `BOUND_TO_DOM`, `BOUND_TWO_WAY` | the provenance tokens |

package/dist/index.d.ts

@@ -83,6 +83,16 @@ export interface SchematicRecord {
      * ("3") or bound ("3 ⟷ app.qty"). tosijs emits it as a bound prop; the
      * declared field gives plain-DOM producers the same home */
     value?: string;
+    /** the producer's ASSERTION that this element can be acted on — for
+     * producers that cannot introspect handlers (React delegates at a root;
+     * vanilla addEventListener is not enumerable from page script). A binding
+     * framework never needs it: `on` and two-way bindings already say so.
+     * Asserting is truth-telling; fabricating `on` to unlock the styling
+     * would be a lie in the payload. (issue #3, haltija) */
+    interactive?: boolean;
+    /** the producer's assertion that text goes in here — the DOM-side
+     * counterpart of contentEditable/two-way bindings (issue #3) */
+    editable?: boolean;
     [boundProp: string]: unknown;
 }
 /** the map: only `wiring` is read. The named optional fields are the
@@ -182,12 +192,49 @@ export interface SchematicLegendEntry {
 export interface SchematicResult {
     svg: string;
     legend: SchematicLegendEntry[];
+    /** set when the map draws affordance-shaped boxes but NO record carries
+     * any affordance evidence: "nothing here is actionable" and "the
+     * producer couldn't tell" are different statements, and a consumer
+     * acting on the first when the truth is the second is the
+     * confident-wrong-answer case (issue #3). Also rides the svg's <desc>. */
+    note?: string;
 }
 /**
  * An element's page-coordinate bounds (the same space describe() records) —
  * the natural `within` argument for a region-scoped schematic.
  */
 export declare const boundsOf: (element: Element) => SchematicBounds;
+/**
+ * "Can I act here?" — the single implementation of the interactivity
+ * predicate, exported so audits (tosijs's auditAccessibility) consume THIS
+ * rather than keeping a drifting copy (issue #4: the two had already
+ * reached contradictory verdicts on the same element). Evidence, any of:
+ * handlers (`on`), a link destination (`href` — a link IS an affordance),
+ * `contentEditable`, a two-way binding in structural position, or the
+ * producer's own `interactive`/`editable` assertion (issue #3). Ground
+ * (structure, list containers) is never interactive.
+ */
+export declare const isInteractive: (w: SchematicRecord) => boolean;
+/** the WCAG 2.5.8 audit floor (24×24, the AA minimum) — one constant so
+ * the option default and the exported rule cannot drift */
+export declare const TARGET_SIZE_DEFAULT = 24;
+/**
+ * The WCAG 2.5.8 target-size rule, exported for the same reason as
+ * `isInteractive` (issue #4): one implementation, geometry judged where the
+ * geometry lives. Returns the measured finding string (the legend fact) or
+ * null. Embodies the settled exemptions: toggles (user-agent-sized); links
+ * plausibly sized by VISIBLE text — the WCAG inline exception as far as
+ * pure geometry can honour it, which is: has text, and the box is WIDER
+ * than tall, the shape text layout produces (issue #2 caught the earlier
+ * text-only rule exempting 16×16 icon links that happened to carry a
+ * label; an accessible name alone never sizes a box, and a square box was
+ * not sized by its text); and supersession by any producer-supplied flag
+ * whose kind mentions `target` — a producer with DOM access (computed
+ * display, parent text nodes) computes the real exception and ships the
+ * finding via `flags`; that is the INTENDED path for DOM producers, and
+ * the built-in never double-marks over it.
+ */
+export declare const targetSizeFinding: (w: SchematicRecord, targetSize?: number) => string | null;
 export declare const schematic: (description: SchematicDescription, options?: SchematicOptions) => SchematicResult;
 /** the string-only form — schematic().svg, kept for drop-in compatibility */
 export declare const schematicSVG: (description: SchematicDescription, options?: SchematicOptions) => string;

package/dist/index.js

@@ -4,13 +4,32 @@ var BOUND_TWO_WAY = "⟷";
 var shownValue = (v) => {
   if (typeof v !== "string")
     return;
-  for (const arrow of [BOUND_TWO_WAY, BOUND_TO_DOM]) {
-    const at = v.indexOf(arrow);
-    if (at >= 0)
-      return v.slice(0, at).trim();
-  }
-  return v;
+  const at = Math.max(v.lastIndexOf(BOUND_TWO_WAY), v.lastIndexOf(BOUND_TO_DOM));
+  return neutralizeArrows(at >= 0 ? v.slice(0, at).trim() : v);
+};
+var neutralizeArrows = (s) => s.replaceAll(BOUND_TWO_WAY, "<->").replaceAll(BOUND_TO_DOM, "<-");
+var boundTwoWay = (v) => {
+  if (typeof v !== "string")
+    return false;
+  const at = v.lastIndexOf(BOUND_TWO_WAY);
+  return at >= 0 && at > v.lastIndexOf(BOUND_TO_DOM);
 };
+var NEVER_BOUND = new Set([
+  "tag",
+  "id",
+  "part",
+  "role",
+  "label",
+  "placeholder",
+  "type",
+  "description",
+  "href",
+  "ref",
+  "image"
+]);
+var hasTwoWayBinding = (w) => Object.entries(w).some(([key, v]) => !NEVER_BOUND.has(key) && boundTwoWay(v));
+var hasActEvidence = (w) => w.on != null || w.interactive === true || typeof w.href === "string" && w.href !== "";
+var hasEditEvidence = (w) => w.editable === true || w.contentEditable === true || hasTwoWayBinding(w);
 var boundsOf = (element) => {
   const rect = element.getBoundingClientRect();
   return {
@@ -20,6 +39,23 @@ var boundsOf = (element) => {
     height: Math.round(rect.height)
   };
 };
+var isGround = (w) => w.structural === true || w.list != null && w.on == null;
+var isInteractive = (w) => !isGround(w) && (hasActEvidence(w) || hasEditEvidence(w));
+var TARGET_SIZE_DEFAULT = 24;
+var targetSizeFinding = (w, targetSize = TARGET_SIZE_DEFAULT) => {
+  if (targetSize <= 0 || w.bounds == null || !isInteractive(w))
+    return null;
+  if (w.type === "checkbox" || w.type === "radio")
+    return null;
+  if (w.tag === "a" && typeof w.text === "string" && w.text !== "" && w.bounds.width > w.bounds.height) {
+    return null;
+  }
+  if (Array.isArray(w.flags) && w.flags.some((f) => f.kind.toLowerCase().includes("target"))) {
+    return null;
+  }
+  const { width, height } = w.bounds;
+  return width < targetSize || height < targetSize ? `${width}×${height} — below ${targetSize}×${targetSize} (WCAG 2.5.8)` : null;
+};
 var intersects = (a, b) => a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height;
 var contains = (outer, inner) => inner.x >= outer.x && inner.y >= outer.y && inner.x + inner.width <= outer.x + outer.width && inner.y + inner.height <= outer.y + outer.height;
 var esc = (s) => s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
@@ -29,6 +65,7 @@ var FLAG_COLORS = {
   warn: "#e6a700",
   info: "#888888"
 };
+var flagColor = (severity) => typeof severity === "string" && Object.hasOwn(FLAG_COLORS, severity) ? FLAG_COLORS[severity] : FLAG_COLORS.warn;
 var wrapCaption = (caption, maxChars, maxLines) => {
   if (maxLines <= 1 || caption.length <= maxChars) {
     return [caption.slice(0, maxChars + 2)];
@@ -64,7 +101,7 @@ var schematic = (description, options = {}) => {
     fontSize = 11,
     within,
     index: showIndex = false,
-    targetSize = 24,
+    targetSize = TARGET_SIZE_DEFAULT,
     legendNote = true,
     decorate
   } = options;
@@ -85,8 +122,9 @@ var schematic = (description, options = {}) => {
   const parts = [
     `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${minX} ${minY} ${maxX - minX} ${maxY - minY}" width="${maxX - minX}" height="${maxY - minY}">`
   ];
-  const ground = (w) => w.structural === true || w.list != null && w.on == null;
-  const drawOrder = [...boxes].sort((a, b) => Number(ground(b)) - Number(ground(a)));
+  const drawOrder = [...boxes].sort((a, b) => Number(isGround(b)) - Number(isGround(a)));
+  const blind = boxes.some((w) => !isGround(w)) && !description.wiring.some(isInteractive);
+  const note = blind ? "no record carries affordance evidence (on, href, contentEditable, " + "a two-way binding, or an interactive/editable assertion) — " + '"nothing here is actionable" is NOT established; a producer that ' + "cannot introspect handlers should assert `interactive`/`editable` " + "per record (see README)" : undefined;
   for (const w of drawOrder) {
     const index = description.wiring.indexOf(w);
     const pinOffsetX = w.viewportFixed === true ? minX + pad : 0;
@@ -115,18 +153,16 @@ var schematic = (description, options = {}) => {
     } else {
       caption = String(w.label ?? shownValue(w.text) ?? shownValue(w.value) ?? w.href ?? `<${w.tag}>`);
     }
-    const structural = ground(w);
-    const actable = !structural && w.on != null;
-    const editable = !structural && (w.contentEditable === true || Object.values(w).some((v) => typeof v === "string" && v.includes(BOUND_TWO_WAY)));
+    caption = neutralizeArrows(caption);
+    const structural = isGround(w);
+    const actable = !structural && hasActEvidence(w);
+    const editable = !structural && hasEditEvidence(w);
     const fill = structural ? "none" : w.style != null ? w.style.background : "transparent";
     const stroke = !structural && w.style != null && w.style.borderColor !== TRANSPARENT ? w.style.borderColor : "currentColor";
     const color = w.style != null ? w.style.color : "currentColor";
     const drawImage = !structural && typeof w.image === "string" && w.image.startsWith("data:");
     const cramped = !structural && (height < minLabelHeight || width < fontSize * 3);
-    const interactive = !structural && (w.on != null || w.contentEditable === true || Object.values(w).some((v) => typeof v === "string" && v.includes(BOUND_TWO_WAY)));
-    const producerTargetFlag = Array.isArray(w.flags) && w.flags.some((f) => f.kind.toLowerCase().includes("target"));
-    const textSizedLink = w.tag === "a" && typeof w.text === "string" && w.text !== "";
-    const undersized = targetSize > 0 && interactive && !producerTargetFlag && !textSizedLink && !(w.type === "checkbox" || w.type === "radio") && (width < targetSize || height < targetSize) ? `${width}×${height} — below ${targetSize}×${targetSize} (WCAG 2.5.8)` : undefined;
+    const undersized = targetSizeFinding(w, targetSize);
     const emphasis = structural ? ' stroke-dasharray="1 3" stroke-linecap="round" opacity="0.45"' : w.disabled === true ? ' opacity="0.4"' : actable ? ' stroke-width="2"' : "";
     parts.push(`<g data-record="${index}"${w.ref != null ? ` data-ref="${esc(String(w.ref))}"` : ""}>`);
     if (w.type === "radio") {
@@ -149,13 +185,11 @@ var schematic = (description, options = {}) => {
     }
     if (!cramped && !structural && Array.isArray(w.flags) && w.flags.length > 0) {
       w.flags.forEach((flag, at) => {
-        const color2 = FLAG_COLORS[flag.severity ?? "warn"] ?? FLAG_COLORS.warn;
-        parts.push(`<rect x="${x + at * 3}" y="${y}" width="3" height="${height}" ` + `fill="${color2}" data-flag="${esc(flag.kind)}"/>`);
+        parts.push(`<rect x="${x + at * 3}" y="${y}" width="3" height="${height}" ` + `fill="${flagColor(flag.severity)}" data-flag="${esc(flag.kind)}"/>`);
       });
       const first = w.flags[0];
       if (first.label && height >= minLabelHeight) {
-        const flagColor = FLAG_COLORS[first.severity ?? "warn"] ?? FLAG_COLORS.warn;
-        parts.push(`<rect x="${x + w.flags.length * 3 + 1}" y="${y + height - 9}" ` + `width="${first.label.length * 4.5 + 2}" height="8" ` + `fill="white" opacity="0.85"/>`, `<text x="${x + w.flags.length * 3 + 2}" y="${y + height - 2}" ` + `font-size="7" font-family="monospace" fill="${flagColor}">` + `${esc(first.label)}</text>`);
+        parts.push(`<rect x="${x + w.flags.length * 3 + 1}" y="${y + height - 9}" ` + `width="${first.label.length * 4.5 + 2}" height="8" ` + `fill="white" opacity="0.85"/>`, `<text x="${x + w.flags.length * 3 + 2}" y="${y + height - 2}" ` + `font-size="7" font-family="monospace" ` + `fill="${flagColor(first.severity)}">` + `${esc(neutralizeArrows(first.label))}</text>`);
       }
     }
     if (undersized != null) {
@@ -245,9 +279,18 @@ var schematic = (description, options = {}) => {
   if (footerExtra > 0) {
     parts.push(`<text x="${minX + pad}" y="${maxY + 10}" font-size="8" ` + `font-family="monospace" fill="currentColor" opacity="0.75">` + `${legend.length} element${legend.length === 1 ? "" : "s"} with ` + `details in legend — match by stamped number</text>`);
   }
-  parts[0] = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${minX} ${minY} ${maxX - minX} ${maxY - minY + footerExtra}" width="${maxX - minX}" height="${maxY - minY + footerExtra}">` + (legend.length > 0 ? `<desc>${description.wiring.length} records; ${legend.length} ` + "legend entries carry metadata the drawing could not — pair this " + "image with its legend JSON (schematic().legend), matched by the " + "stamped number / data-record index.</desc>" : "");
+  const descBits = [];
+  if (legend.length > 0) {
+    descBits.push(`${description.wiring.length} records; ${legend.length} ` + "legend entries carry metadata the drawing could not — pair this " + "image with its legend JSON (schematic().legend), matched by the " + "stamped number / data-record index.");
+  }
+  if (note != null)
+    descBits.push(note);
+  parts[0] = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${minX} ${minY} ${maxX - minX} ${maxY - minY + footerExtra}" width="${maxX - minX}" height="${maxY - minY + footerExtra}">` + (descBits.length > 0 ? `<desc>${esc(descBits.join(" "))}</desc>` : "");
   parts.push("</svg>");
-  return { svg: parts.join(""), legend };
+  const result = { svg: parts.join(""), legend };
+  if (note != null)
+    result.note = note;
+  return result;
 };
 var schematicSVG = (description, options = {}) => schematic(description, options).svg;
 var rasterizeSVG = (svg, options = {}) => {
@@ -289,10 +332,13 @@ var rasterizeSVG = (svg, options = {}) => {
   });
 };
 export {
-  schematicSVG,
-  schematic,
-  rasterizeSVG,
-  boundsOf,
+  BOUND_TO_DOM,
   BOUND_TWO_WAY,
-  BOUND_TO_DOM
+  TARGET_SIZE_DEFAULT,
+  boundsOf,
+  isInteractive,
+  rasterizeSVG,
+  schematic,
+  schematicSVG,
+  targetSizeFinding
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tosijs-floorplan",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Render an agent-surface map (plain records) as a floorplan SVG — the affordance grammar as a pure, dependency-free function. No DOM, no framework. Formerly tosijs-schematic.",
   "type": "module",
   "license": "Apache-2.0",
@@ -27,6 +27,8 @@
   "scripts": {
     "build": "bun build src/index.ts --outdir dist --format esm && tsc -p tsconfig.json",
     "test": "bun test",
+    "typecheck": "tsc -p tsconfig.json --noEmit --emitDeclarationOnly false",
+    "stability": "bun tools/byte-stability.ts",
     "prepublishOnly": "bun test && bun run build"
   },
   "devDependencies": {

package/src/index.ts

@@ -69,6 +69,16 @@ export interface SchematicRecord {
    * ("3") or bound ("3 ⟷ app.qty"). tosijs emits it as a bound prop; the
    * declared field gives plain-DOM producers the same home */
   value?: string
+  /** the producer's ASSERTION that this element can be acted on — for
+   * producers that cannot introspect handlers (React delegates at a root;
+   * vanilla addEventListener is not enumerable from page script). A binding
+   * framework never needs it: `on` and two-way bindings already say so.
+   * Asserting is truth-telling; fabricating `on` to unlock the styling
+   * would be a lie in the payload. (issue #3, haltija) */
+  interactive?: boolean
+  /** the producer's assertion that text goes in here — the DOM-side
+   * counterpart of contentEditable/two-way bindings (issue #3) */
+  editable?: boolean
   [boundProp: string]: unknown
 }
 
@@ -170,20 +180,72 @@ export interface SchematicLegendEntry {
 export interface SchematicResult {
   svg: string
   legend: SchematicLegendEntry[]
+  /** set when the map draws affordance-shaped boxes but NO record carries
+   * any affordance evidence: "nothing here is actionable" and "the
+   * producer couldn't tell" are different statements, and a consumer
+   * acting on the first when the truth is the second is the
+   * confident-wrong-answer case (issue #3). Also rides the svg's <desc>. */
+  note?: string
 }
 
 // strip provenance from a bound-value string: "shown ⟷ path" → "shown"
 // (empty when the binding holds no value yet); a plain string (no arrow)
-// is a live-but-unbound value and passes through whole
+// is a live-but-unbound value and passes through whole.
+// The STRUCTURAL arrow is the LAST one in the string — the surface appends
+// it, so everything before it is data, and data can carry arrow tokens
+// (forged, or from a producer older than tosijs 1.8.0, which neutralizes
+// them at the source). A renderer consumes maps it did not generate, so it
+// parses defensively: split at the last arrow, and neutralize any arrow
+// left INSIDE the shown value (geometry over glyphs — a rare glyph must
+// never ride a caption run, and a fake arrow must never read as structure).
 const shownValue = (v: unknown): string | undefined => {
   if (typeof v !== 'string') return undefined
-  for (const arrow of [BOUND_TWO_WAY, BOUND_TO_DOM]) {
-    const at = v.indexOf(arrow)
-    if (at >= 0) return v.slice(0, at).trim()
-  }
-  return v
+  const at = Math.max(v.lastIndexOf(BOUND_TWO_WAY), v.lastIndexOf(BOUND_TO_DOM))
+  return neutralizeArrows(at >= 0 ? v.slice(0, at).trim() : v)
 }
 
+// arrow tokens inside record data must neither ride a caption run
+// (geometry over glyphs) nor read as structure — neutralized the same way
+// tosijs ≥1.8.0 does at the source
+const neutralizeArrows = (s: string): string =>
+  s.replaceAll(BOUND_TWO_WAY, '<->').replaceAll(BOUND_TO_DOM, '<-')
+
+// is this string a live two-way binding? Only the arrow in STRUCTURAL
+// position (last) counts — a ⟷ buried inside the data must not confer an
+// affordance (a drawing that lies about what the page can do is worse than
+// no drawing).
+const boundTwoWay = (v: unknown): boolean => {
+  if (typeof v !== 'string') return false
+  const at = v.lastIndexOf(BOUND_TWO_WAY)
+  return at >= 0 && at > v.lastIndexOf(BOUND_TO_DOM)
+}
+
+// fields the surface NEVER appends a binding arrow to: identity, naming,
+// hints, destinations. In these, any arrow is data (or forgery) — the
+// last-occurrence rule only protects fields that actually receive an
+// appended binding, so these are excluded from the binding scan entirely
+// (0.4.0 review B1: a lone forged arrow in a never-bindable field is
+// always in "last = structural" position).
+const NEVER_BOUND = new Set([
+  'tag', 'id', 'part', 'role', 'label', 'placeholder', 'type',
+  'description', 'href', 'ref', 'image',
+])
+const hasTwoWayBinding = (w: SchematicRecord): boolean =>
+  Object.entries(w).some(
+    ([key, v]) => !NEVER_BOUND.has(key) && boundTwoWay(v)
+  )
+
+// the two kinds of affordance evidence, split once and shared by the
+// renderer AND the exported predicate — three independently edited copies
+// of this logic is how the renderer and tosijs's audit drifted into
+// contradicting each other (issue #4); parity is now by construction
+const hasActEvidence = (w: SchematicRecord): boolean =>
+  w.on != null ||
+  w.interactive === true ||
+  (typeof w.href === 'string' && w.href !== '')
+const hasEditEvidence = (w: SchematicRecord): boolean =>
+  w.editable === true || w.contentEditable === true || hasTwoWayBinding(w)
+
 /**
  * An element's page-coordinate bounds (the same space describe() records) —
  * the natural `within` argument for a region-scoped schematic.
@@ -198,6 +260,70 @@ export const boundsOf = (element: Element): SchematicBounds => {
   }
 }
 
+// structure behind affordances — a LIST CONTAINER is ground too: it's
+// wired (the collection binds here), but its items are the affordances
+const isGround = (w: SchematicRecord): boolean =>
+  w.structural === true || (w.list != null && w.on == null)
+
+/**
+ * "Can I act here?" — the single implementation of the interactivity
+ * predicate, exported so audits (tosijs's auditAccessibility) consume THIS
+ * rather than keeping a drifting copy (issue #4: the two had already
+ * reached contradictory verdicts on the same element). Evidence, any of:
+ * handlers (`on`), a link destination (`href` — a link IS an affordance),
+ * `contentEditable`, a two-way binding in structural position, or the
+ * producer's own `interactive`/`editable` assertion (issue #3). Ground
+ * (structure, list containers) is never interactive.
+ */
+export const isInteractive = (w: SchematicRecord): boolean =>
+  !isGround(w) && (hasActEvidence(w) || hasEditEvidence(w))
+
+/** the WCAG 2.5.8 audit floor (24×24, the AA minimum) — one constant so
+ * the option default and the exported rule cannot drift */
+export const TARGET_SIZE_DEFAULT = 24
+
+/**
+ * The WCAG 2.5.8 target-size rule, exported for the same reason as
+ * `isInteractive` (issue #4): one implementation, geometry judged where the
+ * geometry lives. Returns the measured finding string (the legend fact) or
+ * null. Embodies the settled exemptions: toggles (user-agent-sized); links
+ * plausibly sized by VISIBLE text — the WCAG inline exception as far as
+ * pure geometry can honour it, which is: has text, and the box is WIDER
+ * than tall, the shape text layout produces (issue #2 caught the earlier
+ * text-only rule exempting 16×16 icon links that happened to carry a
+ * label; an accessible name alone never sizes a box, and a square box was
+ * not sized by its text); and supersession by any producer-supplied flag
+ * whose kind mentions `target` — a producer with DOM access (computed
+ * display, parent text nodes) computes the real exception and ships the
+ * finding via `flags`; that is the INTENDED path for DOM producers, and
+ * the built-in never double-marks over it.
+ */
+export const targetSizeFinding = (
+  w: SchematicRecord,
+  targetSize = TARGET_SIZE_DEFAULT
+): string | null => {
+  if (targetSize <= 0 || w.bounds == null || !isInteractive(w)) return null
+  if (w.type === 'checkbox' || w.type === 'radio') return null
+  if (
+    w.tag === 'a' &&
+    typeof w.text === 'string' &&
+    w.text !== '' &&
+    w.bounds.width > w.bounds.height
+  ) {
+    return null
+  }
+  if (
+    Array.isArray(w.flags) &&
+    w.flags.some((f) => f.kind.toLowerCase().includes('target'))
+  ) {
+    return null
+  }
+  const { width, height } = w.bounds
+  return width < targetSize || height < targetSize
+    ? `${width}×${height} — below ${targetSize}×${targetSize} (WCAG 2.5.8)`
+    : null
+}
+
 const intersects = (a: SchematicBounds, b: SchematicBounds): boolean =>
   a.x < b.x + b.width &&
   b.x < a.x + a.width &&
@@ -227,6 +353,14 @@ const FLAG_COLORS: Record<string, string> = {
   info: '#888888',
 }
 
+// severity comes from producer JSON, so it can be anything — including
+// 'constructor', which a bare index would resolve up the prototype chain
+// into a function serialized straight into a fill attribute
+const flagColor = (severity: unknown): string =>
+  typeof severity === 'string' && Object.hasOwn(FLAG_COLORS, severity)
+    ? FLAG_COLORS[severity]
+    : FLAG_COLORS.warn
+
 // greedy word-wrap: captions should USE vertical room, not truncate with
 // space to spare (a <p> that wraps on the real page has the same height
 // here). Returns at most maxLines lines, each at most maxChars long;
@@ -271,7 +405,7 @@ export const schematic = (
     fontSize = 11,
     within,
     index: showIndex = false,
-    targetSize = 24,
+    targetSize = TARGET_SIZE_DEFAULT,
     legendNote = true,
     decorate,
   } = options
@@ -328,14 +462,29 @@ export const schematic = (
     } ${maxY - minY}" width="${maxX - minX}" height="${maxY - minY}">`,
   ]
   // structure behind affordances: dotted outlines the eye (and the raster)
-  // reads as grouping, not controls. A LIST CONTAINER is ground too — it's
-  // wired (the collection binds here, and the JSON record says so), but its
-  // items are the affordances; drawing it solid would read as actionable.
-  const ground = (w: (typeof boxes)[number]): boolean =>
-    w.structural === true || (w.list != null && w.on == null)
+  // reads as grouping, not controls (isGround, module level — the exported
+  // predicates share it).
   const drawOrder = [...boxes].sort(
-    (a, b) => Number(ground(b)) - Number(ground(a))
+    (a, b) => Number(isGround(b)) - Number(isGround(a))
   )
+  // NO AFFORDANCE EVIDENCE ANYWHERE: for a producer that cannot introspect
+  // handlers (issue #3), every record answers "can I act here?" with no —
+  // silently, which is the confident-wrong-answer failure. "Nothing here is
+  // actionable" and "I couldn't tell" are different statements; when the
+  // map draws non-ground boxes but not one record carries any evidence, the
+  // result says so instead of letting silence claim the first.
+  // evidence is judged over the WHOLE wiring, not the drawn subset: a
+  // `within` crop of a map whose evidence lies outside the region is not a
+  // blind map, it's a blind REGION of a sighted one (review follow-up)
+  const blind =
+    boxes.some((w) => !isGround(w)) && !description.wiring.some(isInteractive)
+  const note = blind
+    ? 'no record carries affordance evidence (on, href, contentEditable, ' +
+      'a two-way binding, or an interactive/editable assertion) — ' +
+      '"nothing here is actionable" is NOT established; a producer that ' +
+      'cannot introspect handlers should assert `interactive`/`editable` ' +
+      'per record (see README)'
+    : undefined
   for (const w of drawOrder) {
     const index = description.wiring.indexOf(w)
     const pinOffsetX = w.viewportFixed === true ? minX + pad : 0
@@ -398,18 +547,18 @@ export const schematic = (
           `<${w.tag}>`
       )
     }
-    const structural = ground(w)
-    // the affordance grammar, explicit: BOLD outline = wired to act (has
-    // handlers); a trailing ⟷ on the caption = editable here (two-way
-    // binding), added when the caption is a label that would otherwise
-    // hide it. Solid = affordance, dotted = structure.
-    const actable = !structural && w.on != null
-    const editable =
-      !structural &&
-      (w.contentEditable === true ||
-        Object.values(w).some(
-          (v) => typeof v === 'string' && v.includes(BOUND_TWO_WAY)
-        ))
+    // EVERY caption source (label, placeholder, href, tag fallback — not
+    // just the text/value paths shownValue serves) is neutralized here, at
+    // one choke point: the 0.4.0 review's B1 found the arrow defense
+    // bypassed by exactly the sources this line now covers
+    caption = neutralizeArrows(caption)
+    const structural = isGround(w)
+    // the affordance grammar, explicit: BOLD outline = wired to act —
+    // handlers, a link destination (href: a link IS an affordance, 0.4.0),
+    // or the producer's `interactive` word. The ↔ badge = editable here.
+    // Solid = affordance, dotted = structure.
+    const actable = !structural && hasActEvidence(w)
+    const editable = !structural && hasEditEvidence(w)
     const fill = structural
       ? 'none'
       : w.style != null
@@ -432,35 +581,11 @@ export const schematic = (
       !structural && (height < minLabelHeight || width < fontSize * 3)
     // UNDERSIZED: an interactive element below the target-size floor is a
     // usability defect in its own right (WCAG 2.5.8: 24×24 AA; 44/48 is the
-    // platform touch bar) — toggles exempt as user-agent-sized controls
-    const interactive =
-      !structural &&
-      (w.on != null || w.contentEditable === true ||
-        Object.values(w).some(
-          (v) => typeof v === 'string' && v.includes(BOUND_TWO_WAY)
-        ))
-    // WCAG 2.5.8 exempts inline targets sized by their text — flagging
-    // prose links fires on every paragraph, and a check that cries wolf
-    // gets ignored, taking the real findings with it. A pure renderer
-    // can't see computed display, so: a link WITH text is presumed
-    // text-sized and exempt (icon links — an <a> wrapping an <svg>, no
-    // text — stay flagged). Producers with DOM access compute this
-    // properly and ship it via `flags`, which also SUPERSEDES the built-in
-    // audit here: no double amber bars for the same finding.
-    const producerTargetFlag =
-      Array.isArray(w.flags) &&
-      w.flags.some((f) => f.kind.toLowerCase().includes('target'))
-    const textSizedLink =
-      w.tag === 'a' && typeof w.text === 'string' && w.text !== ''
-    const undersized =
-      targetSize > 0 &&
-      interactive &&
-      !producerTargetFlag &&
-      !textSizedLink &&
-      !(w.type === 'checkbox' || w.type === 'radio') &&
-      (width < targetSize || height < targetSize)
-        ? `${width}×${height} — below ${targetSize}×${targetSize} (WCAG 2.5.8)`
-        : undefined
+    // platform touch bar). The whole rule — the interactivity predicate,
+    // the toggle and inline-link exemptions, producer-flag supersession —
+    // lives in the exported targetSizeFinding (issue #4: one
+    // implementation, shared with tosijs's audit).
+    const undersized = targetSizeFinding(w, targetSize)
     const emphasis = structural
       ? ' stroke-dasharray="1 3" stroke-linecap="round" opacity="0.45"'
       : w.disabled === true
@@ -517,22 +642,23 @@ export const schematic = (
     // the LEFT edge — the unclaimed slot — plus the first flag's label
     if (!cramped && !structural && Array.isArray(w.flags) && w.flags.length > 0) {
       w.flags.forEach((flag, at) => {
-        const color = FLAG_COLORS[flag.severity ?? 'warn'] ?? FLAG_COLORS.warn
         parts.push(
           `<rect x="${x + at * 3}" y="${y}" width="3" height="${height}" ` +
-            `fill="${color}" data-flag="${esc(flag.kind)}"/>`
+            `fill="${flagColor(flag.severity)}" data-flag="${esc(flag.kind)}"/>`
         )
       })
       const first = w.flags[0]
       if (first.label && height >= minLabelHeight) {
-        const flagColor = FLAG_COLORS[first.severity ?? 'warn'] ?? FLAG_COLORS.warn
         parts.push(
           `<rect x="${x + w.flags.length * 3 + 1}" y="${y + height - 9}" ` +
             `width="${first.label.length * 4.5 + 2}" height="8" ` +
             `fill="white" opacity="0.85"/>`,
           `<text x="${x + w.flags.length * 3 + 2}" y="${y + height - 2}" ` +
-            `font-size="7" font-family="monospace" fill="${flagColor}">` +
-            `${esc(first.label)}</text>`
+            `font-size="7" font-family="monospace" ` +
+            `fill="${flagColor(first.severity)}">` +
+            // the drawn label is a text RUN (neutralize: rare glyphs tofu);
+            // the legend's copy of flags stays verbatim, per the spec
+            `${esc(neutralizeArrows(first.label))}</text>`
         )
       }
     }
@@ -711,20 +837,27 @@ export const schematic = (
         `details in legend — match by stamped number</text>`
     )
   }
+  const descBits: string[] = []
+  if (legend.length > 0) {
+    descBits.push(
+      `${description.wiring.length} records; ${legend.length} ` +
+        'legend entries carry metadata the drawing could not — pair this ' +
+        'image with its legend JSON (schematic().legend), matched by the ' +
+        'stamped number / data-record index.'
+    )
+  }
+  if (note != null) descBits.push(note)
   parts[0] =
     `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${minX} ${minY} ${
       maxX - minX
     } ${maxY - minY + footerExtra}" width="${maxX - minX}" height="${
       maxY - minY + footerExtra
     }">` +
-    (legend.length > 0
-      ? `<desc>${description.wiring.length} records; ${legend.length} ` +
-        'legend entries carry metadata the drawing could not — pair this ' +
-        'image with its legend JSON (schematic().legend), matched by the ' +
-        'stamped number / data-record index.</desc>'
-      : '')
+    (descBits.length > 0 ? `<desc>${esc(descBits.join(' '))}</desc>` : '')
   parts.push('</svg>')
-  return { svg: parts.join(''), legend }
+  const result: SchematicResult = { svg: parts.join(''), legend }
+  if (note != null) result.note = note
+  return result
 }
 
 /** the string-only form — schematic().svg, kept for drop-in compatibility */

package/src/schematic.test.ts

@@ -1,5 +1,5 @@
 import { test, expect, describe } from 'bun:test'
-import { schematicSVG, schematic } from './index'
+import { schematicSVG, schematic, isInteractive, targetSizeFinding } from './index'
 import { SchematicDescription } from './index'
 
 const description: SchematicDescription = {
@@ -690,18 +690,21 @@ describe('the legend convergence — href, value, the inline exception (0.3.0)',
     expect(legend[0].value).toBe('3') // provenance stripped
   })
 
-  test('inline exception: a text-sized link is not flagged undersized; an icon link is', () => {
+  test('inline exception: a text-sized link is not flagged undersized; icon links are — even labelled ones (#2)', () => {
     const { legend } = schematic({
       wiring: [
-        // a link in prose: sized by its text — WCAG 2.5.8 exempts it
+        // a link in prose: sized by its text (wider than tall) — exempt
         { tag: 'a', text: 'terms', href: '/terms', on: { click: 'ƒ' }, bounds: at(10, 10, 34, 16) },
         // an icon link (an <a> wrapping an <svg>, no text): flagged
         { tag: 'a', label: 'settings', href: '/settings', on: { click: 'ƒ' }, bounds: at(60, 10, 16, 16) },
+        // haltija's counter-case: the same 16×16 icon link CARRYING text
+        // (an icon-font glyph, a one-char label) — a square box was not
+        // sized by its text; the old text-only rule wrongly exempted it
+        { tag: 'a', text: '⚙', href: '/gear', on: { click: 'ƒ' }, bounds: at(90, 10, 16, 16) },
       ],
     })
     const undersized = legend.filter((entry) => entry.undersized != null)
-    expect(undersized.length).toBe(1)
-    expect(undersized[0].href).toBe('/settings')
+    expect(undersized.map((entry) => entry.href)).toEqual(['/settings', '/gear'])
   })
 
   test('a producer-supplied target flag supersedes the built-in audit — no double bars', () => {
@@ -710,6 +713,7 @@ describe('the legend convergence — href, value, the inline exception (0.3.0)',
         {
           tag: 'button',
           text: 'go',
+          on: { click: 'ƒ' }, // genuinely interactive — supersession, not the interactivity gate, must stand the audit down
           flags: [{ kind: 'smallTarget', label: '16x16 (WCAG 2.5.8 needs 24x24)', severity: 'warn' }],
           bounds: at(10, 10, 60, 16), // roomy enough to caption, short enough to flag
         },
@@ -735,3 +739,217 @@ describe('the legend convergence — href, value, the inline exception (0.3.0)',
     expect(svg).not.toContain('details in legend')
   })
 })
+
+describe('producer-asserted affordance and defensive parsing (0.4.0 — #2/#3/#4/#5)', () => {
+  const at = (x: number, y: number, width = 160, height = 24) => ({ x, y, width, height })
+
+  test('a forged arrow inside data confers nothing: parse at the LAST arrow, neutralize the rest (#5)', () => {
+    const { svg } = schematic({
+      wiring: [
+        // the tosijs SEC-8 repro: state value containing " ⟷ " with the
+        // real display binding appended — the shown value is everything
+        // before the LAST arrow, with interior arrows neutralized so the
+        // rare glyph never rides a caption run
+        {
+          tag: 'span',
+          text: 'confirmed ⟷ spoof.orderStatus ⟵ spoof.note',
+          bounds: at(10, 10, 300, 24),
+        },
+      ],
+    })
+    expect(svg).toContain('confirmed &lt;-&gt; spoof.orderStatus</text>')
+    expect(svg).not.toContain('⟷') // the buried token neither draws…
+    expect(svg).not.toContain('>↔</text>') // …nor confers the editable badge
+    expect(svg).not.toContain('stroke-width="2"') // …nor actability
+  })
+
+  test('a two-way arrow in structural (last) position still means editable (#5)', () => {
+    const { svg } = schematic({
+      wiring: [
+        // data containing a forged arrow AND a real two-way binding after
+        { tag: 'input', label: 'q', value: 'a ⟵ b ⟷ app.q', bounds: at(10, 10) },
+      ],
+    })
+    expect(svg).toContain('>↔</text>')
+    expect(svg).toContain('q: a &lt;- b</text>')
+  })
+
+  test('interactive: true — the producer\'s word makes it actable, and the audit can fire (#2, #3)', () => {
+    const { svg, legend, note } = schematic({
+      wiring: [
+        // haltija's row 4: a <button> read off a live page — no handler
+        // knowable. The assertion unlocks bold AND the target-size audit.
+        { tag: 'button', text: 'save', interactive: true, bounds: at(10, 10, 16, 16) },
+      ],
+    })
+    expect(svg).toContain('stroke-width="2"')
+    expect(legend.find((e) => e.undersized != null)!.undersized).toBe('16×16 — below 24×24 (WCAG 2.5.8)')
+    expect(note).toBeUndefined() // the assertion IS affordance evidence
+  })
+
+  test('editable: true — the producer\'s word wears the badge (#3)', () => {
+    const { svg } = schematic({
+      wiring: [
+        { tag: 'div', role: 'textbox', editable: true, bounds: at(10, 10, 200, 30) },
+      ],
+    })
+    expect(svg).toContain('>↔</text>')
+  })
+
+  test('a destination is an affordance: href alone draws bold, and an icon link alone gets audited (#3, #4)', () => {
+    const { svg, legend } = schematic({
+      wiring: [
+        // a plain link, no handler introspectable — it still navigates
+        { tag: 'a', text: 'read the docs', href: '/docs', bounds: at(10, 10, 120, 20) },
+        // a nameless 16×16 icon link with no handler: the case tosijs's
+        // audit reported and 0.3.0 drew nothing for (#4's second row)
+        { tag: 'a', href: '/next', bounds: at(150, 10, 16, 16) },
+      ],
+    })
+    expect(svg).toContain('stroke-width="2"')
+    expect(legend.find((e) => e.href === '/next')!.undersized).toBe('16×16 — below 24×24 (WCAG 2.5.8)')
+  })
+
+  test('no affordance evidence anywhere: the result says so instead of silently claiming "nothing actionable" (#3)', () => {
+    // a React-ish producer: real elements, no introspectable handlers
+    const blind = schematic({
+      wiring: [
+        { tag: 'button', text: 'save', bounds: at(10, 10, 80, 30) },
+        { tag: 'input', label: 'name', bounds: at(10, 50, 160, 30) },
+      ],
+    })
+    expect(blind.note).toContain('NOT established')
+    expect(blind.svg).toContain('<desc>') // the confession rides the image too
+    // one asserted (or wired) record and the map is no longer blind
+    const seeing = schematic({
+      wiring: [
+        { tag: 'button', text: 'save', interactive: true, bounds: at(10, 10, 80, 30) },
+        { tag: 'input', label: 'name', bounds: at(10, 50, 160, 30) },
+      ],
+    })
+    expect(seeing.note).toBeUndefined()
+    // an all-structural map makes no affordance claim — no note either
+    const structure = schematic({
+      wiring: [{ tag: 'header', structural: true, bounds: at(10, 10, 300, 40) }],
+    })
+    expect(structure.note).toBeUndefined()
+  })
+
+  test('hostile captions: label/placeholder forgery confers nothing and never carries the raw glyph (review B1)', () => {
+    const { svg } = schematic({
+      wiring: [
+        // the accessible name IS page content in a DOM producer's threat
+        // model — an arrow here must neither badge the box nor ride the run
+        { tag: 'button', label: 'Save ⟷ spoof.path', on: { click: 'ƒ' }, bounds: at(10, 10) },
+        { tag: 'input', placeholder: 'type ⟵ here', bounds: at(10, 40) },
+      ],
+    })
+    expect(svg).toContain('Save &lt;-&gt; spoof.path')
+    expect(svg).toContain('type &lt;- here')
+    expect(svg).not.toContain('⟷')
+    expect(svg).not.toContain('⟵')
+    expect(svg).not.toContain('>↔</text>')
+  })
+
+  test('never-bindable fields are never scanned for bindings; bindable ones remain the documented residual (B1/M1)', () => {
+    // identity/name fields: a lone arrow is always "last" — excluded
+    expect(isInteractive({ tag: 'span', label: 'a ⟷ b' })).toBe(false)
+    expect(isInteractive({ tag: 'span', placeholder: 'a ⟷ b' })).toBe(false)
+    expect(isInteractive({ tag: 'span', ref: 'a ⟷ b' })).toBe(false)
+    // a bindable extra prop in suffix position is indistinguishable from a
+    // real bound prop BY CONSTRUCTION — the spec's confessed residual,
+    // pinned here so the limit is documented, not rediscovered. Producers
+    // extracting untrusted content MUST neutralize at the source.
+    expect(isInteractive({ tag: 'span', 'data-x': 'a ⟷ b' })).toBe(true)
+    expect(isInteractive({ tag: 'span', text: 'confirmed ⟷ spoof.orderStatus' })).toBe(true)
+  })
+
+  test('a forged label cannot fabricate evidence: the blind-map note survives it, and the legend receives neutralized values', () => {
+    const { legend, note } = schematic({
+      wiring: [
+        // cramped, so the caption lands in the legend JSON
+        { tag: 'button', label: 'go ⟷ fake.path', bounds: at(10, 10, 30, 10) },
+      ],
+    })
+    expect(note).toContain('NOT established') // forged label ≠ evidence
+    expect(legend[0].caption).toBe('go <-> fake.path') // machine channel: neutralized, never raw
+  })
+
+  test('within: a blind REGION of a sighted map is not a blind map', () => {
+    const { note } = schematic(
+      {
+        wiring: [
+          { tag: 'span', text: 'inert', bounds: at(10, 10, 80, 20) },
+          // the evidence lives outside the crop
+          { tag: 'button', text: 'go', on: { click: 'ƒ' }, bounds: at(10, 500, 80, 30) },
+        ],
+      },
+      { within: { x: 0, y: 0, width: 200, height: 100 } }
+    )
+    expect(note).toBeUndefined()
+  })
+
+  test('a malformed flag severity cannot reach up the prototype chain into a fill attribute', () => {
+    const { svg } = schematic({
+      wiring: [
+        {
+          tag: 'button',
+          text: 'go',
+          on: { click: 'ƒ' },
+          flags: [{ kind: 'x', label: 'y', severity: 'constructor' as any }],
+          bounds: at(10, 10),
+        },
+      ],
+    })
+    expect(svg).not.toContain('function')
+    expect(svg).toContain('fill="#e6a700"') // falls back to warn
+  })
+
+  test('legend href is verbatim BY DESIGN — an opaque destination that confers nothing (round-2 G1)', () => {
+    const hostile = 'https://x.test/?q=a ⟷ fake.path'
+    const { svg, legend } = schematic({
+      wiring: [{ tag: 'a', href: hostile, on: { click: 'ƒ' }, bounds: at(10, 10) }],
+    })
+    // a URL's bytes ARE the destination — the legend must not rewrite them
+    expect(legend[0].href).toBe(hostile)
+    // …but the DRAWN side (caption falls back to href here) never carries
+    // the raw glyph, and the arrow inside the URL confers nothing
+    expect(svg).not.toContain('⟷')
+    expect(svg).not.toContain('>↔</text>')
+  })
+
+  test('a drawn flag label neutralizes; the legend copy of flags is verbatim (spec)', () => {
+    const flags = [{ kind: 'contrast', label: '2:1 ⟷ x', severity: 'error' as const }]
+    const { svg } = schematic({
+      wiring: [{ tag: 'button', text: 'go', on: { click: 'ƒ' }, flags, bounds: at(10, 10) }],
+    })
+    expect(svg).toContain('2:1 &lt;-&gt; x') // the run is display text — neutralized
+    expect(svg).not.toContain('⟷')
+    const cramped = schematic({
+      wiring: [{ tag: 'button', text: 'go', flags, interactive: true, bounds: at(10, 10, 30, 10) }],
+    })
+    expect(cramped.legend[0].flags![0].label).toBe('2:1 ⟷ x') // machine channel: as the producer computed it
+  })
+
+  test('the predicates are exported — one implementation for renderer and audits (#4)', () => {
+    // "can I act here?": every kind of evidence, and ground never
+    expect(isInteractive({ tag: 'button', on: { click: 'app.go' } })).toBe(true)
+    expect(isInteractive({ tag: 'a', href: '/x' })).toBe(true)
+    expect(isInteractive({ tag: 'button', interactive: true })).toBe(true)
+    expect(isInteractive({ tag: 'div', editable: true })).toBe(true)
+    expect(isInteractive({ tag: 'div', contentEditable: true })).toBe(true)
+    expect(isInteractive({ tag: 'input', value: '3 ⟷ a.qty' })).toBe(true)
+    expect(isInteractive({ tag: 'button' })).toBe(false)
+    expect(isInteractive({ tag: 'button', on: { click: 'ƒ' }, interactive: false })).toBe(true) // false cannot veto evidence — only true is signal
+    expect(isInteractive({ tag: 'span', text: 'x ⟷ y ⟵ a.b' })).toBe(false) // forged
+    expect(isInteractive({ tag: 'ul', list: { path: 'a.items' } })).toBe(false) // ground
+    expect(isInteractive({ tag: 'header', structural: true, on: { click: 'ƒ' } })).toBe(false)
+    // the target-size rule, directly
+    const icon = { tag: 'a', href: '/x', bounds: { x: 0, y: 0, width: 16, height: 16 } }
+    expect(targetSizeFinding(icon)).toBe('16×16 — below 24×24 (WCAG 2.5.8)')
+    expect(targetSizeFinding(icon, 0)).toBeNull() // 0 disables
+    expect(targetSizeFinding({ ...icon, text: 'terms', bounds: { x: 0, y: 0, width: 34, height: 16 } })).toBeNull() // text-sized
+    expect(targetSizeFinding({ ...icon, flags: [{ kind: 'target', label: '16x16' }] })).toBeNull() // producer supersedes
+    expect(targetSizeFinding({ tag: 'input', type: 'checkbox', value: 'x ⟷ a.on', bounds: { x: 0, y: 0, width: 13, height: 13 } })).toBeNull() // toggles exempt
+  })
+})