Adopt reactivity via @preact/signals-core, incrementally (ADR-0001)

[BorisTyshkevich]

Part of #68 (Roadmap to 1.0.0). Decision recorded in docs/ADR-0001-reactivity.md.

Decision

Adopt @preact/signals-core (signal() / effect() / computed() /
batch() / untracked()) and migrate state one slice at a time, behind
accessor helpers. No UI framework (React/Preact/Solid).

Rationale (full record in the ADR): the growth pain is manual render
invalidation, not a missing component model, and we don't need a virtualized
large-list renderer — the one thing a vDOM framework buys. A maintained,
glitch-free signals core (with lazy computed()) beats both a UI framework and
a hand-rolled primitive.

Measured artifact cost (gzip): @preact/signals-core +1.4 KB · hand-rolled
+0.45 KB · Preact+signals +7.3 KB · React ~+45 KB. signals-core is one small,
zero-transitive-dependency package, still inlined → zero third-party requests.
Per CLAUDE.md rule 4 it's a deliberate dependency (the third, after Chart.js and
dagre).

Evidence (branches spike/signals and spike/signals-core)

Two slices converted end-to-end, full suite + per-file coverage gate green, real
npm run build succeeds:

• tabs (tabs + activeTabId) — has activeTab() helper → 16 callers
  untouched; one behavioral test relocation (repaint moved to a createApp()
  effect).
• sidePanel — no helper → every reader changed, but purely mechanical
  .value, no assertion rewrites.

A hand-rolled ~70-line primitive was prototyped first (spike/signals); swapping
it for @preact/signals-core was a 5-line diff (same .value API), so the
choice is reversible.

Migration plan (incremental, between feature work)

Per slice: convert the state field(s) to signal(), route reads through an
accessor helper, replace the manual renderX() invalidation with one effect()
in createApp(), and sweep the slice's tests to .value. Each slice ships on
its own, gate green, and never un-converts another.

Suggested order (cheap → higher churn):

• tabs + activeTabId (done in spike)
• sidePanel (done in spike)
• resultView (drives renderResults; no helper)
• running (cross-cutting run/cancel flag; gate the run button via effect)
• schema / schemaError / schemaFilter (side-panel schema tree)
• libraryName / libraryDirty (header title)

Rules

• Give each converted slice an accessor helper (like activeTab()) to
  contain reader churn and localize behavior.
• Keep the editor and the schema/EXPLAIN SVG imperative — reactivity doesn't
  help canvas/contenteditable code.
• Multi-signal updates use batch() to repaint once.

On first adoption (one-time)

• Land @preact/signals-core + the two converted slices on main.
• Update CLAUDE.md rule 4 ("two bundled runtime dependencies" → three).
• THIRD-PARTY-NOTICES.md + build/build.mjs comments updated (done in spike).

Acceptance (per slice PR)

• State field is a signal; mutators just assign .value.
• Manual renderX() invalidation for that slice is removed; an effect()
  repaints it.
• npm test green at the per-file coverage gate.
• No unrelated slice's behavior changes.

Re-evaluation trigger

Revisit Preact/Solid only if the UI grows many interdependent components with
rich local state, or a genuine large-list / virtualized render need appears.

[BorisTyshkevich]

Decision: adopt @preact/signals-core; no UI framework. Evidence-complete.

Scalar slices landed on spike/signals-core (per-slice commits; full suite + per-file coverage gate green; build clean):

• resultView + running — results pane & Run button repaint via effect()s; manual setRunBtn/renderResults deleted, run-start writes batch()ed.
• libraryName + libraryDirty — header title repaints via an effect; the updateLibraryTitle seam removed.

With tabs/activeTabId/sidePanel already converted, only the schema panel remained.

We spiked the schema panel in Preact (spike/preact-schema; ADR-0001 addendum) — the one slice signals-core fits poorly (nested in-place mutation: db.expanded, an expandedTables Set, tb.columns). Outcome: a component model does remove the anti-pattern and does hit the 100% gate, but adds a second render paradigm app-wide; and the roadmap (#68) is graph (#66/#42) + editor (#60/#83/#84) + core/infra — imperative-island and pure-core work a framework helps least with. No component-heavy panel surface justifies it.

Settled architecture: signals-core for state · pure logic in src/core/ · imperative adapters (editor/graph/Chart) behind injected seams · no UI framework. The schema panel stays imperative/signals-core (the Preact branch is kept as evidence, not merged).

Build order from here: finish signals → CM6 behind an EditorPort seam (#21) → schema-aware autocomplete (#84) + inline docs (#60). Independent of CM6 and schedulable now: row cap (#86) and multiquery (#83), which ride on the current textarea + the signals results pane.