tosijs-floorplan 0.3.0 → 0.5.0

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 = {
@@ -556,6 +556,164 @@ describe('decorate — the plugin seam', () => {
   })
 })
 
+describe('the 1.11.0 adoption feedback (0.5.0 — #7/#8/#9/#10/#12/#15)', () => {
+  const at = (x: number, y: number, width = 160, height = 24) => ({ x, y, width, height })
+
+  test('evidence beats container role: a list-bound <select> that IS the control is an affordance (#7)', () => {
+    const select = {
+      tag: 'select',
+      list: { path: 'app.options', idPath: 'id' },
+      value: 'b ⟷ app.choice',
+      bounds: { x: 10, y: 10, width: 20, height: 20 },
+    }
+    expect(isInteractive(select)).toBe(true)
+    expect(targetSizeFinding(select)).toBe('20×20 — below 24×24 (WCAG 2.5.8)')
+    const { svg } = schematic({ wiring: [select] })
+    expect(svg).not.toContain('stroke-dasharray') // control, not ground
+    // …while a plain list container without evidence of its own stays ground
+    expect(isInteractive({ tag: 'ul', list: { path: 'a.items' } })).toBe(false)
+  })
+
+  test('supersession cannot be bought with a kind that merely mentions target (#8)', () => {
+    const tiny = { tag: 'button', on: { click: 'ƒ' }, bounds: { x: 0, y: 0, width: 10, height: 10 } }
+    const finding = '10×10 — below 24×24 (WCAG 2.5.8)'
+    // claims to BE a target-size finding: supersedes (when honoured)
+    for (const kind of ['target', 'target-size', 'smallTarget', 'TARGET_SIZE']) {
+      expect(targetSizeFinding({ ...tiny, flags: [{ kind, label: 'x' }] }, 24, { honorProducerFlags: true })).toBeNull()
+    }
+    // merely mentions the word: does not
+    for (const kind of ['target-ok', 'TARGETS ARE FINE', 'retargeting']) {
+      expect(targetSizeFinding({ ...tiny, flags: [{ kind, label: 'x' }] }, 24, { honorProducerFlags: true })).toBe(finding)
+    }
+  })
+
+  test('hidden is not small: zero-size records are not undersized (#9)', () => {
+    expect(targetSizeFinding({ tag: 'button', on: { click: 'ƒ' }, bounds: { x: 0, y: 0, width: 0, height: 0 } })).toBeNull()
+  })
+
+  test('capability evidence suppresses the blind-map note: a read-only dashboard is not a blind map (#10)', () => {
+    const dashboard = schematic({
+      wiring: [
+        { tag: 'span', text: '21°C ⟵ dash.temp', bounds: at(10, 10) },
+        { tag: 'span', text: '40% ⟵ dash.humidity', bounds: at(10, 40) },
+      ],
+    })
+    // display bindings prove the producer can see wiring — nothing here is
+    // actionable, and that IS established
+    expect(dashboard.note).toBeUndefined()
+  })
+
+  test('a flags entry without kind neither throws nor colors outside the lines (#12)', () => {
+    const record = {
+      tag: 'button',
+      on: { click: 'ƒ' },
+      label: 'Go',
+      flags: [{ label: 'x' }] as any,
+      bounds: { x: 0, y: 0, width: 10, height: 10 },
+    }
+    expect(targetSizeFinding(record, 24, { honorProducerFlags: true })).toBe('10×10 — below 24×24 (WCAG 2.5.8)')
+    const { svg } = schematic({ wiring: [{ ...record, bounds: at(10, 10) }] })
+    expect(svg).toContain('data-flag=""')
+  })
+
+  test('redaction is FAIL-CLOSED: facts a producer bug left in a secret record never reach drawing or legend (review G1)', () => {
+    const { svg, legend } = schematic({
+      wiring: [
+        {
+          tag: 'a',
+          secret: true,
+          // the failure this guards: marked secret, but the withholding
+          // upstream didn't happen — the renderer must not republish
+          href: 'https://app.example/magic?token=SECRET123',
+          label: 'reset for ada@example.com',
+          text: 'leaky text',
+          value: 'SECRET123',
+          on: { click: 'ƒ' },
+          bounds: at(10, 10),
+        },
+      ],
+    })
+    const everything = svg + JSON.stringify(legend)
+    expect(everything).not.toContain('SECRET123')
+    expect(everything).not.toContain('ada@example.com')
+    expect(everything).not.toContain('leaky text')
+    expect(svg).toContain('&lt;a&gt; [withheld]')
+    expect(legend[0].redacted).toBe(true)
+    expect(legend[0].href).toBeUndefined()
+    expect(legend[0].value).toBeUndefined()
+  })
+
+  test('withheld PIXELS never draw: image joins the fail-closed list (round-2 B1)', () => {
+    const px = 'data:image/gif;base64,SECRETPIXELS0000000000000000000000000000000='
+    const { svg, legend } = schematic({
+      wiring: [{ tag: 'canvas', secret: true, image: px, label: 'private chart', text: 'leaky text', bounds: at(10, 10, 200, 100) }],
+    })
+    const everything = svg + JSON.stringify(legend)
+    expect(everything).not.toContain('SECRETPIXELS')
+    expect(everything).not.toContain('private chart')
+    expect(everything).not.toContain('leaky text')
+    expect(svg).not.toContain('<image')
+    expect(svg).toContain('[withheld]')
+  })
+
+  test('fail-closed means malformed errs toward withholding: a truthy non-boolean secret scrubs (round-2 F1)', () => {
+    const { svg, legend } = schematic({
+      wiring: [{ tag: 'a', secret: 1 as any, href: '/magic?token=SECRET123', label: 'leaky', on: { click: 'ƒ' }, bounds: at(10, 10) }],
+    })
+    const everything = svg + JSON.stringify(legend)
+    expect(everything).not.toContain('SECRET123')
+    expect(everything).not.toContain('leaky')
+    expect(legend[0].redacted).toBe(true)
+  })
+
+  test('the [withheld] caption sits under the choke point: a forged arrow in tag neutralizes (review R1)', () => {
+    const { svg } = schematic({
+      wiring: [{ tag: 'a ⟷ fake', secret: true, bounds: at(10, 10) }],
+    })
+    expect(svg).not.toContain('⟷')
+    expect(svg).toContain('[withheld]')
+  })
+
+  test('structural redaction is still a legend fact — redacted is about the record, not the drawing', () => {
+    const { legend } = schematic({
+      wiring: [{ tag: 'section', structural: true, secret: true, bounds: at(10, 10, 300, 100) }],
+    })
+    expect(legend[0]?.redacted).toBe(true)
+  })
+
+  test('flags:[null] and non-string labels do not take down the render (review R2)', () => {
+    const { svg } = schematic({
+      wiring: [
+        { tag: 'button', on: { click: 'ƒ' }, flags: [null] as any, bounds: at(10, 10) },
+        { tag: 'button', on: { click: 'ƒ' }, flags: [{ kind: 'x', label: 42 }] as any, bounds: at(10, 40) },
+      ],
+    })
+    expect(svg).toContain('data-record="1"') // both drew; nothing threw
+  })
+
+  test('a mid-content display arrow is capability evidence too — any position, by the format\'s own parse (#10 doc pin)', () => {
+    const { note } = schematic({
+      wiring: [{ tag: 'span', text: 'total: 3 ⟵ app.total today', bounds: at(10, 10) }],
+    })
+    expect(note).toBeUndefined()
+  })
+
+  test('a redacted record draws its withholding, and the legend says so (#15)', () => {
+    const { svg, legend } = schematic({
+      wiring: [
+        // tosijs 1.11.0's secret-region shape: neither label nor href
+        { tag: 'a', secret: true, text: '⟵ s.name', on: { click: 'ƒ' }, bounds: at(10, 10) },
+        { tag: 'a', text: 'plain link', href: '/x', on: { click: 'ƒ' }, bounds: at(10, 40) },
+      ],
+    })
+    expect(svg).toContain('&lt;a&gt; [withheld]') // not an anonymous bare box
+    const entry = legend.find((e) => e.redacted)!
+    expect(entry.index).toBe(0)
+    expect(entry.href).toBeUndefined() // withheld, and the legend SAYS withheld
+    expect(legend.find((e) => e.index === 1)!.redacted).toBeUndefined()
+  })
+})
+
 describe('producer compatibility — interface-typed maps assign without casts', () => {
   test("a describe()-shaped interface flows straight in", () => {
     // mirrors tosijs's AgentDescription: an INTERFACE (no implicit index
@@ -690,18 +848,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 +871,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 +897,220 @@ 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
+    // supersession is opt-in as of 0.5.0 (#8): the bare rule reports
+    // geometry truth; only the renderer (no double bars) passes true
+    expect(targetSizeFinding({ ...icon, flags: [{ kind: 'target', label: '16x16' }] })).toBe('16×16 — below 24×24 (WCAG 2.5.8)')
+    expect(targetSizeFinding({ ...icon, flags: [{ kind: 'target', label: '16x16' }] }, 24, { honorProducerFlags: true })).toBeNull()
+    expect(targetSizeFinding({ tag: 'input', type: 'checkbox', value: 'x ⟷ a.on', bounds: { x: 0, y: 0, width: 13, height: 13 } })).toBeNull() // toggles exempt
+  })
+})