From dc9697b9c7253c7d396b748a174061f283e58be6 Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Fri, 3 Jul 2026 05:34:34 +0000
Subject: [PATCH 01/27] =?UTF-8?q?Circuit=20View=20v2=20=E2=80=94=20M0=20co?=
 =?UTF-8?q?re=20skeleton=20(circuit-editor=20branch)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

New greenfield module at src/renderer/src/circuit/ per docs/circuit-view-tech-spec.md:
- core/model: circuit.json v2 schema, parse/serialize, v1+Wokwi migration,
  unknown-key preservation (B3)
- core/routing: wireRouting port with Wokwi '*' journey semantics (B2),
  parametric junction math
- core/nets: DSU nets across both views — buses (B8 seam), junction-by-identity
  (B9), net labels, implicit-connection seam; canonical keys (B10)
- core/commands + core/store: pure Commands, undo/redo with gesture merging,
  duplicate-wire guard (B5), delete cascades with junction repair
- core/geometry + core/refdes: pin transforms, pin-grid snapping, spatial hash,
  refdes assignment
- views/CircuitView: read-only M0 preview mounted in the Circuit tab behind
  localStorage flag tinystudio.circuitV2 (legacy DiagramEditor untouched)
- 35 core tests (npm run test:circuit, esbuild + node:test); typecheck clean

Docs: architecture comparison (circuit-architecture-and-roadmap.md), tech spec
with resolved decisions (circuit-view-tech-spec.md), agent progress log
(circuit-editor-progress.md).
---
 docs/circuit-architecture-and-roadmap.md      | 282 ++++++++++
 docs/circuit-editor-progress.md               |  59 +++
 docs/circuit-view-tech-spec.md                | 490 ++++++++++++++++++
 package.json                                  |   1 +
 scripts/test-circuit.mjs                      |  50 ++
 .../src/circuit/__tests__/model.test.ts       | 135 +++++
 .../src/circuit/__tests__/nets.test.ts        | 102 ++++
 .../src/circuit/__tests__/routing.test.ts     | 139 +++++
 .../src/circuit/__tests__/store.test.ts       | 152 ++++++
 src/renderer/src/circuit/core/commands.ts     | 301 +++++++++++
 src/renderer/src/circuit/core/geometry.ts     | 121 +++++
 src/renderer/src/circuit/core/model.ts        | 456 ++++++++++++++++
 src/renderer/src/circuit/core/nets.ts         | 197 +++++++
 src/renderer/src/circuit/core/refdes.ts       |  57 ++
 src/renderer/src/circuit/core/routing.ts      | 353 +++++++++++++
 src/renderer/src/circuit/core/store.ts        | 145 ++++++
 src/renderer/src/circuit/index.ts             |  29 ++
 .../src/circuit/views/CircuitView.tsx         | 337 ++++++++++++
 src/renderer/src/components/EditorPanel.tsx   |   8 +
 19 files changed, 3414 insertions(+)
 create mode 100644 docs/circuit-architecture-and-roadmap.md
 create mode 100644 docs/circuit-editor-progress.md
 create mode 100644 docs/circuit-view-tech-spec.md
 create mode 100644 scripts/test-circuit.mjs
 create mode 100644 src/renderer/src/circuit/__tests__/model.test.ts
 create mode 100644 src/renderer/src/circuit/__tests__/nets.test.ts
 create mode 100644 src/renderer/src/circuit/__tests__/routing.test.ts
 create mode 100644 src/renderer/src/circuit/__tests__/store.test.ts
 create mode 100644 src/renderer/src/circuit/core/commands.ts
 create mode 100644 src/renderer/src/circuit/core/geometry.ts
 create mode 100644 src/renderer/src/circuit/core/model.ts
 create mode 100644 src/renderer/src/circuit/core/nets.ts
 create mode 100644 src/renderer/src/circuit/core/refdes.ts
 create mode 100644 src/renderer/src/circuit/core/routing.ts
 create mode 100644 src/renderer/src/circuit/core/store.ts
 create mode 100644 src/renderer/src/circuit/index.ts
 create mode 100644 src/renderer/src/circuit/views/CircuitView.tsx

diff --git a/docs/circuit-architecture-and-roadmap.md b/docs/circuit-architecture-and-roadmap.md
new file mode 100644
index 0000000..10af7be
--- /dev/null
+++ b/docs/circuit-architecture-and-roadmap.md
@@ -0,0 +1,282 @@
+# Circuit Design Document — Fritzing vs. tinyStudio, Fritzing Part Import, and the Road to KiCad
+
+**Status:** Draft for review · **Date:** 2026-07-02 · **Scope:** `fritzing-app` (upstream reference) and `tinyStudio` Circuit view (`DiagramEditor.tsx`, `wireRouting.ts`, `circuitNets.ts`, `partsLibrary.ts`, `PartsEditor.tsx`, `scripts/fritzing-import.mjs`)
+
+This document explains how Fritzing's breadboard/wiring/parts architecture works, how tinyStudio's circuit view works today, the exact differences between them, how a Fritzing part can be imported directly, the bugs and gaps in the current circuit designer, and a phased roadmap toward "the best breadboard view ever" with schematic generation and KiCad export — while keeping `diagram.json` Wokwi-compatible.
+
+---
+
+## Part I — How Fritzing works
+
+Fritzing is a Qt/C++ desktop app built on `QGraphicsScene`. One electrical **model** drives four synchronized **views** (icon, breadboard, schematic, PCB). Everything below is verified against the `fritzing-app` source in this workspace.
+
+### 1.1 The part model: `.fzp` + per-view SVGs
+
+A Fritzing part is an XML file (`.fzp`) plus up to four SVG files (one per view). The `.fzp` contains:
+
+- **Metadata** — `moduleId` (unique id), title, label, author, date, tags, `taxonomy`, description.
+- **Properties** — a `family` (parts in the same family are hot-swappable in the Inspector) plus free-form key/value pairs (`resistance`, `package`, `voltage` …).
+- **Views** — for each of `iconView` / `breadboardView` / `schematicView` / `pcbView`, an `image` path to an SVG and one or more `layer` ids (`breadboard`, `schematic`, `copper0`, `copper1`, `silkscreen` …). PCB parts reference multiple layers inside a single SVG.
+- **Connectors** — each `<connector>` has an `id` (`connector0` …), a human `name` (`V+`, `GND`), a `type` (**male** or **female** — this drives breadboard behavior, see §1.3), optional ERC metadata (`<erc etype="VCC">`, current/voltage hints), and per-view bindings:
+  - `svgId` — the id of the graphic element in that view's SVG that *is* the pin (e.g. `connector0pin`).
+  - `terminalId` (optional) — a smaller element marking the exact wire-attach point (used mostly in schematic view; without it the terminal defaults to the center of the `svgId` element).
+  - `legId` (optional) — for parts with bendable rubber-band legs (LEDs, resistors in breadboard view), the SVG element that is the flexible leg.
+- **Buses** — `<buses>` declares internal connectivity: a `<bus>` lists `<nodeMember connectorId="…">` pins that are permanently connected inside the part. **This is how a breadboard works in Fritzing**: the breadboard part has hundreds of female connectors, and each 5-hole row (and each power rail) is a bus.
+- **Subparts** (schematic only) — multi-unit parts (e.g. quad op-amps) that can be placed as separate schematic symbols.
+
+Key insight: **the `.fzp` stores no pin coordinates.** Geometry lives entirely in the SVGs; the `.fzp` binds connector ids to SVG element ids. Any importer must resolve those elements inside the SVG (including ancestor `transform`s) to get pin positions — which is exactly what `scripts/fritzing-import.mjs` does.
+
+Parts ship as `.fzpz` (a ZIP of the `.fzp` + its SVGs); sketches ship as `.fzz` (a ZIP containing a `.fz` XML plus any non-core parts used).
+
+### 1.2 The scene/item architecture
+
+- `ModelPart` / `ModelPartShared` — the in-memory part (shared data parsed once from the `.fzp`).
+- `ItemBase` → `PaletteItem` → concrete classes (`Breadboard`, `Resistor`, `Wire`, `SymbolPaletteItem` for net labels/power symbols, `Dip`, `MysteryPart` …) — a `QGraphicsItem` per part *per view*. `PartFactory` picks the class from the moduleId/family.
+- `ConnectorItem` — a `QGraphicsRectItem` child of each part for every connector in every view; handles hover highlight, hit testing, and holds the list of `connectedTo` ConnectorItems.
+- `Bus` / `BusShared` — internal-connection groups from the `.fzp`.
+- `SketchWidget` (≈10,800 lines) — the shared view controller; `BreadboardSketchWidget`, `SchematicSketchWidget`, `PcbSketchWidget` subclass it with per-view rules (`ignoreFemale()`, `canDropModelPart()`, trace widths, colors, grid defaults: 0.1 in breadboard/schematic, 0.05 in PCB).
+- Every mutation is a `QUndoCommand` on a shared undo stack, and commands carry a **CrossViewType** so an action in one view replays into the others.
+
+### 1.3 Breadboard view mechanics (the part to learn from)
+
+The breadboard view has no special "breadboard mode" — it emerges from a few composable rules:
+
+1. **Male vs. female connectors.** Breadboard holes are *female*; component pins and wire ends are *male*. When a part is dropped or moved, `findConnectorsUnder()` hit-tests each of its male ConnectorItems against female ConnectorItems beneath it (`Breadboard::canFindConnectorsUnder()` returns false — the board itself never searches; things land *on it*). Overlap ⇒ an implicit connection is formed, with no wire drawn. Move the part away ⇒ the connection dissolves (`disconnectFromFemale`).
+2. **Buses make rows live.** Inserting a pin into one hole connects it to the whole 5-hole row because the row is a bus in the breadboard's `.fzp`. Power rails are long buses.
+3. **Stickiness.** The breadboard is *sticky* (`ItemBase::m_sticky`): parts dropped on it are recorded in `m_stickyList` and move with it when the board is dragged.
+4. **Wires with bendpoints.** A user wire is a chain of `Wire` items — each `Wire` is one straight `QGraphicsLineItem` segment with a ConnectorItem at each end; a bendpoint is where two segments share a position. `Wire::collectChained()` walks the chain to find true endpoints. Breadboard wires may also carry **Bézier curvature** per segment (`<bezier>` control points in the sketch file) for the pretty curved-jumper look. Dragging from any male/female connector spawns a temp wire (`createTempWireForDragging`); dropping on a legal target commits it.
+5. **Rubber-band legs.** Parts with `legId` connectors (LED, resistor) have draggable legs that stretch to reach holes — the leg is part geometry, not a wire.
+6. **Ratsnest sync.** Every connect/disconnect calls `ratsnestConnect()`; other views receive **VirtualWire** ratsnest lines grouping equal-potential connectors, which the user then routes properly in that view (schematic wires, PCB traces). This is the bridge that turns a breadboard layout into a schematic to route.
+
+### 1.4 Nets, ERC and routing
+
+- Equal-potential collection is a flood fill (`collectEqualPotential`) across: wire connections, female/male stacking, part-internal buses, and same-net symbols (net labels, power symbols via `symbolpaletteitem`).
+- `RoutingStatus` tracks nets total / routed / connectors-to-route per view.
+- ERC data (`erc.h`, connector `etype`, current/voltage) supports a basic electrical rule check and drives the newer simulation module (`src/simulation`, ngspice-based).
+- PCB view has a full maze autorouter + DRC (`src/autoroute`), Gerber export (`svg2gerber`), and ground-plane generation. Schematic/breadboard have no autorouter — humans route; only the ratsnest guides them.
+- `src/svg/kicad2svg` imports **KiCad → Fritzing** (modules and schematic symbols → part SVGs). There is no KiCad *export* in Fritzing — a gap tinyStudio can leapfrog.
+
+### 1.5 Sketch file format (`.fz` inside `.fzz`)
+
+XML `<module>` with `<views>` (per-view background/grid settings) and `<instances>`. Each `<instance>` has `moduleIdRef`, a per-view `<geometry>` (x/y/z, and for wires `x1/y1/x2/y2` + `wireFlags`), optional `<wireExtras>` (width, color, Bézier control points), and a `<connectors>` block whose `<connect>` children record the id + modelIndex of everything each connector touches. Connections are therefore stored **explicitly and per-view**, symmetric on both sides.
+
+---
+
+## Part II — How tinyStudio's Circuit view works
+
+The Circuit view is a React component tree inside an Electron (or web) app. The single source of truth is a **`diagram.json` file in the user's project**, edited live: `EditorPanel.tsx → CircuitView` loads `diagram.json` (creating a default if absent) and hands its text to `DiagramEditor`, which parses on every change and writes back serialized JSON through Redux (`updateFileContent`). Editing the JSON in the Code view and dragging parts in the Circuit view are the same operation on the same buffer.
+
+### 2.1 Data model (Wokwi-first)
+
+```jsonc
+{
+  "version": 1,
+  "editor": "tinystudio",
+  "author": "…",
+  "parts": [ { "type": "resistor", "id": "resistor_a1x", "left": 520, "top": 230, "rotate": 90, "attrs": {…} } ],
+  "connections": [ ["tinycore:SIG", "resistor:Pin 0", "#36c46b", ["v-22.73", "h-179.8"]] ],
+  "schematic": { "pos": { "partId": [x, y] }, "routes": { "<connKey>": ["h…","v…"] } }
+}
+```
+
+- **Parts** use Wokwi's `id`/`type`/`left`/`top`/`rotate`/`attrs` fields (px @ 96 DPI; 0.1 in = 9.6 px grid).
+- **Connections** use Wokwi's 4-tuple `[from, to, color, journey]` with `h<px>`/`v<px>` instructions. Two tinyStudio extensions: a `d<dx>,<dy>` instruction for diagonal ("straight mode") segments, and endpoints may be a free point `{x, y}` (a junction tapping another wire's body) instead of `"part:pin"`.
+- **`schematic`** is a per-view overlay (positions + routes) so a future schematic view can diverge from the breadboard layout without duplicating the electrical data. Pin *names* are stable across views, so connections stay valid when switching views.
+
+### 2.2 Parts library (`partsLibrary.ts`)
+
+One schema for all parts (`PartDef`): `type`, `label`, `family`, and `views.{breadboard,schematic}` each `{ svg, w, h, pins: { name: [x, y] } }` — inline SVG plus pin coordinates in px from the part's top-left. Sources:
+
+1. **Built-ins** — the tiny* boards, authored inline with generated SVG.
+2. **Fritzing-imported catalogue** — 29 parts currently under `assets/parts/`, one JSON per part, lazy-loaded via Vite dynamic import; `index.json` is the eagerly-loaded manifest (label, family, icon, pin count) that fills the palette.
+3. **User parts** — `PartsEditor` (modal: upload SVG, click to drop pins, drag to place, name them) registers a `PartDef` into the live registry via `registerPart()`. **In-memory only — not persisted** (see bug B7).
+
+### 2.3 The import pipeline that already exists (`scripts/fritzing-import.mjs`)
+
+This is the crucial piece for "take a Fritzing part and drop it straight into the circuit view." It already works, offline, against a checkout of `fritzing-parts`:
+
+1. Parse the `.fzp` (metadata, per-view `image`, connector list with `svgId`/`terminalId`/`legId`).
+2. Load the view SVG; read `viewBox` + real-world `width`/`height` (in/mm/pt…), convert to px @ 96 DPI (`in×96`, `mm×3.7795` …).
+3. For each connector, find the `svgId`/`terminalId` element (schematic prefers `terminalId` — the precise attach point; breadboard prefers `svgId`), compute its **local anchor** (rect center, circle center, path/polygon bbox center, line far-end heuristic, first-child for `<g>` wrappers), then apply the **cumulative ancestor transform chain** and scale into canvas px.
+4. Emit `PartDef` JSON + manifest entry + `_report.json` (ok / partial / failed / skipped).
+
+So the conversion math (the genuinely hard part: FZP→pixels with transforms and units) is done and validated. What's missing is productization — see Part IV.
+
+### 2.4 Wiring engine (`wireRouting.ts` — ported from the tinySchematic prototype)
+
+- **Absolute bendpoints.** A wire's stored instruction list is decoded into interior bend positions *fixed in world space*. When a part moves, only the leg(s) touching it re-anchor (`collectFrozen` → `buildWirePoints(source, bends, target)`); the wire body holds still. This mirrors Fritzing's behavior, where bendpoints are their own objects.
+- **Orthogonal elbow routing.** `calculateOrthogonalPath` builds L-paths; the final segment approaches the pin along the major travel axis so wires dock perpendicular. Hold Shift for straight/diagonal mode (`d` instructions).
+- **Junctions.** While drawing (or dragging an endpoint), landing on another wire's body clamps the endpoint onto that segment (`clampOntoSegment`) and stores a free `{x,y}` endpoint; a solder dot is rendered, and the net model merges the nets.
+- **Editing.** Selected wires get Fritzing-style handles: squares mid-segment (perpendicular segment drag via `dragSegment`, inserting corner bends at anchored ends), circles at bends (`vertexDrag` keeps neighbors orthogonal), rings at endpoints (retarget to a pin, a wire body, or free space). Double-click adds/removes a bend. `simplifyWirePoints` drops collinear/duplicate points before saving.
+
+### 2.5 Net model (`circuitNets.ts`)
+
+Union-find (DSU) over endpoint keys with three edge types: physical connections, part-internal **buses** (via an optional `busesFor` callback — **currently never supplied by the editor**, see bug B8), and junction endpoints lying within 2 px of another wire's polyline. Output maps pins/connections → net index; drives the yellow equipotential hover glow and the "Nets: N" counter. This is a faithful miniature of Fritzing's `collectEqualPotential`.
+
+### 2.6 Rendering & UX
+
+Parts are absolutely-positioned `<div>`s with `dangerouslySetInnerHTML` SVG bodies (CSS `rotate` around center); wires are a single SVG overlay (glow → dark outline → color core → animated selection dashes, rounded fillets via quadratic arcs); pins are 16 px hit targets rendered only in edit mode. Custom camera (`{scale, tx, ty}`), wheel zoom (0.25–3×), middle/Alt-drag pan, fit-to-view. Two-column palette rail (left) and Inspector (right: name, x/y, rotation, free-form `attrs` properties, wire color, net pin count). PNG export composes a standalone SVG and rasterizes at 2×. View/edit toggle; footer status pills.
+
+---
+
+## Part III — Architecture comparison
+
+| Aspect | Fritzing | tinyStudio Circuit view |
+|---|---|---|
+| Platform | Qt/C++, QGraphicsScene | Electron/web, React + SVG/DOM |
+| Document | `.fzz` (zipped XML), instances with per-view geometry, symmetric explicit connects | `diagram.json` (Wokwi format + extensions), connections as endpoint tuples |
+| Views | 4 synced views (icon/bb/schematic/pcb), cross-view undo commands | Breadboard live; schematic exists as a per-view overlay in data + code but is **not reachable in the UI** (view state is hard-locked) |
+| Part format | `.fzp` XML + per-view SVGs, pins = SVG element refs | `PartDef` JSON, pins = resolved px coordinates, SVG inlined |
+| Pin identity | `connector0…N` ids + names, male/female typed | pin *names* only; no male/female concept |
+| Breadboard | Real part: female connectors + row buses + sticky + drop-to-connect | No breadboard part; wires connect pin-to-pin only |
+| Bendpoints | Wire = chain of segment items; Bézier curves optional | Instruction list (`h/v/d`) decoded to absolute bendpoints |
+| Junctions | Bendpoint-on-wire creates a shared connector | Free `{x,y}` endpoint + proximity net merge |
+| Nets | Flood fill incl. buses, net labels, power symbols | DSU incl. junctions; bus support present but unused; no net labels/power symbols |
+| Undo | Full QUndoStack, cross-view | **None** (every drag frame rewrites the file buffer) |
+| ERC/simulation | ERC types per connector; ngspice simulation | None (Wokwi compat is the intended simulation path) |
+| PCB | Full view, maze autorouter, DRC, Gerber | Out of scope (KiCad export is the plan) |
+| KiCad | Import only (KiCad→Fritzing SVG) | None yet — export is roadmap Phase 4 |
+| Rubber-band legs | Yes (`legId`) | No |
+| Part swapping | Family-based Inspector swap | No |
+
+---
+
+## Part IV — Importing a Fritzing part directly into the Circuit view
+
+### 4.1 Why it already (mostly) just works
+
+The importer proves the mapping is clean:
+
+| Fritzing | tinyStudio | Notes |
+|---|---|---|
+| `.fzp` title/label/family/description | `label` / `family` / `description` | `family` also groups the palette |
+| filename / `moduleId` | `type` (slugged filename; moduleId kept in `source`) | moduleIds in core are often random hashes; filenames are the stable human identity |
+| `breadboardView`/`schematicView` image SVG | `views.{breadboard,schematic}.svg` (minified, width/height stripped, viewBox kept) | |
+| SVG real-world size | `w`/`h` in px @ 96 DPI | `in×96`, `mm×3.7795`, `pt×1.333` |
+| connector `name` (fallback `id`) | pin name (deduped `name.2`, `name.3`…) | names must stay stable across views |
+| `svgId`/`terminalId` element position | `pins[name] = [x, y]` | ancestor transforms accumulated; schematic prefers `terminalId` |
+
+Because pin coordinates are resolved to Wokwi pixel space at import time, an imported part **drops straight into `diagram.json`** and wires exactly like a hand-made or built-in part. There is no runtime dependency on Fritzing.
+
+### 4.2 What's still missing for "no difficulty" in-app import
+
+1. **`.fzpz` drag-and-drop in the app.** Today import is a build-time Node script against a repo checkout. Ship the same logic in the renderer (it's pure XML/string work; bundle `@xmldom/xmldom` or use the browser `DOMParser`, and `fflate` for the ZIP): drop a `.fzpz` onto the palette → unzip → parse `.fzp` → resolve pins from the bundled SVGs → `registerPart()` → **persist** (see B7). The only script feature needing care is path resolution (`.fzpz` bundles its SVGs with prefixed names like `svg.breadboard.foo.svg`, so section-searching isn't needed).
+2. **Buses.** The importer drops `<buses>` entirely. Emit `buses: string[][]` (groups of pin names) into `PartDef` and pass a `busesFor` callback to `buildNets` (the parameter already exists). Without this, any imported part with internal common pins — most importantly *a breadboard* — nets wrongly.
+3. **Female connectors.** Add `pinType: 'male' | 'female'` per pin. Needed for drop-to-connect breadboard behavior (Phase 2) and for better wire-end semantics; harmless otherwise.
+4. **Bendable legs (`legId`).** Currently ignored; leg pins resolve to the drawn leg end, which is acceptable. Real rubber-band legs are a Phase 2 renderer feature; importer just needs to tag `leg: true` on those pins.
+5. **SVG hygiene at import time** (fixes live rendering *and* PNG export):
+   - **Namespace all `id`s** (`<part-type>-<id>`) — Fritzing SVGs freely reuse ids (`connector0pin`, gradient ids), and multiple inlined parts on one page currently collide (bug B6).
+   - Inline `class`-based styles (some parts carry `<style>` blocks that leak or get lost).
+   - Font mapping: Fritzing text uses OCRA and Droid Sans; map to bundled/system fallbacks or convert text to paths at import for pixel fidelity.
+6. **Coverage QA.** Run `--all --views breadboard,schematic` against the whole `fritzing-parts` core (~4,000 parts), triage `_report.json` partials (unresolved pins mostly come from exotic anchor shapes and `<use>` references — add `<use>`/`href` resolution to `localAnchor`), and land the catalogue in releases as a downloadable pack rather than bundling everything.
+7. **Multi-unit subparts and PCB layers** — explicitly out of scope for breadboard/schematic import; note in `_report`.
+
+---
+
+## Part V — Bugs and gaps in the current circuit designer
+
+Verified against the code, roughly ordered by user impact.
+
+### Correctness bugs
+
+- **B1 — Schematic view is unreachable.** `DiagramEditor` line ~279: `const [view] = React.useState<ViewKind>('breadboard')` — there is no setter and no UI toggle, so all the per-view schematic code (`schematic.pos`, `schematic.routes`, `viewFor` fallbacks, schematic wire styling) is dead in the UI. Either ship the toggle or remove the overlay until Phase 3.
+- **B2 — Wokwi `"*"` journey instruction is ignored.** `accumulatePoints()` skips `*`, treating *all* instructions as source-anchored. Wokwi's format applies pre-`*` instructions from the source and post-`*` instructions **in reverse from the target**. Any real Wokwi diagram using `*` renders wrong wire routes in tinyStudio. Fix the decoder; on write, keep emitting source-anchored lists (valid Wokwi).
+- **B3 — Unknown top-level keys are dropped on save.** `write()` reconstructs the JSON with only `version/editor/author/parts/connections/schematic`. A Wokwi project's `serialMonitor` and `dependencies` sections (and any future keys) are silently destroyed the first time a part is nudged. Preserve unknown keys on round-trip.
+- **B4 — Wire identity is positional and collision-prone.** Selection (`selWire`) is an array index (stale after deletes reorder), and `connKey` = `"from>to"` collides when two wires share endpoints (both schematic routes land in one key; deleting one wire's route deletes the other's). Give connections a hidden stable key (or dedupe by construction) and select by key.
+- **B5 — Duplicate-wire guard misses object endpoints.** `onPinClick`'s `exists` check compares `c[1] === ref` strictly; junction (`{x,y}`) endpoints and reversed duplicates slip through.
+- **B6 — SVG id collisions across inlined parts.** Every built-in board SVG defines `id="g"` for its gradient; Fritzing SVGs reuse ids across parts. With several parts inlined into one document, `url(#g)` resolves to the *first* match — wrong gradients/clips on later parts, and the same corruption is baked into PNG export. Namespace ids per instance at render/import time.
+- **B7 — Custom parts vanish on restart.** `PartsEditor` → `registerPart()` is memory-only. A `diagram.json` referencing a custom part loads as an unknown-type placeholder next session. Persist user parts (project-local `parts/` folder next to `diagram.json`, plus optional global user library) and hydrate the registry on project open.
+- **B8 — Bus support exists but is never wired up.** `buildNets(…, busesFor)` is called without `busesFor`; `PartDef` has no `buses` field. Internal-bus parts (breadboards, boards with multiple GND pins that are really one net) net incorrectly.
+- **B9 — Junction wires dangle after their host wire is deleted/moved.** A free `{x,y}` endpoint is a coordinate, not a reference: deleting or rerouting the tapped wire leaves the tapping wire floating in space, silently detached from the net. Junctions need to reference the host connection (e.g. `{ on: <connKey>, t: 0.42 }`) or be re-validated on edit.
+- **B10 — Inconsistent free-point keying.** `circuitNets.refKey` rounds to 2 dp; `DiagramEditor.refStr` uses raw coordinates for route keys — near-coincident points can split or merge inconsistently between the net model and the route store.
+
+### Architecture / UX gaps
+
+- **B11 — No undo/redo.** Worse: `onPartMove` calls `write()` **per pointer-move frame**, so every drag floods Redux/file-content updates (dirty-flag churn, JSON.stringify per frame). Introduce an in-editor draft state committed on pointer-up, plus a proper undo stack (Fritzing treats undo as core infrastructure for a reason).
+- **B12 — No multi-select, box-select, copy/paste, duplicate, or keyboard nudge.** Single-part selection only.
+- **B13 — Only 90° rotations, no flip/mirror.** Fritzing supports 45° and horizontal/vertical flips; schematics need mirroring. (Wokwi `rotate` is free-form degrees, so the format allows it.)
+- **B14 — No breadboard.** The "breadboard view" has no breadboard: no female holes, no row buses, no drop-to-connect, no stickiness. This is the core of Part VI.
+- **B15 — Part `type` names don't map to Wokwi types.** `resistor` vs `wokwi-resistor`, `tinycore` vs `board-esp32-s3-devkitc-1`. A diagram saved by tinyStudio won't simulate in Wokwi as-is. Add a per-part `wokwiType` alias (plus attrs mapping) and an "Export for Wokwi simulation" that emits translated types, straightens `d` segments, and resolves junction endpoints into shared-pin fan-outs.
+- **B16 — Junction endpoints and `d` moves are tinyStudio-only.** Fine as extensions, but the Wokwi exporter must normalize them (junction → two wires meeting at the nearest pin, or a fan-out from the shared pin; `d` → h+v staircase).
+- **B17 — Performance cliffs.** Junction dot resolution is O(n²) per render in the component body (not memoized); `buildNets` re-resolves every wire's points on every diagram/tick change; fine at 20 parts, painful at 300 (a real breadboard sketch). Cache resolved points per connection, memoize junctions, and move net building behind `useMemo` keyed on a structural hash.
+- **B18 — Fixed logical canvas (1100×640) and zoom clamps (0.25–3×)** — arbitrary bounds for big boards; the empty-state hint centers on the fixed canvas, not the viewport.
+- **B19 — Wheel-zoom hijacks scrolling** (no Ctrl-to-zoom option) and there's no touch/trackpad pinch on the custom camera.
+- **B20 — `uid()` is 3 chars at collision risk** for part ids (36³ ≈ 46k space, birthday collisions plausible in long-lived projects); ids are also user-invisible. Lengthen and dedupe.
+- **B21 — Dead/legacy code.** `CircuitEditor.tsx` (static SVG/PNG viewer) appears unused by `EditorPanel` (which mounts `DiagramEditor`); confusing next to the real editor. Remove or repurpose as the read-only embed.
+- **B22 — No ERC of any kind.** No polarity/short warnings (e.g., LED without resistor, V+ tied to GND). Fritzing's per-connector `erc` metadata survives in the `.fzp` sources and could be imported for a cheap win.
+- **B23 — Rotated-part labels and pin hits.** Label counter-rotates around its own origin (drifts for 180/270°); pin hit targets don't grow at low zoom (hard to click when zoomed out — Fritzing scales hover targets).
+
+---
+
+## Part VI — Design: the best breadboard view ever → schematics → KiCad
+
+### 6.1 Guiding principles
+
+1. **`diagram.json` stays Wokwi-valid.** Extensions live in namespaced keys (`schematic`, future `tinystudio` block) that Wokwi-side tooling can ignore — plus an explicit Wokwi export that normalizes the extensions away (B15/B16). One file: layout + wiring + (via Wokwi) simulation.
+2. **Nets are the spine.** Breadboard, schematic, and KiCad export are three projections of one net model — exactly Fritzing's architecture, minus the C++.
+3. **Steal Fritzing's proven interactions** (drop-to-connect, sticky boards, bendpoint wires, family swap, ratsnest), skip its baggage (per-view duplicated geometry XML, monolithic SketchWidget).
+
+### 6.2 The breadboard experience (Phase 2)
+
+- **A real breadboard part**: generated procedurally (`half+`, `full+`, mini sizes) rather than imported — holes on the 9.6 px grid, row buses `[a1…e1]`, rails as buses, `pinType: 'female'` throughout. Procedural generation gives crisp SVG, parametric sizes, and correct buses for free.
+- **Drop-to-connect**: when a part is dropped/moved, hit-test its male pins against female pins beneath (spatial hash on the grid — O(pins)); snap the part so all pins seat in holes; seated pins form implicit connections (rendered as subtle hole highlights, not wires). Moving away dissolves them. This is Fritzing rule-for-rule (§1.3.1–2).
+- **Stickiness**: parts seated on the board move with it.
+- **Curved jumpers**: optional Bézier rendering for wires between holes (pure eye candy; store as an extension field like Fritzing's `wireExtras/bezier`, straighten on Wokwi export).
+- **Bendable legs** for LED/resistor class parts (import `legId`), so components can straddle the center channel realistically.
+- **Quality bar**: hole-level hover tooltips (`row 12, column c — net N`), net glow lighting whole rows, alignment guides, auto-color for power rails (red/blue), and one-key part swap within a family (Fritzing's killer Inspector feature — the `family` field is already imported).
+
+### 6.3 Breadboard → schematic (Phase 3)
+
+- Unlock the existing dual-view data model (fix B1): same parts + connections, per-view positions/routes in `schematic.pos/routes`, schematic symbols from the already-imported `schematicView` SVGs (`terminalId`-anchored pins).
+- **Ratsnest, not magic**: when entering schematic view, place unpositioned parts by a simple heuristic (MCU center, passives orbiting by connectivity), draw grey ratsnest lines for unrouted nets, and let the user pull real orthogonal wires — the engine already does absolute-bendpoint orthogonal routing. Auto-layout can improve later (ELK layered layout is a good web-native fit).
+- **Schematic niceties that KiCad export needs anyway**: net labels and power symbols (GND/3V3 as parts with `netlabel` semantics — Fritzing models them as SymbolPaletteItems joining nets by name), reference designators (auto-assign R1/C2/D3 from family), and value fields surfaced from `attrs`.
+
+### 6.4 KiCad export (Phase 4)
+
+Two deliverables, in order of increasing effort:
+
+1. **Netlist export** (fast, high value): emit a KiCad S-expression netlist (`(export (version "E") (components …) (nets …))`). Components carry ref/value/footprint; nets list `(node (ref R1) (pin 1))`. KiCad's pcbnew imports this directly ("Import Netlist") — users get PCB layout from a tinyStudio breadboard without a schematic. Requirements: net model (have), refdes (Phase 3), a **footprint mapping table** per part (`resistor → Resistor_THT:R_Axial_DIN0207…`, stored in `PartDef.kicad.footprint`, user-overridable in the Inspector).
+2. **`.kicad_sch` export**: generate KiCad 8/9 S-expression schematics — symbol instances from a **symbol mapping table** (`PartDef.kicad.symbol` → `Device:R` etc., with per-pin number mapping), positions scaled from `schematic.pos` (KiCad grid = 1.27 mm; snap), wires from routed segments, net labels carried over. Unmapped parts fall back to a generated generic symbol (rectangle + named pins) so export never blocks. Validate by round-tripping demo projects into KiCad and running ERC there.
+
+### 6.5 Fritzing import, productized (Phase 1–2, per Part IV)
+
+`.fzpz` drop-in import, bus + pinType + leg extraction, id namespacing, persisted user/project libraries, full-core catalogue QA, and an optional "parts pack" download so the app stays lean.
+
+---
+
+## Part VII — Feature roadmap
+
+**Phase 0 — Stabilize (1–2 weeks of focused work)**
+Fix B2 (`*` decoding), B3 (preserve unknown keys), B4/B5 (stable wire identity + dedupe), B6 (SVG id namespacing), B10, B20, B23; remove dead `CircuitEditor.tsx` (B21). Add draft-state dragging + undo/redo stack (B11) — do this before any new features multiply the mutation surface. Add multi-select/copy/paste/nudge (B12). CI check: every demo `diagram.json` passes `wokwi-cli lint` after normalization.
+
+**Phase 1 — Parts pipeline (2–4 weeks)**
+In-app `.fzpz` import; persist custom/imported parts per-project + global library (B7); importer emits `buses`/`pinType`/`leg`; wire `busesFor` into `buildNets` (B8); junction endpoints become host-referencing (B9); full `fritzing-parts` core import QA + downloadable catalogue pack; Wokwi type alias table + "Export for Wokwi" normalizer (B15/B16).
+
+**Phase 2 — Best breadboard view ever (4–8 weeks)**
+Procedural breadboard parts with row/rail buses; drop-to-connect + snapping + stickiness; hole/net hover intelligence; bendable legs; curved jumpers; family part-swap in the Inspector; alignment guides; performance pass (B17: spatial hash, memoized nets/junctions) targeting 500+ connectors; camera/zoom polish (B18/B19); basic ERC warnings (B22: shorts, floating pins, LED-without-resistor).
+
+**Phase 3 — Schematic view (4–6 weeks)**
+Unlock the view toggle (B1); ratsnest for unrouted nets; auto-placement heuristic; net labels + power symbols; auto reference designators + value fields; mirror/flip (B13); schematic-quality wire styling (junction dots per IEEE convention, 4-way-junction avoidance).
+
+**Phase 4 — KiCad export (3–5 weeks)**
+Footprint/symbol mapping tables in `PartDef` + Inspector overrides; KiCad netlist export (pcbnew-ready); `.kicad_sch` generation with generic-symbol fallback; round-trip validation against KiCad ERC on the demo projects.
+
+**Phase 5 — Beyond (ongoing)**
+Wokwi-elements rendering option for simulatable parts (the `@wokwi/elements` web components are open source, giving pixel-identical Wokwi visuals); in-app simulation via Wokwi; auto-routing assistance in schematic view; community parts sharing; PCB preview via KiCad CLI.
+
+**Dependency chain:** Phase 0 → 1 → 2 are strictly ordered (undo before breadboard; buses before breadboard). Phase 3 needs Phase 1 (schematic SVGs + terminal anchoring). Phase 4 needs Phase 3 only for `.kicad_sch` — the netlist exporter needs just Phases 0–1 and could ship early as a teaser.
+
+---
+
+## Appendix A — File/format quick reference
+
+- Fritzing part: `.fzp` XML + `svg/<section>/{breadboard,schematic,pcb,icon}/*.svg`; bundle: `.fzpz` (ZIP). Sketch: `.fz` XML; bundle: `.fzz` (ZIP).
+- tinyStudio part: `src/renderer/src/assets/parts/<type>.json` (`PartDef`), manifest `index.json`, import report `_report.json`.
+- tinyStudio diagram: `<project>/diagram.json` — Wokwi `version/author/editor/parts/connections` + tinyStudio `schematic` overlay + extensions (`d` moves, `{x,y}` junction endpoints).
+- Wokwi journey: `["v10","h5","*","v-15","h10"]` — pre-`*` from source, post-`*` reverse from target, remainder auto-completed (tinyStudio must honor `*` on read; emits source-anchored lists on write).
+- KiCad targets: S-expression netlist (pcbnew import) and `.kicad_sch` (KiCad 8/9), 1.27 mm grid, symbol libs like `Device:R`.
+
+## Appendix B — Key source locations
+
+- Fritzing: `src/model/modelpart*` (part model) · `src/connectors/{connector,connectoritem,bus}*` (connectivity) · `src/sketch/sketchwidget.cpp` + `breadboardsketchwidget.cpp` (view logic, `findConnectorsUnder`, ratsnest) · `src/items/wire.*` (segment/bendpoint wires) · `src/items/breadboard.*` (sticky, no-45°) · `src/svg/kicad2svg*` (KiCad import precedent) · `resources/parts/core/*.fzp` (canonical FZP examples, e.g. `dcpower.fzp` for buses + ERC metadata).
+- tinyStudio: `components/DiagramEditor.tsx` (editor) · `lib/wireRouting.ts` (routing/bendpoints) · `lib/circuitNets.ts` (DSU nets) · `lib/partsLibrary.ts` (registry/schema) · `components/PartsEditor.tsx` (custom parts) · `scripts/fritzing-import.mjs` (FZP→PartDef converter) · `components/EditorPanel.tsx#CircuitView` (file binding).
diff --git a/docs/circuit-editor-progress.md b/docs/circuit-editor-progress.md
new file mode 100644
index 0000000..70ea109
--- /dev/null
+++ b/docs/circuit-editor-progress.md
@@ -0,0 +1,59 @@
+# Circuit Editor v2 — Progress Log
+
+**Branch:** `circuit-editor` · **Spec:** `docs/circuit-view-tech-spec.md` · **Background:** `docs/circuit-architecture-and-roadmap.md`
+
+This file is the running context for agents working on the Circuit View v2. Read the spec first; read this second; append (never rewrite history) as you land work. Keep entries terse and factual.
+
+---
+
+## How to work on this
+
+- All v2 code lives in `src/renderer/src/circuit/`. **`core/` must stay React-free and Node-free** (runs in renderer, web build, workers, and tests).
+- Every doc mutation is a Command (`core/commands.ts`) dispatched through `CircuitStore` (`core/store.ts`) — never mutate the doc directly; that's what gives us undo/redo for free.
+- Tests: `npm run test:circuit` (bundles `circuit/__tests__/*.test.ts` with esbuild → `node --test`). Plain `node:test` + `node:assert` — no framework. Add tests with every core change; migrate to vitest only as a deliberate repo-wide decision.
+- Typecheck before committing: `npm run typecheck`.
+- **Enable the v2 view:** DevTools → `localStorage.setItem('tinystudio.circuitV2','1')` → reopen the Circuit tab. Unset (or `'0'`) to get the legacy DiagramEditor back. Same window slot, works in desktop and `dev:web`.
+- Decisions already made (don't relitigate without Geoff): JSON `circuit.json` v2 format; greenfield module (legacy `DiagramEditor.tsx` untouched until M4 removes it); sim = ngspice-WASM behind `SimBackend`, **tscircuit's build as intended default** (M4 bake-off vs eecircuit-engine); KiCad export via circuit-json + `circuit-json-to-kicad` first; theme follows tinyStudio design system; US/IEEE symbols default; default parts pack in a new `tinyparts` repo (Mister-Industries); Fritzing CC-BY-SA art OK with per-pack ATTRIBUTION.
+
+---
+
+## 2026-07-02 — M0: core skeleton ✅ (this commit)
+
+### Added
+
+- `circuit/core/model.ts` — `circuit.json` v2 types (parts with independent `bb`/`sch` placements, per-view wires, `{wire,t}` junction ends, netLabels, sim config); `parseCircuitFile` (never throws; detects v2 / v1-tinyStudio / Wokwi by shape); **migration** from v1 `diagram.json` + Wokwi incl. `schematic.pos/routes` overlay → per-view placements/wires; stable-ordered `serializeDoc`; **unknown top-level keys preserved** round-trip (fixes B3).
+- `circuit/core/routing.ts` — port of `lib/wireRouting.ts` with the **Wokwi `*` journey fix (B2)**: `decodeJourney` anchors pre-`*` at source, applies post-`*` reversed from target, auto-completes the gap. Plus `pointAtT`/`tAtPoint`/`polylineLength` for parametric junctions, `hitWire` by wire id (not index).
+- `circuit/core/nets.ts` — DSU net engine over: wires (both views share nets), **junction-by-identity** (B9), part buses (`busesFor` — actually consumed now, B8 seam), same-named net labels (label virtual pin `<id>:1`), and caller-supplied **implicit connections** (breadboard seating seam for M2). One canonical key scheme (B10). `danglingJunctions` validator.
+- `circuit/core/commands.ts` — pure Commands: add/place/attr/rename/delete parts, add/reroute/reconnect/recolor/delete wires, net labels, sim config, `composite`. Duplicate-wire guard incl. reversed + per-view (B5). `renamePart` rewrites wire endpoints. **`cascadeWireRemoval`**: junction riders re-anchor to the removed host's `from` (recursively), degenerate wires dropped.
+- `circuit/core/store.ts` — `CircuitStore`: immutable snapshots, undo/redo (depth 200), **mergeKey** gesture collapsing (1.2 s window), `useSyncExternalStore`-ready subscribe/revision, `serialize()` echo-guard + `replaceFromFile()` (external Code-tab edits become an undoable step). Fixes B11's architecture (no per-frame file writes).
+- `circuit/core/geometry.ts` — rotate/flip local→world pin transform, **snap-by-first-pin** (Fritzing behavior), `SpatialHash` for drop-to-connect/hit tests.
+- `circuit/core/refdes.ts` — family→prefix map, `nextRefdes`, id validation (part ids ARE refdes).
+- `circuit/index.ts` — public API + `circuitV2Enabled()` (`localStorage tinystudio.circuitV2`).
+- `circuit/views/CircuitView.tsx` — M0 **read-only preview** in the real IDE slot: parses (auto-migrates in memory; the file on disk is untouched), renders bb parts + wires + junction dots on the dot-grid with zoom/pan/fit, status pills (parts/wires/nets, migration notes). Part visuals via the **legacy `partsLibrary` adapter** (temporary until the M2 registry).
+- `circuit/__tests__/` — 35 tests: routing (incl. the Wokwi-docs `*` example verbatim), model round-trip/migration/key-preservation, nets (buses/junctions/labels/implicit/dangling), store (undo/redo/merge/cascades/echo), refdes.
+- `scripts/test-circuit.mjs` + `package.json` `test:circuit` script.
+- `EditorPanel.tsx` — 4-line flag branch mounting `CircuitViewV2` in the Circuit tab.
+
+### State / verification
+
+- `npm run test:circuit` → **35/35 pass**. `npm run typecheck` (node + web) → clean.
+- Legacy editor untouched and default-on; v2 behind the flag.
+
+### Known gaps / notes for the next agent
+
+- v1 free-point junction endpoints migrate as *pending junctions* (`{wire:'', t:-1, x, y}`) — geometric resolution to `{wire,t}` must happen in the editor on first render (M1, where pin geometry exists). `CircuitView.tsx#makeResolver` already renders them via raw coords.
+- The preview resolves pins through the legacy `partsLibrary` (breadboard view only, no flip support there). The v2 parts registry (M2, `circuit/parts/`) replaces this adapter.
+- `deleteParts` cascade removes wires in BOTH views (correct per spec §6.1) — the M1 UI should communicate that.
+- Editing is NOT wired yet — M1 is: pointer state machines (`views/canvas/`), palette, inspector, wire gestures, camera polish, save path (debounced `store.serialize()` → Redux `updateFileContent`, writing `circuit.json` + one-time `diagram.json.bak`).
+- Watch out (tooling, this session): file writes through the Cowork mount occasionally truncated files / left NUL bytes — if a file looks cut off, restore via `git show HEAD:<path>` and re-apply. Verify with typecheck after bulk edits.
+
+### Next up (M1 — breadboard editor parity)
+
+1. `views/canvas/Canvas.tsx`: camera + pointer routing + selection/marquee.
+2. Wire gestures ported from DiagramEditor behaviors (draw, bend, segment/vertex/endpoint handles, junction taps → `{wire,t}` via `tAtPoint`).
+3. Part drag with `collectFrozen`-style reroutes → `placePart(…, reroutes, merge=true)`.
+4. Palette + Inspector (reuse legacy partsLibrary until M2).
+5. Save path + `circuit.json` adoption + `.bak` migration write.
+6. Keyboard: undo/redo (Ctrl+Z/Y), delete, rotate R, nudge arrows, Esc.
+7. Multi-select, copy/paste (`application/x-tinystudio-circuit`), duplicate.
+8. SVG/PNG export with id-namespacing (B6) — namespacing helper belongs in `circuit/parts/svg.ts`.
diff --git a/docs/circuit-view-tech-spec.md b/docs/circuit-view-tech-spec.md
new file mode 100644
index 0000000..a45ef5a
--- /dev/null
+++ b/docs/circuit-view-tech-spec.md
@@ -0,0 +1,490 @@
+# tinyStudio Circuit View v2 — Technical Specification
+
+**Status:** Approved-direction draft · **Date:** 2026-07-02 · **Owner:** Geoff / MR.INDUSTRIES
+**Decisions locked:** ngspice-WASM simulation · JSON-superset file format · greenfield module (not an evolution of `DiagramEditor.tsx`)
+
+---
+
+## 0. One-paragraph vision
+
+A brand-new Circuit View that runs alongside Code and Visual in tinyStudio: **a Fritzing-feeling breadboard editor and a CircuitLab-feeling schematic editor over one shared electrical model**, saved as a single local JSON file per project, simulated with real SPICE (ngspice compiled to WASM), able to import Fritzing parts (`.fzpz`) and Wokwi diagrams, able to export KiCad netlists and schematics, and fed by installable parts libraries hosted on GitHub — the way Arduino's Boards Manager loads board packages from index URLs. Effectively: **Fritzing's interaction model, refactored into TypeScript/Electron, with CircuitLab's simulation UX bolted on.**
+
+This spec is written so an agent can start building without further context. Companion background document: `docs/circuit-architecture-and-roadmap.md` (deep dives on Fritzing internals, current-code bugs B1–B23, and format research). Implementation progress log: `docs/circuit-editor-progress.md` (branch `circuit-editor`).
+
+**Platform contract (hard requirements):** runs in **both** the Electron desktop build and the web build (`build:web`) — no Node-only APIs in the renderer module; sim is WASM-in-worker (browser-native); pack storage falls back to IndexedDB on web. It mounts in the **same window slot** the Circuit view occupies today (`EditorPanel → CircuitView`), alongside Code/Visual — one integrated IDE, not a separate window.
+
+---
+
+## 1. Goals and non-goals
+
+### Goals (in priority order)
+
+1. **G1 — Dual-view editing.** Breadboard view (looks/feels like Fritzing) and schematic view (looks/feels like CircuitLab) over one net model. Move a wire in one, the ratsnest updates in the other.
+2. **G2 — Local-first single file.** Everything (parts placement, wires, both view layouts, sim setup, probe positions) in `circuit.json` in the project folder. Human-diffable, git-friendly, versioned.
+3. **G3 — Analog simulation.** DC operating point, DC sweep, transient, AC/frequency — CircuitLab's four modes — via ngspice-WASM in a worker. Visuals + nets first; MCU/firmware simulation explicitly deferred (future: tinyService backend).
+4. **G4 — Parts as data.** One part schema serving both views + simulation + export. In-app part editor. Installable **part packs** from GitHub URLs (Boards-Manager pattern), including a default tinyStudio pack the app auto-loads.
+5. **G5 — Import.** Fritzing `.fzpz` (single part) and bulk `fritzing-parts` conversion; Wokwi `diagram.json` (best-effort convert-on-open).
+6. **G6 — Export.** KiCad netlist (pcbnew-ready) and `.kicad_sch`; Wokwi `diagram.json` (lossy, for simulation on wokwi.com); SVG/PNG image.
+7. **G7 — Fits the IDE.** TypeScript, React 18, Redux Toolkit, Tailwind + tinyStudio design tokens, Electron + web build both work; sim engine loads lazily so the web build stays light.
+
+### Non-goals (v2.0)
+
+- PCB layout view (KiCad is the PCB tool; we export to it).
+- MCU/digital co-simulation (Wokwi-style AVR/ESP32 emulation) — architecture leaves a seam for tinyService later (§10.6).
+- Full Wokwi round-trip fidelity. Wokwi is an *import source* and *export target*, not the native format.
+- Autorouting. Manual wires with great ergonomics beat a bad autorouter.
+- Real-time animated current flow (Falstad-style). Possible later on top of the DC solver results.
+
+---
+
+## 2. What we keep, what we discard
+
+### Keep (port into the new module as pure libraries — they are already good)
+
+| Existing code | Fate |
+|---|---|
+| `lib/wireRouting.ts` | Keep ~as-is → `circuit/core/routing.ts`. Absolute bendpoints, orthogonal elbows, segment/vertex/endpoint drag math, simplify. Add `*`-aware journey decoding (bug B2). |
+| `lib/circuitNets.ts` | Keep DSU approach → `circuit/core/nets.ts`. Wire in `busesFor` (B8), add implicit-connection edges (breadboard seating, §7.3), net labels (§8.4), junction refs (B9 fix). |
+| `scripts/fritzing-import.mjs` | Extract the resolver (fzp parse, transform-chain math, unit scaling, anchor heuristics) into `circuit/import/fritzing/` shared by the CLI script **and** the in-app `.fzpz` importer. Extend: `buses`, `pinType`, `legId`, `<use>` resolution, id namespacing. |
+| `PartsEditor.tsx` | Keep the UX; rewire to save PartDef v2 into the project/user pack (persistence, B7). |
+| Design system (tokens, tactile buttons, dot grid, wire tube styling) | Keep. The new view must be visually indistinguishable from the rest of the IDE. |
+| `EditorPanel.tsx` Circuit tab plumbing, `useProjectFile` | Keep the mount point; swap `DiagramEditor` for `CircuitView2` behind a feature flag during development. |
+
+### Discard / replace
+
+- `DiagramEditor.tsx` (2,000-line monolith: state, geometry, rendering, palette, inspector in one component) → replaced by the module in §3.
+- `CircuitEditor.tsx` (legacy static viewer) → delete.
+- Direct-to-file writes per pointermove → replaced by an in-memory document store with command-based undo, debounced serialization (§6).
+- `diagram.json` as the native format → superseded by `circuit.json` v2 (§4). A migration shim converts old files on open (they are near-Wokwi, so the Wokwi importer handles them).
+
+---
+
+## 3. Architecture
+
+### 3.1 Module layout (all under `src/renderer/src/circuit/`)
+
+```
+circuit/
+  core/                      # ZERO React. Pure TS, unit-testable.
+    model.ts                 # document types (§4), invariants, migration
+    store.ts                 # CircuitDocument class: state + command dispatch + undo/redo + subscriptions
+    commands.ts              # every mutation as a Command {do, undo, merge?} (Fritzing's QUndoStack, in TS)
+    nets.ts                  # DSU net engine (+ buses, implicit, labels, junctions)
+    routing.ts               # ported wireRouting
+    geometry.ts              # transforms, rotation, snapping, spatial hash
+    refdes.ts                # R1/C2/U3 auto-assignment
+  parts/
+    schema.ts                # PartDef v2 + PackManifest types (§5)
+    registry.ts              # in-memory registry; resolution order: project → user packs → default pack → builtin
+    packs.ts                 # pack fetch/install/update/cache from GitHub index URLs (§5.4)
+    svg.ts                   # SVG sanitize, id-namespacing, symbol generation (generic fallback symbols)
+  views/
+    CircuitView.tsx          # shell: toolbar, view toggle, palette, inspector, statusbar
+    canvas/
+      Canvas.tsx             # camera, pointer routing, selection, marquee; renders active view
+      BreadboardLayer.tsx    # parts, legs, breadboard, wires (Fritzing look)
+      SchematicLayer.tsx     # symbols, wires, net labels, probes (CircuitLab look)
+      WireGestures.ts        # drawing/editing state machines (§8)
+    palette/  inspector/  simulator/   # SimPanel, plots (§10.5), probe UI
+  sim/
+    netlist.ts               # document → SPICE netlist (§10.2–10.3)
+    engine.ts                # eecircuit-engine wrapper in a Web Worker; typed request/response
+    results.ts               # vectors → probe series; units, cursors
+  import/
+    fritzing/                # fzp resolver, fzpz (zip) reader, fzz sketch reader (stretch)
+    wokwi.ts                 # diagram.json → circuit.json
+  export/
+    kicadNetlist.ts  kicadSch.ts  wokwi.ts  image.ts
+  index.ts                   # public API: mount, open/save, feature flag
+```
+
+**Rule:** `core/`, `parts/`, `sim/`, `import/`, `export/` never import React. Views subscribe to the store. This is the inverse of today's monolith and is what makes sim, importers, and exporters testable in Node/Vitest without a DOM.
+
+### 3.2 State management
+
+- **Document state** (the circuit itself) lives in `CircuitDocument` — a plain-TS class holding the parsed model, a command stack (undo/redo, command merging so a drag is one undo step), and a change-notification. React components use `useSyncExternalStore`.
+- **Ephemeral UI state** (camera, hover, selection, active tool, drawing-in-progress) stays in React state within the view — never serialized.
+- **App integration:** the document syncs to Redux `fileSlice` (dirty flag, save) via a debounced (250 ms) serializer, and listens for external content changes (user edits `circuit.json` in the Code tab) — last-writer-wins with a structural diff to avoid churn.
+- Redux is *not* used for per-frame editing (that's what killed the old editor — B11).
+
+### 3.3 Rendering
+
+SVG, one `<svg>` scene per view (not DOM-divs-plus-SVG-overlay like today):
+
+- Parts render as `<g transform>` wrapping their (sanitized, id-namespaced) SVG body. Rotation/flip on the group.
+- Wires, junction dots, handles, ratsnest, pin hits are sibling layers in z-order: `board < parts < legs < wires < junctions < handles < overlays`.
+- Pin hit targets scale inversely with zoom (min 10 screen px — B23).
+- Perf budget: 500 parts / 1,500 wire segments at 60 fps pan/zoom (a full breadboard project). Achieved via: spatial hash for hit tests, memoized per-connection point caches keyed by a document revision counter, `will-change: transform` camera on the scene group, and virtualized palette lists. If SVG hits a wall past 2k elements, the escape hatch is rendering wires to a single `<path>` per net — decided by benchmark, not up front.
+
+---
+
+## 4. File format: `circuit.json` v2
+
+One file per project (same slot `diagram.json` occupies today). JSON, 2-space, stable key order for clean diffs.
+
+```jsonc
+{
+  "format": "tinystudio-circuit",
+  "version": 2,
+  "meta": { "author": "…", "created": "…", "modified": "…" },
+
+  "packs": [                       // parts provenance — enables auto-install prompts
+    { "id": "tinystudio-core", "version": "1.4.0", "url": "https://raw.githubusercontent.com/Mister-Industries/tinyparts/main/index.json" }
+  ],
+
+  "parts": [
+    {
+      "id": "R1",                  // == reference designator, unique, user-visible (§6.4)
+      "type": "resistor",          // PartDef type within resolved packs
+      "attrs": { "value": "220" }, // part-schema-declared properties (drive sim + BOM)
+      "bb":  { "x": 480, "y": 240, "rotate": 0, "flip": false, "legs": { "1": [ -14, 28 ] } },
+      "sch": { "x": 300, "y": 160, "rotate": 90, "flip": false }   // absent ⇒ unplaced (ratsnest)
+    }
+  ],
+
+  "wires": [
+    {
+      "id": "w7",                  // stable id (B4 fix) — 8-char nanoid
+      "from": "R1:2",              // "partId:pinName"
+      "to":   { "wire": "w3", "t": 0.42 },   // OR a junction: parametric point on another wire (B9 fix)
+      "view": "bb",                // each wire belongs to ONE view ("bb" | "sch")
+      "color": "#2fa46a",          // bb only; schematic wires are always ink
+      "route": ["h48", "v-19.2"],  // Wokwi-style journey, source-anchored; "d dx,dy" allowed in bb
+      "curve": true                // bb only: render as bezier jumper (route still authoritative for hit tests)
+    }
+  ],
+
+  "netLabels": [                   // schematic-only named nets (GND, 3V3, SDA…)
+    { "id": "nl1", "name": "GND", "kind": "ground", "sch": { "x": 340, "y": 260, "rotate": 0 }, "pin": "nl1:1" }
+  ],
+
+  "sim": {
+    "analyses": [
+      { "id": "tran1", "kind": "tran", "step": "10us", "stop": "5ms", "enabled": true },
+      { "id": "dc1",   "kind": "op", "enabled": true },
+      { "id": "sweep1","kind": "dc", "source": "V1", "from": 0, "to": 5, "step": 0.05 },
+      { "id": "ac1",   "kind": "ac", "sweep": "dec", "points": 20, "fstart": "1", "fstop": "1meg" }
+    ],
+    "probes": [
+      { "id": "p1", "kind": "voltage", "at": "net:GND->led_anode", "label": "V(out)", "color": "#42a5f5" },
+      { "id": "p2", "kind": "current", "at": "part:R1", "label": "I(R1)" }
+    ]
+  },
+
+  "camera": { "bb": { "x": 0, "y": 0, "zoom": 1 }, "sch": { "x": 0, "y": 0, "zoom": 1 } }   // convenience, non-semantic
+}
+```
+
+Design decisions and invariants:
+
+- **Wires are per-view.** Breadboard wires and schematic wires are different physical objects (Fritzing models it the same way). The **net model is the shared truth**: a connection made in breadboard shows as ratsnest in schematic until the user draws the schematic wire, and vice versa. (This replaces v1's awkward `schematic.pos/routes` overlay where one connection was shared.)
+- **Implicit connections are not stored.** Breadboard seating (pin-in-hole) is *derived* from geometry on load/edit — storing it would let the file lie. Same for junction net membership.
+- **Junction endpoints reference the host wire** (`{wire, t}`), never a bare coordinate — they survive rerouting and deletion is cascaded (delete host ⇒ junction wires re-anchor to nearest pin of the host's net, or get flagged dangling).
+- **Coordinates:** px @ 96 DPI. Grids: bb 2.54 mm = 9.6 px (holes), sch 4.8 px fine / 9.6 px major (CircuitLab uses a similar half-pitch feel). All pins land on-grid by part-schema contract.
+- **`id` is the refdes** (`R1`, `LED2`, `U1`) — user-visible, auto-assigned by family prefix, editable with uniqueness enforcement. This makes netlists, BOM, and KiCad export trivially consistent.
+- **Unknown keys are preserved** on round-trip (B3 fix): the serializer patches known sections and carries the rest.
+- **Migration:** v1 `diagram.json` (and raw Wokwi files) are detected by shape and converted on open via the Wokwi importer + v1 shim; the file is rewritten as `circuit.json` v2 next save (old file kept as `diagram.json.bak` once).
+
+**Why JSON, not XML:** everything downstream (Wokwi import, packs, TS tooling, git diffs) is JSON-native; Fritzing's XML buys nothing but familiarity to Fritzing itself. Fritzing compatibility lives in importers, not in the native format.
+
+---
+
+## 5. Parts system
+
+### 5.1 PartDef v2 (per-part JSON)
+
+```jsonc
+{
+  "schema": 2,
+  "type": "resistor",
+  "label": "Resistor",
+  "family": "Passive",              // palette grouping + swap group + refdes prefix table
+  "prefix": "R",                    // refdes prefix (falls back to family map)
+  "description": "…",
+  "tags": ["basic"],
+  "properties": {                   // typed, Inspector-rendered, sim-visible
+    "value":     { "kind": "spice-number", "default": "1k", "unit": "Ω", "label": "Resistance" },
+    "tolerance": { "kind": "enum", "options": ["1%", "5%"], "default": "5%" }
+  },
+
+  "pins": [                         // single source of truth for pin identity/order
+    { "name": "1", "type": "male", "erc": "passive" },
+    { "name": "2", "type": "male", "erc": "passive" }
+  ],
+  "buses": [],                      // e.g. breadboard: [["1a","1b","1c","1d","1e"], …]
+
+  "views": {
+    "breadboard": {
+      "svg": "…", "w": 68.5, "h": 9.6,
+      "pins": { "1": [0.9, 4.8], "2": [67.5, 4.8] },
+      "legs": { "1": true, "2": true }          // bendable rubber-band legs
+    },
+    "schematic": {
+      "svg": "…", "w": 57.6, "h": 19.2,         // CircuitLab-style symbol art (§9.2)
+      "pins": { "1": [0, 9.6], "2": [57.6, 9.6] },
+      "labels": { "ref": [28.8, -4], "value": [28.8, 26] }   // default text anchor slots
+    }
+  },
+
+  "spice": {                        // §10.3 — omit ⇒ part is sim-transparent or sim-blocking per `ercRole`
+    "template": "R{REF} {1} {2} {value}",
+    "models": []                    // optional .model / .subckt cards to emit once
+  },
+  "kicad":  { "symbol": "Device:R", "footprint": "Resistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P10.16mm_Horizontal", "pinMap": { "1": "1", "2": "2" } },
+  "wokwi":  { "type": "wokwi-resistor", "attrs": { "value": "{value}" }, "pinMap": { "1": "1", "2": "2" } },
+  "source": { "origin": "fritzing", "fzp": "resistor.fzp", "moduleId": "…" }
+}
+```
+
+Notes:
+
+- `pins[]` (ordered, typed) is new vs v1's per-view map — pin *names* stay the cross-view join key, but identity/ERC/type live view-independently.
+- `spice.template` placeholders: `{REF}`, `{pinName}` (replaced with node names), `{property}`. Multi-line templates allowed (e.g. op-amp emits `X{REF} … opamp_model` and `models` carries the `.subckt`).
+- The **breadboard part itself is a PartDef** generated procedurally (`breadboard-half`, `breadboard-full`, `breadboard-mini`): female pins named `a1…j63`, `power+/-` rails, `buses` for rows/rails. Generator lives in `parts/svg.ts` so sizes are parametric and SVG is crisp.
+- **Generated schematic symbols:** parts lacking a schematic view get an auto-generated IC-style box symbol (name on top, pins on sides by `pins[]` order) so schematic view and KiCad export never block on missing art.
+
+### 5.2 Registry and resolution
+
+`registry.ts` resolves `type → PartDef` in order: **project parts** (`<project>/parts/*.json`) → **installed packs** (userData) → **default pack** (bundled) → **builtins** (tiny* boards, breadboards, net labels, sources/probes). First hit wins; the Inspector shows provenance. Lazy per-part loading stays (manifest eager, bodies on demand).
+
+### 5.3 Pack format
+
+A pack is a repo/folder: `pack.json` + `parts/*.json` (+ optional `README`, preview images).
+
+```jsonc
+// pack.json
+{
+  "schema": 1,
+  "id": "tinystudio-core",
+  "name": "tinyStudio Core Parts",
+  "version": "1.4.0",              // semver; app checks for updates
+  "homepage": "https://github.com/Mister-Industries/tinyparts",
+  "parts": [ { "type": "resistor", "label": "Resistor", "family": "Passive", "file": "parts/resistor.json", "icon": "<svg…>", "pins": 2, "views": ["breadboard","schematic"], "sim": true } ]
+}
+```
+
+### 5.4 GitHub distribution (Boards-Manager pattern)
+
+- Settings → Parts Libraries: a list of **index URLs** (default seeded with the official tinyStudio pack index), exactly like Arduino's "Additional boards manager URLs".
+- An index URL points to a JSON listing packs: `{ "packs": [ { "id", "name", "version", "url" (zip or raw dir), "sha256" } ] }`. Hosting a pack = a GitHub repo + a raw `index.json`; releases can serve zips.
+- Install = download → verify hash → unpack to `app.getPath('userData')/parts-packs/<id>/<version>/` → register. Update check on launch (non-blocking). Web build: cache in IndexedDB/OPFS.
+- Opening a project whose `packs[]` names an uninstalled pack prompts one-click install (this is why provenance is in the file).
+- **Security:** parts contain SVG + templates only — sanitize SVG on install (strip scripts/foreign objects/event attrs, namespace ids), never eval anything. Spice templates are string substitution only.
+
+### 5.5 Part authoring
+
+- **In-app Part Editor** (evolved `PartsEditor`): SVG upload per view, click-to-place pins, pin type/name editing, property schema builder, spice/kicad/wokwi mapping tabs, live test-drop onto a scratch canvas. Saves to project parts or a local user pack (persistent — fixes B7).
+- **`.fzpz` drop-import** shares the Fritzing resolver (§11.1) and lands the result in the same editor for review before save.
+
+---
+
+## 6. Core editing model
+
+### 6.1 Commands and undo
+
+Every mutation is a `Command` object (`AddPart`, `MovePart`, `DrawWire`, `RerouteWire`, `SetAttr`, `RotatePart`, `DeleteSelection`, `PasteClipboard`, …) with `do/undo` and optional `merge(prev)` (pointer-drag frames merge into one step). Stack depth 200. Cross-view effects (e.g. deleting a part removes its wires in both views) happen inside one composite command — Fritzing's cross-view command semantics, simplified because we have one document.
+
+### 6.2 Selection and clipboard
+
+Multi-select (click, shift-click, marquee), copy/paste/duplicate (offset + refdes reassignment), arrow-key nudge (grid step; shift = 5×), select-whole-net (double-click a wire in view mode). Clipboard is JSON on the system clipboard (`application/x-tinystudio-circuit`), enabling cross-project paste.
+
+### 6.3 Geometry
+
+Rotation 0/90/180/270 both views (45° increments allowed for bb wires' aesthetics, not parts, v2.0); horizontal/vertical flip in schematic (mirrored symbols are mandatory for readable schematics — B13). Snapping: parts snap so *pins* land on-grid (not the part origin — this is a subtle Fritzing behavior that makes everything line up).
+
+### 6.4 Reference designators
+
+Auto-assigned on add from `prefix`/family map (`R`, `C`, `D`, `LED`, `U`, `SW`, `J`); renaming validates uniqueness; renumber-all command (compacts gaps) offered before KiCad export.
+
+---
+
+## 7. Breadboard view — "feels like Fritzing"
+
+The behaviors below are the Fritzing breadboard contract, restated as requirements (source analysis in the companion doc, Part I).
+
+### 7.1 Look
+
+- Photorealistic-style SVG parts (the Fritzing catalogue art, imported) on the tinyStudio dot-grid canvas; procedural breadboards with realistic hole geometry, row numbering, rail striping (red/blue).
+- Wires: the existing glossy-tube rendering (dark outline → color core), rounded corners; optional **curved jumper** rendering (`curve: true`, cubic Bézier with sag proportional to length) matching Fritzing's signature look.
+- Junction solder dots; yellow equipotential glow on hover (keep — it's better than Fritzing).
+
+### 7.2 Placement interactions
+
+- Drag from palette (ghost preview under cursor, pins highlight candidate holes); double-click to drop at center.
+- **R**/right-click/Inspector to rotate; drag to move with wires holding their bends (existing absolute-bendpoint behavior — keep).
+- Part swap within family from the Inspector (preserves id, attrs where compatible, and connections by pin name).
+
+### 7.3 Drop-to-connect (the heart of it)
+
+- On part drop/move-end: for each male pin, spatial-hash query for a female pin within snap radius (0.5 grid). If **all** seatable pins can seat with one rigid translation ≤ radius, snap the part and create **implicit connections** (derived, not stored — §4).
+- Seated pins render a subtle green seat mark (Fritzing shows green square highlights); hovering a hole tooltips `e12 · net 4 (R1.2, LED1.anode)`.
+- Row/rail buses come from the breadboard PartDef's `buses` and merge nets via `busesFor` (already supported by the DSU engine).
+- Boards are **sticky**: parts seated on a breadboard move with it. Wire ends may plug directly into holes (wire-end = male pin), Fritzing-style.
+- Bendable **legs** (`legs` in PartDef): leg endpoint drags independently of the body, rendered as a curved leg path; the pin position for netting is the leg tip. Body drag keeps seated leg tips anchored (rubber-band), matching Fritzing.
+
+### 7.4 Wiring
+
+Keep the current gesture set (it's already Fritzing-grade): click-pin → click-pin/hole/wire-body with orthogonal preview; Shift = straight/diagonal; click = bend while drawing; Esc cancels. Selected-wire editing: segment squares (perpendicular drag), bend circles, endpoint rings; double-click adds/removes bends. Junction taps clamp onto the host segment and store `{wire, t}`.
+
+---
+
+## 8. Schematic view — "looks like CircuitLab"
+
+CircuitLab's editor reads as: white/paper background, fine grid, **black ink symbols and wires**, blue accents for selection/probes, value+refdes text next to every part, ground/named-net symbols instead of long wires, Build/Simulate modes on a bottom toolbar. That's the target ("CircuitLab skin" over our engine).
+
+### 8.1 Look
+
+- Canvas: `--bg` paper surface (light in light theme; dark theme uses ink-on-charcoal, staying within tinyStudio tokens), 4.8/9.6 px grid dots.
+- Symbols: 2 px ink strokes, standard symbol library (IEEE-style zigzag resistor by default; IEC rectangle later as a setting — Fritzing offers both). Text: refdes above-left, value below-right by default, per-instance draggable (anchors in PartDef `labels`).
+- Wires: 2 px ink, strictly orthogonal (no `d` moves in sch), solder dots at T-junctions; 4-way crossings never auto-join (must offset or dot deliberately — classic schematic hygiene).
+- Net labels & power symbols: GND (three-bar), VCC/named flags — placeable parts (`netLabels`) that join nets by name (§8.4).
+
+### 8.2 Ratsnest sync (the dual-view contract)
+
+- **Either view can lead.** A part exists once; `bb` and `sch` placements are independent and each optional. Design schematic-first, breadboard-first, or mixed — the other view shows the part in its **"unplaced" tray** on the canvas edge; clicking one attaches it to the cursor for placement (better than Fritzing's pile-at-origin). The tray exists in *both* views.
+- Nets connected in breadboard but not yet drawn in schematic render as light dashed **ratsnest** lines between nearest unconnected pins of the net. Drawing a real wire over a ratsnest satisfies it. Symmetrically, schematic-made connections show as ratsnest in breadboard.
+- Status pill: `Nets: 9 · routed here: 6 / 9` per view.
+
+### 8.3 Wiring
+
+Same gesture engine as breadboard with schematic constraints: orthogonal only, wires may start/end on wire bodies (junction dot), dragging a part **drags wire ends with it and re-elbows** (absolute bendpoints already do this).
+
+### 8.4 Net labels
+
+A net label is a 1-pin builtin part whose net merges with every other label of the same name (`kind: ground` is just the name `GND` with the ground glyph). This gives clean schematics *and* named nets for netlists/KiCad (`GND`, `3V3`, `SDA`) — same mechanism Fritzing's SymbolPaletteItem uses.
+
+---
+
+## 9. ERC (lightweight, both views)
+
+Non-blocking warnings panel + inline markers: floating pins on placed parts (info), directly shorted source terminals (error, uses `erc` pin types: `power-out` vs `power-out`), missing ground when sim requested (error — SPICE needs node 0), LED/diode with no series resistance to a source (warn, heuristic), single-pin nets with a wire (warn). Runs on the net model in a debounced worker-free pass (<5 ms typical).
+
+---
+
+## 10. Simulation (CircuitLab modes on ngspice-WASM)
+
+### 10.1 Engine
+
+- **Default: tscircuit's ngspice WASM build** (`tscircuit/ngspice`, the engine behind `tsci simulate` — MIT ecosystem, active project we want to align with). **Fallback: `eecircuit-engine`** (the original ngspice-WASM build it derives from; API: `new Simulation()` → `start()` → `setNetList(str)` → `runSim()`). Both sit behind the `SimBackend` interface; M4 opens with a 2-day bake-off (bundle size, cold-start, convergence on the golden netlists, error reporting quality) and the winner ships as default — "tscircuit if it really works well" is enforced by the abstraction. Runs in a **Web Worker** (module worker; WASM ~a few MB, lazy-loaded on first Simulate).
+- **tscircuit alignment (decision):** we adopt **circuit-json as an interop layer**, not tscircuit's stack — tscircuit is code-first (TSX → auto-layouted circuit-json) with no interactive dual-view editor, so our document model stays ours. But emitting circuit-json from our net model unlocks their whole converter ecosystem (KiCad, Gerber, BOM, DSN) at near-zero cost. See §12.
+- Wrap in `sim/engine.ts` with a typed protocol: `{ netlist, analyses } → { vectors | error(line, message) }`, cancellation (terminate+restart worker), and a 10 s watchdog.
+
+### 10.2 Netlist generation (`sim/netlist.ts`)
+
+1. Build nets (existing DSU) including implicit breadboard seats, buses, junctions, net labels.
+2. Node naming: net containing a `GND` label ⇒ node `0`. Others: label name if present, else `n<index>` (stable ordering for diffable golden tests).
+3. For each part with `spice.template`: substitute `{REF}`, `{pin}` → node names, `{prop}` → attr values (spice-number normalization: `220`, `4.7k`, `10u`). Collect `models` cards once per model name.
+4. Emit analysis cards from `sim.analyses` (`.op` implicit for DC display; `.tran step stop`; `.dc SRC from to step`; `.ac dec points fstart fstop`).
+5. Parts without spice mapping: 2-pin unknowns default to open (excluded, warn); breadboards/connectors are transparent (buses only); MCUs/boards are **excluded with an info banner** ("tinyCore is not simulated — model its pins with sources," and a pin-stub helper that lets the user pin a voltage source to a board pin). This is the seam where tinyService MCU co-sim plugs in later (§10.6).
+
+### 10.3 Sources & instruments (builtin parts pack)
+
+DC voltage/current source, battery, AC/sine source (amplitude, freq, phase), pulse/step source (CircuitLab's step sources), waveform generator (PWL, stretch). Probes: voltage (attach to net), current (attach through a part), differential voltage (2 pins). Probes are placeable 0/1-pin builtins rendered as CircuitLab-style flags; they populate `sim.probes`.
+
+### 10.4 Modes & UX (mirrors CircuitLab's Build/Simulate)
+
+- Bottom toolbar: **Build | Simulate** toggle. Simulate opens the Sim panel (docked bottom, resizable): analysis tabs (DC / DC Sweep / Transient / Frequency), parameters, **Run**.
+- **DC (op):** after run, node voltages annotate the schematic next to nets (CircuitLab's killer teaching feature) and current arrows on part hover; breadboard view shows the same values on hole tooltips.
+- **Transient / Sweep / AC:** plot area (uPlot — tiny, fast, MIT) with probe traces, cursors, zoom, log axes for AC (magnitude dB + phase), CSV export. Plot state (visible traces) persists in `sim`.
+- Errors map back: ngspice message → offending part/net highlighted where parseable.
+- Auto-rerun-on-edit toggle (debounced 500 ms) for the live-feel without a custom engine.
+
+### 10.6 Future seam: MCU co-simulation
+
+Out of scope, but the interface is defined now: a `SimBackend` abstraction (`spice-wasm` today). A future `tinyservice` backend can run firmware (Arduino CLI build → simavr/emulation on the service) and exchange pin states with the SPICE side per timestep. Nothing in v2 may assume "SPICE only" in UI copy or types.
+
+---
+
+## 11. Importers
+
+### 11.1 Fritzing part (`.fzpz`, and bulk `fritzing-parts`)
+
+- Shared resolver (from `fritzing-import.mjs`): fzp parse → per-view SVG → connector geometry via `svgId`/`terminalId` with full ancestor-transform accumulation → px @ 96 DPI. **Extensions (required):** `<buses>` → `buses`, connector `type` → `pinType`, `legId` → `legs`, `<use>`/`xlink:href` anchor resolution, SVG sanitize + id-namespace, ERC `etype` → pin `erc`.
+- In-app: drop `.fzpz` on the palette (or File → Import Part) → unzip (`fflate`) → resolve → open in Part Editor pre-filled → save to project/user pack. `.fzpz` bundles SVGs with `svg.<view>.<name>.svg` naming — no repo layout needed.
+- Bulk CLI (kept as a script) regenerates the default pack from a `fritzing-parts` checkout; `_report.json` triages coverage. Target: >90% of core breadboard parts clean; failures documented.
+- Spice/kicad/wokwi mappings can't come from Fritzing — they come from a **curated overlay table** in the default pack (hand-maintained for the ~100 most-used parts; everything else imports as visual-only and still nets/exports via generated symbols + generic footprint prompt).
+- Stretch: `.fzz` sketch import (instances+connects → parts+wires; per-view geometry maps cleanly — see companion doc §1.5).
+
+### 11.2 Wokwi diagram (`diagram.json`)
+
+- Detect by shape (`version: 1` + `parts[].type` strings). Convert: `wokwi-*`/`board-*` types via the same overlay mapping table (reverse direction), `left/top/rotate/attrs` → `bb` placement, connections → bb wires (**honor the `*` journey instruction**: pre-`*` from source, post-`*` reversed from target — B2), colors kept.
+- Unmapped Wokwi types: placeholder part with correct pin names scraped from the connection list (pins at generated positions), flagged in an import report. `serialMonitor`/`dependencies` preserved in an `x-wokwi` passthrough key for later export.
+- tinyStudio v1 `diagram.json` files ride this importer (plus `schematic.pos/routes` → `sch` placements).
+
+## 12. Exporters
+
+**Primary KiCad path (decision):** our document → **circuit-json** (`export/circuitJson.ts`) → **`circuit-json-to-kicad`** (`CircuitJsonToKicadSchConverter`, tscircuit, MIT) for `.kicad_sch`. Evaluated at M5 start; if fidelity falls short (symbol mapping, wire routing, label support), we fall back to our own writers below — the netlist writer is trivial enough to keep regardless.
+
+### 12.1 KiCad netlist (ships first — needs only nets + refdes)
+
+S-expression netlist (`(export (version "E") (components …) (nets …))`) with refdes, `value` from attrs, footprint from `kicad.footprint` (Inspector-overridable; unmapped → dialog with footprint field). Imports directly into pcbnew ("File → Import Netlist"). Golden-file tests against KiCad 9 import.
+
+### 12.2 `.kicad_sch`
+
+KiCad 8/9 s-expression schematic (dev-docs.kicad.org spec): embedded `lib_symbols` (either referenced standard symbols like `Device:R` from `kicad.symbol`, or our generated generic box symbols serialized as full symbol defs so the file is self-contained), symbol instances from `sch` placements (px → mm, snapped to 1.27 mm grid, rotation/mirror mapped), wires from routed segments, junctions, labels from netLabels, `.op`-style text notes skipped. Validation: file opens in KiCad ≥8 with zero ERC *format* errors on demo projects; electrical ERC issues are the user's circuit's business.
+
+### 12.3 Wokwi export (lossy, for wokwi.com simulation)
+
+Types via mapping table (parts without `wokwi.type` → error list), junction endpoints normalized to pin-anchored fan-outs, `d` segments staircased, colors kept, `x-wokwi` passthrough restored. Validated with `wokwi-cli lint` in CI.
+
+### 12.4 Image
+
+SVG (vector, exact scene) and PNG @2×, per view, with the tinyStudio watermark. Fixes the id-collision corruption via the namespacing done at registry time.
+
+---
+
+## 13. tinyStudio integration
+
+- `EditorPanel.CircuitView` mounts `circuit/index.ts` behind a feature flag (`settings.circuitV2`, default off until M4) — old editor remains during development; the flag flips per-project once `circuit.json` exists.
+- File plumbing: `useProjectFile('circuit.json', defaultDoc)` (with `diagram.json` migration probe), Redux `updateFileContent` on the debounced serializer, Code-tab `</>` deep link kept.
+- AI assistant: expose a small imperative API (`getDocument()`, `applyOperations(ops[])`, `getNetlist()`) so Studio AI can read/modify circuits and reason over netlists — the current "Auto-wired by Studio AI" flow ports over.
+- Web build: everything works except pack install to disk (uses IndexedDB) — ngspice-WASM is browser-native, Electron not required for sim.
+
+## 14. Testing
+
+- **Unit (Vitest, no DOM):** routing math (port existing behaviors as table tests), DSU nets incl. buses/junctions/labels, netlist golden files (RC divider, RC transient, RLC AC, diode+LED sweep), fzp resolver against a fixture set of ~30 real Fritzing parts (incl. transform-heavy and `<use>`-based ones), Wokwi import golden files (incl. `*` journeys), KiCad exports parsed with a minimal sexpr reader.
+- **Sim integration:** run eecircuit-engine in CI (Node worker) on the golden netlists; assert vector shapes + spot values (±1%).
+- **Interaction (Playwright):** draw wire, drag part with bends held, drop-to-connect on breadboard, undo/redo depth, dual-view ratsnest sync, simulate-and-plot smoke test.
+- **Manual QA matrix:** the 4 demo projects rebuilt in v2, exported to KiCad and opened, exported to Wokwi and linted.
+
+## 15. Milestones
+
+| # | Deliverable (demoable) | Contents | Est. |
+|---|---|---|---|
+| **M0** | Core skeleton | `core/` model+store+commands+undo, ported routing/nets with fixes (B2, B4, B9, B10), file load/save/migration, feature-flag mount, unit test rig | 2 wk |
+| **M1** | Breadboard editor parity | Canvas/camera, palette (packs read-only from bundled default), place/move/rotate/wire/junction/inspector, multi-select+clipboard+nudge, SVG/PNG export — *matches old editor, plus undo* | 3 wk |
+| **M2** | Real breadboard + parts pipeline | Procedural breadboards, drop-to-connect+sticky+legs, hole tooltips; `.fzpz` drop-import; Part Editor v2 with persistence; pack manager UI + GitHub index install; default pack regenerated with buses/pinType/legs | 4 wk |
+| **M3** | Schematic view | View toggle, symbol rendering, unplaced tray + ratsnest sync, net labels/ground, flip/mirror, ERC panel, refdes system | 4 wk |
+| **M4** | Simulation | Sources/probes builtins, netlist gen, worker engine, Build/Simulate UI, DC annotations, transient/sweep/AC plots, error mapping. Flag default ON; old editor removed | 4 wk |
+| **M5** | Interop | KiCad netlist + `.kicad_sch` export, Wokwi import/export + lint CI, curated mapping overlay (top 100 parts), `.fzz` import (stretch) | 3 wk |
+
+Dependencies: M0→M1→M2; M3 needs M0/M1 (not M2); M4 needs M3 (probes/labels); M5's netlist exporter can start after M3. Two agents can parallelize M2 ∥ M3 after M1.
+
+## 16. Decisions (open questions resolved 2026-07-02)
+
+1. **Filename:** `circuit.json`; old `diagram.json` migrated on open. ✅
+2. **Theme:** both views follow the tinyStudio design system / Design Guide tokens (no forced paper-white); a "paper" style is an *export* option only. ✅
+3. **Symbol standard:** US/IEEE default, IEC later as a setting. ✅
+4. **Default pack hosting:** new `tinyparts` repo under Mister-Industries; CI runs the bulk importer and publishes `index.json`. ✅
+5. **Mapping overlay:** lives in the `tinyparts` repo, community-PR-able. ✅
+6. **Licensing:** approved — ship converted CC-BY-SA Fritzing art in the default pack with a per-pack ATTRIBUTION file; behaviors (not code) ported from GPLv3 fritzing-app; tinyStudio is GPL-3.0 so either is compatible. ✅
+7. **Sim engine:** **tscircuit's ngspice build is the default**, eecircuit-engine the fallback, both behind `SimBackend`, winner confirmed by the M4 bake-off (§10.1). KiCad export goes through circuit-json + `circuit-json-to-kicad` first (§12). ✅
+8. **M1 look:** pixel-identical wires/canvas to the current editor — "same editor, now with undo." ✅
+
+## 17. Risks
+
+- **ngspice-WASM robustness** (nonconvergence on user circuits): mitigate with `.options` defaults (gmin stepping, itl bumps), watchdog, and readable error mapping. CircuitLab hides SPICE-isms well; we should crib their error copy tone.
+- **Fritzing SVG variance** (transforms, `<use>`, fonts, CSS): the resolver already handles the worst; budget real time in M2 for the long tail; `_report.json` keeps it honest.
+- **Scope gravity on the schematic view**: CircuitLab look is a *skin* discipline — resist rebuilding their whole parameter-expression system in v2 (plain values + spice-number parsing only).
+- **Dual-view confusion** (users expect wires to teleport between views): ratsnest + status pills + a first-run tour mitigate; this is Fritzing's model and it's learnable.
+
+---
+
+## Appendix — External references
+
+- Wokwi diagram format: https://docs.wokwi.com/diagram-format (journey mini-language incl. `*`)
+- Wokwi elements (MIT, visuals only): https://github.com/wokwi/wokwi-elements
+- eecircuit-engine (ngspice WASM): https://github.com/eelab-dev/EEcircuit-engine · demo https://eecircuit.com · alternative build https://github.com/tscircuit/ngspice
+- KiCad s-expression schematic spec: https://dev-docs.kicad.org/en/file-formats/sexpr-schematic/index.html
+- CircuitLab UX reference: https://www.circuitlab.com/docs/the-basics/ (Build/Simulate modes, DC/Sweep/Transient/Frequency)
+- Fritzing internals + current-code bug catalogue: `docs/circuit-architecture-and-roadmap.md` (this repo)
diff --git a/package.json b/package.json
index 094ad16..acd5491 100644
--- a/package.json
+++ b/package.json
@@ -19,6 +19,7 @@
     "typecheck:node": "tsc --noEmit -p tsconfig.node.json --composite false",
     "typecheck:web": "tsc --noEmit -p tsconfig.web.json --composite false",
     "typecheck": "npm run typecheck:node && npm run typecheck:web",
+    "test:circuit": "node scripts/test-circuit.mjs",
     "start": "electron-vite preview",
     "fetch:arduino-cli": "node scripts/fetch-arduino-cli.mjs",
     "prebuild": "node scripts/fetch-arduino-cli.mjs",
diff --git a/scripts/test-circuit.mjs b/scripts/test-circuit.mjs
new file mode 100644
index 0000000..7f4c7df
--- /dev/null
+++ b/scripts/test-circuit.mjs
@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+/**
+ * test-circuit.mjs — zero-extra-dependency test runner for the Circuit v2 core.
+ *
+ * Bundles each src/renderer/src/circuit/__tests__/*.test.ts with esbuild
+ * (already a transitive dependency via vite) into a temp dir, then runs them
+ * with Node's built-in test runner (node:test).
+ *
+ *   npm run test:circuit
+ *
+ * Why not vitest? Nothing against it — adopt it whenever it lands in the repo;
+ * these test files are plain node:test + assert and will port in minutes.
+ */
+import { build } from 'esbuild'
+import { spawnSync } from 'node:child_process'
+import { mkdtempSync, readdirSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const testDir = resolve(__dirname, '..', 'src', 'renderer', 'src', 'circuit', '__tests__')
+const files = readdirSync(testDir).filter((f) => f.endsWith('.test.ts'))
+if (files.length === 0) {
+  console.error('No test files found in', testDir)
+  process.exit(1)
+}
+
+const out = mkdtempSync(join(tmpdir(), 'circuit-tests-'))
+try {
+  await build({
+    entryPoints: files.map((f) => join(testDir, f)),
+    outdir: out,
+    bundle: true,
+    format: 'esm',
+    platform: 'node',
+    target: 'node20',
+    sourcemap: 'inline',
+    external: ['node:*'],
+    outExtension: { '.js': '.mjs' },
+    logLevel: 'error'
+  })
+  const compiled = readdirSync(out)
+    .filter((f) => f.endsWith('.mjs'))
+    .map((f) => join(out, f))
+  const res = spawnSync(process.execPath, ['--test', ...compiled], { stdio: 'inherit' })
+  process.exit(res.status ?? 1)
+} finally {
+  rmSync(out, { recursive: true, force: true })
+}
diff --git a/src/renderer/src/circuit/__tests__/model.test.ts b/src/renderer/src/circuit/__tests__/model.test.ts
new file mode 100644
index 0000000..ec44b22
--- /dev/null
+++ b/src/renderer/src/circuit/__tests__/model.test.ts
@@ -0,0 +1,135 @@
+/**
+ * circuit/core/model tests — v2 parse/serialize round-trip, v1/Wokwi
+ * migration, unknown-key preservation (B3), duplicate handling.
+ */
+import { strict as assert } from 'node:assert'
+import { test } from 'node:test'
+import {
+  emptyDoc,
+  parseCircuitFile,
+  serializeDoc,
+  splitPinRef,
+  type CircuitDoc
+} from '../core/model'
+
+test('v2 round-trip is lossless and stable', () => {
+  const doc: CircuitDoc = {
+    ...emptyDoc('geoff'),
+    parts: [
+      { id: 'R1', type: 'resistor', attrs: { value: '220' }, bb: { x: 96, y: 48 }, sch: { x: 10, y: 10, rotate: 90 } }
+    ],
+    wires: [{ id: 'w1', from: 'R1:1', to: 'R1:2', view: 'bb', color: '#2fa46a', route: ['h10'] }]
+  }
+  const text = serializeDoc(doc)
+  const { doc: back, migrated } = parseCircuitFile(text)
+  assert.equal(migrated, false)
+  assert.equal(back.parts.length, 1)
+  assert.deepEqual(back.parts[0].attrs, { value: '220' })
+  assert.equal(back.wires[0].id, 'w1')
+  assert.equal(serializeDoc(back), text) // stable output
+})
+
+test('unknown top-level keys survive round-trip (B3)', () => {
+  const input = JSON.stringify({
+    format: 'tinystudio-circuit',
+    version: 2,
+    parts: [],
+    wires: [],
+    serialMonitor: { display: 'terminal' },
+    dependencies: { foo: '1.0' }
+  })
+  const { doc } = parseCircuitFile(input)
+  const out = JSON.parse(serializeDoc(doc))
+  assert.deepEqual(out.serialMonitor, { display: 'terminal' })
+  assert.deepEqual(out.dependencies, { foo: '1.0' })
+})
+
+test('garbage input yields empty doc + warning, never throws', () => {
+  const r1 = parseCircuitFile('not json at all {')
+  assert.equal(r1.doc.parts.length, 0)
+  assert.ok(r1.warnings.length > 0)
+  const r2 = parseCircuitFile('null')
+  assert.equal(r2.doc.parts.length, 0)
+})
+
+test('duplicate part ids are dropped with a warning', () => {
+  const input = JSON.stringify({
+    format: 'tinystudio-circuit',
+    version: 2,
+    parts: [
+      { id: 'R1', type: 'resistor' },
+      { id: 'R1', type: 'resistor' }
+    ],
+    wires: []
+  })
+  const { doc, warnings } = parseCircuitFile(input)
+  assert.equal(doc.parts.length, 1)
+  assert.ok(warnings.some((w) => w.includes('Duplicate')))
+})
+
+test('v1 tinyStudio diagram.json migrates: placements, wires, schematic overlay', () => {
+  const v1 = JSON.stringify({
+    version: 1,
+    editor: 'tinystudio',
+    author: 'tinyStudio',
+    parts: [
+      { type: 'tinycore', id: 'tinycore', left: 150, top: 240 },
+      { type: 'resistor', id: 'resistor', left: 520, top: 230, rotate: 90, attrs: { value: '1k' } }
+    ],
+    connections: [
+      ['tinycore:SIG', 'resistor:Pin 0', '#36c46b', ['v-22.73', 'h-179.8']]
+    ],
+    schematic: {
+      pos: { resistor: [40, 60] },
+      routes: { 'tinycore:SIG>resistor:Pin 0': ['h20'] }
+    }
+  })
+  const { doc, migrated } = parseCircuitFile(v1)
+  assert.equal(migrated, true)
+  assert.equal(doc.parts.length, 2)
+  const res = doc.parts.find((p) => p.id === 'resistor')!
+  assert.deepEqual(res.bb, { x: 520, y: 230, rotate: 90 })
+  assert.deepEqual(res.sch, { x: 40, y: 60 })
+  assert.deepEqual(res.attrs, { value: '1k' })
+  const bbWires = doc.wires.filter((w) => w.view === 'bb')
+  const schWires = doc.wires.filter((w) => w.view === 'sch')
+  assert.equal(bbWires.length, 1)
+  assert.equal(bbWires[0].color, '#36c46b')
+  assert.deepEqual(bbWires[0].route, ['v-22.73', 'h-179.8'])
+  assert.equal(schWires.length, 1)
+  assert.deepEqual(schWires[0].route, ['h20'])
+  assert.equal(splitPinRef(bbWires[0].from as string).part, 'tinycore')
+})
+
+test('Wokwi diagram.json migrates and preserves foreign keys', () => {
+  const wokwi = JSON.stringify({
+    version: 1,
+    author: 'Uri',
+    editor: 'wokwi',
+    parts: [{ id: 'led1', type: 'wokwi-led', left: 100, top: 50, attrs: { color: 'red' } }],
+    connections: [['led1:A', 'led1:C', 'green', ['v10', '*', 'h-5']]],
+    serialMonitor: { display: 'terminal' }
+  })
+  const { doc, migrated } = parseCircuitFile(wokwi)
+  assert.equal(migrated, true)
+  assert.equal(doc.parts[0].type, 'wokwi-led')
+  assert.deepEqual(doc.wires[0].route, ['v10', '*', 'h-5']) // '*' kept for the router
+  assert.deepEqual(doc.extra?.serialMonitor, { display: 'terminal' })
+  const out = JSON.parse(serializeDoc(doc))
+  assert.deepEqual(out.serialMonitor, { display: 'terminal' })
+})
+
+test('v1 free-point junction endpoints become pending junctions, not drops', () => {
+  const v1 = JSON.stringify({
+    version: 1,
+    parts: [{ id: 'a', type: 'resistor', left: 0, top: 0 }],
+    connections: [
+      ['a:1', 'a:2', '#fff', ['h10']],
+      ['a:2', { x: 5, y: 0 }, '#fff', []]
+    ]
+  })
+  const { doc } = parseCircuitFile(v1)
+  assert.equal(doc.wires.length, 2)
+  const j = doc.wires[1].to
+  assert.equal(typeof j, 'object')
+})
diff --git a/src/renderer/src/circuit/__tests__/nets.test.ts b/src/renderer/src/circuit/__tests__/nets.test.ts
new file mode 100644
index 0000000..f790818
--- /dev/null
+++ b/src/renderer/src/circuit/__tests__/nets.test.ts
@@ -0,0 +1,102 @@
+/**
+ * circuit/core/nets tests — DSU nets across views, buses, junction identity
+ * (B9), net labels, dangling detection.
+ */
+import { strict as assert } from 'node:assert'
+import { test } from 'node:test'
+import { buildNets, danglingJunctions } from '../core/nets'
+import { emptyDoc, type CircuitDoc } from '../core/model'
+
+function doc(partial: Partial<CircuitDoc>): CircuitDoc {
+  return { ...emptyDoc(), ...partial }
+}
+
+test('wires merge pins into one net; views share the net model', () => {
+  const d = doc({
+    parts: [
+      { id: 'R1', type: 'resistor', bb: { x: 0, y: 0 } },
+      { id: 'LED1', type: 'led', bb: { x: 50, y: 0 } }
+    ],
+    wires: [
+      { id: 'w1', from: 'R1:2', to: 'LED1:anode', view: 'bb' },
+      { id: 'w2', from: 'R1:2', to: 'LED1:anode', view: 'sch' } // same net drawn in sch
+    ]
+  })
+  const m = buildNets(d)
+  assert.equal(m.meaningful, 1)
+  assert.equal(m.pinToNet.get('R1:2'), m.pinToNet.get('LED1:anode'))
+  assert.equal(m.wireToNet.get('w1'), m.wireToNet.get('w2'))
+})
+
+test('junction endpoint joins the HOST WIRE net by identity (B9)', () => {
+  const d = doc({
+    wires: [
+      { id: 'w1', from: 'A:1', to: 'B:1', view: 'bb' },
+      { id: 'w2', from: 'C:1', to: { wire: 'w1', t: 0.5 }, view: 'bb' }
+    ]
+  })
+  const m = buildNets(d)
+  assert.equal(m.meaningful, 1)
+  assert.equal(m.pinToNet.get('C:1'), m.pinToNet.get('A:1'))
+})
+
+test('buses merge internally-common pins (breadboard rows)', () => {
+  const d = doc({
+    parts: [{ id: 'BB1', type: 'breadboard-half', bb: { x: 0, y: 0 } }],
+    wires: [
+      { id: 'w1', from: 'X:1', to: 'BB1:a1', view: 'bb' },
+      { id: 'w2', from: 'Y:1', to: 'BB1:e1', view: 'bb' }
+    ]
+  })
+  const buses = (type: string): string[][] | undefined =>
+    type === 'breadboard-half' ? [['a1', 'b1', 'c1', 'd1', 'e1']] : undefined
+  const with_ = buildNets(d, { busesFor: buses })
+  assert.equal(with_.pinToNet.get('X:1'), with_.pinToNet.get('Y:1'))
+  const without = buildNets(d)
+  assert.notEqual(without.pinToNet.get('X:1'), without.pinToNet.get('Y:1'))
+})
+
+test('same-named net labels merge nets and name them', () => {
+  const d = doc({
+    netLabels: [
+      { id: 'nl1', name: 'GND', kind: 'ground', sch: { x: 0, y: 0 } },
+      { id: 'nl2', name: 'GND', kind: 'ground', sch: { x: 100, y: 0 } }
+    ],
+    wires: [
+      { id: 'w1', from: 'A:1', to: 'nl1:1', view: 'sch' },
+      { id: 'w2', from: 'B:1', to: 'nl2:1', view: 'sch' }
+    ]
+  })
+  const m = buildNets(d)
+  assert.equal(m.pinToNet.get('A:1'), m.pinToNet.get('B:1'))
+  const idx = m.pinToNet.get('A:1')!
+  assert.equal(m.netNames[idx], 'GND')
+})
+
+test('implicit connections (drop-to-connect seam) merge nets', () => {
+  const d = doc({
+    wires: [{ id: 'w1', from: 'BB1:a5', to: 'LED1:anode', view: 'bb' }]
+  })
+  const m = buildNets(d, { implicit: [['R1:1', 'BB1:a5']] })
+  assert.equal(m.pinToNet.get('R1:1'), m.pinToNet.get('LED1:anode'))
+})
+
+test('danglingJunctions finds bad hosts, cross-view refs, self-refs', () => {
+  const d = doc({
+    wires: [
+      { id: 'w1', from: 'A:1', to: 'B:1', view: 'bb' },
+      { id: 'ok', from: 'C:1', to: { wire: 'w1', t: 0.3 }, view: 'bb' },
+      { id: 'gone', from: 'D:1', to: { wire: 'nope', t: 0.3 }, view: 'bb' },
+      { id: 'xview', from: 'E:1', to: { wire: 'w1', t: 0.3 }, view: 'sch' },
+      { id: 'selfy', from: 'F:1', to: { wire: 'selfy', t: 0.3 }, view: 'bb' }
+    ]
+  })
+  const bad = danglingJunctions(d).sort()
+  assert.deepEqual(bad, ['gone', 'selfy', 'xview'])
+})
+
+test('bare bus pins are not counted as meaningful nets', () => {
+  const d = doc({ parts: [{ id: 'BB1', type: 'bb', bb: { x: 0, y: 0 } }] })
+  const m = buildNets(d, { busesFor: () => [['a1', 'b1']] })
+  assert.equal(m.meaningful, 0)
+})
diff --git a/src/renderer/src/circuit/__tests__/routing.test.ts b/src/renderer/src/circuit/__tests__/routing.test.ts
new file mode 100644
index 0000000..8d631ad
--- /dev/null
+++ b/src/renderer/src/circuit/__tests__/routing.test.ts
@@ -0,0 +1,139 @@
+/**
+ * circuit/core/routing tests — journey decode/encode incl. the Wokwi "*"
+ * semantics (B2 fix), bend extraction, simplification, junction parametrics.
+ * Runner: `npm run test:circuit` (esbuild bundle → node --test).
+ */
+import { strict as assert } from 'node:assert'
+import { test } from 'node:test'
+import {
+  bendsFromJourney,
+  buildWirePoints,
+  decodeJourney,
+  dragSegment,
+  isStraightRoute,
+  journeyFromPoints,
+  pointAtT,
+  simplifyWirePoints,
+  tAtPoint,
+  wirePoints
+} from '../core/routing'
+
+const src = { x: 0, y: 0 }
+const tgt = { x: 100, y: 50 }
+
+test('decodeJourney: plain source-anchored h/v', () => {
+  const pts = decodeJourney(src, tgt, ['h100', 'v50'])
+  assert.deepEqual(pts, [
+    { x: 0, y: 0 },
+    { x: 100, y: 0 },
+    { x: 100, y: 50 }
+  ])
+})
+
+test('decodeJourney: empty journey auto-completes orthogonally', () => {
+  const pts = decodeJourney(src, tgt)
+  assert.equal(pts[0].x, 0)
+  assert.equal(pts[pts.length - 1].y, 50)
+  assert.ok(pts.length >= 2)
+  // all segments axis-aligned
+  for (let i = 1; i < pts.length; i++) {
+    const dx = Math.abs(pts[i].x - pts[i - 1].x)
+    const dy = Math.abs(pts[i].y - pts[i - 1].y)
+    assert.ok(dx < 0.001 || dy < 0.001, `segment ${i} not orthogonal`)
+  }
+})
+
+test('decodeJourney: Wokwi "*" — post-star applies in reverse from target (B2)', () => {
+  // Wokwi docs example: ["v10","h5","*","v-15","h10"]
+  // v10,h5 from source; from TARGET walk back: h10 → 10px left of target,
+  // then v-15 → 15px below target; gap auto-completed.
+  const s = { x: 0, y: 0 }
+  const t = { x: 100, y: 100 }
+  const pts = decodeJourney(s, t, ['v10', 'h5', '*', 'v-15', 'h10'])
+  // source chain
+  assert.deepEqual(pts[0], { x: 0, y: 0 })
+  assert.deepEqual(pts[1], { x: 0, y: 10 })
+  assert.deepEqual(pts[2], { x: 5, y: 10 })
+  // target chain end: …, {90,115}, {90,100}? walk: target(100,100) ← h10 means
+  // "10 right of target-side point", so backward = (90,100); then v-15 backward = (90,115)
+  const n = pts.length
+  assert.deepEqual(pts[n - 1], { x: 100, y: 100 })
+  assert.deepEqual(pts[n - 2], { x: 90, y: 100 })
+  assert.deepEqual(pts[n - 3], { x: 90, y: 115 })
+})
+
+test('decodeJourney: "*" with empty halves degrades gracefully', () => {
+  const pts = decodeJourney(src, tgt, ['*'])
+  assert.deepEqual(pts[0], src)
+  assert.deepEqual(pts[pts.length - 1], tgt)
+})
+
+test('journeyFromPoints round-trips orthogonal routes', () => {
+  const original = ['h48', 'v-19.2', 'h20']
+  const pts = decodeJourney(src, { x: 68, y: -19.2 }, original)
+  const encoded = journeyFromPoints(pts)
+  assert.deepEqual(encoded, original)
+})
+
+test('straight (d) routes survive encode/decode', () => {
+  const j = ['d30,40', 'h10']
+  assert.ok(isStraightRoute(j))
+  const pts = wirePoints(src, { x: 40, y: 40 }, j)
+  assert.deepEqual(pts[1], { x: 30, y: 40 })
+  const back = journeyFromPoints(pts, true)
+  assert.deepEqual(back, j)
+})
+
+test('bendsFromJourney drops endpoint-coincident points', () => {
+  const bends = bendsFromJourney(['h100', 'v50'], src, tgt)
+  assert.deepEqual(bends, [{ x: 100, y: 0 }])
+})
+
+test('buildWirePoints re-elbows around fixed bends', () => {
+  const bends = [{ x: 50, y: 0 }]
+  const pts = buildWirePoints({ x: 0, y: 10 }, bends, { x: 100, y: 60 })
+  assert.deepEqual(pts[0], { x: 0, y: 10 })
+  assert.deepEqual(pts[pts.length - 1], { x: 100, y: 60 })
+  assert.ok(pts.some((p) => p.x === 50 && p.y === 0))
+})
+
+test('simplifyWirePoints removes collinear + duplicate points', () => {
+  const pts = simplifyWirePoints([
+    { x: 0, y: 0 },
+    { x: 10, y: 0 },
+    { x: 10, y: 0 },
+    { x: 20, y: 0 },
+    { x: 20, y: 30 }
+  ])
+  assert.deepEqual(pts, [
+    { x: 0, y: 0 },
+    { x: 20, y: 0 },
+    { x: 20, y: 30 }
+  ])
+})
+
+test('dragSegment inserts corners at anchored endpoints (U-pull)', () => {
+  const pts = [
+    { x: 0, y: 0 },
+    { x: 100, y: 0 }
+  ]
+  const out = dragSegment(pts, 0, 'horizontal', 0, 20)
+  assert.deepEqual(out, [
+    { x: 0, y: 0 },
+    { x: 0, y: 20 },
+    { x: 100, y: 20 },
+    { x: 100, y: 0 }
+  ])
+})
+
+test('pointAtT / tAtPoint are inverse-ish along a polyline', () => {
+  const pts = [
+    { x: 0, y: 0 },
+    { x: 100, y: 0 },
+    { x: 100, y: 100 }
+  ]
+  const mid = pointAtT(pts, 0.5)
+  assert.deepEqual(mid, { x: 100, y: 0 })
+  assert.ok(Math.abs(tAtPoint(pts, { x: 100, y: 1 }) - 0.505) < 0.01)
+  assert.ok(Math.abs(tAtPoint(pts, { x: 50, y: 0 }) - 0.25) < 0.001)
+})
diff --git a/src/renderer/src/circuit/__tests__/store.test.ts b/src/renderer/src/circuit/__tests__/store.test.ts
new file mode 100644
index 0000000..c51910f
--- /dev/null
+++ b/src/renderer/src/circuit/__tests__/store.test.ts
@@ -0,0 +1,152 @@
+/**
+ * circuit/core store + commands tests — undo/redo, drag merging, cascades,
+ * duplicate-wire guard (B5), rename rewrites (B4-adjacent), echo guard.
+ */
+import { strict as assert } from 'node:assert'
+import { test } from 'node:test'
+import {
+  addPart,
+  addWire,
+  composite,
+  deleteParts,
+  deleteWires,
+  placePart,
+  renamePart,
+  setPartAttr
+} from '../core/commands'
+import { emptyDoc } from '../core/model'
+import { nextRefdes, prefixForFamily } from '../core/refdes'
+import { CircuitStore } from '../core/store'
+
+function freshStore(): CircuitStore {
+  return new CircuitStore(emptyDoc('test'))
+}
+
+test('dispatch/undo/redo round-trip', () => {
+  const s = freshStore()
+  s.dispatch(addPart({ id: 'R1', type: 'resistor', bb: { x: 0, y: 0 } }))
+  assert.equal(s.getDoc().parts.length, 1)
+  assert.ok(s.canUndo())
+  s.undo()
+  assert.equal(s.getDoc().parts.length, 0)
+  assert.ok(s.canRedo())
+  s.redo()
+  assert.equal(s.getDoc().parts.length, 1)
+})
+
+test('merge-key drags collapse into ONE undo step', () => {
+  const s = freshStore()
+  s.dispatch(addPart({ id: 'R1', type: 'resistor', bb: { x: 0, y: 0 } }))
+  for (let i = 1; i <= 10; i++) {
+    s.dispatch(placePart('R1', 'bb', { x: i * 9.6, y: 0 }, [], true))
+  }
+  assert.equal(s.getDoc().parts[0].bb!.x, 96)
+  s.undo() // one undo returns to pre-drag position
+  assert.equal(s.getDoc().parts[0].bb!.x, 0)
+  s.undo()
+  assert.equal(s.getDoc().parts.length, 0)
+})
+
+test('attr edits merge per key; new command breaks the merge chain', () => {
+  const s = freshStore()
+  s.dispatch(addPart({ id: 'R1', type: 'resistor' }))
+  s.dispatch(setPartAttr('R1', 'value', '1'))
+  s.dispatch(setPartAttr('R1', 'value', '10'))
+  s.dispatch(setPartAttr('R1', 'value', '100'))
+  s.dispatch(setPartAttr('R1', 'tolerance', '5%')) // different key → new step
+  assert.equal(s.getDoc().parts[0].attrs!.value, '100')
+  s.undo()
+  assert.equal(s.getDoc().parts[0].attrs!.tolerance, undefined)
+  assert.equal(s.getDoc().parts[0].attrs!.value, '100')
+  s.undo()
+  assert.equal(s.getDoc().parts[0].attrs?.value, undefined)
+})
+
+test('duplicate wires are rejected either direction (B5)', () => {
+  const s = freshStore()
+  s.dispatch(addWire({ id: 'w1', from: 'A:1', to: 'B:1', view: 'bb' }))
+  s.dispatch(addWire({ id: 'w2', from: 'B:1', to: 'A:1', view: 'bb' })) // reversed dup
+  assert.equal(s.getDoc().wires.length, 1)
+  s.dispatch(addWire({ id: 'w3', from: 'A:1', to: 'B:1', view: 'sch' })) // other view OK
+  assert.equal(s.getDoc().wires.length, 2)
+})
+
+test('renamePart rewrites wire endpoints; collision is a no-op', () => {
+  const s = freshStore()
+  s.dispatch(addPart({ id: 'R1', type: 'resistor' }))
+  s.dispatch(addPart({ id: 'R2', type: 'resistor' }))
+  s.dispatch(addWire({ from: 'R1:1', to: 'R2:1', view: 'bb' }))
+  s.dispatch(renamePart('R1', 'R9'))
+  assert.equal(s.getDoc().wires[0].from, 'R9:1')
+  const before = s.getDoc()
+  s.dispatch(renamePart('R9', 'R2')) // collision
+  assert.equal(s.getDoc(), before)
+})
+
+test('deleteParts cascades wires and repairs junction riders', () => {
+  const s = freshStore()
+  s.dispatch(addPart({ id: 'A', type: 'x' }))
+  s.dispatch(addPart({ id: 'B', type: 'x' }))
+  s.dispatch(addPart({ id: 'C', type: 'x' }))
+  s.dispatch(addWire({ id: 'host', from: 'A:1', to: 'B:1', view: 'bb' }))
+  s.dispatch(addWire({ id: 'rider', from: 'C:1', to: { wire: 'host', t: 0.5 }, view: 'bb' }))
+  // deleting B removes host (touches B) — rider re-anchors to host.from = A:1
+  s.dispatch(deleteParts(['B']))
+  const wires = s.getDoc().wires
+  assert.equal(wires.length, 1)
+  assert.equal(wires[0].id, 'rider')
+  assert.equal(wires[0].to, 'A:1')
+  // undo restores everything as one step
+  s.undo()
+  assert.equal(s.getDoc().wires.length, 2)
+  assert.equal(s.getDoc().parts.length, 3)
+})
+
+test('deleteWires drops degenerate riders that collapse onto themselves', () => {
+  const s = freshStore()
+  s.dispatch(addWire({ id: 'host', from: 'A:1', to: 'B:1', view: 'bb' }))
+  s.dispatch(addWire({ id: 'rider', from: 'A:1', to: { wire: 'host', t: 0.5 }, view: 'bb' }))
+  s.dispatch(deleteWires(['host']))
+  // rider re-anchors to A:1 → degenerate (A:1 → A:1) → removed
+  assert.equal(s.getDoc().wires.length, 0)
+})
+
+test('composite = one undo step', () => {
+  const s = freshStore()
+  s.dispatch(
+    composite('Add wired pair', [
+      addPart({ id: 'R1', type: 'resistor' }),
+      addPart({ id: 'R2', type: 'resistor' }),
+      addWire({ from: 'R1:2', to: 'R2:1', view: 'bb' })
+    ])
+  )
+  assert.equal(s.getDoc().parts.length, 2)
+  assert.equal(s.getDoc().wires.length, 1)
+  s.undo()
+  assert.equal(s.getDoc().parts.length, 0)
+  assert.equal(s.getDoc().wires.length, 0)
+})
+
+test('replaceFromFile: echo ignored, external edit is undoable', () => {
+  const { store } = CircuitStore.fromFile('{}')
+  store.dispatch(addPart({ id: 'R1', type: 'resistor' }))
+  const text = store.serialize()
+  const echo = store.replaceFromFile(text)
+  assert.equal(echo.applied, false)
+  const edited = text.replace('"R1"', '"R7"')
+  const ext = store.replaceFromFile(edited)
+  assert.equal(ext.applied, true)
+  assert.equal(store.getDoc().parts[0].id, 'R7')
+  store.undo()
+  assert.equal(store.getDoc().parts[0].id, 'R1')
+})
+
+test('refdes assignment', () => {
+  const d = emptyDoc()
+  d.parts.push({ id: 'R1', type: 'r' }, { id: 'R3', type: 'r' }, { id: 'LED1', type: 'led' })
+  assert.equal(nextRefdes(d, 'R'), 'R4')
+  assert.equal(nextRefdes(d, 'LED'), 'LED2')
+  assert.equal(nextRefdes(d, 'U'), 'U1')
+  assert.equal(prefixForFamily('Diode LED'), 'D') // 'diode' matches first
+  assert.equal(prefixForFamily(undefined, 'Q'), 'Q')
+})
diff --git a/src/renderer/src/circuit/core/commands.ts b/src/renderer/src/circuit/core/commands.ts
new file mode 100644
index 0000000..da19ce2
--- /dev/null
+++ b/src/renderer/src/circuit/core/commands.ts
@@ -0,0 +1,301 @@
+/**
+ * circuit/core/commands — every document mutation as a Command.
+ *
+ * Commands are PURE: `apply(doc)` returns a new doc (structural sharing, no
+ * mutation), which makes undo trivial (the store keeps the previous doc) and
+ * React integration free. `mergeKey` lets high-frequency gestures (drags)
+ * collapse into a single undo step: consecutive commands with the same
+ * mergeKey replace the top stack entry instead of pushing a new one.
+ *
+ * Geometry-dependent updates (wire re-anchoring while a part moves) are
+ * computed by the VIEW (it owns pin positions via the registry) and passed in
+ * as data — core stays free of parts/geometry knowledge.
+ */
+
+import {
+  isJunction,
+  newId,
+  splitPinRef,
+  type Analysis,
+  type CircuitDoc,
+  type CircuitPart,
+  type CircuitWire,
+  type NetLabel,
+  type Placement,
+  type Probe,
+  type ViewId,
+  type WireEnd
+} from './model'
+
+export interface Command {
+  label: string
+  /** Same key on consecutive commands ⇒ they merge into one undo step. */
+  mergeKey?: string
+  apply(doc: CircuitDoc): CircuitDoc
+}
+
+export interface WireReroute {
+  wireId: string
+  route: string[]
+}
+
+// ── parts ────────────────────────────────────────────────────────────────────
+
+export function addPart(part: CircuitPart): Command {
+  return {
+    label: `Add ${part.id}`,
+    apply: (doc) => ({ ...doc, parts: [...doc.parts, part] })
+  }
+}
+
+/** Move/replace a part's placement in one view; `reroutes` keeps its wires' bends fixed. */
+export function placePart(
+  id: string,
+  view: ViewId,
+  placement: Placement | undefined,
+  reroutes: WireReroute[] = [],
+  merge = false
+): Command {
+  return {
+    label: `Move ${id}`,
+    mergeKey: merge ? `place:${view}:${id}` : undefined,
+    apply: (doc) => ({
+      ...doc,
+      parts: doc.parts.map((p) =>
+        p.id === id ? { ...p, [view]: placement } : p
+      ),
+      wires: applyReroutes(doc.wires, reroutes)
+    })
+  }
+}
+
+export function setPartAttr(id: string, key: string, value: string | number | boolean | undefined): Command {
+  return {
+    label: `Set ${id}.${key}`,
+    mergeKey: `attr:${id}:${key}`,
+    apply: (doc) => ({
+      ...doc,
+      parts: doc.parts.map((p) => {
+        if (p.id !== id) return p
+        const attrs = { ...(p.attrs || {}) }
+        if (value === undefined) delete attrs[key]
+        else attrs[key] = value
+        return { ...p, attrs }
+      })
+    })
+  }
+}
+
+/** Rename a part (refdes). Rewrites every wire endpoint that references it. */
+export function renamePart(oldId: string, next: string): Command {
+  return {
+    label: `Rename ${oldId} → ${next}`,
+    apply: (doc) => {
+      if (doc.parts.some((p) => p.id === next)) return doc // uniqueness guard — no-op
+      const fixEnd = (e: WireEnd): WireEnd => {
+        if (typeof e !== 'string') return e
+        const { part, pin } = splitPinRef(e)
+        return part === oldId ? `${next}:${pin}` : e
+      }
+      return {
+        ...doc,
+        parts: doc.parts.map((p) => (p.id === oldId ? { ...p, id: next } : p)),
+        wires: doc.wires.map((w) => ({ ...w, from: fixEnd(w.from), to: fixEnd(w.to) }))
+      }
+    }
+  }
+}
+
+/**
+ * Delete parts (both views) and cascade: wires touching them are removed,
+ * junction riders on removed wires are repaired (§ junction cascade).
+ */
+export function deleteParts(ids: string[]): Command {
+  const idSet = new Set(ids)
+  return {
+    label: ids.length === 1 ? `Delete ${ids[0]}` : `Delete ${ids.length} parts`,
+    apply: (doc) => {
+      const touchesDeleted = (e: WireEnd): boolean =>
+        typeof e === 'string' && idSet.has(splitPinRef(e).part)
+      const goneWires = new Set(
+        doc.wires.filter((w) => touchesDeleted(w.from) || touchesDeleted(w.to)).map((w) => w.id)
+      )
+      return {
+        ...doc,
+        parts: doc.parts.filter((p) => !idSet.has(p.id)),
+        wires: cascadeWireRemoval(doc.wires, goneWires)
+      }
+    }
+  }
+}
+
+// ── wires ────────────────────────────────────────────────────────────────────
+
+export function addWire(wire: Omit<CircuitWire, 'id'> & { id?: string }): Command {
+  const w: CircuitWire = { id: wire.id ?? newId('w'), ...wire } as CircuitWire
+  return {
+    label: 'Add wire',
+    apply: (doc) => {
+      // duplicate guard (B5): identical endpoints in either order, same view
+      const dup = doc.wires.some(
+        (x) =>
+          x.view === w.view &&
+          ((sameEnd(x.from, w.from) && sameEnd(x.to, w.to)) ||
+            (sameEnd(x.from, w.to) && sameEnd(x.to, w.from)))
+      )
+      if (dup) return doc
+      return { ...doc, wires: [...doc.wires, w] }
+    }
+  }
+}
+
+export function rerouteWire(id: string, route: string[], merge = false): Command {
+  return {
+    label: 'Reshape wire',
+    mergeKey: merge ? `route:${id}` : undefined,
+    apply: (doc) => ({
+      ...doc,
+      wires: doc.wires.map((w) => (w.id === id ? { ...w, route } : w))
+    })
+  }
+}
+
+export function setWireEnds(id: string, from: WireEnd | undefined, to: WireEnd | undefined, route?: string[]): Command {
+  return {
+    label: 'Reconnect wire',
+    apply: (doc) => ({
+      ...doc,
+      wires: doc.wires.map((w) =>
+        w.id === id
+          ? { ...w, from: from ?? w.from, to: to ?? w.to, ...(route ? { route } : {}) }
+          : w
+      )
+    })
+  }
+}
+
+export function recolorWire(id: string, color: string): Command {
+  return {
+    label: 'Recolor wire',
+    apply: (doc) => ({
+      ...doc,
+      wires: doc.wires.map((w) => (w.id === id ? { ...w, color } : w))
+    })
+  }
+}
+
+export function deleteWires(ids: string[]): Command {
+  return {
+    label: ids.length === 1 ? 'Delete wire' : `Delete ${ids.length} wires`,
+    apply: (doc) => ({ ...doc, wires: cascadeWireRemoval(doc.wires, new Set(ids)) })
+  }
+}
+
+// ── net labels ───────────────────────────────────────────────────────────────
+
+export function addNetLabel(label: NetLabel): Command {
+  return {
+    label: `Add label ${label.name}`,
+    apply: (doc) => ({ ...doc, netLabels: [...(doc.netLabels ?? []), label] })
+  }
+}
+export function deleteNetLabel(id: string): Command {
+  return {
+    label: 'Delete label',
+    apply: (doc) => ({
+      ...doc,
+      netLabels: (doc.netLabels ?? []).filter((l) => l.id !== id),
+      wires: cascadeWireRemoval(
+        doc.wires,
+        new Set(
+          doc.wires
+            .filter(
+              (w) =>
+                (typeof w.from === 'string' && splitPinRef(w.from).part === id) ||
+                (typeof w.to === 'string' && splitPinRef(w.to).part === id)
+            )
+            .map((w) => w.id)
+        )
+      )
+    })
+  }
+}
+
+// ── sim ──────────────────────────────────────────────────────────────────────
+
+export function setAnalyses(analyses: Analysis[]): Command {
+  return {
+    label: 'Configure simulation',
+    apply: (doc) => ({ ...doc, sim: { ...(doc.sim ?? {}), analyses } })
+  }
+}
+export function setProbes(probes: Probe[]): Command {
+  return {
+    label: 'Update probes',
+    apply: (doc) => ({ ...doc, sim: { ...(doc.sim ?? {}), probes } })
+  }
+}
+
+// ── batch ────────────────────────────────────────────────────────────────────
+
+/** Compose several commands into one undo step (cross-view cascades, paste…). */
+export function composite(label: string, commands: Command[]): Command {
+  return {
+    label,
+    apply: (doc) => commands.reduce((d, c) => c.apply(d), doc)
+  }
+}
+
+// ── internals ────────────────────────────────────────────────────────────────
+
+function sameEnd(a: WireEnd, b: WireEnd): boolean {
+  if (typeof a === 'string' || typeof b === 'string') return a === b
+  return a.wire === b.wire && Math.abs(a.t - b.t) < 0.01
+}
+
+function applyReroutes(wires: CircuitWire[], reroutes: WireReroute[]): CircuitWire[] {
+  if (!reroutes.length) return wires
+  const byId = new Map(reroutes.map((r) => [r.wireId, r.route]))
+  return wires.map((w) => (byId.has(w.id) ? { ...w, route: byId.get(w.id)! } : w))
+}
+
+/**
+ * Remove a set of wires and repair junction riders that referenced them:
+ * a rider's junction end is re-anchored to the removed host's `from` endpoint
+ * (which keeps it on the same net); if that is itself removed, the repair
+ * recurses; unrepairable riders are removed too. (B9 cascade.)
+ */
+export function cascadeWireRemoval(wires: CircuitWire[], gone: Set<string>): CircuitWire[] {
+  const byId = new Map(wires.map((w) => [w.id, w]))
+  const resolveAnchor = (hostId: string, seen: Set<string>): WireEnd | null => {
+    if (seen.has(hostId)) return null
+    seen.add(hostId)
+    const host = byId.get(hostId)
+    if (!host) return null
+    if (!gone.has(hostId)) return { wire: hostId, t: 0.5 } // host survives — shouldn't happen, keep rider
+    if (typeof host.from === 'string') return host.from
+    return resolveAnchor(host.from.wire, seen)
+  }
+  const out: CircuitWire[] = []
+  for (const w of wires) {
+    if (gone.has(w.id)) continue
+    let from = w.from
+    let to = w.to
+    let dead = false
+    if (isJunction(from) && gone.has(from.wire)) {
+      const a = resolveAnchor(from.wire, new Set([w.id]))
+      if (a) from = a
+      else dead = true
+    }
+    if (!dead && isJunction(to) && gone.has(to.wire)) {
+      const a = resolveAnchor(to.wire, new Set([w.id]))
+      if (a) to = a
+      else dead = true
+    }
+    if (dead) continue
+    // collapse degenerate wires (both ends now identical)
+    if (sameEnd(from, to)) continue
+    out.push(from === w.from && to === w.to ? w : { ...w, from, to })
+  }
+  return out
+}
diff --git a/src/renderer/src/circuit/core/geometry.ts b/src/renderer/src/circuit/core/geometry.ts
new file mode 100644
index 0000000..da4763e
--- /dev/null
+++ b/src/renderer/src/circuit/core/geometry.ts
@@ -0,0 +1,121 @@
+/**
+ * circuit/core/geometry — snapping, rotation, and a spatial hash for pin
+ * hit-testing / drop-to-connect. Pure math; no document knowledge.
+ */
+
+import { GRID_BB, GRID_SCH, type Pt, type ViewId } from './model'
+
+export function gridFor(view: ViewId): number {
+  return view === 'bb' ? GRID_BB : GRID_SCH
+}
+
+export function snap(v: number, grid: number): number {
+  return Math.round(v / grid) * grid
+}
+export function snapPt(p: Pt, grid: number): Pt {
+  return { x: snap(p.x, grid), y: snap(p.y, grid) }
+}
+
+/** Rotate/flip a local point inside a w×h part box (flip is horizontal, applied before rotation). */
+export function transformLocalPoint(
+  px: number,
+  py: number,
+  w: number,
+  h: number,
+  rotate = 0,
+  flip = false
+): Pt {
+  let x = flip ? w - px : px
+  const y = py
+  const rad = (rotate * Math.PI) / 180
+  const cos = Math.cos(rad)
+  const sin = Math.sin(rad)
+  const dx = x - w / 2
+  const dy = y - h / 2
+  return { x: w / 2 + dx * cos - dy * sin, y: h / 2 + dx * sin + dy * cos }
+}
+
+/**
+ * Pin position in world space for a part placed at (x,y) with rotation/flip.
+ * `local` is the pin's PartDef coordinate; `w`/`h` the view's part box.
+ */
+export function pinWorld(
+  local: [number, number],
+  placement: { x: number; y: number; rotate?: number; flip?: boolean },
+  w: number,
+  h: number,
+  legOffset?: [number, number]
+): Pt {
+  const p = transformLocalPoint(
+    local[0] + (legOffset?.[0] ?? 0),
+    local[1] + (legOffset?.[1] ?? 0),
+    w,
+    h,
+    placement.rotate ?? 0,
+    placement.flip ?? false
+  )
+  return { x: placement.x + p.x, y: placement.y + p.y }
+}
+
+/**
+ * Snap a part's placement so its PINS land on-grid (not its origin) — the
+ * Fritzing behavior that keeps everything lined up. Uses the first pin as the
+ * alignment reference.
+ */
+export function snapPlacementToPinGrid(
+  placement: { x: number; y: number; rotate?: number; flip?: boolean },
+  firstPinLocal: [number, number] | undefined,
+  w: number,
+  h: number,
+  grid: number
+): { x: number; y: number } {
+  if (!firstPinLocal) return { x: snap(placement.x, grid), y: snap(placement.y, grid) }
+  const pin = pinWorld(firstPinLocal, placement, w, h)
+  const snapped = snapPt(pin, grid)
+  return {
+    x: placement.x + (snapped.x - pin.x),
+    y: placement.y + (snapped.y - pin.y)
+  }
+}
+
+// ── spatial hash ─────────────────────────────────────────────────────────────
+
+/** Uniform-grid spatial hash for point sets (pins, holes). Cell = 2 grid units. */
+export class SpatialHash<T> {
+  private cells = new Map<string, { p: Pt; v: T }[]>()
+  constructor(private cellSize = GRID_BB * 2) {}
+
+  private key(x: number, y: number): string {
+    return `${Math.floor(x / this.cellSize)},${Math.floor(y / this.cellSize)}`
+  }
+
+  insert(p: Pt, v: T): void {
+    const k = this.key(p.x, p.y)
+    let cell = this.cells.get(k)
+    if (!cell) this.cells.set(k, (cell = []))
+    cell.push({ p, v })
+  }
+
+  /** Nearest entry within `radius` of `p`, or null. */
+  nearest(p: Pt, radius: number): { p: Pt; v: T; dist: number } | null {
+    const r = Math.ceil(radius / this.cellSize)
+    const cx = Math.floor(p.x / this.cellSize)
+    const cy = Math.floor(p.y / this.cellSize)
+    let best: { p: Pt; v: T; dist: number } | null = null
+    for (let gx = cx - r; gx <= cx + r; gx++) {
+      for (let gy = cy - r; gy <= cy + r; gy++) {
+        const cell = this.cells.get(`${gx},${gy}`)
+        if (!cell) continue
+        for (const e of cell) {
+          const d = Math.hypot(e.p.x - p.x, e.p.y - p.y)
+          if (d <= radius && (!best || d < best.dist)) best = { ...e, dist: d }
+        }
+      }
+    }
+    return best
+  }
+
+  clear(): void {
+    this.cells.clear()
+  }
+}
diff --git a/src/renderer/src/circuit/core/model.ts b/src/renderer/src/circuit/core/model.ts
new file mode 100644
index 0000000..1211132
--- /dev/null
+++ b/src/renderer/src/circuit/core/model.ts
@@ -0,0 +1,456 @@
+/**
+ * circuit/core/model — the Circuit View v2 document model.
+ *
+ * `circuit.json` v2 schema (docs/circuit-view-tech-spec.md §4), plus parsing,
+ * validation, serialization and migration from v1 `diagram.json` / Wokwi files.
+ *
+ * ZERO React, ZERO Node — pure TypeScript usable in renderer, web build, workers
+ * and unit tests alike.
+ */
+
+// ── geometry ─────────────────────────────────────────────────────────────────
+
+export interface Pt {
+  x: number
+  y: number
+}
+
+export type ViewId = 'bb' | 'sch'
+
+/** 0.1 in at 96 DPI — breadboard hole pitch and the base grid. */
+export const GRID_BB = 9.6
+/** Schematic fine grid (half pitch). */
+export const GRID_SCH = 4.8
+
+// ── document types ───────────────────────────────────────────────────────────
+
+export interface Placement {
+  x: number
+  y: number
+  rotate?: 0 | 90 | 180 | 270
+  flip?: boolean
+  /** Per-pin bendable-leg tip offsets (bb only), relative to the pin's rest position. */
+  legs?: Record<string, [number, number]>
+  /** Label anchor offset override. */
+  labelOffset?: [number, number]
+}
+
+export interface CircuitPart {
+  /** Reference designator — unique, user-visible (R1, LED2, U1…). */
+  id: string
+  /** PartDef type resolved through the parts registry. */
+  type: string
+  /** Typed properties declared by the part schema (value, color…). */
+  attrs?: Record<string, string | number | boolean>
+  /** Breadboard placement; absent ⇒ unplaced in bb view (tray). */
+  bb?: Placement
+  /** Schematic placement; absent ⇒ unplaced in sch view (tray). */
+  sch?: Placement
+}
+
+/** A wire endpoint: a part pin, or a junction on another wire's body. */
+export type WireEnd = string | JunctionEnd // "partId:pinName"
+export interface JunctionEnd {
+  /** Host wire id. */
+  wire: string
+  /** Parametric position along the host wire's rendered polyline, 0..1 by length. */
+  t: number
+}
+
+export interface CircuitWire {
+  /** Stable id (nanoid-8) — selection/route identity survives reorders (fixes B4). */
+  id: string
+  from: WireEnd
+  to: WireEnd
+  /** The single view this wire lives in. Nets are shared; wires are per-view. */
+  view: ViewId
+  /** Wokwi-style journey, source-anchored: h<px>, v<px>, d<dx>,<dy> (bb only). */
+  route?: string[]
+  /** bb only — schematic wires are always ink. */
+  color?: string
+  /** bb only — render as a curved jumper (route stays authoritative for geometry). */
+  curve?: boolean
+}
+
+export type NetLabelKind = 'ground' | 'power' | 'net'
+export interface NetLabel {
+  id: string
+  name: string
+  kind: NetLabelKind
+  sch: Placement
+}
+
+export type AnalysisKind = 'op' | 'dc' | 'tran' | 'ac'
+export interface Analysis {
+  id: string
+  kind: AnalysisKind
+  enabled?: boolean
+  [k: string]: unknown
+}
+export interface Probe {
+  id: string
+  kind: 'voltage' | 'current' | 'diff'
+  at: string
+  label?: string
+  color?: string
+}
+
+export interface PackRef {
+  id: string
+  version?: string
+  url?: string
+}
+
+export interface CircuitDoc {
+  format: 'tinystudio-circuit'
+  version: 2
+  meta?: { author?: string; created?: string; modified?: string }
+  packs?: PackRef[]
+  parts: CircuitPart[]
+  wires: CircuitWire[]
+  netLabels?: NetLabel[]
+  sim?: { analyses?: Analysis[]; probes?: Probe[] }
+  camera?: Partial<Record<ViewId, { x: number; y: number; zoom: number }>>
+  /**
+   * Round-trip bag: every top-level key we don't model is preserved verbatim
+   * (fixes B3 — never destroy foreign data like Wokwi's serialMonitor).
+   */
+  extra?: Record<string, unknown>
+}
+
+// ── ids ──────────────────────────────────────────────────────────────────────
+
+const ID_ALPHABET = 'abcdefghijklmnopqrstuvwxyz0123456789'
+
+/** 8-char random id (no crypto dependency; collision space 36^8 ≈ 2.8e12). */
+export function newId(prefix = ''): string {
+  let s = ''
+  for (let i = 0; i < 8; i++) s += ID_ALPHABET[(Math.random() * ID_ALPHABET.length) | 0]
+  return prefix ? `${prefix}_${s}` : s
+}
+
+export function isJunction(end: WireEnd): end is JunctionEnd {
+  return typeof end === 'object' && end !== null && 'wire' in end
+}
+
+/** Split a "partId:pinName" pin ref. Pin names may contain ':'? No — first colon splits. */
+export function splitPinRef(ref: string): { part: string; pin: string } {
+  const i = ref.indexOf(':')
+  return { part: ref.slice(0, i), pin: ref.slice(i + 1) }
+}
+
+// ── construction / validation ────────────────────────────────────────────────
+
+export function emptyDoc(author?: string): CircuitDoc {
+  return {
+    format: 'tinystudio-circuit',
+    version: 2,
+    meta: { author, created: new Date().toISOString() },
+    parts: [],
+    wires: []
+  }
+}
+
+const KNOWN_KEYS = new Set([
+  'format',
+  'version',
+  'meta',
+  'packs',
+  'parts',
+  'wires',
+  'netLabels',
+  'sim',
+  'camera'
+])
+
+export interface ParseResult {
+  doc: CircuitDoc
+  /** True when the input was a v1/Wokwi file and got migrated. */
+  migrated: boolean
+  warnings: string[]
+}
+
+/**
+ * Parse any supported circuit file text: v2 native, tinyStudio v1 diagram.json,
+ * or a Wokwi diagram.json. Never throws on bad input — returns an empty doc
+ * with warnings instead (the editor must always mount).
+ */
+export function parseCircuitFile(text: string): ParseResult {
+  const warnings: string[] = []
+  let raw: Record<string, unknown>
+  try {
+    raw = JSON.parse(text || '{}')
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) throw new Error('not an object')
+  } catch (e) {
+    return {
+      doc: emptyDoc(),
+      migrated: false,
+      warnings: [`Unparseable circuit file (${(e as Error).message}); starting empty.`]
+    }
+  }
+
+  if (raw.format === 'tinystudio-circuit' && raw.version === 2) {
+    return { doc: normalizeV2(raw, warnings), migrated: false, warnings }
+  }
+  // v1 tinyStudio & plain Wokwi both look like { version: 1, parts, connections }
+  if (Array.isArray(raw.parts) && Array.isArray(raw.connections)) {
+    return { doc: migrateV1(raw, warnings), migrated: true, warnings }
+  }
+  if (Array.isArray(raw.parts) || Array.isArray(raw.wires)) {
+    // half-formed v2-ish content — salvage what we can
+    return { doc: normalizeV2({ format: 'tinystudio-circuit', version: 2, ...raw }, warnings), migrated: false, warnings }
+  }
+  return { doc: emptyDoc(), migrated: false, warnings: ['Unknown circuit file shape; starting empty.'] }
+}
+
+function normalizeV2(raw: Record<string, unknown>, warnings: string[]): CircuitDoc {
+  const doc = emptyDoc()
+  doc.meta = (raw.meta as CircuitDoc['meta']) ?? doc.meta
+  doc.packs = raw.packs as PackRef[] | undefined
+  doc.netLabels = raw.netLabels as NetLabel[] | undefined
+  doc.sim = raw.sim as CircuitDoc['sim']
+  doc.camera = raw.camera as CircuitDoc['camera']
+
+  const seenPart = new Set<string>()
+  for (const p of (raw.parts as unknown[]) ?? []) {
+    const part = p as CircuitPart
+    if (!part || typeof part.id !== 'string' || typeof part.type !== 'string') {
+      warnings.push('Dropped malformed part entry.')
+      continue
+    }
+    if (seenPart.has(part.id)) {
+      warnings.push(`Duplicate part id "${part.id}" — dropped duplicate.`)
+      continue
+    }
+    seenPart.add(part.id)
+    doc.parts.push(part)
+  }
+
+  const seenWire = new Set<string>()
+  for (const w of (raw.wires as unknown[]) ?? []) {
+    const wire = w as CircuitWire
+    if (!wire || !wire.from || !wire.to || (wire.view !== 'bb' && wire.view !== 'sch')) {
+      warnings.push('Dropped malformed wire entry.')
+      continue
+    }
+    if (!wire.id || seenWire.has(wire.id)) wire.id = newId('w')
+    seenWire.add(wire.id)
+    doc.wires.push(wire)
+  }
+
+  // Preserve unknown top-level keys verbatim (B3).
+  for (const k of Object.keys(raw)) {
+    if (!KNOWN_KEYS.has(k)) {
+      doc.extra = doc.extra || {}
+      doc.extra[k] = raw[k]
+    }
+  }
+  return doc
+}
+
+// ── v1 / Wokwi migration ─────────────────────────────────────────────────────
+
+type V1Conn = [unknown, unknown, string?, string[]?]
+
+/**
+ * Migrate a tinyStudio v1 `diagram.json` or a plain Wokwi diagram into v2.
+ *  - parts left/top → bb placement; v1 `schematic.pos` → sch placement
+ *  - connections → bb wires; v1 `schematic.routes` → sch wires (same endpoints)
+ *  - free {x,y} junction endpoints → resolved to {wire,t} against the *already
+ *    migrated* wires where possible (B9); else dropped with a warning
+ *  - part ids kept (they become refdes-ish; a later renumber can clean up)
+ *  - Wokwi extras (serialMonitor, dependencies…) preserved in `extra`
+ */
+function migrateV1(raw: Record<string, unknown>, warnings: string[]): CircuitDoc {
+  const doc = emptyDoc(typeof raw.author === 'string' ? raw.author : undefined)
+  const sch = (raw.schematic as { pos?: Record<string, [number, number]>; routes?: Record<string, string[]> }) || {}
+
+  for (const p of (raw.parts as Record<string, unknown>[]) ?? []) {
+    if (!p || p.id == null || p.type == null) continue
+    const part: CircuitPart = {
+      id: String(p.id),
+      type: String(p.type),
+      bb: {
+        x: Number(p.left ?? p.x ?? 0),
+        y: Number(p.top ?? p.y ?? 0),
+        ...(p.rotate ? { rotate: (((Number(p.rotate) % 360) + 360) % 360) as 0 | 90 | 180 | 270 } : {})
+      }
+    }
+    const attrs = p.attrs as Record<string, string | number | boolean> | undefined
+    if (attrs && Object.keys(attrs).length) {
+      const { labelOffset, ...rest } = attrs as Record<string, unknown>
+      if (Array.isArray(labelOffset) && part.bb) part.bb.labelOffset = labelOffset as [number, number]
+      if (Object.keys(rest).length) part.attrs = rest as Record<string, string | number | boolean>
+    }
+    const sp = sch.pos?.[part.id]
+    if (sp) part.sch = { x: sp[0], y: sp[1] }
+    doc.parts.push(part)
+  }
+
+  // Pass 1: pin-to-pin wires (junction resolution needs these to exist first).
+  interface Pending {
+    conn: V1Conn
+    key: string
+  }
+  const pending: Pending[] = []
+  const refStr = (r: unknown): string =>
+    typeof r === 'string' ? r : `${(r as Pt).x},${(r as Pt).y}`
+
+  for (const c of (raw.connections as V1Conn[]) ?? []) {
+    if (!Array.isArray(c) || c.length < 2) continue
+    const key = `${refStr(c[0])}>${refStr(c[1])}`
+    if (typeof c[0] === 'string' && typeof c[1] === 'string') {
+      doc.wires.push({
+        id: newId('w'),
+        from: c[0],
+        to: c[1],
+        view: 'bb',
+        color: typeof c[2] === 'string' ? c[2] : undefined,
+        route: normalizeJourney(c[3])
+      })
+      const schRoute = sch.routes?.[key]
+      if (schRoute) {
+        doc.wires.push({ id: newId('w'), from: c[0], to: c[1], view: 'sch', route: schRoute.slice() })
+      }
+    } else {
+      pending.push({ conn: c, key })
+    }
+  }
+
+  // Pass 2: junction endpoints. v1 stored a bare {x,y}; we cannot geometrically
+  // resolve it here without part pin positions (registry lives above core), so
+  // we keep the coordinate as a *pending junction* the editor resolves on first
+  // render (it has geometry there). Encoded as { wire: '', t: -1, x, y } via extra.
+  for (const { conn } of pending) {
+    const [a, b, color, route] = conn
+    const fix = (r: unknown): WireEnd | null => {
+      if (typeof r === 'string') return r
+      if (r && typeof r === 'object' && 'x' in (r as Pt))
+        return { wire: '', t: -1, ...(r as Pt) } as unknown as JunctionEnd
+      return null
+    }
+    const from = fix(a)
+    const to = fix(b)
+    if (!from || !to) {
+      warnings.push('Dropped a v1 connection with unusable endpoints.')
+      continue
+    }
+    doc.wires.push({
+      id: newId('w'),
+      from,
+      to,
+      view: 'bb',
+      color: typeof color === 'string' ? color : undefined,
+      route: normalizeJourney(route)
+    })
+    warnings.push('A junction endpoint was migrated as a pending junction (resolved on first render).')
+  }
+
+  // Preserve Wokwi/foreign keys.
+  for (const k of Object.keys(raw)) {
+    if (!['version', 'editor', 'author', 'parts', 'connections', 'schematic'].includes(k)) {
+      doc.extra = doc.extra || {}
+      doc.extra[k] = raw[k]
+    }
+  }
+  return doc
+}
+
+/**
+ * Normalize a Wokwi journey to source-anchored form (fixes B2).
+ * Wokwi: instructions before "*" run from the source; instructions after "*"
+ * run from the TARGET in reverse order. We fold both halves into a single
+ * source-anchored list by keeping the source half; the target half becomes a
+ * `@` marker consumed by routing.decodeJourney (which needs live endpoints to
+ * finish the fold). To stay dependency-free here we keep the raw list and let
+ * routing handle "*" — this function only trims garbage.
+ */
+export function normalizeJourney(route: unknown): string[] | undefined {
+  if (!Array.isArray(route)) return undefined
+  const out = route.filter(
+    (s) => typeof s === 'string' && (/^[hv]-?[\d.]+$/.test(s) || /^d-?[\d.]+,-?[\d.]+$/.test(s) || s === '*')
+  ) as string[]
+  return out.length ? out : undefined
+}
+
+// ── serialization ────────────────────────────────────────────────────────────
+
+/** Stable-ordered serializer: same input ⇒ same text ⇒ clean git diffs. */
+export function serializeDoc(doc: CircuitDoc): string {
+  const out: Record<string, unknown> = {
+    format: doc.format,
+    version: doc.version,
+    ...(doc.meta ? { meta: doc.meta } : {}),
+    ...(doc.packs?.length ? { packs: doc.packs } : {}),
+    parts: doc.parts.map(serializePart),
+    wires: doc.wires.map(serializeWire),
+    ...(doc.netLabels?.length ? { netLabels: doc.netLabels } : {}),
+    ...(doc.sim && (doc.sim.analyses?.length || doc.sim.probes?.length) ? { sim: doc.sim } : {}),
+    ...(doc.camera ? { camera: doc.camera } : {}),
+    ...(doc.extra || {})
+  }
+  return JSON.stringify(out, null, 2) + '\n'
+}
+
+function serializePart(p: CircuitPart): Record<string, unknown> {
+  return {
+    id: p.id,
+    type: p.type,
+    ...(p.attrs && Object.keys(p.attrs).length ? { attrs: p.attrs } : {}),
+    ...(p.bb ? { bb: serializePlacement(p.bb) } : {}),
+    ...(p.sch ? { sch: serializePlacement(p.sch) } : {})
+  }
+}
+
+function serializePlacement(pl: Placement): Record<string, unknown> {
+  return {
+    x: round2(pl.x),
+    y: round2(pl.y),
+    ...(pl.rotate ? { rotate: pl.rotate } : {}),
+    ...(pl.flip ? { flip: true } : {}),
+    ...(pl.legs && Object.keys(pl.legs).length ? { legs: pl.legs } : {}),
+    ...(pl.labelOffset ? { labelOffset: pl.labelOffset } : {})
+  }
+}
+
+function serializeWire(w: CircuitWire): Record<string, unknown> {
+  return {
+    id: w.id,
+    from: w.from,
+    to: w.to,
+    view: w.view,
+    ...(w.color ? { color: w.color } : {}),
+    ...(w.route?.length ? { route: w.route } : {}),
+    ...(w.curve ? { curve: true } : {})
+  }
+}
+
+export const round2 = (n: number): number => Math.round(n * 100) / 100
+
+// ── queries (pure helpers used by store/commands/views) ──────────────────────
+
+export function partById(doc: CircuitDoc, id: string): CircuitPart | undefined {
+  return doc.parts.find((p) => p.id === id)
+}
+export function wireById(doc: CircuitDoc, id: string): CircuitWire | undefined {
+  return doc.wires.find((w) => w.id === id)
+}
+export function wiresInView(doc: CircuitDoc, view: ViewId): CircuitWire[] {
+  return doc.wires.filter((w) => w.view === view)
+}
+/** All wires touching a part (either endpoint is one of its pins), per view. */
+export function wiresTouchingPart(doc: CircuitDoc, partId: string, view?: ViewId): CircuitWire[] {
+  return doc.wires.filter((w) => {
+    if (view && w.view !== view) return false
+    const hit = (e: WireEnd): boolean => typeof e === 'string' && splitPinRef(e).part === partId
+    return hit(w.from) || hit(w.to)
+  })
+}
+/** Wires whose junction endpoint rides on the given wire. */
+export function junctionRiders(doc: CircuitDoc, hostWireId: string): CircuitWire[] {
+  return doc.wires.filter(
+    (w) =>
+      (isJunction(w.from) && w.from.wire === hostWireId) ||
+      (isJunction(w.to) && w.to.wire === hostWireId)
+  )
+}
diff --git a/src/renderer/src/circuit/core/nets.ts b/src/renderer/src/circuit/core/nets.ts
new file mode 100644
index 0000000..0baa5e5
--- /dev/null
+++ b/src/renderer/src/circuit/core/nets.ts
@@ -0,0 +1,197 @@
+/**
+ * circuit/core/nets — the equipotential net model (the spine of Circuit v2).
+ *
+ * A net is a connected component of the electrical graph over five edge types:
+ *   1. wires        — every wire ties its two endpoints together (BOTH views:
+ *                     the net model is shared; wires are per-view)
+ *   2. junctions    — a {wire,t} endpoint joins the HOST WIRE's net directly
+ *                     (fixes B9: identity-based, no coordinate proximity)
+ *   3. buses        — pins internally common inside a part (breadboard rows,
+ *                     multi-GND boards), supplied by the parts registry
+ *   4. net labels   — schematic labels with the same name share a net (GND…)
+ *   5. implicit     — derived connections supplied by callers (breadboard
+ *                     pin-in-hole seating, M2), as pin-ref pairs
+ *
+ * Successor to lib/circuitNets.ts. Keys are canonical strings (B10 fix: one
+ * canonicalization for everyone — no more refKey/refStr divergence).
+ */
+
+import {
+  isJunction,
+  splitPinRef,
+  type CircuitDoc,
+  type WireEnd
+} from './model'
+
+/** Canonical endpoint key: pins are "part:pin", junctions collapse to the host wire. */
+export function endKey(end: WireEnd): string {
+  return isJunction(end) ? `~w:${end.wire}` : end
+}
+/** Key for a wire's own body (junction riders attach to this). */
+export function wireKey(wireId: string): string {
+  return `~w:${wireId}`
+}
+export function labelKey(labelId: string): string {
+  return `~l:${labelId}`
+}
+
+class DSU {
+  private parent = new Map<string, string>()
+  find(k: string): string {
+    if (!this.parent.has(k)) this.parent.set(k, k)
+    let root = k
+    while (this.parent.get(root) !== root) root = this.parent.get(root)!
+    let cur = k
+    while (this.parent.get(cur) !== root) {
+      const next = this.parent.get(cur)!
+      this.parent.set(cur, root)
+      cur = next
+    }
+    return root
+  }
+  union(a: string, b: string): void {
+    this.parent.set(this.find(a), this.find(b))
+  }
+  keys(): IterableIterator<string> {
+    return this.parent.keys()
+  }
+}
+
+export interface NetModel {
+  /** Pins per net (only "part:pin" members — the electrically meaningful view). */
+  nets: string[][]
+  /** Net name (from labels) per net index, if any. */
+  netNames: (string | undefined)[]
+  pinToNet: Map<string, number>
+  wireToNet: Map<string, number>
+  labelToNet: Map<string, number>
+  /** Count of nets containing 2+ pins. */
+  meaningful: number
+}
+
+export interface BuildNetsOptions {
+  /** Internally-common pin-name groups for a part type (from the registry). */
+  busesFor?: (type: string) => string[][] | undefined
+  /** Derived pin-ref pairs (e.g. breadboard seating): [["R1:1","bb1:e12"], …] */
+  implicit?: [string, string][]
+}
+
+export function buildNets(doc: CircuitDoc, opts: BuildNetsOptions = {}): NetModel {
+  const dsu = new DSU()
+  const allPins = new Set<string>()
+
+  // 1+2. wires and junction endpoints — a wire's body key unions with both of
+  // its endpoints, so a rider on the wire is in the same component.
+  for (const w of doc.wires) {
+    const wk = wireKey(w.id)
+    for (const end of [w.from, w.to]) {
+      const k = endKey(end)
+      dsu.union(wk, k)
+      if (!isJunction(end)) allPins.add(end)
+    }
+  }
+
+  // 3. part-internal buses
+  for (const part of doc.parts) {
+    const buses = opts.busesFor?.(part.type)
+    if (!Array.isArray(buses)) continue
+    for (const group of buses) {
+      for (let i = 1; i < group.length; i++) {
+        const a = `${part.id}:${group[0]}`
+        const b = `${part.id}:${group[i]}`
+        dsu.union(a, b)
+        // NOTE: bus pins are only *listed* in nets when something connects to
+        // them (allPins gate) — a bare breadboard is 0 meaningful nets.
+      }
+    }
+  }
+
+  // 4. net labels: wires attach to a label's virtual pin "<labelId>:1"; that
+  // pin unions with the label key, and same-named labels union together.
+  const byName = new Map<string, string>()
+  for (const l of doc.netLabels ?? []) {
+    const lk = labelKey(l.id)
+    dsu.union(lk, `${l.id}:1`)
+    const prev = byName.get(l.name)
+    if (prev) dsu.union(lk, prev)
+    else byName.set(l.name, lk)
+  }
+
+  // 5. implicit connections (breadboard seating etc.)
+  for (const [a, b] of opts.implicit ?? []) {
+    dsu.union(a, b)
+    allPins.add(a)
+    allPins.add(b)
+  }
+
+  // Assemble components.
+  const rootToNet = new Map<string, number>()
+  const nets: string[][] = []
+  const netNames: (string | undefined)[] = []
+  const pinToNet = new Map<string, number>()
+  const wireToNet = new Map<string, number>()
+  const labelToNet = new Map<string, number>()
+
+  const netFor = (root: string): number => {
+    let idx = rootToNet.get(root)
+    if (idx === undefined) {
+      idx = nets.length
+      rootToNet.set(root, idx)
+      nets.push([])
+      netNames.push(undefined)
+    }
+    return idx
+  }
+
+  for (const pin of allPins) {
+    const idx = netFor(dsu.find(pin))
+    pinToNet.set(pin, idx)
+    nets[idx].push(pin)
+  }
+  for (const w of doc.wires) {
+    wireToNet.set(w.id, netFor(dsu.find(wireKey(w.id))))
+  }
+  for (const l of doc.netLabels ?? []) {
+    const idx = netFor(dsu.find(labelKey(l.id)))
+    labelToNet.set(l.id, idx)
+    if (netNames[idx] === undefined) netNames[idx] = l.name
+  }
+
+  for (const net of nets) net.sort()
+  const meaningful = nets.filter((n) => n.length >= 2).length
+  return { nets, netNames, pinToNet, wireToNet, labelToNet, meaningful }
+}
+
+/** Human description of a net (for tooltips / status): named or by members. */
+export function describeNet(model: NetModel, index: number): string {
+  const name = model.netNames[index]
+  const members = model.nets[index] ?? []
+  if (name) return `${name} (${members.length} pins)`
+  return members.slice(0, 4).join(', ') + (members.length > 4 ? ` +${members.length - 4}` : '')
+}
+
+/** Validate junction endpoints: every rider must reference an existing wire in
+ * the same view, and never (transitively) itself. Returns wire ids to repair. */
+export function danglingJunctions(doc: CircuitDoc): string[] {
+  const byId = new Map(doc.wires.map((w) => [w.id, w]))
+  const bad: string[] = []
+  for (const w of doc.wires) {
+    for (const end of [w.from, w.to]) {
+      if (!isJunction(end)) continue
+      const host = byId.get(end.wire)
+      if (!host || host.view !== w.view || end.wire === w.id) bad.push(w.id)
+    }
+  }
+  return bad
+}
+
+/** Pins of a part actually referenced by any wire (used by ERC + delete cascades). */
+export function connectedPins(doc: CircuitDoc, partId: string): Set<string> {
+  const out = new Set<string>()
+  for (const w of doc.wires) {
+    for (const end of [w.from, w.to]) {
+      if (typeof end === 'string' && splitPinRef(end).part === partId) out.add(splitPinRef(end).pin)
+    }
+  }
+  return out
+}
diff --git a/src/renderer/src/circuit/core/refdes.ts b/src/renderer/src/circuit/core/refdes.ts
new file mode 100644
index 0000000..88dbc2c
--- /dev/null
+++ b/src/renderer/src/circuit/core/refdes.ts
@@ -0,0 +1,57 @@
+/**
+ * circuit/core/refdes — reference-designator assignment (R1, C2, LED3, U4…).
+ * Part ids ARE refdes in circuit.json v2 (§6.4 of the tech spec).
+ */
+
+import type { CircuitDoc } from './model'
+
+/** Family → prefix map (extended by PartDef.prefix when the registry knows better). */
+const FAMILY_PREFIX: Record<string, string> = {
+  passive: 'R',
+  resistor: 'R',
+  capacitor: 'C',
+  inductor: 'L',
+  diode: 'D',
+  led: 'LED',
+  transistor: 'Q',
+  mosfet: 'Q',
+  ic: 'U',
+  microcontroller: 'U',
+  board: 'U',
+  switch: 'SW',
+  button: 'SW',
+  connector: 'J',
+  battery: 'BT',
+  source: 'V',
+  breadboard: 'BB',
+  label: 'NL'
+}
+
+export function prefixForFamily(family?: string, explicit?: string): string {
+  if (explicit) return explicit
+  if (!family) return 'P'
+  const f = family.toLowerCase()
+  for (const key of Object.keys(FAMILY_PREFIX)) {
+    if (f.includes(key)) return FAMILY_PREFIX[key]
+  }
+  return 'P'
+}
+
+/** Next free refdes for a prefix: R1, R2, … (fills gaps only via renumberAll). */
+export function nextRefdes(doc: CircuitDoc, prefix: string): string {
+  let max = 0
+  const re = new RegExp(`^${escapeRe(prefix)}(\\d+)$`)
+  for (const p of doc.parts) {
+    const m = re.exec(p.id)
+    if (m) max = Math.max(max, parseInt(m[1], 10))
+  }
+  return `${prefix}${max + 1}`
+}
+
+export function isValidRefdes(id: string): boolean {
+  return /^[A-Za-z][A-Za-z0-9_-]*$/.test(id)
+}
+
+function escapeRe(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
diff --git a/src/renderer/src/circuit/core/routing.ts b/src/renderer/src/circuit/core/routing.ts
new file mode 100644
index 0000000..2f190f0
--- /dev/null
+++ b/src/renderer/src/circuit/core/routing.ts
@@ -0,0 +1,353 @@
+/**
+ * circuit/core/routing — orthogonal wire routing + bendpoint model.
+ *
+ * Port of `lib/wireRouting.ts` (the tinySchematic/Fritzing-style engine) into
+ * the v2 core, with one behavioral fix and one extension:
+ *
+ *  FIX (B2): Wokwi's "*" journey instruction is honored. Instructions before
+ *  "*" are anchored at the SOURCE pin; instructions after "*" are applied in
+ *  REVERSE from the TARGET pin; the remaining gap is auto-completed with an
+ *  orthogonal elbow — exactly the semantics documented at
+ *  https://docs.wokwi.com/diagram-format#wire-placement-mini-language.
+ *  On serialization we always emit source-anchored lists (valid Wokwi).
+ *
+ *  EXT: `d<dx>,<dy>` diagonal moves (tinyStudio straight-mode extension) are
+ *  decoded/encoded as before; they never co-exist with "*".
+ *
+ * Pure TS. No document knowledge beyond Pt — endpoints are resolved by callers.
+ */
+
+import type { Pt } from './model'
+
+const COINCIDENT = 0.5
+const samePoint = (a: Pt, b: Pt): boolean =>
+  Math.abs(a.x - b.x) < COINCIDENT && Math.abs(a.y - b.y) < COINCIDENT
+
+/** True when an instruction list describes a straight (diagonal-capable) wire. */
+export function isStraightRoute(instr?: string[]): boolean {
+  return !!instr && instr.some((s) => s.startsWith('d'))
+}
+
+/** L-shaped orthogonal path; `endOnMajorAxis` docks the wire into the pin. */
+export function calculateOrthogonalPath(
+  fromX: number,
+  fromY: number,
+  toX: number,
+  toY: number,
+  endOnMajorAxis = false
+): Pt[] {
+  const dx = toX - fromX
+  const dy = toY - fromY
+  const isWide = Math.abs(dx) > Math.abs(dy)
+  const goHorizontalFirst = endOnMajorAxis ? !isWide : isWide
+  if (goHorizontalFirst) {
+    return [
+      { x: fromX, y: fromY },
+      { x: toX, y: fromY },
+      { x: toX, y: toY }
+    ]
+  }
+  return [
+    { x: fromX, y: fromY },
+    { x: fromX, y: toY },
+    { x: toX, y: toY }
+  ]
+}
+
+/** Apply one h/v/d instruction to a cursor; returns null for invalid. */
+function step(cur: Pt, instr: string): Pt | null {
+  if (instr.startsWith('d')) {
+    const [dx, dy] = instr.slice(1).split(',').map(Number)
+    if (Number.isNaN(dx) || Number.isNaN(dy)) return null
+    return { x: cur.x + dx, y: cur.y + dy }
+  }
+  const val = parseFloat(instr.substring(1))
+  if (Number.isNaN(val)) return null
+  if (instr.startsWith('v')) return { x: cur.x, y: cur.y + val }
+  if (instr.startsWith('h')) return { x: cur.x + val, y: cur.y }
+  return null
+}
+
+/**
+ * Decode a journey (possibly containing "*") into the full waypoint list
+ * between live `source` and `target` points — Wokwi semantics (B2 fix):
+ *   pre-"*"  → walked forward from source
+ *   post-"*" → walked in reverse from target
+ *   gap      → auto-completed orthogonally
+ * Journeys without "*" behave exactly like the old decoder.
+ */
+export function decodeJourney(source: Pt, target: Pt, instr?: string[]): Pt[] {
+  const list = instr ?? []
+  const star = list.indexOf('*')
+  const srcInstr = star === -1 ? list : list.slice(0, star)
+  const tgtInstr = star === -1 ? [] : list.slice(star + 1)
+
+  const fromSrc: Pt[] = [{ x: source.x, y: source.y }]
+  for (const s of srcInstr) {
+    const n = step(fromSrc[fromSrc.length - 1], s)
+    if (n) fromSrc.push(n)
+  }
+
+  // Target-side instructions are listed source→target in the file, but are
+  // applied starting at the target walking backward, then the walked chain is
+  // reversed so the polyline reads source→target.
+  const fromTgt: Pt[] = [{ x: target.x, y: target.y }]
+  for (let i = tgtInstr.length - 1; i >= 0; i--) {
+    // walking backward = inverse move
+    const s = tgtInstr[i]
+    const inv = s.startsWith('h')
+      ? `h${-parseFloat(s.slice(1))}`
+      : s.startsWith('v')
+        ? `v${-parseFloat(s.slice(1))}`
+        : null
+    if (!inv) continue
+    const n = step(fromTgt[fromTgt.length - 1], inv)
+    if (n) fromTgt.push(n)
+  }
+  fromTgt.reverse()
+
+  const a = fromSrc[fromSrc.length - 1]
+  const b = fromTgt[0]
+  const mid: Pt[] = samePoint(a, b) ? [] : calculateOrthogonalPath(a.x, a.y, b.x, b.y, false).slice(1, -1)
+  return simplifyWirePoints([...fromSrc, ...mid, ...fromTgt])
+}
+
+/**
+ * Interior bendpoints (absolute) of a wire from its stored journey; points
+ * coincident with the live source/target are endpoints, not bends.
+ */
+export function bendsFromJourney(instr: string[] | undefined, source: Pt, target: Pt): Pt[] {
+  const pts = decodeJourney(source, target, instr)
+  const interior = pts.slice(1)
+  while (interior.length && samePoint(interior[interior.length - 1], target)) interior.pop()
+  while (interior.length && samePoint(interior[0], source)) interior.shift()
+  return interior.map((p) => ({ x: p.x, y: p.y }))
+}
+
+/**
+ * Full rendered point list from live endpoints + fixed interior bends.
+ * Orthogonal wires insert an elbow per segment (final segment on the major
+ * travel axis); straight wires join waypoints directly.
+ */
+export function buildWirePoints(source: Pt, bends: Pt[], target: Pt, straight = false): Pt[] {
+  const waypoints = [source, ...bends, target]
+  if (straight) return simplifyWirePoints(waypoints.map((p) => ({ x: p.x, y: p.y })))
+  const pts: Pt[] = [{ x: waypoints[0].x, y: waypoints[0].y }]
+  for (let i = 1; i < waypoints.length; i++) {
+    const a = waypoints[i - 1]
+    const b = waypoints[i]
+    const ortho = calculateOrthogonalPath(a.x, a.y, b.x, b.y, i === waypoints.length - 1)
+    for (let k = 1; k < ortho.length; k++) pts.push(ortho[k])
+  }
+  return simplifyWirePoints(pts)
+}
+
+/** Rendered polyline for a wire given resolved endpoints and its journey. */
+export function wirePoints(source: Pt, target: Pt, instr?: string[]): Pt[] {
+  const straight = isStraightRoute(instr)
+  if (straight) {
+    const bends = bendsFromJourney(instr, source, target)
+    return buildWirePoints(source, bends, target, true)
+  }
+  return decodeJourney(source, target, instr)
+}
+
+/**
+ * Serialize an absolute point list into a source-anchored journey.
+ * Orthogonal → h/v; straight mode → d moves for diagonal segments.
+ */
+export function journeyFromPoints(points: Pt[], straight = false): string[] {
+  const out: string[] = []
+  const round = (v: number): number => Math.round(v * 1000) / 1000
+  for (let i = 1; i < points.length; i++) {
+    const dx = points[i].x - points[i - 1].x
+    const dy = points[i].y - points[i - 1].y
+    if (straight && Math.abs(dx) > 0.001 && Math.abs(dy) > 0.001) {
+      out.push(`d${round(dx)},${round(dy)}`)
+      continue
+    }
+    if (Math.abs(dx) > 0.001) out.push(`h${round(dx)}`)
+    if (Math.abs(dy) > 0.001) out.push(`v${round(dy)}`)
+  }
+  return out
+}
+
+/** Drop duplicate and collinear points so saved routes stay minimal. */
+export function simplifyWirePoints(points: Pt[]): Pt[] {
+  if (points.length < 3) return points
+  const unique: Pt[] = [points[0]]
+  for (let i = 1; i < points.length; i++) {
+    const prev = unique[unique.length - 1]
+    if (Math.abs(points[i].x - prev.x) > 0.001 || Math.abs(points[i].y - prev.y) > 0.001)
+      unique.push(points[i])
+  }
+  if (unique.length < 3) return unique
+  const simple: Pt[] = [unique[0]]
+  for (let i = 1; i < unique.length - 1; i++) {
+    const prev = simple[simple.length - 1]
+    const curr = unique[i]
+    const next = unique[i + 1]
+    const horizontal = Math.abs(prev.y - curr.y) < 0.001 && Math.abs(curr.y - next.y) < 0.001
+    const vertical = Math.abs(prev.x - curr.x) < 0.001 && Math.abs(curr.x - next.x) < 0.001
+    if (!horizontal && !vertical) simple.push(curr)
+  }
+  simple.push(unique[unique.length - 1])
+  return simple
+}
+
+/**
+ * Drag a whole segment perpendicular to itself; anchored endpoints grow a new
+ * corner instead of moving (pulls a straight wire into a "U").
+ */
+export function dragSegment(
+  points: Pt[],
+  index: number,
+  axis: 'horizontal' | 'vertical',
+  newX: number,
+  newY: number
+): Pt[] {
+  const cl = (p: Pt): Pt => ({ x: p.x, y: p.y })
+  const a = points[index]
+  const b = points[index + 1]
+  const isFirst = index === 0
+  const isLast = index + 1 === points.length - 1
+  let na: Pt
+  let nb: Pt
+  if (axis === 'horizontal') {
+    na = { x: a.x, y: newY }
+    nb = { x: b.x, y: newY }
+  } else {
+    na = { x: newX, y: a.y }
+    nb = { x: newX, y: b.y }
+  }
+  const head = points.slice(0, index).map(cl)
+  const tail = points.slice(index + 2).map(cl)
+  const mid: Pt[] = []
+  if (isFirst) mid.push(cl(a))
+  mid.push(na, nb)
+  if (isLast) mid.push(cl(b))
+  return [...head, ...mid, ...tail]
+}
+
+/** Keep neighbours orthogonal while dragging an interior vertex. */
+export function vertexDrag(orig: Pt[], index: number, x: number, y: number): Pt[] {
+  const points = orig.map((p) => ({ x: p.x, y: p.y }))
+  points[index].x = x
+  points[index].y = y
+  if (index > 0) {
+    if (Math.abs(points[index - 1].y - points[index].y) < Math.abs(points[index - 1].x - points[index].x)) {
+      if (index - 1 > 0) points[index - 1].y = points[index].y
+      else points[index].y = points[index - 1].y
+    } else {
+      if (index - 1 > 0) points[index - 1].x = points[index].x
+      else points[index].x = points[index - 1].x
+    }
+  }
+  if (index < points.length - 1) {
+    if (Math.abs(points[index + 1].y - points[index].y) < Math.abs(points[index + 1].x - points[index].x)) {
+      if (index + 1 < points.length - 1) points[index + 1].y = points[index].y
+      else points[index].y = points[index + 1].y
+    } else {
+      if (index + 1 < points.length - 1) points[index + 1].x = points[index].x
+      else points[index].x = points[index + 1].x
+    }
+  }
+  return points
+}
+
+// ── hit testing / junctions ──────────────────────────────────────────────────
+
+export function distanceToSegment(p: Pt, v: Pt, w: Pt): number {
+  const l2 = (v.x - w.x) ** 2 + (v.y - w.y) ** 2
+  if (l2 === 0) return Math.hypot(p.x - v.x, p.y - v.y)
+  let t = ((p.x - v.x) * (w.x - v.x) + (p.y - v.y) * (w.y - v.y)) / l2
+  t = Math.max(0, Math.min(1, t))
+  return Math.hypot(p.x - (v.x + t * (w.x - v.x)), p.y - (v.y + t * (w.y - v.y)))
+}
+
+/** Clamp a point onto an axis-aligned segment (junction drops). */
+export function clampOntoSegment(p1: Pt, p2: Pt, x: number, y: number): Pt {
+  if (Math.abs(p1.x - p2.x) > 0.1) {
+    return { x: Math.max(Math.min(x, Math.max(p1.x, p2.x)), Math.min(p1.x, p2.x)), y: p1.y }
+  }
+  return { x: p1.x, y: Math.max(Math.min(y, Math.max(p1.y, p2.y)), Math.min(p1.y, p2.y)) }
+}
+
+/** Total polyline length. */
+export function polylineLength(pts: Pt[]): number {
+  let l = 0
+  for (let i = 1; i < pts.length; i++) l += Math.hypot(pts[i].x - pts[i - 1].x, pts[i].y - pts[i - 1].y)
+  return l
+}
+
+/** Point at parametric position t (0..1 by length) along a polyline. */
+export function pointAtT(pts: Pt[], t: number): Pt {
+  if (pts.length === 0) return { x: 0, y: 0 }
+  if (pts.length === 1 || t <= 0) return { ...pts[0] }
+  const total = polylineLength(pts)
+  if (total === 0 || t >= 1) return { ...pts[pts.length - 1] }
+  let remain = t * total
+  for (let i = 1; i < pts.length; i++) {
+    const seg = Math.hypot(pts[i].x - pts[i - 1].x, pts[i].y - pts[i - 1].y)
+    if (remain <= seg) {
+      const f = seg === 0 ? 0 : remain / seg
+      return {
+        x: pts[i - 1].x + (pts[i].x - pts[i - 1].x) * f,
+        y: pts[i - 1].y + (pts[i].y - pts[i - 1].y) * f
+      }
+    }
+    remain -= seg
+  }
+  return { ...pts[pts.length - 1] }
+}
+
+/** Parametric position (0..1 by length) of the point on the polyline nearest to p. */
+export function tAtPoint(pts: Pt[], p: Pt): number {
+  const total = polylineLength(pts)
+  if (total === 0) return 0
+  let best = 0
+  let bestDist = Infinity
+  let walked = 0
+  for (let i = 1; i < pts.length; i++) {
+    const v = pts[i - 1]
+    const w = pts[i]
+    const seg = Math.hypot(w.x - v.x, w.y - v.y)
+    const l2 = seg * seg
+    let t = l2 === 0 ? 0 : ((p.x - v.x) * (w.x - v.x) + (p.y - v.y) * (w.y - v.y)) / l2
+    t = Math.max(0, Math.min(1, t))
+    const q = { x: v.x + t * (w.x - v.x), y: v.y + t * (w.y - v.y) }
+    const d = Math.hypot(p.x - q.x, p.y - q.y)
+    if (d < bestDist) {
+      bestDist = d
+      best = (walked + t * seg) / total
+    }
+    walked += seg
+  }
+  return best
+}
+
+export interface WireHit {
+  id: string
+  segmentIndex: number
+  p1: Pt
+  p2: Pt
+}
+
+/** Topmost wire whose body lies within hitDist (zoom-scaled) of (mx,my). */
+export function hitWire(
+  mx: number,
+  my: number,
+  wires: { id: string; points: Pt[] }[],
+  zoom: number
+): WireHit | null {
+  const hitDist = 6 / zoom
+  for (let i = wires.length - 1; i >= 0; i--) {
+    const { id, points } = wires[i]
+    for (let j = 0; j < points.length - 1; j++) {
+      if (distanceToSegment({ x: mx, y: my }, points[j], points[j + 1]) < hitDist) {
+        return { id, segmentIndex: j, p1: points[j], p2: points[j + 1] }
+      }
+    }
+  }
+  return null
+}
diff --git a/src/renderer/src/circuit/core/store.ts b/src/renderer/src/circuit/core/store.ts
new file mode 100644
index 0000000..3b510fa
--- /dev/null
+++ b/src/renderer/src/circuit/core/store.ts
@@ -0,0 +1,145 @@
+/**
+ * circuit/core/store — CircuitStore: document state + undo/redo + subscriptions.
+ *
+ * The store holds the parsed document (immutable snapshots — commands return
+ * new docs with structural sharing) and an undo/redo stack of previous
+ * snapshots. Because snapshots share structure, memory cost per step is the
+ * delta, not a copy. Merge keys collapse drag gestures into one step.
+ *
+ * React binds via `useSyncExternalStore(store.subscribe, store.getRevision)`.
+ * File I/O is the caller's job: `serialize()` for saves (debounce upstream),
+ * `replaceFromFile()` when the file changes externally (Code-tab edits).
+ */
+
+import type { Command } from './commands'
+import {
+  parseCircuitFile,
+  serializeDoc,
+  type CircuitDoc
+} from './model'
+
+const MAX_UNDO = 200
+/** Consecutive same-mergeKey commands within this window merge (ms). */
+const MERGE_WINDOW = 1200
+
+interface UndoEntry {
+  doc: CircuitDoc
+  label: string
+  mergeKey?: string
+  at: number
+}
+
+export class CircuitStore {
+  private doc: CircuitDoc
+  private undoStack: UndoEntry[] = []
+  private redoStack: UndoEntry[] = []
+  private revision = 0
+  private listeners = new Set<() => void>()
+  /** Last text produced by serialize()/accepted by replaceFromFile — echo guard. */
+  private lastText: string | null = null
+
+  constructor(doc: CircuitDoc) {
+    this.doc = doc
+  }
+
+  static fromFile(text: string): { store: CircuitStore; migrated: boolean; warnings: string[] } {
+    const { doc, migrated, warnings } = parseCircuitFile(text)
+    const store = new CircuitStore(doc)
+    if (!migrated) store.lastText = text
+    return { store, migrated, warnings }
+  }
+
+  // ── access ────────────────────────────────────────────────────────────────
+
+  getDoc(): CircuitDoc {
+    return this.doc
+  }
+  /** Monotonic change counter — cheap useSyncExternalStore snapshot. */
+  getRevision = (): number => this.revision
+
+  subscribe = (fn: () => void): (() => void) => {
+    this.listeners.add(fn)
+    return () => this.listeners.delete(fn)
+  }
+
+  private notify(): void {
+    this.revision++
+    for (const fn of this.listeners) fn()
+  }
+
+  // ── mutation ──────────────────────────────────────────────────────────────
+
+  dispatch(cmd: Command): void {
+    const next = cmd.apply(this.doc)
+    if (next === this.doc) return // no-op command (guards, merges into nothing)
+
+    const now = Date.now()
+    const top = this.undoStack[this.undoStack.length - 1]
+    const merged =
+      cmd.mergeKey !== undefined &&
+      top?.mergeKey === cmd.mergeKey &&
+      now - top.at < MERGE_WINDOW
+
+    if (!merged) {
+      this.undoStack.push({ doc: this.doc, label: cmd.label, mergeKey: cmd.mergeKey, at: now })
+      if (this.undoStack.length > MAX_UNDO) this.undoStack.shift()
+    } else if (top) {
+      top.at = now // keep the ORIGINAL pre-gesture doc; just extend the window
+    }
+    this.redoStack = []
+    this.doc = next
+    this.notify()
+  }
+
+  canUndo(): boolean {
+    return this.undoStack.length > 0
+  }
+  canRedo(): boolean {
+    return this.redoStack.length > 0
+  }
+  undoLabel(): string | undefined {
+    return this.undoStack[this.undoStack.length - 1]?.label
+  }
+
+  undo(): void {
+    const entry = this.undoStack.pop()
+    if (!entry) return
+    this.redoStack.push({ doc: this.doc, label: entry.label, at: Date.now() })
+    this.doc = entry.doc
+    this.notify()
+  }
+
+  redo(): void {
+    const entry = this.redoStack.pop()
+    if (!entry) return
+    this.undoStack.push({ doc: this.doc, label: entry.label, at: Date.now() })
+    this.doc = entry.doc
+    this.notify()
+  }
+
+  // ── file sync ─────────────────────────────────────────────────────────────
+
+  /** Serialize the current doc; remembers the text to recognize echoes. */
+  serialize(): string {
+    const text = serializeDoc(this.doc)
+    this.lastText = text
+    return text
+  }
+
+  /**
+   * The file changed outside the editor (Code tab / disk). If it's our own
+   * echo, ignore. Otherwise adopt it as a new undoable state (the user can
+   * undo a bad hand-edit).
+   */
+  replaceFromFile(text: string): { applied: boolean; warnings: string[] } {
+    if (text === this.lastText) return { applied: false, warnings: [] }
+    const { doc, warnings } = parseCircuitFile(text)
+    this.undoStack.push({ doc: this.doc, label: 'Edit as code', at: Date.now() })
+    if (this.undoStack.length > MAX_UNDO) this.undoStack.shift()
+    this.redoStack = []
+    this.doc = doc
+    this.lastText = text
+    this.notify()
+    return { applied: true, warnings }
+  }
+}
diff --git a/src/renderer/src/circuit/index.ts b/src/renderer/src/circuit/index.ts
new file mode 100644
index 0000000..3163975
--- /dev/null
+++ b/src/renderer/src/circuit/index.ts
@@ -0,0 +1,29 @@
+/**
+ * circuit/ — public API of the Circuit View v2 module.
+ *
+ * Everything outside this folder should import from here (or from
+ * `circuit/views/CircuitView` for the React mount) — internals may reshuffle.
+ *
+ * Feature flag (M0–M3): localStorage `tinystudio.circuitV2` = '1' switches the
+ * Circuit tab from the legacy DiagramEditor to the v2 module. Flip it from
+ * DevTools:  localStorage.setItem('tinystudio.circuitV2', '1')
+ */
+
+export * from './core/model'
+export * as routing from './core/routing'
+export { buildNets, describeNet, danglingJunctions, endKey, wireKey } from './core/nets'
+export type { NetModel, BuildNetsOptions } from './core/nets'
+export * as commands from './core/commands'
+export { CircuitStore } from './core/store'
+export * from './core/geometry'
+export * from './core/refdes'
+
+export const CIRCUIT_V2_FLAG = 'tinystudio.circuitV2'
+
+export function circuitV2Enabled(): boolean {
+  try {
+    return globalThis.localStorage?.getItem(CIRCUIT_V2_FLAG) === '1'
+  } catch {
+    return false
+  }
+}
diff --git a/src/renderer/src/circuit/views/CircuitView.tsx b/src/renderer/src/circuit/views/CircuitView.tsx
new file mode 100644
index 0000000..55a44f1
--- /dev/null
+++ b/src/renderer/src/circuit/views/CircuitView.tsx
@@ -0,0 +1,337 @@
+/**
+ * circuit/views/CircuitView — the v2 Circuit View shell (M0: read-only preview).
+ *
+ * M0 scope: prove the core end-to-end inside the real IDE window slot —
+ * parse (with v1/Wokwi migration) → store → net model → render parts + wires
+ * on the tinyStudio dot-grid canvas with fit/zoom/pan. NO editing yet (M1).
+ * Part visuals come from the existing partsLibrary as a temporary adapter
+ * until the v2 parts registry lands (M2).
+ *
+ * Mounted by EditorPanel behind the `tinystudio.circuitV2` flag, in the same
+ * window space the legacy DiagramEditor occupies — desktop and web builds.
+ */
+
+import { CircuitBoard, Maximize, ZoomIn, ZoomOut } from 'lucide-react'
+import React from 'react'
+import { ensureParts, getPart, viewFor } from '../../lib/partsLibrary'
+import {
+  isJunction,
+  splitPinRef,
+  type CircuitDoc,
+  type CircuitWire,
+  type Pt,
+  type WireEnd
+} from '../core/model'
+import { pinWorld } from '../core/geometry'
+import { buildNets } from '../core/nets'
+import { pointAtT, wirePoints } from '../core/routing'
+import { CircuitStore } from '../core/store'
+
+const WIRE_W = 2.8
+const WIRE_OUTLINE_W = WIRE_W + 1.8
+
+function darken(hex: string, f = 0.55): string {
+  const m = /^#?([0-9a-fA-F]{6})$/.exec(hex.trim())
+  if (!m) return 'rgba(0,0,0,0.45)'
+  const n = parseInt(m[1], 16)
+  return `rgb(${Math.round(((n >> 16) & 255) * f)}, ${Math.round(((n >> 8) & 255) * f)}, ${Math.round((n & 255) * f)})`
+}
+
+function roundedPath(points: Pt[], r = 4): string {
+  if (points.length < 2) return ''
+  if (points.length === 2) return `M${points[0].x} ${points[0].y} L${points[1].x} ${points[1].y}`
+  let d = `M${points[0].x} ${points[0].y}`
+  for (let i = 1; i < points.length - 1; i++) {
+    const p = points[i - 1]
+    const c = points[i]
+    const n = points[i + 1]
+    const d1 = Math.hypot(c.x - p.x, c.y - p.y) || 1
+    const d2 = Math.hypot(n.x - c.x, n.y - c.y) || 1
+    const rr = Math.max(0, Math.min(r, d1 / 2, d2 / 2))
+    const a = { x: c.x - ((c.x - p.x) / d1) * rr, y: c.y - ((c.y - p.y) / d1) * rr }
+    const b = { x: c.x + ((n.x - c.x) / d2) * rr, y: c.y + ((n.y - c.y) / d2) * rr }
+    d += ` L${a.x} ${a.y} Q${c.x} ${c.y} ${b.x} ${b.y}`
+  }
+  const last = points[points.length - 1]
+  d += ` L${last.x} ${last.y}`
+  return d
+}
+
+/** Resolve a wire endpoint to a world point using the legacy parts adapter. */
+function makeResolver(doc: CircuitDoc): (end: WireEnd, seen?: Set<string>) => Pt | null {
+  const wireById = new Map(doc.wires.map((w) => [w.id, w]))
+  const resolve = (end: WireEnd, seen: Set<string> = new Set()): Pt | null => {
+    if (isJunction(end)) {
+      // pending v1-migrated junction carries raw coords
+      const raw = end as unknown as { x?: number; y?: number; wire: string; t: number }
+      if (end.wire === '' && raw.x !== undefined) return { x: raw.x!, y: raw.y! }
+      if (seen.has(end.wire)) return null
+      seen.add(end.wire)
+      const host = wireById.get(end.wire)
+      if (!host) return null
+      const pts = resolveWire(host, seen)
+      return pts ? pointAtT(pts, end.t) : null
+    }
+    const { part: partId, pin } = splitPinRef(end)
+    const part = doc.parts.find((p) => p.id === partId)
+    if (!part?.bb) return null
+    const def = getPart(part.type)
+    const v = def && viewFor(def, 'breadboard')
+    const local = v?.pins[pin]
+    if (!v || !local) return null
+    return pinWorld(local, part.bb, v.w, v.h, part.bb.legs?.[pin])
+  }
+  const resolveWire = (w: CircuitWire, seen: Set<string>): Pt[] | null => {
+    const s = resolve(w.from, seen)
+    const t = resolve(w.to, seen)
+    if (!s || !t) return null
+    return wirePoints(s, t, w.route)
+  }
+  return resolve
+}
+
+export function CircuitViewV2({ content }: { content: string }): React.JSX.Element {
+  const [{ store, migrated, warnings }] = React.useState(() => CircuitStore.fromFile(content))
+  const revision = React.useSyncExternalStore(store.subscribe, store.getRevision)
+  const doc = store.getDoc()
+  const [, force] = React.useReducer((n: number) => n + 1, 0)
+  const [cam, setCam] = React.useState({ scale: 1, tx: 40, ty: 40 })
+  const viewRef = React.useRef<HTMLDivElement>(null)
+  const pan = React.useRef<Pt | null>(null)
+  const didFit = React.useRef(false)
+
+  // adopt external content changes (Code tab)
+  React.useEffect(() => {
+    store.replaceFromFile(content)
+  }, [content, store])
+
+  // lazy-load part defs through the legacy adapter
+  React.useEffect(() => {
+    const missing = doc.parts.map((p) => p.type).filter((t) => !getPart(t))
+    if (missing.length) ensureParts(missing).then(force)
+  }, [doc.parts])
+
+  const resolve = React.useMemo(() => makeResolver(doc), [doc, revision])
+  const nets = React.useMemo(() => buildNets(doc), [doc])
+
+  const wireGeom = React.useMemo(() => {
+    return doc.wires
+      .filter((w) => w.view === 'bb')
+      .map((w) => {
+        const s = resolve(w.from)
+        const t = resolve(w.to)
+        return { w, pts: s && t ? wirePoints(s, t, w.route) : [] }
+      })
+  }, [doc, resolve])
+
+  const fit = React.useCallback((): void => {
+    const el = viewRef.current
+    if (!el) return
+    let minX = Infinity
+    let minY = Infinity
+    let maxX = -Infinity
+    let maxY = -Infinity
+    for (const part of doc.parts) {
+      if (!part.bb) continue
+      const def = getPart(part.type)
+      const v = def && viewFor(def, 'breadboard')
+      if (!v) continue
+      minX = Math.min(minX, part.bb.x)
+      minY = Math.min(minY, part.bb.y)
+      maxX = Math.max(maxX, part.bb.x + v.w)
+      maxY = Math.max(maxY, part.bb.y + v.h)
+    }
+    for (const { pts } of wireGeom)
+      for (const p of pts) {
+        minX = Math.min(minX, p.x)
+        minY = Math.min(minY, p.y)
+        maxX = Math.max(maxX, p.x)
+        maxY = Math.max(maxY, p.y)
+      }
+    if (!isFinite(minX)) return
+    const pad = 48
+    const bw = maxX - minX + pad * 2
+    const bh = maxY - minY + pad * 2
+    const f = Math.max(0.25, Math.min(3, Math.min(el.clientWidth / bw, el.clientHeight / bh)))
+    setCam({
+      scale: f,
+      tx: (el.clientWidth - bw * f) / 2 - (minX - pad) * f,
+      ty: (el.clientHeight - bh * f) / 2 - (minY - pad) * f
+    })
+  }, [doc, wireGeom])
+
+  React.useEffect(() => {
+    if (didFit.current) return
+    if (doc.parts.length === 0 || doc.parts.every((p) => getPart(p.type))) {
+      fit()
+      didFit.current = true
+    }
+  })
+
+  const zoomAt = (factor: number, sx: number, sy: number): void =>
+    setCam((c) => {
+      const ns = Math.max(0.25, Math.min(3, c.scale * factor))
+      const k = ns / c.scale
+      return { scale: ns, tx: sx - (sx - c.tx) * k, ty: sy - (sy - c.ty) * k }
+    })
+
+  const tool =
+    'tactile-bordered h-8 px-2.5 flex items-center gap-1.5 rounded-md bg-surface-card text-text-muted text-xs hover:text-text-body active:translate-y-px'
+
+  return (
+    <div className="size-full relative overflow-hidden bg-bg-sunken">
+      {/* v2 badge + status */}
+      <div className="absolute top-3 left-3 z-10 flex gap-1.5 items-center">
+        <span className="px-2.5 py-1 rounded-full bg-surface-card border border-brand/40 text-brand text-[11px] font-semibold">
+          Circuit v2 preview
+        </span>
+        {migrated && (
+          <span className="px-2.5 py-1 rounded-full bg-surface-card border border-border-default text-text-muted text-[11px]">
+            migrated from diagram.json (in memory)
+          </span>
+        )}
+      </div>
+      <div className="absolute bottom-3 right-3.5 z-10 flex gap-1.5">
+        <button className={`${tool} w-8 justify-center px-0`} onClick={() => {
+          const el = viewRef.current
+          if (el) zoomAt(1 / 1.15, el.clientWidth / 2, el.clientHeight / 2)
+        }} title="Zoom out">
+          <ZoomOut size={15} />
+        </button>
+        <span className={`${tool} pointer-events-none min-w-[52px] justify-center`}>
+          {Math.round(cam.scale * 100)}%
+        </span>
+        <button className={`${tool} w-8 justify-center px-0`} onClick={() => {
+          const el = viewRef.current
+          if (el) zoomAt(1.15, el.clientWidth / 2, el.clientHeight / 2)
+        }} title="Zoom in">
+          <ZoomIn size={15} />
+        </button>
+        <button className={`${tool} w-8 justify-center px-0`} onClick={fit} title="Fit to view">
+          <Maximize size={15} />
+        </button>
+      </div>
+      <div className="absolute bottom-3 left-3 z-10 flex gap-2 text-[11px]">
+        <span className="px-2.5 py-1 rounded-full bg-surface-card border border-border-default text-text-body">
+          Parts: {doc.parts.length} · Wires: {doc.wires.length} · Nets: {nets.meaningful}
+        </span>
+        {warnings.length > 0 && (
+          <span className="px-2.5 py-1 rounded-full bg-surface-card border border-status-warning/40 text-status-warning" title={warnings.join('\n')}>
+            {warnings.length} migration note{warnings.length > 1 ? 's' : ''}
+          </span>
+        )}
+      </div>
+
+      <div
+        ref={viewRef}
+        className="size-full"
+        style={{
+          touchAction: 'none',
+          backgroundImage: 'radial-gradient(var(--dot-color) 1.1px, transparent 1.1px)',
+          backgroundSize: `${9.6 * cam.scale}px ${9.6 * cam.scale}px`,
+          backgroundPosition: `${cam.tx}px ${cam.ty}px`
+        }}
+        onWheel={(e) => {
+          const r = viewRef.current!.getBoundingClientRect()
+          zoomAt(e.deltaY < 0 ? 1.12 : 1 / 1.12, e.clientX - r.left, e.clientY - r.top)
+        }}
+        onPointerDown={(e) => {
+          if (e.button !== 1 && !(e.button === 0 && e.altKey) && e.button !== 0) return
+          pan.current = { x: e.clientX, y: e.clientY }
+          ;(e.target as HTMLElement).setPointerCapture(e.pointerId)
+        }}
+        onPointerMove={(e) => {
+          const p = pan.current
+          if (!p) return
+          setCam((c) => ({ ...c, tx: c.tx + (e.clientX - p.x), ty: c.ty + (e.clientY - p.y) }))
+          pan.current = { x: e.clientX, y: e.clientY }
+        }}
+        onPointerUp={() => (pan.current = null)}
+      >
+        <div
+          style={{
+            position: 'absolute',
+            left: 0,
+            top: 0,
+            transform: `translate(${cam.tx}px, ${cam.ty}px) scale(${cam.scale})`,
+            transformOrigin: '0 0'
+          }}
+        >
+          {/* parts */}
+          {doc.parts.map((part) => {
+            if (!part.bb) return null
+            const def = getPart(part.type)
+            const v = def && viewFor(def, 'breadboard')
+            if (!v) {
+              return (
+                <div
+                  key={part.id}
+                  style={{ position: 'absolute', left: part.bb.x, top: part.bb.y }}
+                  className="px-2 py-1 rounded bg-surface-card border border-border-default text-[10px] text-text-faint"
+                >
+                  {part.type}…
+                </div>
+              )
+            }
+            return (
+              <div
+                key={part.id}
+                style={{
+                  position: 'absolute',
+                  left: part.bb.x,
+                  top: part.bb.y,
+                  width: v.w,
+                  height: v.h,
+                  transform: part.bb.rotate ? `rotate(${part.bb.rotate}deg)` : undefined,
+                  transformOrigin: 'center'
+                }}
+              >
+                <div
+                  className="size-full [&>svg]:size-full [&>svg]:block pointer-events-none select-none"
+                  dangerouslySetInnerHTML={{ __html: v.svg }}
+                />
+                <div
+                  className="absolute text-[11px] whitespace-nowrap select-none text-text-muted"
+                  style={{ left: 0, top: v.h + 4 }}
+                >
+                  {part.id}
+                </div>
+              </div>
+            )
+          })}
+
+          {/* wires */}
+          <svg style={{ position: 'absolute', inset: 0, overflow: 'visible', pointerEvents: 'none' }}>
+            {wireGeom.map(({ w, pts }) => {
+              if (pts.length < 2) return null
+              const core = w.color || '#2fa46a'
+              const d = roundedPath(pts)
+              return (
+                <g key={w.id}>
+                  <path d={d} fill="none" stroke={darken(core)} strokeWidth={WIRE_OUTLINE_W} strokeLinejoin="round" strokeLinecap="round" />
+                  <path d={d} fill="none" stroke={core} strokeWidth={WIRE_W} strokeLinejoin="round" strokeLinecap="round" />
+                </g>
+              )
+            })}
+            {/* junction dots */}
+            {doc.wires.flatMap((w) =>
+              [w.from, w.to]
+                .filter(isJunction)
+                .map((j, i) => {
+                  const p = resolve(j)
+                  return p ? <circle key={`${w.id}j${i}`} cx={p.x} cy={p.y} r={3} fill={w.color || 'var(--text-strong)'} /> : null
+                })
+            )}
+          </svg>
+
+          {doc.parts.length === 0 && (
+            <div className="absolute flex flex-col items-center gap-2 text-text-faint text-sm text-center" style={{ left: 200, top: 160, width: 320 }}>
+              <CircuitBoard size={42} />
+              <div>Circuit v2 — empty document. Editing lands in M1.</div>
+            </div>
+          )}
+        </div>
+      </div>
+    </div>
+  )
+}
diff --git a/src/renderer/src/components/EditorPanel.tsx b/src/renderer/src/components/EditorPanel.tsx
index 30edd1b..f441628 100644
--- a/src/renderer/src/components/EditorPanel.tsx
+++ b/src/renderer/src/components/EditorPanel.tsx
@@ -34,6 +34,8 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { notify as toast } from '@renderer/lib/notify'
 import { BlocklyEditor } from './BlocklyEditor'
 import { DiagramEditor } from './DiagramEditor'
+import { circuitV2Enabled } from '../circuit'
+import { CircuitViewV2 } from '../circuit/views/CircuitView'
 import { MonacoEditor, MonacoEditorRef } from './MonacoEditor'
 import {
   Dialog,
@@ -369,6 +371,12 @@ function CircuitView(): React.JSX.Element {
   if (!workspace) return <EmptyHint icon="circuit" label="Open a project to design its circuit." />
   if (!file) return <LoadingHint label="Loading circuit…" />
 
+  // Circuit View v2 (docs/circuit-view-tech-spec.md) — same window slot, both
+  // desktop and web builds. Enable: localStorage.setItem('tinystudio.circuitV2','1')
+  if (circuitV2Enabled()) {
+    return <CircuitViewV2 content={file.content} />
+  }
+
   return (
     <DiagramEditor
       content={file.content}

From f12699acdac1419a5cfe0a1ab914ab6b40561a20 Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Fri, 3 Jul 2026 15:32:42 +0000
Subject: [PATCH 02/27] =?UTF-8?q?Circuit=20v2=20M1:=20core=20additions=20?=
 =?UTF-8?q?=E2=80=94=20clipboard=20fragments,=20composite=20mergeKey,=20pe?=
 =?UTF-8?q?nding-junction=20typing?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- core/clipboard.ts: buildClipboard (fixpoint filtering of junction riders),
  parseClipboard (shape-detected JSON), materializePaste (fresh refdes ids,
  endpoint rewrite, placement offset)
- commands.composite() gains an optional mergeKey so multi-part drag frames
  collapse into one undo step like single-part gestures
- model: PendingJunctionEnd + isPendingJunction for v1-migrated free-point
  endpoints awaiting geometric resolution
- 18 new tests (53 total)
---
 .../src/circuit/__tests__/clipboard.test.ts   |  90 ++++++++++
 src/renderer/src/circuit/__tests__/m1.test.ts |  84 ++++++++++
 src/renderer/src/circuit/core/clipboard.ts    | 157 ++++++++++++++++++
 src/renderer/src/circuit/core/commands.ts     |   7 +-
 src/renderer/src/circuit/core/model.ts        |  14 ++
 5 files changed, 350 insertions(+), 2 deletions(-)
 create mode 100644 src/renderer/src/circuit/__tests__/clipboard.test.ts
 create mode 100644 src/renderer/src/circuit/__tests__/m1.test.ts
 create mode 100644 src/renderer/src/circuit/core/clipboard.ts

diff --git a/src/renderer/src/circuit/__tests__/clipboard.test.ts b/src/renderer/src/circuit/__tests__/clipboard.test.ts
new file mode 100644
index 0000000..48ae5d8
--- /dev/null
+++ b/src/renderer/src/circuit/__tests__/clipboard.test.ts
@@ -0,0 +1,90 @@
+/** Tests for core/clipboard — copy payload rules + paste re-iding. */
+
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { buildClipboard, materializePaste, parseClipboard, CLIPBOARD_FORMAT } from '../core/clipboard'
+import { emptyDoc, type CircuitDoc, type JunctionEnd } from '../core/model'
+
+function fixture(): CircuitDoc {
+  const doc = emptyDoc()
+  doc.parts = [
+    { id: 'R1', type: 'resistor', attrs: { value: '220' }, bb: { x: 96, y: 96 } },
+    { id: 'R2', type: 'resistor', bb: { x: 192, y: 96 } },
+    { id: 'LED1', type: 'led-generic-5mm', bb: { x: 288, y: 96 } }
+  ]
+  doc.wires = [
+    { id: 'w1', from: 'R1:2', to: 'R2:1', view: 'bb', color: '#2fa46a' },
+    { id: 'w2', from: 'R2:2', to: 'LED1:anode', view: 'bb' },
+    { id: 'w3', from: 'LED1:cathode', to: { wire: 'w1', t: 0.5 }, view: 'bb' }
+  ]
+  return doc
+}
+
+test('buildClipboard keeps only wires fully inside the selection', () => {
+  const doc = fixture()
+  const payload = buildClipboard(doc, ['R1', 'R2'])!
+  assert.equal(payload.parts.length, 2)
+  // w1 is between R1 and R2 → kept; w2 leaves the selection → dropped;
+  // w3 is a junction on w1 but its pin end (LED1) is outside → dropped.
+  assert.deepEqual(payload.wires.map((w) => w.id), ['w1'])
+})
+
+test('buildClipboard keeps junction riders when the host and both parts are in', () => {
+  const doc = fixture()
+  const payload = buildClipboard(doc, ['R1', 'R2', 'LED1'])!
+  assert.equal(payload.wires.length, 3)
+})
+
+test('buildClipboard drops junction riders whose host wire is dropped (fixpoint)', () => {
+  const doc = fixture()
+  // select all parts but explicitly only wire w3 — its host w1 is a candidate
+  // via both-pins-selected, so w3 survives; then remove R2 → w1 dies → w3 dies.
+  const p1 = buildClipboard(doc, ['R1', 'R2', 'LED1'], ['w3'])!
+  assert.ok(p1.wires.some((w) => w.id === 'w3'))
+  const p2 = buildClipboard(doc, ['R1', 'LED1'], ['w3'])
+  assert.ok(!p2 || !p2.wires.some((w) => w.id === 'w3'))
+})
+
+test('parseClipboard round-trips and rejects foreign text', () => {
+  const doc = fixture()
+  const payload = buildClipboard(doc, ['R1', 'R2'])!
+  const back = parseClipboard(JSON.stringify(payload))!
+  assert.equal(back.format, CLIPBOARD_FORMAT)
+  assert.equal(back.parts.length, 2)
+  assert.equal(parseClipboard('{"hello":"world"}'), null)
+  assert.equal(parseClipboard('not json'), null)
+})
+
+test('materializePaste assigns fresh refdes, rewrites endpoints, offsets placements', () => {
+  const doc = fixture()
+  const payload = buildClipboard(doc, ['R1', 'R2'])!
+  const { parts, wires, idMap } = materializePaste(doc, payload, { x: 19.2, y: 19.2 })
+  // R1/R2 exist → next free are R3/R4
+  assert.deepEqual(parts.map((p) => p.id).sort(), ['R3', 'R4'])
+  assert.equal(idMap.get('R1'), 'R3')
+  assert.equal(parts[0].bb!.x, 96 + 19.2)
+  assert.equal(wires.length, 1)
+  assert.notEqual(wires[0].id, 'w1')
+  assert.equal(wires[0].from, 'R3:2')
+  assert.equal(wires[0].to, 'R4:1')
+})
+
+test('materializePaste rewrites junction hosts to the new wire ids', () => {
+  const doc = fixture()
+  const payload = buildClipboard(doc, ['R1', 'R2', 'LED1'])!
+  const { wires } = materializePaste(doc, payload, { x: 0, y: 0 })
+  const oldW1 = payload.wires.find((w) => w.id === 'w1')!
+  const newW1 = wires.find((w) => w.from.toString().startsWith('R') && (w.to as string).toString().startsWith('R'))!
+  const rider = wires.find((w) => typeof w.to === 'object')!
+  assert.notEqual(newW1.id, oldW1.id)
+  assert.equal((rider.to as JunctionEnd).wire, newW1.id)
+  assert.equal((rider.to as JunctionEnd).t, 0.5)
+})
+
+test('materializePaste against a doc with gaps continues numbering from max', () => {
+  const doc = fixture()
+  doc.parts.push({ id: 'R9', type: 'resistor', bb: { x: 0, y: 0 } })
+  const payload = buildClipboard(doc, ['R1'])!
+  const { parts } = materializePaste(doc, payload, { x: 0, y: 0 })
+  assert.equal(parts[0].id, 'R10')
+})
diff --git a/src/renderer/src/circuit/__tests__/m1.test.ts b/src/renderer/src/circuit/__tests__/m1.test.ts
new file mode 100644
index 0000000..d2c82a4
--- /dev/null
+++ b/src/renderer/src/circuit/__tests__/m1.test.ts
@@ -0,0 +1,84 @@
+/** M1 core additions: composite mergeKey gesture collapsing, pending-junction
+ * detection, and reroute application through placePart composites. */
+
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import * as cmd from '../core/commands'
+import { emptyDoc, isPendingJunction, type CircuitDoc, type JunctionEnd } from '../core/model'
+import { CircuitStore } from '../core/store'
+
+function fixture(): CircuitDoc {
+  const doc = emptyDoc()
+  doc.parts = [
+    { id: 'R1', type: 'resistor', bb: { x: 0, y: 0 } },
+    { id: 'R2', type: 'resistor', bb: { x: 96, y: 0 } }
+  ]
+  doc.wires = [{ id: 'w1', from: 'R1:2', to: 'R2:1', view: 'bb', route: ['h48'] }]
+  return doc
+}
+
+test('composite commands with a mergeKey collapse into one undo step', () => {
+  const store = new CircuitStore(fixture())
+  for (let i = 1; i <= 5; i++) {
+    store.dispatch(
+      cmd.composite(
+        'Move 2 parts',
+        [
+          cmd.placePart('R1', 'bb', { x: i * 9.6, y: 0 }),
+          cmd.placePart('R2', 'bb', { x: 96 + i * 9.6, y: 0 })
+        ],
+        'movebb:R1,R2'
+      )
+    )
+  }
+  assert.equal(store.getDoc().parts[0].bb!.x, 48)
+  store.undo()
+  // one undo returns to the pre-gesture doc, not the previous frame
+  assert.equal(store.getDoc().parts[0].bb!.x, 0)
+  assert.equal(store.getDoc().parts[1].bb!.x, 96)
+  assert.equal(store.canUndo(), false)
+})
+
+test('different mergeKeys do not merge', () => {
+  const store = new CircuitStore(fixture())
+  store.dispatch(cmd.composite('Move', [cmd.placePart('R1', 'bb', { x: 9.6, y: 0 })], 'movebb:R1'))
+  store.dispatch(cmd.composite('Move', [cmd.placePart('R2', 'bb', { x: 105.6, y: 0 })], 'movebb:R2'))
+  store.undo()
+  assert.equal(store.getDoc().parts[1].bb!.x, 96)
+  assert.equal(store.getDoc().parts[0].bb!.x, 9.6)
+  assert.equal(store.canUndo(), true)
+})
+
+test('placePart applies reroutes alongside the placement', () => {
+  const store = new CircuitStore(fixture())
+  store.dispatch(cmd.placePart('R1', 'bb', { x: 9.6, y: 0 }, [{ wireId: 'w1', route: ['h38.4'] }]))
+  assert.deepEqual(store.getDoc().wires[0].route, ['h38.4'])
+  store.undo()
+  assert.deepEqual(store.getDoc().wires[0].route, ['h48'])
+})
+
+test('isPendingJunction recognizes migrated free-point endpoints only', () => {
+  const pending = { wire: '', t: -1, x: 10, y: 20 } as unknown as JunctionEnd
+  assert.equal(isPendingJunction(pending), true)
+  assert.equal(isPendingJunction({ wire: 'w1', t: 0.5 }), false)
+  assert.equal(isPendingJunction('R1:1'), false)
+})
+
+test('setWireEnds resolves a pending junction to a real {wire,t}', () => {
+  const doc = fixture()
+  doc.wires.push({
+    id: 'w2',
+    from: 'R2:2',
+    to: { wire: '', t: -1, x: 48, y: 0 } as unknown as JunctionEnd,
+    view: 'bb'
+  })
+  const store = new CircuitStore(doc)
+  store.dispatch(
+    cmd.composite('Resolve migrated junctions', [
+      cmd.setWireEnds('w2', undefined, { wire: 'w1', t: 0.5 })
+    ])
+  )
+  const w2 = store.getDoc().wires.find((w) => w.id === 'w2')!
+  assert.deepEqual(w2.to, { wire: 'w1', t: 0.5 })
+  assert.equal(isPendingJunction(w2.to), false)
+})
diff --git a/src/renderer/src/circuit/core/clipboard.ts b/src/renderer/src/circuit/core/clipboard.ts
new file mode 100644
index 0000000..440b16d
--- /dev/null
+++ b/src/renderer/src/circuit/core/clipboard.ts
@@ -0,0 +1,157 @@
+/**
+ * circuit/core/clipboard — copy/paste/duplicate as pure document logic.
+ *
+ * The clipboard payload is JSON (spec §6.2): a self-contained fragment of
+ * parts + wires. It travels on the system clipboard as text (a custom MIME
+ * type is unreliable across the desktop and web builds), detected by shape.
+ *
+ * Rules:
+ *  - a wire is included only if BOTH its endpoints stay resolvable inside the
+ *    payload: pin ends must reference included parts; junction ends must
+ *    reference included wires (filtered to a fixpoint).
+ *  - on paste, parts get fresh refdes ids (prefix derived from the old id),
+ *    wires get fresh ids, endpoints are rewritten, placements are offset.
+ */
+
+import { newId, splitPinRef, isJunction, type CircuitDoc, type CircuitPart, type CircuitWire, type WireEnd } from './model'
+
+export const CLIPBOARD_FORMAT = 'tinystudio-circuit-clipboard'
+
+export interface ClipboardPayload {
+  format: typeof CLIPBOARD_FORMAT
+  version: 2
+  parts: CircuitPart[]
+  wires: CircuitWire[]
+}
+
+/** Build a payload from a selection. Returns null when nothing copyable. */
+export function buildClipboard(
+  doc: CircuitDoc,
+  partIds: Iterable<string>,
+  wireIds: Iterable<string> = []
+): ClipboardPayload | null {
+  const pset = new Set(partIds)
+  const wsel = new Set(wireIds)
+  const parts = doc.parts.filter((p) => pset.has(p.id))
+
+  // candidates: explicitly selected wires + wires whose pin ends all sit on
+  // selected parts (junction ends are provisionally in — the fixpoint below
+  // keeps them only if their host wire survives)
+  const pinIn = (e: WireEnd): boolean => typeof e === 'string' && pset.has(splitPinRef(e).part)
+  const endIn = (e: WireEnd): boolean => isJunction(e) || pinIn(e)
+  const candidates = doc.wires.filter(
+    (w) => wsel.has(w.id) || (endIn(w.from) && endIn(w.to) && (pinIn(w.from) || pinIn(w.to)))
+  )
+
+  // filter to a fixpoint: every endpoint must resolve inside the payload
+  let keep = new Map(candidates.map((w) => [w.id, w]))
+  for (;;) {
+    const next = new Map<string, CircuitWire>()
+    for (const w of keep.values()) {
+      const ok = (e: WireEnd): boolean =>
+        isJunction(e) ? keep.has(e.wire) : pset.has(splitPinRef(e).part)
+      if (ok(w.from) && ok(w.to)) next.set(w.id, w)
+    }
+    if (next.size === keep.size) break
+    keep = next
+  }
+
+  if (parts.length === 0 && keep.size === 0) return null
+  return {
+    format: CLIPBOARD_FORMAT,
+    version: 2,
+    parts: parts.map((p) => structuredClone(p)),
+    wires: [...keep.values()].map((w) => structuredClone(w))
+  }
+}
+
+/** Parse clipboard text into a payload, or null when it isn't ours. */
+export function parseClipboard(text: string): ClipboardPayload | null {
+  try {
+    const raw = JSON.parse(text)
+    if (raw?.format !== CLIPBOARD_FORMAT || raw.version !== 2) return null
+    return {
+      format: CLIPBOARD_FORMAT,
+      version: 2,
+      parts: Array.isArray(raw.parts) ? raw.parts : [],
+      wires: Array.isArray(raw.wires) ? raw.wires : []
+    }
+  } catch {
+    return null
+  }
+}
+
+/** Refdes prefix of an existing id: "R12" → "R", "led_3a" → "led". */
+function idPrefix(id: string): string {
+  const m = /^([A-Za-z][A-Za-z_-]*?)[_-]?\d*$/.exec(id)
+  return m ? m[1] : 'P'
+}
+
+export interface MaterializedPaste {
+  parts: CircuitPart[]
+  wires: CircuitWire[]
+  /** old part id → new part id (for selecting the pasted set). */
+  idMap: Map<string, string>
+}
+
+/**
+ * Re-id a payload against a target document and offset its placements.
+ * Pure — the caller wraps the result in addPart/addWire commands.
+ */
+export function materializePaste(
+  doc: CircuitDoc,
+  payload: ClipboardPayload,
+  offset: { x: number; y: number }
+): MaterializedPaste {
+  // seed per-prefix counters from the target doc
+  const counters = new Map<string, number>()
+  const bump = (prefix: string): number => {
+    if (!counters.has(prefix)) {
+      let max = 0
+      const re = new RegExp(`^${prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(\\d+)$`)
+      for (const p of doc.parts) {
+        const m = re.exec(p.id)
+        if (m) max = Math.max(max, parseInt(m[1], 10))
+      }
+      counters.set(prefix, max)
+    }
+    const n = counters.get(prefix)! + 1
+    counters.set(prefix, n)
+    return n
+  }
+
+  const idMap = new Map<string, string>()
+  const parts = payload.parts.map((src) => {
+    const p = structuredClone(src)
+    const prefix = idPrefix(p.id)
+    p.id = `${prefix}${bump(prefix)}`
+    idMap.set(src.id, p.id)
+    if (p.bb) {
+      p.bb.x += offset.x
+      p.bb.y += offset.y
+    }
+    if (p.sch) {
+      p.sch.x += offset.x
+      p.sch.y += offset.y
+    }
+    return p
+  })
+
+  const wireIdMap = new Map<string, string>()
+  for (const w of payload.wires) wireIdMap.set(w.id, newId('w'))
+  const fixEnd = (e: WireEnd): WireEnd => {
+    if (isJunction(e)) return { ...e, wire: wireIdMap.get(e.wire) ?? e.wire }
+    const { part, pin } = splitPinRef(e)
+    const mapped = idMap.get(part)
+    return mapped ? `${mapped}:${pin}` : e
+  }
+  const wires = payload.wires.map((src) => {
+    const w = structuredClone(src)
+    w.id = wireIdMap.get(src.id)!
+    w.from = fixEnd(w.from)
+    w.to = fixEnd(w.to)
+    return w
+  })
+
+  return { parts, wires, idMap }
+}
diff --git a/src/renderer/src/circuit/core/commands.ts b/src/renderer/src/circuit/core/commands.ts
index da19ce2..f91d5cf 100644
--- a/src/renderer/src/circuit/core/commands.ts
+++ b/src/renderer/src/circuit/core/commands.ts
@@ -238,10 +238,13 @@ export function setProbes(probes: Probe[]): Command {
 
 // ── batch ────────────────────────────────────────────────────────────────────
 
-/** Compose several commands into one undo step (cross-view cascades, paste…). */
-export function composite(label: string, commands: Command[]): Command {
+/** Compose several commands into one undo step (cross-view cascades, paste…).
+ * `mergeKey` lets composite gestures (multi-part drags) collapse like single
+ * commands do. */
+export function composite(label: string, commands: Command[], mergeKey?: string): Command {
   return {
     label,
+    mergeKey,
     apply: (doc) => commands.reduce((d, c) => c.apply(d), doc)
   }
 }
diff --git a/src/renderer/src/circuit/core/model.ts b/src/renderer/src/circuit/core/model.ts
index 1211132..f8a0d8a 100644
--- a/src/renderer/src/circuit/core/model.ts
+++ b/src/renderer/src/circuit/core/model.ts
@@ -133,6 +133,20 @@ export function isJunction(end: WireEnd): end is JunctionEnd {
   return typeof end === 'object' && end !== null && 'wire' in end
 }
 
+/**
+ * A v1-migrated junction endpoint the editor hasn't geometrically resolved
+ * yet: carries the original raw coordinate; `wire` is '' and `t` is -1 until
+ * the first render (where pin geometry exists) rewrites it to a real
+ * `{wire, t}` — see migrateV1 pass 2.
+ */
+export interface PendingJunctionEnd extends JunctionEnd {
+  x: number
+  y: number
+}
+export function isPendingJunction(end: WireEnd): end is PendingJunctionEnd {
+  return isJunction(end) && end.wire === '' && (end as PendingJunctionEnd).x !== undefined
+}
+
 /** Split a "partId:pinName" pin ref. Pin names may contain ':'? No — first colon splits. */
 export function splitPinRef(ref: string): { part: string; pin: string } {
   const i = ref.indexOf(':')

From 61d3c9a33b8826e5855dec083768a97a0aa94b28 Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Fri, 3 Jul 2026 15:32:57 +0000
Subject: [PATCH 03/27] Circuit v2 M1: SVG id-namespacing (B6) + SVG/PNG scene
 export
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- parts/svg.ts: namespaceSvgIds / svgNs / stripSvgSize / escapeXml — pure
  string transforms, unit-tested; full sanitizer arrives with M2 packs
- views/exportImage.ts: composeSceneSvg (namespaced per part instance),
  exportSvg / exportPng @2x with watermark
- index.ts re-exports clipboard + svg helpers
---
 .../src/circuit/__tests__/svg.test.ts         |  49 ++++++
 src/renderer/src/circuit/index.ts             |   2 +
 src/renderer/src/circuit/parts/svg.ts         |  54 +++++++
 src/renderer/src/circuit/views/exportImage.ts | 142 ++++++++++++++++++
 4 files changed, 247 insertions(+)
 create mode 100644 src/renderer/src/circuit/__tests__/svg.test.ts
 create mode 100644 src/renderer/src/circuit/parts/svg.ts
 create mode 100644 src/renderer/src/circuit/views/exportImage.ts

diff --git a/src/renderer/src/circuit/__tests__/svg.test.ts b/src/renderer/src/circuit/__tests__/svg.test.ts
new file mode 100644
index 0000000..fd15e78
--- /dev/null
+++ b/src/renderer/src/circuit/__tests__/svg.test.ts
@@ -0,0 +1,49 @@
+/** Tests for parts/svg — id namespacing (B6) and helpers. */
+
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { escapeXml, namespaceSvgIds, stripSvgSize, svgNs } from '../parts/svg'
+
+test('namespaceSvgIds prefixes defined ids and their references', () => {
+  const svg =
+    '<svg><defs><linearGradient id="g"><stop/></linearGradient></defs>' +
+    '<rect fill="url(#g)"/><use href="#g"/><use xlink:href="#g"/></svg>'
+  const out = namespaceSvgIds(svg, 'pR1')
+  assert.ok(out.includes('id="pR1-g"'))
+  assert.ok(out.includes('url(#pR1-g)'))
+  assert.ok(out.includes('href="#pR1-g"'))
+  assert.ok(out.includes('xlink:href="#pR1-g"'))
+  assert.ok(!out.includes('id="g"'))
+})
+
+test('namespaceSvgIds leaves external references and unknown ids alone', () => {
+  const svg = '<svg><rect fill="url(#other)"/><use href="https://x/#frag"/><g id="mine"/></svg>'
+  const out = namespaceSvgIds(svg, 'ns')
+  assert.ok(out.includes('url(#other)')) // not defined here — untouched
+  assert.ok(out.includes('href="https://x/#frag"'))
+  assert.ok(out.includes('id="ns-mine"'))
+})
+
+test('two parts sharing an id stop colliding after namespacing (B6)', () => {
+  const a = namespaceSvgIds('<svg><g id="body" fill="url(#body)"/></svg>', svgNs('R1'))
+  const b = namespaceSvgIds('<svg><g id="body" fill="url(#body)"/></svg>', svgNs('LED1'))
+  assert.ok(a.includes('pR1-body'))
+  assert.ok(b.includes('pLED1-body'))
+  assert.ok(!a.includes('id="body"') && !b.includes('id="body"'))
+})
+
+test('svgNs sanitizes weird part ids', () => {
+  assert.equal(svgNs('R1'), 'pR1')
+  assert.equal(svgNs('led 2/a'), 'pled_2_a')
+})
+
+test('stripSvgSize removes root width/height only', () => {
+  const out = stripSvgSize('<svg width="10" height="20" viewBox="0 0 10 20"><rect width="5"/></svg>')
+  assert.ok(!/^<svg[^>]*width="10"/.test(out))
+  assert.ok(out.includes('<rect width="5"/>'))
+  assert.ok(out.includes('viewBox="0 0 10 20"'))
+})
+
+test('escapeXml escapes the five specials', () => {
+  assert.equal(escapeXml(`<a href="x">R&D's</a>`), '&lt;a href=&quot;x&quot;&gt;R&amp;D&apos;s&lt;/a&gt;')
+})
diff --git a/src/renderer/src/circuit/index.ts b/src/renderer/src/circuit/index.ts
index 3163975..073dcc7 100644
--- a/src/renderer/src/circuit/index.ts
+++ b/src/renderer/src/circuit/index.ts
@@ -17,6 +17,8 @@ export * as commands from './core/commands'
 export { CircuitStore } from './core/store'
 export * from './core/geometry'
 export * from './core/refdes'
+export * from './core/clipboard'
+export { namespaceSvgIds, svgNs, stripSvgSize, escapeXml } from './parts/svg'
 
 export const CIRCUIT_V2_FLAG = 'tinystudio.circuitV2'
 
diff --git a/src/renderer/src/circuit/parts/svg.ts b/src/renderer/src/circuit/parts/svg.ts
new file mode 100644
index 0000000..220a0d2
--- /dev/null
+++ b/src/renderer/src/circuit/parts/svg.ts
@@ -0,0 +1,54 @@
+/**
+ * circuit/parts/svg — SVG utilities for part artwork.
+ *
+ * M1 ships the pieces the image exporter needs (B6 fix): id-namespacing so
+ * two parts whose SVGs both define e.g. `id="g"` don't corrupt each other in
+ * a composed export, plus small size/escape helpers. The full sanitizer and
+ * the procedural breadboard generator land in M2 (spec §5).
+ *
+ * Pure string transforms — no DOM — so they run in tests, workers, exports.
+ */
+
+/**
+ * Prefix every id defined in an SVG string (and every internal reference to
+ * one: url(#…), href="#…", xlink:href="#…") with `ns-`. External hrefs are
+ * untouched.
+ */
+export function namespaceSvgIds(svg: string, ns: string): string {
+  const ids = new Set<string>()
+  for (const m of svg.matchAll(/\bid\s*=\s*"([^"]+)"/g)) ids.add(m[1])
+  for (const m of svg.matchAll(/\bid\s*=\s*'([^']+)'/g)) ids.add(m[1])
+  if (ids.size === 0) return svg
+  const has = (id: string): boolean => ids.has(id)
+
+  return svg
+    .replace(/\bid\s*=\s*"([^"]+)"/g, (all, id) => (has(id) ? `id="${ns}-${id}"` : all))
+    .replace(/\bid\s*=\s*'([^']+)'/g, (all, id) => (has(id) ? `id='${ns}-${id}'` : all))
+    .replace(/url\(#([^)]+)\)/g, (all, id) => (has(id) ? `url(#${ns}-${id})` : all))
+    .replace(/\b(xlink:href|href)\s*=\s*"#([^"]+)"/g, (all, attr, id) =>
+      has(id) ? `${attr}="#${ns}-${id}"` : all
+    )
+    .replace(/\b(xlink:href|href)\s*=\s*'#([^']+)'/g, (all, attr, id) =>
+      has(id) ? `${attr}='#${ns}-${id}'` : all
+    )
+}
+
+/** Sanitize a part id into a token safe for use as an SVG id namespace. */
+export function svgNs(partId: string): string {
+  return 'p' + partId.replace(/[^A-Za-z0-9_-]/g, '_')
+}
+
+/** Strip width/height attributes off the root <svg> (the composer sizes it). */
+export function stripSvgSize(svg: string): string {
+  return svg
+    .replace(/<svg([^>]*?)\swidth\s*=\s*"[^"]*"/i, '<svg$1')
+    .replace(/<svg([^>]*?)\sheight\s*=\s*"[^"]*"/i, '<svg$1')
+}
+
+/** Escape text for inclusion in generated SVG markup. */
+export function escapeXml(s: string): string {
+  return s.replace(
+    /[<>&'"]/g,
+    (c) => ({ '<': '&lt;', '>': '&gt;', '&': '&amp;', "'": '&apos;', '"': '&quot;' })[c] as string
+  )
+}
diff --git a/src/renderer/src/circuit/views/exportImage.ts b/src/renderer/src/circuit/views/exportImage.ts
new file mode 100644
index 0000000..afd8d0f
--- /dev/null
+++ b/src/renderer/src/circuit/views/exportImage.ts
@@ -0,0 +1,142 @@
+/**
+ * circuit/views/exportImage — compose the bb scene into a standalone SVG and
+ * download it as .svg or rasterized .png @2×. Part SVG ids are namespaced per
+ * instance (fixes B6: two parts sharing `id="g"` corrupted exports).
+ */
+
+import { escapeXml, namespaceSvgIds, stripSvgSize, svgNs } from '../parts/svg'
+import { isJunction, type CircuitDoc } from '../core/model'
+import { bbBounds, bbVisual, bbWireGeometry, makeEndResolver } from './partsAdapter'
+
+const WIRE_W = 2.8
+const WIRE_OUTLINE_W = WIRE_W + 1.8
+
+function darken(hex: string, f = 0.55): string {
+  const m = /^#?([0-9a-fA-F]{6})$/.exec(hex.trim())
+  if (!m) return 'rgba(0,0,0,0.45)'
+  const n = parseInt(m[1], 16)
+  return `rgb(${Math.round(((n >> 16) & 255) * f)}, ${Math.round(((n >> 8) & 255) * f)}, ${Math.round((n & 255) * f)})`
+}
+
+function roundedPath(points: { x: number; y: number }[], r = 4): string {
+  if (points.length < 2) return ''
+  if (points.length === 2) return `M${points[0].x} ${points[0].y} L${points[1].x} ${points[1].y}`
+  let d = `M${points[0].x} ${points[0].y}`
+  for (let i = 1; i < points.length - 1; i++) {
+    const p = points[i - 1]
+    const c = points[i]
+    const n = points[i + 1]
+    const d1 = Math.hypot(c.x - p.x, c.y - p.y) || 1
+    const d2 = Math.hypot(n.x - c.x, n.y - c.y) || 1
+    const rr = Math.max(0, Math.min(r, d1 / 2, d2 / 2))
+    const a = { x: c.x - ((c.x - p.x) / d1) * rr, y: c.y - ((c.y - p.y) / d1) * rr }
+    const b = { x: c.x + ((n.x - c.x) / d2) * rr, y: c.y + ((n.y - c.y) / d2) * rr }
+    d += ` L${a.x} ${a.y} Q${c.x} ${c.y} ${b.x} ${b.y}`
+  }
+  const last = points[points.length - 1]
+  d += ` L${last.x} ${last.y}`
+  return d
+}
+
+/** Build the standalone scene SVG (exported for tests). */
+export function composeSceneSvg(doc: CircuitDoc, bg: string): string | null {
+  const bounds = bbBounds(doc)
+  if (!bounds) return null
+  const pad = 36
+  const minX = bounds.minX - pad
+  const minY = bounds.minY - pad
+  const maxX = bounds.maxX + pad + 60 // room for labels
+  const maxY = bounds.maxY + pad + 16 // room for the watermark
+  const W = Math.round(maxX - minX)
+  const H = Math.round(maxY - minY)
+
+  const geom = bbWireGeometry(doc)
+  const wires = geom
+    .map(({ w, pts }) => {
+      if (pts.length < 2) return ''
+      const core = w.color || '#2fa46a'
+      const d = roundedPath(pts)
+      return `<path d="${d}" fill="none" stroke="${darken(core)}" stroke-width="${WIRE_OUTLINE_W}" stroke-linejoin="round" stroke-linecap="round"/><path d="${d}" fill="none" stroke="${core}" stroke-width="${WIRE_W}" stroke-linejoin="round" stroke-linecap="round"/>`
+    })
+    .join('')
+
+  const resolve = makeEndResolver(doc)
+  const dots = doc.wires
+    .filter((w) => w.view === 'bb')
+    .flatMap((w) =>
+      [w.from, w.to].filter(isJunction).map((j) => {
+        const p = resolve(j)
+        return p ? `<circle cx="${p.x}" cy="${p.y}" r="3" fill="${w.color || '#c9ced6'}"/>` : ''
+      })
+    )
+    .join('')
+
+  const partsSvg = doc.parts
+    .map((part) => {
+      if (!part.bb) return ''
+      const vis = bbVisual(part.type)
+      if (!vis) return ''
+      const { x, y } = part.bb
+      const inner = stripSvgSize(namespaceSvgIds(vis.v.svg, svgNs(part.id))).replace(
+        '<svg',
+        `<svg x="${x}" y="${y}" width="${vis.v.w}" height="${vis.v.h}"`
+      )
+      const rot = part.bb.rotate
+        ? ` transform="rotate(${part.bb.rotate} ${x + vis.v.w / 2} ${y + vis.v.h / 2})"`
+        : ''
+      const off = part.bb.labelOffset || [0, 0]
+      const labelText = String(part.attrs?.label ?? part.id)
+      const label = `<text x="${x + off[0]}" y="${y + vis.v.h + 13 + off[1]}" fill="#969ba3" font-family="Plus Jakarta Sans, sans-serif" font-size="11">${escapeXml(labelText)}</text>`
+      return `<g${rot}>${inner}</g>${label}`
+    })
+    .join('')
+
+  const watermark = `<text x="${maxX - 10}" y="${maxY - 10}" text-anchor="end" fill="#79818c" fill-opacity="0.75" font-family="Plus Jakarta Sans, sans-serif" font-size="13" font-weight="600">tinyStudio</text>`
+  return `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="${W}" height="${H}" viewBox="${minX} ${minY} ${W} ${H}"><rect x="${minX}" y="${minY}" width="${W}" height="${H}" fill="${bg}"/>${wires}${dots}${partsSvg}${watermark}</svg>`
+}
+
+function download(blob: Blob, name: string): void {
+  const a = document.createElement('a')
+  const href = URL.createObjectURL(blob)
+  a.href = href
+  a.download = name
+  a.click()
+  setTimeout(() => URL.revokeObjectURL(href), 1000)
+}
+
+export function exportSvg(doc: CircuitDoc): void {
+  const bg = (getComputedStyle(document.documentElement).getPropertyValue('--bg-sunken') || '#1e1f22').trim()
+  const svg = composeSceneSvg(doc, bg)
+  if (!svg) return
+  download(new Blob([svg], { type: 'image/svg+xml;charset=utf-8' }), 'circuit.svg')
+}
+
+export function exportPng(doc: CircuitDoc): void {
+  const bg = (getComputedStyle(document.documentElement).getPropertyValue('--bg-sunken') || '#1e1f22').trim()
+  const svg = composeSceneSvg(doc, bg)
+  if (!svg) return
+  const m = /width="(\d+)" height="(\d+)"/.exec(svg)
+  const W = m ? parseInt(m[1], 10) : 800
+  const H = m ? parseInt(m[2], 10) : 600
+  const url = URL.createObjectURL(new Blob([svg], { type: 'image/svg+xml;charset=utf-8' }))
+  const img = new Image()
+  img.onload = () => {
+    const sf = 2
+    const canvas = document.createElement('canvas')
+    canvas.width = W * sf
+    canvas.height = H * sf
+    const ctx = canvas.getContext('2d')
+    if (!ctx) {
+      URL.revokeObjectURL(url)
+      return
+    }
+    ctx.scale(sf, sf)
+    ctx.drawImage(img, 0, 0)
+    URL.revokeObjectURL(url)
+    canvas.toBlob((png) => {
+      if (png) download(png, 'circuit.png')
+    }, 'image/png')
+  }
+  img.onerror = () => URL.revokeObjectURL(url)
+  img.src = url
+}

From 9a98df959d596b2a79a1d12cb8b836ca6a1886b1 Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Fri, 3 Jul 2026 15:33:19 +0000
Subject: [PATCH 04/27] =?UTF-8?q?Circuit=20v2=20M1:=20breadboard=20editor?=
 =?UTF-8?q?=20=E2=80=94=20Canvas,=20gestures,=20palette,=20inspector?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- views/partsAdapter.ts: legacy-partsLibrary geometry glue (pin transforms,
  endpoint resolution incl. junction chains, frozen-bend reroutes,
  snap-by-first-pin per spec §6.3) — swapped for the M2 registry later
- views/canvas/Canvas.tsx: camera (wheel zoom, pan, fit), selection +
  marquee, wire draw (pin→pin/junction tap via {wire,t} tAtPoint, Shift
  straight, Esc), selected-wire handles (segment/vertex/endpoint;
  endpoint re-targets to pin or junction, reverts on empty space —
  v2 has no free endpoints), part drag single+multi with frozen bends
  (between-two-moved wires translate), label drag, R/context rotate,
  arrow nudge (Shift=5x), Del cascade, Ctrl+Z/Y undo/redo,
  Ctrl+C/X/V/D clipboard via core/clipboard, pending-junction resolution
  on first render (closes the M0 migration gap)
- views/palette/Palette.tsx, views/inspector/Inspector.tsx: legacy rail +
  inspector ported; inspector renames refdes (validated), edits attrs,
  moves/rotates with reroutes
- views/CircuitView.tsx: shell — store owner, debounced (250ms) save via
  onChange with external-edit echo/skip guard, toolbar, zoom cluster,
  status pills, PartsEditor modal
---
 .../src/circuit/views/CircuitView.tsx         |  546 ++++----
 .../src/circuit/views/canvas/Canvas.tsx       | 1179 +++++++++++++++++
 .../src/circuit/views/inspector/Inspector.tsx |  366 +++++
 .../src/circuit/views/palette/Palette.tsx     |  131 ++
 .../src/circuit/views/partsAdapter.ts         |  230 ++++
 5 files changed, 2156 insertions(+), 296 deletions(-)
 create mode 100644 src/renderer/src/circuit/views/canvas/Canvas.tsx
 create mode 100644 src/renderer/src/circuit/views/inspector/Inspector.tsx
 create mode 100644 src/renderer/src/circuit/views/palette/Palette.tsx
 create mode 100644 src/renderer/src/circuit/views/partsAdapter.ts

diff --git a/src/renderer/src/circuit/views/CircuitView.tsx b/src/renderer/src/circuit/views/CircuitView.tsx
index 55a44f1..12a22ef 100644
--- a/src/renderer/src/circuit/views/CircuitView.tsx
+++ b/src/renderer/src/circuit/views/CircuitView.tsx
@@ -1,337 +1,291 @@
 /**
- * circuit/views/CircuitView — the v2 Circuit View shell (M0: read-only preview).
- *
- * M0 scope: prove the core end-to-end inside the real IDE window slot —
- * parse (with v1/Wokwi migration) → store → net model → render parts + wires
- * on the tinyStudio dot-grid canvas with fit/zoom/pan. NO editing yet (M1).
- * Part visuals come from the existing partsLibrary as a temporary adapter
- * until the v2 parts registry lands (M2).
+ * circuit/views/CircuitView — the Circuit View v2 shell (M1: breadboard
+ * editor parity). Composes: components palette · interactive Canvas ·
+ * Inspector rail · toolbar (edit toggle, grid, export, code) · zoom cluster ·
+ * status pills. Owns the CircuitStore and the debounced save path
+ * (store.serialize() → onChange → Redux buffer; disk save stays on Ctrl+S,
+ * same as every other editor buffer).
  *
  * Mounted by EditorPanel behind the `tinystudio.circuitV2` flag, in the same
- * window space the legacy DiagramEditor occupies — desktop and web builds.
+ * window slot the legacy DiagramEditor occupies — desktop and web builds.
  */
 
-import { CircuitBoard, Maximize, ZoomIn, ZoomOut } from 'lucide-react'
+import {
+  CodeXml,
+  Eye,
+  FileCode2,
+  Grid3x3,
+  ImageDown,
+  Maximize,
+  Pencil,
+  Redo2,
+  Undo2,
+  ZoomIn,
+  ZoomOut
+} from 'lucide-react'
 import React from 'react'
-import { ensureParts, getPart, viewFor } from '../../lib/partsLibrary'
 import {
-  isJunction,
-  splitPinRef,
-  type CircuitDoc,
-  type CircuitWire,
-  type Pt,
-  type WireEnd
-} from '../core/model'
-import { pinWorld } from '../core/geometry'
+  ensureParts,
+  getPart,
+  loadPart,
+  registerPart,
+  viewFor,
+  type PartDef
+} from '../../lib/partsLibrary'
+import { PartsEditor } from '../../components/PartsEditor'
+import * as cmd from '../core/commands'
+import { type Pt } from '../core/model'
 import { buildNets } from '../core/nets'
-import { pointAtT, wirePoints } from '../core/routing'
+import { nextRefdes, prefixForFamily } from '../core/refdes'
 import { CircuitStore } from '../core/store'
+import { Canvas, emptySel, type Cam, type CanvasHandle, type Selection } from './canvas/Canvas'
+import { exportPng, exportSvg } from './exportImage'
+import { InspectorRail } from './inspector/Inspector'
+import { Palette, WIRE_COLORS } from './palette/Palette'
+import { snapBB } from './partsAdapter'
 
-const WIRE_W = 2.8
-const WIRE_OUTLINE_W = WIRE_W + 1.8
-
-function darken(hex: string, f = 0.55): string {
-  const m = /^#?([0-9a-fA-F]{6})$/.exec(hex.trim())
-  if (!m) return 'rgba(0,0,0,0.45)'
-  const n = parseInt(m[1], 16)
-  return `rgb(${Math.round(((n >> 16) & 255) * f)}, ${Math.round(((n >> 8) & 255) * f)}, ${Math.round((n & 255) * f)})`
-}
-
-function roundedPath(points: Pt[], r = 4): string {
-  if (points.length < 2) return ''
-  if (points.length === 2) return `M${points[0].x} ${points[0].y} L${points[1].x} ${points[1].y}`
-  let d = `M${points[0].x} ${points[0].y}`
-  for (let i = 1; i < points.length - 1; i++) {
-    const p = points[i - 1]
-    const c = points[i]
-    const n = points[i + 1]
-    const d1 = Math.hypot(c.x - p.x, c.y - p.y) || 1
-    const d2 = Math.hypot(n.x - c.x, n.y - c.y) || 1
-    const rr = Math.max(0, Math.min(r, d1 / 2, d2 / 2))
-    const a = { x: c.x - ((c.x - p.x) / d1) * rr, y: c.y - ((c.y - p.y) / d1) * rr }
-    const b = { x: c.x + ((n.x - c.x) / d2) * rr, y: c.y + ((n.y - c.y) / d2) * rr }
-    d += ` L${a.x} ${a.y} Q${c.x} ${c.y} ${b.x} ${b.y}`
-  }
-  const last = points[points.length - 1]
-  d += ` L${last.x} ${last.y}`
-  return d
-}
-
-/** Resolve a wire endpoint to a world point using the legacy parts adapter. */
-function makeResolver(doc: CircuitDoc): (end: WireEnd, seen?: Set<string>) => Pt | null {
-  const wireById = new Map(doc.wires.map((w) => [w.id, w]))
-  const resolve = (end: WireEnd, seen: Set<string> = new Set()): Pt | null => {
-    if (isJunction(end)) {
-      // pending v1-migrated junction carries raw coords
-      const raw = end as unknown as { x?: number; y?: number; wire: string; t: number }
-      if (end.wire === '' && raw.x !== undefined) return { x: raw.x!, y: raw.y! }
-      if (seen.has(end.wire)) return null
-      seen.add(end.wire)
-      const host = wireById.get(end.wire)
-      if (!host) return null
-      const pts = resolveWire(host, seen)
-      return pts ? pointAtT(pts, end.t) : null
-    }
-    const { part: partId, pin } = splitPinRef(end)
-    const part = doc.parts.find((p) => p.id === partId)
-    if (!part?.bb) return null
-    const def = getPart(part.type)
-    const v = def && viewFor(def, 'breadboard')
-    const local = v?.pins[pin]
-    if (!v || !local) return null
-    return pinWorld(local, part.bb, v.w, v.h, part.bb.legs?.[pin])
-  }
-  const resolveWire = (w: CircuitWire, seen: Set<string>): Pt[] | null => {
-    const s = resolve(w.from, seen)
-    const t = resolve(w.to, seen)
-    if (!s || !t) return null
-    return wirePoints(s, t, w.route)
-  }
-  return resolve
-}
-
-export function CircuitViewV2({ content }: { content: string }): React.JSX.Element {
+export function CircuitViewV2({
+  content,
+  onChange,
+  onOpenCode,
+  onEditChange
+}: {
+  content: string
+  onChange: (next: string) => void
+  onOpenCode?: () => void
+  onEditChange?: (editing: boolean) => void
+}): React.JSX.Element {
   const [{ store, migrated, warnings }] = React.useState(() => CircuitStore.fromFile(content))
   const revision = React.useSyncExternalStore(store.subscribe, store.getRevision)
   const doc = store.getDoc()
-  const [, force] = React.useReducer((n: number) => n + 1, 0)
-  const [cam, setCam] = React.useState({ scale: 1, tx: 40, ty: 40 })
-  const viewRef = React.useRef<HTMLDivElement>(null)
-  const pan = React.useRef<Pt | null>(null)
-  const didFit = React.useRef(false)
 
-  // adopt external content changes (Code tab)
+  const [editable, setEditable] = React.useState(false)
+  const [grid, setGrid] = React.useState(true)
+  const [sel, setSel] = React.useState<Selection>(emptySel())
+  const [wireColor, setWireColor] = React.useState(WIRE_COLORS[0])
+  const [cam, setCam] = React.useState<Cam>({ scale: 1, tx: 40, ty: 40 })
+  const [editorPart, setEditorPart] = React.useState<PartDef | null | undefined>(undefined)
+  const [defsTick, bumpDefs] = React.useReducer((n: number) => n + 1, 0)
+  const canvasRef = React.useRef<CanvasHandle>(null)
+
+  // ── file sync ───────────────────────────────────────────────────────────────
+
+  // External content changes (Code tab / disk) fold in as an undoable step;
+  // our own serialized echoes are ignored by the store. Externally-caused
+  // revisions must NOT trigger a save (that would reformat under the user's
+  // cursor in the Code tab).
+  const skipSaveRev = React.useRef(0)
   React.useEffect(() => {
-    store.replaceFromFile(content)
+    const res = store.replaceFromFile(content)
+    if (res.applied) skipSaveRev.current = store.getRevision()
   }, [content, store])
 
+  React.useEffect(() => {
+    if (revision === 0 || revision === skipSaveRev.current) return
+    const t = setTimeout(() => onChange(store.serialize()), 250)
+    return () => clearTimeout(t)
+  }, [revision, store, onChange])
+
   // lazy-load part defs through the legacy adapter
   React.useEffect(() => {
     const missing = doc.parts.map((p) => p.type).filter((t) => !getPart(t))
-    if (missing.length) ensureParts(missing).then(force)
+    if (missing.length) void ensureParts(missing).then(bumpDefs)
   }, [doc.parts])
 
-  const resolve = React.useMemo(() => makeResolver(doc), [doc, revision])
-  const nets = React.useMemo(() => buildNets(doc), [doc])
+  // drop selection entries that no longer exist (undo, delete, external edit)
+  React.useEffect(() => {
+    const partIds = new Set(doc.parts.map((p) => p.id))
+    const wireIds = new Set(doc.wires.map((w) => w.id))
+    if ([...sel.parts].every((id) => partIds.has(id)) && [...sel.wires].every((id) => wireIds.has(id)))
+      return
+    setSel({
+      parts: new Set([...sel.parts].filter((id) => partIds.has(id))),
+      wires: new Set([...sel.wires].filter((id) => wireIds.has(id)))
+    })
+  }, [doc, sel])
 
-  const wireGeom = React.useMemo(() => {
-    return doc.wires
-      .filter((w) => w.view === 'bb')
-      .map((w) => {
-        const s = resolve(w.from)
-        const t = resolve(w.to)
-        return { w, pts: s && t ? wirePoints(s, t, w.route) : [] }
-      })
-  }, [doc, resolve])
+  const netModel = React.useMemo(() => buildNets(doc), [doc])
 
-  const fit = React.useCallback((): void => {
-    const el = viewRef.current
-    if (!el) return
-    let minX = Infinity
-    let minY = Infinity
-    let maxX = -Infinity
-    let maxY = -Infinity
-    for (const part of doc.parts) {
-      if (!part.bb) continue
-      const def = getPart(part.type)
-      const v = def && viewFor(def, 'breadboard')
-      if (!v) continue
-      minX = Math.min(minX, part.bb.x)
-      minY = Math.min(minY, part.bb.y)
-      maxX = Math.max(maxX, part.bb.x + v.w)
-      maxY = Math.max(maxY, part.bb.y + v.h)
-    }
-    for (const { pts } of wireGeom)
-      for (const p of pts) {
-        minX = Math.min(minX, p.x)
-        minY = Math.min(minY, p.y)
-        maxX = Math.max(maxX, p.x)
-        maxY = Math.max(maxY, p.y)
-      }
-    if (!isFinite(minX)) return
-    const pad = 48
-    const bw = maxX - minX + pad * 2
-    const bh = maxY - minY + pad * 2
-    const f = Math.max(0.25, Math.min(3, Math.min(el.clientWidth / bw, el.clientHeight / bh)))
-    setCam({
-      scale: f,
-      tx: (el.clientWidth - bw * f) / 2 - (minX - pad) * f,
-      ty: (el.clientHeight - bh * f) / 2 - (minY - pad) * f
-    })
-  }, [doc, wireGeom])
+  // ── actions ─────────────────────────────────────────────────────────────────
 
-  React.useEffect(() => {
-    if (didFit.current) return
-    if (doc.parts.length === 0 || doc.parts.every((p) => getPart(p.type))) {
-      fit()
-      didFit.current = true
-    }
-  })
+  const addPartAt = async (type: string, at?: Pt): Promise<void> => {
+    const def = getPart(type) || (await loadPart(type))
+    if (!def) return
+    bumpDefs()
+    const v = viewFor(def, 'breadboard')
+    const w = v?.w || 80
+    const h = v?.h || 40
+    const p = at ?? canvasRef.current?.centerWorld() ?? { x: 300, y: 200 }
+    const id = nextRefdes(store.getDoc(), prefixForFamily(`${def.family ?? ''} ${def.type}`))
+    const bb = snapBB(type, { x: Math.round(p.x - w / 2), y: Math.round(p.y - h / 2) })
+    store.dispatch(cmd.addPart({ id, type, bb }))
+    setSel({ parts: new Set([id]), wires: new Set() })
+  }
 
-  const zoomAt = (factor: number, sx: number, sy: number): void =>
-    setCam((c) => {
-      const ns = Math.max(0.25, Math.min(3, c.scale * factor))
-      const k = ns / c.scale
-      return { scale: ns, tx: sx - (sx - c.tx) * k, ty: sy - (sy - c.ty) * k }
-    })
+  const pickColor = (c: string): void => {
+    setWireColor(c)
+    if (sel.wires.size === 1 && sel.parts.size === 0)
+      store.dispatch(cmd.recolorWire([...sel.wires][0], c))
+  }
+
+  const editExisting = async (type: string): Promise<void> => {
+    const def = getPart(type) || (await loadPart(type))
+    if (def) setEditorPart(def)
+  }
 
   const tool =
     'tactile-bordered h-8 px-2.5 flex items-center gap-1.5 rounded-md bg-surface-card text-text-muted text-xs hover:text-text-body active:translate-y-px'
 
   return (
-    <div className="size-full relative overflow-hidden bg-bg-sunken">
-      {/* v2 badge + status */}
-      <div className="absolute top-3 left-3 z-10 flex gap-1.5 items-center">
-        <span className="px-2.5 py-1 rounded-full bg-surface-card border border-brand/40 text-brand text-[11px] font-semibold">
-          Circuit v2 preview
-        </span>
-        {migrated && (
-          <span className="px-2.5 py-1 rounded-full bg-surface-card border border-border-default text-text-muted text-[11px]">
-            migrated from diagram.json (in memory)
-          </span>
-        )}
-      </div>
-      <div className="absolute bottom-3 right-3.5 z-10 flex gap-1.5">
-        <button className={`${tool} w-8 justify-center px-0`} onClick={() => {
-          const el = viewRef.current
-          if (el) zoomAt(1 / 1.15, el.clientWidth / 2, el.clientHeight / 2)
-        }} title="Zoom out">
-          <ZoomOut size={15} />
-        </button>
-        <span className={`${tool} pointer-events-none min-w-[52px] justify-center`}>
-          {Math.round(cam.scale * 100)}%
-        </span>
-        <button className={`${tool} w-8 justify-center px-0`} onClick={() => {
-          const el = viewRef.current
-          if (el) zoomAt(1.15, el.clientWidth / 2, el.clientHeight / 2)
-        }} title="Zoom in">
-          <ZoomIn size={15} />
-        </button>
-        <button className={`${tool} w-8 justify-center px-0`} onClick={fit} title="Fit to view">
-          <Maximize size={15} />
-        </button>
-      </div>
-      <div className="absolute bottom-3 left-3 z-10 flex gap-2 text-[11px]">
-        <span className="px-2.5 py-1 rounded-full bg-surface-card border border-border-default text-text-body">
-          Parts: {doc.parts.length} · Wires: {doc.wires.length} · Nets: {nets.meaningful}
-        </span>
-        {warnings.length > 0 && (
-          <span className="px-2.5 py-1 rounded-full bg-surface-card border border-status-warning/40 text-status-warning" title={warnings.join('\n')}>
-            {warnings.length} migration note{warnings.length > 1 ? 's' : ''}
-          </span>
-        )}
-      </div>
+    <div className="size-full relative flex bg-bg overflow-hidden pb-7">
+      {editable && (
+        <Palette
+          wireColor={wireColor}
+          onPickColor={pickColor}
+          onAdd={(type) => void addPartAt(type)}
+          onEditPart={(type) => void editExisting(type)}
+          onNewPart={() => setEditorPart(null)}
+        />
+      )}
 
-      <div
-        ref={viewRef}
-        className="size-full"
-        style={{
-          touchAction: 'none',
-          backgroundImage: 'radial-gradient(var(--dot-color) 1.1px, transparent 1.1px)',
-          backgroundSize: `${9.6 * cam.scale}px ${9.6 * cam.scale}px`,
-          backgroundPosition: `${cam.tx}px ${cam.ty}px`
-        }}
-        onWheel={(e) => {
-          const r = viewRef.current!.getBoundingClientRect()
-          zoomAt(e.deltaY < 0 ? 1.12 : 1 / 1.12, e.clientX - r.left, e.clientY - r.top)
-        }}
-        onPointerDown={(e) => {
-          if (e.button !== 1 && !(e.button === 0 && e.altKey) && e.button !== 0) return
-          pan.current = { x: e.clientX, y: e.clientY }
-          ;(e.target as HTMLElement).setPointerCapture(e.pointerId)
-        }}
-        onPointerMove={(e) => {
-          const p = pan.current
-          if (!p) return
-          setCam((c) => ({ ...c, tx: c.tx + (e.clientX - p.x), ty: c.ty + (e.clientY - p.y) }))
-          pan.current = { x: e.clientX, y: e.clientY }
-        }}
-        onPointerUp={() => (pan.current = null)}
-      >
-        <div
-          style={{
-            position: 'absolute',
-            left: 0,
-            top: 0,
-            transform: `translate(${cam.tx}px, ${cam.ty}px) scale(${cam.scale})`,
-            transformOrigin: '0 0'
-          }}
-        >
-          {/* parts */}
-          {doc.parts.map((part) => {
-            if (!part.bb) return null
-            const def = getPart(part.type)
-            const v = def && viewFor(def, 'breadboard')
-            if (!v) {
-              return (
-                <div
-                  key={part.id}
-                  style={{ position: 'absolute', left: part.bb.x, top: part.bb.y }}
-                  className="px-2 py-1 rounded bg-surface-card border border-border-default text-[10px] text-text-faint"
-                >
-                  {part.type}…
-                </div>
-              )
-            }
-            return (
-              <div
-                key={part.id}
-                style={{
-                  position: 'absolute',
-                  left: part.bb.x,
-                  top: part.bb.y,
-                  width: v.w,
-                  height: v.h,
-                  transform: part.bb.rotate ? `rotate(${part.bb.rotate}deg)` : undefined,
-                  transformOrigin: 'center'
-                }}
+      <div className="flex-1 relative min-w-0 overflow-hidden flex">
+        {/* left toolbar: edit toggle + undo/redo */}
+        <div className="absolute top-3 left-3 z-10 flex gap-1.5">
+          <button
+            className={`${tool} w-8 justify-center px-0 ${editable ? 'text-brand' : ''}`}
+            onClick={() => {
+              const next = !editable
+              setEditable(next)
+              setSel(emptySel())
+              onEditChange?.(next)
+            }}
+            title={editable ? 'Editing — click for view-only' : 'View-only — click to edit'}
+          >
+            {editable ? <Eye size={15} /> : <Pencil size={15} />}
+          </button>
+          {editable && (
+            <>
+              <button
+                className={`${tool} w-8 justify-center px-0 disabled:opacity-40`}
+                disabled={!store.canUndo()}
+                onClick={() => store.undo()}
+                title={store.undoLabel() ? `Undo ${store.undoLabel()} (Ctrl+Z)` : 'Undo (Ctrl+Z)'}
+              >
+                <Undo2 size={15} />
+              </button>
+              <button
+                className={`${tool} w-8 justify-center px-0 disabled:opacity-40`}
+                disabled={!store.canRedo()}
+                onClick={() => store.redo()}
+                title="Redo (Ctrl+Y)"
               >
-                <div
-                  className="size-full [&>svg]:size-full [&>svg]:block pointer-events-none select-none"
-                  dangerouslySetInnerHTML={{ __html: v.svg }}
-                />
-                <div
-                  className="absolute text-[11px] whitespace-nowrap select-none text-text-muted"
-                  style={{ left: 0, top: v.h + 4 }}
-                >
-                  {part.id}
-                </div>
-              </div>
-            )
-          })}
+                <Redo2 size={15} />
+              </button>
+            </>
+          )}
+        </div>
 
-          {/* wires */}
-          <svg style={{ position: 'absolute', inset: 0, overflow: 'visible', pointerEvents: 'none' }}>
-            {wireGeom.map(({ w, pts }) => {
-              if (pts.length < 2) return null
-              const core = w.color || '#2fa46a'
-              const d = roundedPath(pts)
-              return (
-                <g key={w.id}>
-                  <path d={d} fill="none" stroke={darken(core)} strokeWidth={WIRE_OUTLINE_W} strokeLinejoin="round" strokeLinecap="round" />
-                  <path d={d} fill="none" stroke={core} strokeWidth={WIRE_W} strokeLinejoin="round" strokeLinecap="round" />
-                </g>
-              )
-            })}
-            {/* junction dots */}
-            {doc.wires.flatMap((w) =>
-              [w.from, w.to]
-                .filter(isJunction)
-                .map((j, i) => {
-                  const p = resolve(j)
-                  return p ? <circle key={`${w.id}j${i}`} cx={p.x} cy={p.y} r={3} fill={w.color || 'var(--text-strong)'} /> : null
-                })
-            )}
-          </svg>
+        {/* right toolbar: export / grid / code */}
+        <div className="absolute top-3 right-3.5 z-10 flex gap-1.5">
+          <button className={`${tool} w-8 justify-center px-0`} onClick={() => exportPng(doc)} title="Export as PNG">
+            <ImageDown size={15} />
+          </button>
+          <button className={`${tool} w-8 justify-center px-0`} onClick={() => exportSvg(doc)} title="Export as SVG">
+            <FileCode2 size={15} />
+          </button>
+          <button
+            className={`${tool} w-8 justify-center px-0 ${grid ? 'text-brand' : ''}`}
+            onClick={() => setGrid((g) => !g)}
+            title="Toggle grid"
+          >
+            <Grid3x3 size={15} />
+          </button>
+          {onOpenCode && (
+            <button className={`${tool} w-8 justify-center px-0`} onClick={onOpenCode} title="Edit circuit.json as code">
+              <CodeXml size={15} />
+            </button>
+          )}
+        </div>
 
-          {doc.parts.length === 0 && (
-            <div className="absolute flex flex-col items-center gap-2 text-text-faint text-sm text-center" style={{ left: 200, top: 160, width: 320 }}>
-              <CircuitBoard size={42} />
-              <div>Circuit v2 — empty document. Editing lands in M1.</div>
-            </div>
+        {/* zoom cluster */}
+        <div className="absolute bottom-3 right-3.5 z-10 flex gap-1.5">
+          <button
+            className={`${tool} w-8 justify-center px-0`}
+            onClick={() => canvasRef.current?.zoomCenter(1 / 1.15)}
+            title="Zoom out"
+          >
+            <ZoomOut size={15} />
+          </button>
+          <span className={`${tool} pointer-events-none min-w-[52px] justify-center`}>
+            {Math.round(cam.scale * 100)}%
+          </span>
+          <button
+            className={`${tool} w-8 justify-center px-0`}
+            onClick={() => canvasRef.current?.zoomCenter(1.15)}
+            title="Zoom in"
+          >
+            <ZoomIn size={15} />
+          </button>
+          <button className={`${tool} w-8 justify-center px-0`} onClick={() => canvasRef.current?.fit()} title="Fit to view">
+            <Maximize size={15} />
+          </button>
+        </div>
+
+        {/* status pills */}
+        <div className="absolute bottom-3 left-3 z-10 flex flex-wrap gap-2 text-[11px] max-w-[60%]">
+          <span className="px-2.5 py-1 rounded-full bg-surface-card border border-border-default text-text-body">
+            Parts: {doc.parts.length} · Wires: {doc.wires.length} · Nets: {netModel.meaningful}
+          </span>
+          {migrated && (
+            <span className="px-2.5 py-1 rounded-full bg-surface-card border border-brand/40 text-brand">
+              migrated from diagram.json
+            </span>
+          )}
+          {warnings.length > 0 && (
+            <span
+              className="px-2.5 py-1 rounded-full bg-surface-card border border-status-warning/40 text-status-warning"
+              title={warnings.join('\n')}
+            >
+              {warnings.length} migration note{warnings.length > 1 ? 's' : ''}
+            </span>
           )}
         </div>
+
+        <Canvas
+          store={store}
+          doc={doc}
+          editable={editable}
+          grid={grid}
+          sel={sel}
+          setSel={setSel}
+          wireColor={wireColor}
+          netModel={netModel}
+          defsTick={defsTick}
+          cam={cam}
+          setCam={setCam}
+          handleRef={canvasRef}
+          onDropPart={(type, at) => void addPartAt(type, at)}
+        />
+
+        {/* watermark */}
+        <div className="absolute bottom-12 right-4 z-0 pointer-events-none select-none text-[12px] font-semibold text-text-faint/70">
+          tinyStudio
+        </div>
       </div>
+
+      {editable && <InspectorRail doc={doc} store={store} sel={sel} setSel={setSel} netModel={netModel} />}
+
+      {editorPart !== undefined && (
+        <PartsEditor
+          initial={editorPart}
+          onClose={() => setEditorPart(undefined)}
+          onSave={(def: PartDef) => {
+            registerPart(def)
+            bumpDefs()
+            setEditorPart(undefined)
+          }}
+        />
+      )}
     </div>
   )
 }
diff --git a/src/renderer/src/circuit/views/canvas/Canvas.tsx b/src/renderer/src/circuit/views/canvas/Canvas.tsx
new file mode 100644
index 0000000..2cde9c9
--- /dev/null
+++ b/src/renderer/src/circuit/views/canvas/Canvas.tsx
@@ -0,0 +1,1179 @@
+/**
+ * circuit/views/canvas/Canvas — the interactive breadboard scene (M1).
+ *
+ * Owns: camera (zoom/pan/fit), pointer routing, selection + marquee, wire
+ * drawing/editing state machines, part drag with frozen-bend reroutes, and
+ * rendering (parts, glossy-tube wires, junction dots, handles, preview).
+ * The gesture set is a 1:1 port of DiagramEditor's editor behaviors, re-said
+ * as Commands against the CircuitStore — same editor, now with undo.
+ *
+ * Document mutations ONLY go through store.dispatch(command). Ephemeral state
+ * (camera, hover, armed wire, marquee, edit buffer) never touches the doc.
+ */
+
+import { CircuitBoard, MousePointer2, Zap } from 'lucide-react'
+import React from 'react'
+import { buildClipboard, materializePaste, parseClipboard } from '../../core/clipboard'
+import * as cmd from '../../core/commands'
+import {
+  GRID_BB,
+  isJunction,
+  isPendingJunction,
+  type CircuitDoc,
+  type Placement,
+  type Pt,
+  type WireEnd
+} from '../../core/model'
+import type { NetModel } from '../../core/nets'
+import {
+  calculateOrthogonalPath,
+  clampOntoSegment,
+  dragSegment,
+  hitWire,
+  isStraightRoute,
+  journeyFromPoints,
+  simplifyWirePoints,
+  tAtPoint,
+  vertexDrag,
+  type WireHit
+} from '../../core/routing'
+import type { CircuitStore } from '../../core/store'
+import {
+  bbVisual,
+  bbBounds,
+  bbWireGeometry,
+  collectFrozen,
+  makeEndResolver,
+  pinAtWorld,
+  reroutesFor,
+  snapBB,
+  type FrozenWire
+} from '../partsAdapter'
+
+// wire look (identical to DiagramEditor / tinySchematic)
+const WIRE_W = 2.8
+const WIRE_OUTLINE_W = WIRE_W + 1.8
+const WIRE_GLOW_W = WIRE_W + 5
+const WIRE_CORNER = 4
+const NET_GLOW = 'rgba(243, 203, 0, 0.30)'
+
+const snap = (v: number): number => Math.round(v / GRID_BB) * GRID_BB
+
+export interface Selection {
+  parts: Set<string>
+  wires: Set<string>
+}
+export const emptySel = (): Selection => ({ parts: new Set(), wires: new Set() })
+
+export interface Cam {
+  scale: number
+  tx: number
+  ty: number
+}
+
+export interface CanvasHandle {
+  fit: () => void
+  zoomCenter: (factor: number) => void
+  /** World coordinate at the viewport centre (palette double-click drops). */
+  centerWorld: () => Pt
+}
+
+type HandleKind = 'vertex' | 'edge' | 'endpoint'
+
+interface Armed {
+  from: string // "part:pin" — drawing always starts on a pin
+  points: Pt[]
+  straight: boolean
+}
+
+function darken(hex: string, f = 0.55): string {
+  const m = /^#?([0-9a-fA-F]{6})$/.exec(hex.trim())
+  if (!m) return 'rgba(0,0,0,0.45)'
+  const n = parseInt(m[1], 16)
+  return `rgb(${Math.round(((n >> 16) & 255) * f)}, ${Math.round(((n >> 8) & 255) * f)}, ${Math.round((n & 255) * f)})`
+}
+
+function roundedPath(points: Pt[], r = WIRE_CORNER): string {
+  if (points.length < 2) return ''
+  if (points.length === 2) return `M${points[0].x} ${points[0].y} L${points[1].x} ${points[1].y}`
+  let d = `M${points[0].x} ${points[0].y}`
+  for (let i = 1; i < points.length - 1; i++) {
+    const p = points[i - 1]
+    const c = points[i]
+    const n = points[i + 1]
+    const d1 = Math.hypot(c.x - p.x, c.y - p.y) || 1
+    const d2 = Math.hypot(n.x - c.x, n.y - c.y) || 1
+    const rr = Math.max(0, Math.min(r, d1 / 2, d2 / 2))
+    const a = { x: c.x - ((c.x - p.x) / d1) * rr, y: c.y - ((c.y - p.y) / d1) * rr }
+    const b = { x: c.x + ((n.x - c.x) / d2) * rr, y: c.y + ((n.y - c.y) / d2) * rr }
+    d += ` L${a.x} ${a.y} Q${c.x} ${c.y} ${b.x} ${b.y}`
+  }
+  const last = points[points.length - 1]
+  d += ` L${last.x} ${last.y}`
+  return d
+}
+
+export function Canvas({
+  store,
+  doc,
+  editable,
+  grid,
+  sel,
+  setSel,
+  wireColor,
+  netModel,
+  defsTick,
+  cam,
+  setCam,
+  handleRef,
+  onDropPart
+}: {
+  store: CircuitStore
+  doc: CircuitDoc
+  editable: boolean
+  grid: boolean
+  sel: Selection
+  setSel: (s: Selection) => void
+  wireColor: string
+  netModel: NetModel
+  /** bumps when lazy part defs finish loading (geometry depends on them) */
+  defsTick: number
+  cam: Cam
+  setCam: React.Dispatch<React.SetStateAction<Cam>>
+  handleRef: React.Ref<CanvasHandle>
+  onDropPart: (type: string, at: Pt) => void
+}): React.JSX.Element {
+  const scale = cam.scale
+  const viewRef = React.useRef<HTMLDivElement>(null)
+  const innerRef = React.useRef<HTMLDivElement>(null)
+
+  const [armed, setArmed] = React.useState<Armed | null>(null)
+  const [straight, setStraight] = React.useState(false)
+  const [hoverPin, setHoverPin] = React.useState<{ id: string; pin: string } | null>(null)
+  const [hoverWire, setHoverWire] = React.useState<string | null>(null)
+  const [mouse, setMouse] = React.useState<Pt>({ x: 0, y: 0 })
+  const [editPts, setEditPts] = React.useState<Pt[] | null>(null)
+  const [marquee, setMarquee] = React.useState<{ a: Pt; b: Pt } | null>(null)
+  // live placement overrides while a part drag is in flight (render source)
+  const [dragOverrides, setDragOverrides] = React.useState<Map<string, Placement> | null>(null)
+
+  const pan = React.useRef<Pt | null>(null)
+  const partDrag = React.useRef<{
+    ids: string[]
+    grabbed: string
+    offX: number
+    offY: number
+    orig: Map<string, Placement>
+    frozen: FrozenWire[]
+  } | null>(null)
+  const handleDrag = React.useRef<{ kind: HandleKind } | null>(null)
+  const labelDrag = React.useRef<{ id: string; ox: number; oy: number } | null>(null)
+  const suppressClick = React.useRef(false)
+
+  // ── geometry ────────────────────────────────────────────────────────────────
+
+  const resolve = React.useMemo(
+    () => makeEndResolver(doc, dragOverrides ?? undefined),
+    [doc, dragOverrides, defsTick]
+  )
+  const wireGeom = React.useMemo(
+    () => bbWireGeometry(doc, dragOverrides ?? undefined),
+    [doc, dragOverrides, defsTick]
+  )
+  const geomForHit = React.useMemo(
+    () => wireGeom.filter((g) => g.pts.length >= 2).map((g) => ({ id: g.w.id, points: g.pts })),
+    [wireGeom]
+  )
+
+  const canvasPoint = (e: { clientX: number; clientY: number }): Pt => {
+    const r = innerRef.current!.getBoundingClientRect()
+    return { x: (e.clientX - r.left) / scale, y: (e.clientY - r.top) / scale }
+  }
+  const placementOf = (id: string): Placement | undefined =>
+    dragOverrides?.get(id) ?? doc.parts.find((p) => p.id === id)?.bb
+
+  // selected wire edit buffer stays in sync with the doc (undo, external edits)
+  const soloWire = sel.wires.size === 1 && sel.parts.size === 0 ? [...sel.wires][0] : null
+  React.useEffect(() => {
+    if (handleDrag.current) return
+    if (!soloWire) {
+      setEditPts(null)
+      return
+    }
+    const g = wireGeom.find((x) => x.w.id === soloWire)
+    setEditPts(g && g.pts.length >= 2 ? g.pts : null)
+  }, [soloWire, wireGeom])
+
+  // resolve v1-migrated *pending junctions* once geometry exists (M0 gap)
+  const pendingDone = React.useRef(false)
+  React.useEffect(() => {
+    if (pendingDone.current) return
+    const pending = doc.wires.filter(
+      (w) => isPendingJunction(w.from) || isPendingJunction(w.to)
+    )
+    if (pending.length === 0) {
+      pendingDone.current = true
+      return
+    }
+    if (doc.parts.some((p) => p.bb && !bbVisual(p.type))) return // defs still loading
+    const fixes: cmd.Command[] = []
+    for (const w of pending) {
+      const fix = (end: WireEnd): WireEnd => {
+        if (!isPendingJunction(end)) return end
+        const others = geomForHit.filter((g) => g.id !== w.id)
+        const hit = hitWire(end.x, end.y, others, 0.75) // 8 world px tolerance
+        if (!hit) return end // stays pending; renders at its raw coordinate
+        const host = others.find((g) => g.id === hit.id)!
+        return { wire: hit.id, t: tAtPoint(host.points, { x: end.x, y: end.y }) }
+      }
+      const from = fix(w.from)
+      const to = fix(w.to)
+      if (from !== w.from || to !== w.to) fixes.push(cmd.setWireEnds(w.id, from, to))
+    }
+    pendingDone.current = true
+    if (fixes.length) store.dispatch(cmd.composite('Resolve migrated junctions', fixes))
+  }, [doc, geomForHit, store, defsTick])
+
+  // ── net highlight ───────────────────────────────────────────────────────────
+
+  const highlightNet = React.useMemo(() => {
+    if (hoverPin) {
+      const i = netModel.pinToNet.get(`${hoverPin.id}:${hoverPin.pin}`)
+      if (i != null) return i
+    }
+    const wid = hoverWire ?? soloWire
+    if (wid != null) {
+      const i = netModel.wireToNet.get(wid)
+      if (i != null) return i
+    }
+    return -1
+  }, [hoverPin, hoverWire, soloWire, netModel])
+
+  // ── camera ──────────────────────────────────────────────────────────────────
+
+  const fit = React.useCallback((): void => {
+    const el = viewRef.current
+    if (!el) return
+    const b = bbBounds(doc)
+    if (!b) return
+    const pad = 48
+    const bw = b.maxX - b.minX + pad * 2
+    const bh = b.maxY - b.minY + pad * 2
+    const f = Math.max(0.25, Math.min(3, Math.min(el.clientWidth / bw, el.clientHeight / bh)))
+    setCam({
+      scale: f,
+      tx: (el.clientWidth - bw * f) / 2 - (b.minX - pad) * f,
+      ty: (el.clientHeight - bh * f) / 2 - (b.minY - pad) * f
+    })
+  }, [doc, setCam])
+
+  const zoomAt = (factor: number, sx: number, sy: number): void =>
+    setCam((c) => {
+      const ns = Math.max(0.25, Math.min(3, c.scale * factor))
+      const k = ns / c.scale
+      return { scale: ns, tx: sx - (sx - c.tx) * k, ty: sy - (sy - c.ty) * k }
+    })
+
+  React.useImperativeHandle(
+    handleRef,
+    () => ({
+      fit,
+      zoomCenter: (factor: number) => {
+        const el = viewRef.current
+        if (el) zoomAt(factor, el.clientWidth / 2, el.clientHeight / 2)
+      },
+      centerWorld: () => {
+        const el = viewRef.current
+        if (!el) return { x: 0, y: 0 }
+        return {
+          x: (el.clientWidth / 2 - cam.tx) / scale,
+          y: (el.clientHeight / 2 - cam.ty) / scale
+        }
+      }
+    }),
+    [fit, cam, scale]
+  )
+
+  const didFit = React.useRef(false)
+  React.useEffect(() => {
+    if (didFit.current) return
+    if (doc.parts.length === 0 || doc.parts.every((p) => !p.bb || bbVisual(p.type))) {
+      fit()
+      didFit.current = true
+    }
+  })
+
+  // ── part drag (frozen bends; multi-select moves together) ───────────────────
+
+  const onPartDown = (e: React.PointerEvent, partId: string): void => {
+    if ((e.target as HTMLElement).closest('.pin-hit')) return
+    e.stopPropagation()
+    if (!editable) {
+      setSel({ parts: new Set([partId]), wires: new Set() })
+      return
+    }
+    if (e.shiftKey) {
+      const parts = new Set(sel.parts)
+      if (parts.has(partId)) parts.delete(partId)
+      else parts.add(partId)
+      setSel({ parts, wires: new Set() })
+      return
+    }
+    const moveIds = sel.parts.has(partId) ? [...sel.parts] : [partId]
+    if (!sel.parts.has(partId)) setSel({ parts: new Set([partId]), wires: new Set() })
+
+    const grabbedPl = placementOf(partId)
+    if (!grabbedPl) return
+    const r = innerRef.current!.getBoundingClientRect()
+    const orig = new Map<string, Placement>()
+    for (const id of moveIds) {
+      const pl = doc.parts.find((p) => p.id === id)?.bb
+      if (pl) orig.set(id, pl)
+    }
+    partDrag.current = {
+      ids: [...orig.keys()],
+      grabbed: partId,
+      offX: (e.clientX - r.left) / scale - grabbedPl.x,
+      offY: (e.clientY - r.top) / scale - grabbedPl.y,
+      orig,
+      frozen: collectFrozen(doc, new Set(orig.keys()))
+    }
+    window.addEventListener('pointermove', onPartMove)
+    window.addEventListener('pointerup', onPartUp)
+  }
+
+  const onPartMove = (e: PointerEvent): void => {
+    const d = partDrag.current
+    if (!d) return
+    const r = innerRef.current!.getBoundingClientRect()
+    const grabbedOrig = d.orig.get(d.grabbed)!
+    const part = doc.parts.find((p) => p.id === d.grabbed)
+    if (!part) return
+    const raw: Placement = {
+      ...grabbedOrig,
+      x: (e.clientX - r.left) / scale - d.offX,
+      y: (e.clientY - r.top) / scale - d.offY
+    }
+    const snapped = snapBB(part.type, raw)
+    const delta = { x: snapped.x - grabbedOrig.x, y: snapped.y - grabbedOrig.y }
+
+    const placements = new Map<string, Placement>()
+    for (const [id, pl] of d.orig) {
+      placements.set(id, { ...pl, x: pl.x + delta.x, y: pl.y + delta.y })
+    }
+    setDragOverrides(placements)
+
+    const reroutes = reroutesFor(doc, d.frozen, placements, delta)
+    const cmds = [...placements.entries()].map(([id, pl], i) =>
+      cmd.placePart(id, 'bb', pl, i === 0 ? reroutes : [])
+    )
+    store.dispatch(
+      cmd.composite(
+        d.ids.length === 1 ? `Move ${d.grabbed}` : `Move ${d.ids.length} parts`,
+        cmds,
+        `movebb:${d.ids.slice().sort().join(',')}`
+      )
+    )
+  }
+
+  const onPartUp = (): void => {
+    partDrag.current = null
+    setDragOverrides(null)
+    window.removeEventListener('pointermove', onPartMove)
+    window.removeEventListener('pointerup', onPartUp)
+  }
+
+  // drag a part's title label (offset stored on the bb placement)
+  const onLabelDown = (e: React.PointerEvent, partId: string): void => {
+    if (!editable) return
+    e.stopPropagation()
+    setSel({ parts: new Set([partId]), wires: new Set() })
+    const start = canvasPoint(e)
+    const pl = placementOf(partId)
+    if (!pl) return
+    const off = pl.labelOffset || [0, 0]
+    labelDrag.current = { id: partId, ox: off[0] - start.x, oy: off[1] - start.y }
+    const move = (ev: PointerEvent): void => {
+      const ld = labelDrag.current
+      if (!ld) return
+      const cur = doc.parts.find((p) => p.id === ld.id)?.bb
+      if (!cur) return
+      const cp = canvasPoint(ev)
+      const offset: [number, number] = [Math.round(ld.ox + cp.x), Math.round(ld.oy + cp.y)]
+      store.dispatch(cmd.placePart(ld.id, 'bb', { ...cur, labelOffset: offset }, [], true))
+    }
+    const up = (): void => {
+      labelDrag.current = null
+      window.removeEventListener('pointermove', move)
+      window.removeEventListener('pointerup', up)
+    }
+    window.addEventListener('pointermove', move)
+    window.addEventListener('pointerup', up)
+  }
+
+  // ── wire drawing ────────────────────────────────────────────────────────────
+
+  const finalizeSegment = (target: Pt, clean: boolean): { pts: Pt[]; str: boolean } => {
+    const pts = [...armed!.points]
+    const last = pts[pts.length - 1]
+    const str = armed!.straight || straight
+    if (str) pts.push(target)
+    else pts.push(...calculateOrthogonalPath(last.x, last.y, target.x, target.y, clean).slice(1))
+    return { pts: simplifyWirePoints(pts), str }
+  }
+
+  const commitWire = (from: WireEnd, to: WireEnd, pts: Pt[], str: boolean): void => {
+    store.dispatch(
+      cmd.addWire({
+        from,
+        to,
+        view: 'bb',
+        color: wireColor,
+        route: journeyFromPoints(pts, str)
+      })
+    )
+  }
+
+  const onPinClick = (e: React.MouseEvent, partId: string, pin: string): void => {
+    if (!editable) return
+    e.stopPropagation()
+    const ref = `${partId}:${pin}`
+    const pos = resolve(ref)
+    if (!pos) return
+    if (!armed) {
+      setArmed({ from: ref, points: [pos], straight: false })
+      setSel(emptySel())
+      return
+    }
+    if (armed.from === ref) {
+      setArmed(null)
+      return
+    }
+    const { pts, str } = finalizeSegment(pos, true)
+    commitWire(armed.from, ref, pts, str)
+    setArmed(null)
+  }
+
+  // tap a junction onto an existing wire at the click point → {wire, t}
+  const tapJunction = (hit: WireHit): void => {
+    const host = geomForHit.find((g) => g.id === hit.id)
+    if (!host || !armed) return
+    const jp = clampOntoSegment(hit.p1, hit.p2, snap(mouse.x), snap(mouse.y))
+    const t = tAtPoint(host.points, jp)
+    const { pts, str } = finalizeSegment(jp, false)
+    commitWire(armed.from, { wire: hit.id, t }, pts, str)
+    setArmed(null)
+  }
+
+  const onCanvasClick = (e: React.MouseEvent): void => {
+    if (suppressClick.current) {
+      suppressClick.current = false
+      return
+    }
+    if (armed) {
+      const cp = canvasPoint(e)
+      const hit = hitWire(cp.x, cp.y, geomForHit, scale)
+      if (hit) {
+        setMouse(cp)
+        tapJunction(hit)
+        return
+      }
+      const target = { x: snap(cp.x), y: snap(cp.y) }
+      const last = armed.points[armed.points.length - 1]
+      const seg = straight
+        ? [last, target]
+        : calculateOrthogonalPath(last.x, last.y, target.x, target.y, false)
+      setArmed({
+        ...armed,
+        points: [...armed.points, ...seg.slice(1)],
+        straight: armed.straight || straight
+      })
+      return
+    }
+    if (!e.shiftKey) setSel(emptySel())
+  }
+
+  // ── selected-wire editing (segment / vertex / endpoint handles) ─────────────
+
+  const resolveEndpointTarget = (wx: number, wy: number, selfId: string): WireEnd | null => {
+    const pin = pinAtWorld(doc, wx, wy, 8 / scale)
+    if (pin) return `${pin.id}:${pin.pin}`
+    const others = geomForHit.filter((g) => g.id !== selfId)
+    const hit = hitWire(wx, wy, others, scale)
+    if (hit) {
+      const host = others.find((g) => g.id === hit.id)!
+      const jp = clampOntoSegment(hit.p1, hit.p2, snap(wx), snap(wy))
+      return { wire: hit.id, t: tAtPoint(host.points, jp) }
+    }
+    return null // v2 has no free-point endpoints — caller reverts
+  }
+
+  const startHandleDrag = (e: React.PointerEvent, kind: HandleKind, idx: number, end?: 0 | 1): void => {
+    if (!editable || !soloWire || !editPts) return
+    e.stopPropagation()
+    const wireId = soloWire
+    const wire = doc.wires.find((w) => w.id === wireId)
+    if (!wire) return
+    const orig = editPts
+    const str = isStraightRoute(wire.route)
+    const axis: 'horizontal' | 'vertical' =
+      kind === 'edge' && Math.abs(orig[idx].y - orig[idx + 1].y) < 0.001 ? 'horizontal' : 'vertical'
+    const endIdx = end === 0 ? 0 : orig.length - 1
+    let live = orig
+    let lastWorld = { x: 0, y: 0 }
+    handleDrag.current = { kind }
+    const move = (ev: PointerEvent): void => {
+      const cp = canvasPoint(ev)
+      if (kind === 'vertex') {
+        live = vertexDrag(orig, idx, snap(cp.x), snap(cp.y))
+      } else if (kind === 'edge') {
+        live = dragSegment(orig, idx, axis, snap(cp.x), snap(cp.y))
+      } else {
+        lastWorld = cp
+        const p = { x: snap(cp.x), y: snap(cp.y) }
+        live = orig.map((pt, k) => (k === endIdx ? p : pt))
+      }
+      setEditPts(live)
+    }
+    const up = (): void => {
+      window.removeEventListener('pointermove', move)
+      window.removeEventListener('pointerup', up)
+      handleDrag.current = null
+      if (kind === 'endpoint') {
+        const tgt = resolveEndpointTarget(lastWorld.x, lastWorld.y, wireId)
+        const origEnd = end === 0 ? wire.from : wire.to
+        const finalEnd = tgt ?? origEnd // no valid target → endpoint stays put
+        const rp = resolve(finalEnd)
+        if (rp) live = live.map((pt, k) => (k === endIdx ? rp : pt))
+        store.dispatch(
+          cmd.setWireEnds(
+            wireId,
+            end === 0 ? finalEnd : undefined,
+            end === 1 ? finalEnd : undefined,
+            journeyFromPoints(simplifyWirePoints(live), str)
+          )
+        )
+      } else {
+        store.dispatch(cmd.rerouteWire(wireId, journeyFromPoints(simplifyWirePoints(live), str)))
+      }
+    }
+    window.addEventListener('pointermove', move)
+    window.addEventListener('pointerup', up)
+  }
+
+  const onWireDoubleClick = (e: React.MouseEvent, wireId: string): void => {
+    if (!editable) return
+    e.stopPropagation()
+    const g = wireGeom.find((x) => x.w.id === wireId)
+    if (!g || g.pts.length < 2) return
+    const str = isStraightRoute(g.w.route)
+    const cp = canvasPoint(e)
+    const handleR = 7 / scale
+    for (let k = 1; k < g.pts.length - 1; k++) {
+      if (Math.hypot(g.pts[k].x - cp.x, g.pts[k].y - cp.y) < handleR) {
+        const next = simplifyWirePoints(g.pts.filter((_, j) => j !== k))
+        store.dispatch(cmd.rerouteWire(wireId, journeyFromPoints(next, str)))
+        setEditPts(next)
+        return
+      }
+    }
+    const hit = hitWire(cp.x, cp.y, [{ id: wireId, points: g.pts }], scale)
+    if (hit) {
+      const next = g.pts.slice()
+      next.splice(hit.segmentIndex + 1, 0, { x: snap(cp.x), y: snap(cp.y) })
+      store.dispatch(cmd.rerouteWire(wireId, journeyFromPoints(next, str)))
+      setSel({ parts: new Set(), wires: new Set([wireId]) })
+      setEditPts(next)
+    }
+  }
+
+  const onWireClick = (e: React.MouseEvent, wireId: string): void => {
+    e.stopPropagation()
+    if (armed) {
+      const cp = canvasPoint(e)
+      setMouse(cp)
+      const hit = hitWire(cp.x, cp.y, geomForHit.filter((g) => g.id === wireId), scale)
+      if (hit) tapJunction(hit)
+      return
+    }
+    if (e.shiftKey && editable) {
+      const wires = new Set(sel.wires)
+      if (wires.has(wireId)) wires.delete(wireId)
+      else wires.add(wireId)
+      setSel({ parts: sel.parts, wires })
+      return
+    }
+    setSel({ parts: new Set(), wires: new Set([wireId]) })
+  }
+
+  // ── background: pan / marquee ───────────────────────────────────────────────
+
+  const onViewPointerDown = (e: React.PointerEvent): void => {
+    const panButton = e.button === 1 || (e.button === 0 && e.altKey) || (e.button === 0 && !editable)
+    if (panButton) {
+      e.preventDefault()
+      pan.current = { x: e.clientX, y: e.clientY }
+      const move = (ev: PointerEvent): void => {
+        const p = pan.current
+        if (!p) return
+        setCam((c) => ({ ...c, tx: c.tx + (ev.clientX - p.x), ty: c.ty + (ev.clientY - p.y) }))
+        pan.current = { x: ev.clientX, y: ev.clientY }
+        suppressClick.current = true
+      }
+      const up = (): void => {
+        pan.current = null
+        window.removeEventListener('pointermove', move)
+        window.removeEventListener('pointerup', up)
+      }
+      window.addEventListener('pointermove', move)
+      window.addEventListener('pointerup', up)
+      return
+    }
+    // left-drag on empty canvas in edit mode (not while drawing) = marquee.
+    // Parts/pins/wires/handles all stopPropagation, so reaching here on the
+    // view div (or the zero-size scene div) means the press hit empty canvas.
+    if (e.button === 0 && editable && !armed) {
+      const start = canvasPoint(e)
+      const additive = e.shiftKey
+      let rect: { a: Pt; b: Pt } | null = null
+      const move = (ev: PointerEvent): void => {
+        rect = { a: start, b: canvasPoint(ev) }
+        setMarquee(rect)
+      }
+      const up = (): void => {
+        window.removeEventListener('pointermove', move)
+        window.removeEventListener('pointerup', up)
+        setMarquee(null)
+        if (!rect) return // plain click — onCanvasClick handles deselect
+        const x0 = Math.min(rect.a.x, rect.b.x)
+        const y0 = Math.min(rect.a.y, rect.b.y)
+        const x1 = Math.max(rect.a.x, rect.b.x)
+        const y1 = Math.max(rect.a.y, rect.b.y)
+        if (x1 - x0 < 3 && y1 - y0 < 3) return
+        suppressClick.current = true
+        const parts = new Set(additive ? sel.parts : [])
+        for (const part of doc.parts) {
+          if (!part.bb) continue
+          const vis = bbVisual(part.type)
+          if (!vis) continue
+          if (part.bb.x < x1 && part.bb.x + vis.v.w > x0 && part.bb.y < y1 && part.bb.y + vis.v.h > y0)
+            parts.add(part.id)
+        }
+        const wires = new Set(additive ? sel.wires : [])
+        for (const g of wireGeom) {
+          if (g.pts.some((p) => p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1)) wires.add(g.w.id)
+        }
+        setSel({ parts, wires })
+      }
+      window.addEventListener('pointermove', move)
+      window.addEventListener('pointerup', up)
+    }
+  }
+
+  const onCanvasMove = (e: React.PointerEvent): void => {
+    if (armed) setMouse(canvasPoint(e))
+  }
+
+  const onDrop = (e: React.DragEvent): void => {
+    e.preventDefault()
+    const type = e.dataTransfer.getData('text/tinystudio-part')
+    if (type) onDropPart(type, canvasPoint(e))
+  }
+
+  // ── keyboard: undo/redo, delete, rotate, nudge, clipboard, Esc, Shift ───────
+
+  const rotateSelection = React.useCallback((): void => {
+    const ids = [...sel.parts]
+    if (!ids.length) return
+    const frozen = collectFrozen(doc, new Set(ids))
+    const placements = new Map<string, Placement>()
+    const cmds: cmd.Command[] = []
+    for (const id of ids) {
+      const cur = doc.parts.find((p) => p.id === id)?.bb
+      if (!cur) continue
+      const next = (((((cur.rotate ?? 0) + 90) % 360) + 360) % 360) as 0 | 90 | 180 | 270
+      placements.set(id, { ...cur, rotate: next || undefined })
+    }
+    const reroutes = reroutesFor(doc, frozen, placements, { x: 0, y: 0 })
+    let first = true
+    for (const [id, pl] of placements) {
+      cmds.push(cmd.placePart(id, 'bb', pl, first ? reroutes : []))
+      first = false
+    }
+    if (cmds.length) store.dispatch(cmd.composite(`Rotate ${ids.length > 1 ? `${ids.length} parts` : ids[0]}`, cmds))
+  }, [doc, sel, store])
+
+  const nudgeSelection = React.useCallback(
+    (dx: number, dy: number): void => {
+      const ids = [...sel.parts]
+      if (!ids.length) return
+      const frozen = collectFrozen(doc, new Set(ids))
+      const placements = new Map<string, Placement>()
+      for (const id of ids) {
+        const cur = doc.parts.find((p) => p.id === id)?.bb
+        if (cur) placements.set(id, { ...cur, x: cur.x + dx, y: cur.y + dy })
+      }
+      const reroutes = reroutesFor(doc, frozen, placements, { x: dx, y: dy })
+      let first = true
+      const cmds: cmd.Command[] = []
+      for (const [id, pl] of placements) {
+        cmds.push(cmd.placePart(id, 'bb', pl, first ? reroutes : []))
+        first = false
+      }
+      if (cmds.length)
+        store.dispatch(cmd.composite('Nudge', cmds, `nudge:${ids.slice().sort().join(',')}`))
+    },
+    [doc, sel, store]
+  )
+
+  const deleteSelection = React.useCallback((): void => {
+    const cmds: cmd.Command[] = []
+    if (sel.parts.size) cmds.push(cmd.deleteParts([...sel.parts]))
+    if (sel.wires.size) cmds.push(cmd.deleteWires([...sel.wires]))
+    if (!cmds.length) return
+    store.dispatch(cmds.length === 1 ? cmds[0] : cmd.composite('Delete selection', cmds))
+    setSel(emptySel())
+  }, [sel, store, setSel])
+
+  const copySelection = React.useCallback(async (): Promise<boolean> => {
+    const payload = buildClipboard(doc, sel.parts, sel.wires)
+    if (!payload) return false
+    try {
+      await navigator.clipboard.writeText(JSON.stringify(payload))
+      return true
+    } catch {
+      return false
+    }
+  }, [doc, sel])
+
+  const pastePayload = React.useCallback(
+    (payload: NonNullable<ReturnType<typeof parseClipboard>>): void => {
+      const { parts, wires, idMap } = materializePaste(doc, payload, { x: GRID_BB * 2, y: GRID_BB * 2 })
+      if (!parts.length && !wires.length) return
+      store.dispatch(
+        cmd.composite(`Paste ${parts.length} part${parts.length === 1 ? '' : 's'}`, [
+          ...parts.map((p) => cmd.addPart(p)),
+          ...wires.map((w) => cmd.addWire(w))
+        ])
+      )
+      setSel({ parts: new Set(idMap.values()), wires: new Set(wires.map((w) => w.id)) })
+    },
+    [doc, store, setSel]
+  )
+
+  React.useEffect(() => {
+    const down = (e: KeyboardEvent): void => {
+      if (document.activeElement && /INPUT|TEXTAREA|SELECT/.test(document.activeElement.tagName)) return
+      if (e.key === 'Shift') setStraight(true)
+      if (e.key === 'Escape') {
+        setArmed(null)
+        setSel(emptySel())
+        return
+      }
+      if (!editable) return
+      const mod = e.ctrlKey || e.metaKey
+      if (mod && (e.key === 'z' || e.key === 'Z')) {
+        e.preventDefault()
+        if (e.shiftKey) store.redo()
+        else store.undo()
+        return
+      }
+      if (mod && (e.key === 'y' || e.key === 'Y')) {
+        e.preventDefault()
+        store.redo()
+        return
+      }
+      if (mod && (e.key === 'c' || e.key === 'C')) {
+        void copySelection()
+        return
+      }
+      if (mod && (e.key === 'x' || e.key === 'X')) {
+        void copySelection().then((ok) => {
+          if (ok) deleteSelection()
+        })
+        return
+      }
+      if (mod && (e.key === 'v' || e.key === 'V')) {
+        void navigator.clipboard.readText().then((text) => {
+          const payload = parseClipboard(text)
+          if (payload) pastePayload(payload)
+        })
+        return
+      }
+      if (mod && (e.key === 'd' || e.key === 'D')) {
+        e.preventDefault()
+        const payload = buildClipboard(doc, sel.parts, sel.wires)
+        if (payload) pastePayload(payload)
+        return
+      }
+      if (e.key === 'r' || e.key === 'R' || e.key === ' ') {
+        if (sel.parts.size) {
+          e.preventDefault()
+          rotateSelection()
+        }
+        return
+      }
+      if (e.key === 'Delete' || e.key === 'Backspace') {
+        deleteSelection()
+        return
+      }
+      if (e.key.startsWith('Arrow') && sel.parts.size) {
+        e.preventDefault()
+        const step = GRID_BB * (e.shiftKey ? 5 : 1)
+        const d = {
+          ArrowLeft: [-step, 0],
+          ArrowRight: [step, 0],
+          ArrowUp: [0, -step],
+          ArrowDown: [0, step]
+        }[e.key]
+        if (d) nudgeSelection(d[0], d[1])
+      }
+    }
+    const up = (e: KeyboardEvent): void => {
+      if (e.key === 'Shift') setStraight(false)
+    }
+    window.addEventListener('keydown', down)
+    window.addEventListener('keyup', up)
+    return () => {
+      window.removeEventListener('keydown', down)
+      window.removeEventListener('keyup', up)
+    }
+  }, [editable, sel, doc, store, setSel, copySelection, pastePayload, deleteSelection, rotateSelection, nudgeSelection])
+
+  // ── derived render bits ─────────────────────────────────────────────────────
+
+  const previewPts = React.useMemo((): Pt[] | null => {
+    if (!armed) return null
+    const last = armed.points[armed.points.length - 1]
+    let target = { x: snap(mouse.x), y: snap(mouse.y) }
+    let clean = false
+    if (hoverPin) {
+      const pos = resolve(`${hoverPin.id}:${hoverPin.pin}`)
+      if (pos) {
+        target = pos
+        clean = true
+      }
+    }
+    if (armed.straight || straight) return [...armed.points, target]
+    return [...armed.points, ...calculateOrthogonalPath(last.x, last.y, target.x, target.y, clean).slice(1)]
+  }, [armed, mouse, hoverPin, straight, resolve])
+
+  // junction solder dots (junction endpoints take the host wire's color)
+  const junctionDots = React.useMemo(() => {
+    const out: { key: string; pt: Pt; color: string }[] = []
+    const colorOf = new Map(doc.wires.map((w) => [w.id, w.color || '#2fa46a']))
+    doc.wires
+      .filter((w) => w.view === 'bb')
+      .forEach((w) =>
+        [w.from, w.to].forEach((end, i) => {
+          if (!isJunction(end)) return
+          const p = resolve(end)
+          if (!p) return
+          const color = isPendingJunction(end)
+            ? w.color || '#2fa46a'
+            : colorOf.get(end.wire) || w.color || '#2fa46a'
+          out.push({ key: `${w.id}:${i}`, pt: p, color })
+        })
+      )
+    return out
+  }, [doc, resolve])
+
+  const hint = !editable
+    ? { icon: <MousePointer2 size={12} />, text: 'View-only · hover a wire to light its net · click edit to change', hot: false }
+    : armed
+      ? { icon: <Zap size={12} />, text: 'Click a pin or wire to connect · click for a bend · hold Shift for straight · Esc to cancel', hot: true }
+      : soloWire
+        ? { icon: null, text: 'Drag a handle to reshape · double-click to add/remove a bend · Del to remove', hot: true }
+        : { icon: <MousePointer2 size={12} />, text: 'Scroll to zoom · drag to marquee-select · middle/Alt-drag to pan · click a pin to wire', hot: false }
+
+  return (
+    <div className="flex-1 relative min-w-0 overflow-hidden">
+      <div
+        ref={viewRef}
+        className="size-full overflow-hidden"
+        style={{
+          touchAction: 'none',
+          cursor: armed ? 'crosshair' : 'default',
+          backgroundColor: 'var(--bg-sunken)',
+          backgroundImage: grid ? 'radial-gradient(var(--dot-color) 1.1px, transparent 1.1px)' : 'none',
+          backgroundSize: `${GRID_BB * scale}px ${GRID_BB * scale}px`,
+          backgroundPosition: `${cam.tx}px ${cam.ty}px`
+        }}
+        onWheel={(e) => {
+          const r = viewRef.current!.getBoundingClientRect()
+          zoomAt(e.deltaY < 0 ? 1.12 : 1 / 1.12, e.clientX - r.left, e.clientY - r.top)
+        }}
+        onPointerDown={onViewPointerDown}
+        onPointerMove={onCanvasMove}
+        onDragOver={(e) => {
+          e.preventDefault()
+          e.dataTransfer.dropEffect = 'copy'
+        }}
+        onDrop={onDrop}
+        onClick={onCanvasClick}
+      >
+        <div
+          ref={innerRef}
+          style={{
+            position: 'absolute',
+            left: 0,
+            top: 0,
+            transform: `translate(${cam.tx}px, ${cam.ty}px) scale(${scale})`,
+            transformOrigin: '0 0'
+          }}
+        >
+          {/* wires */}
+          <svg style={{ position: 'absolute', inset: 0, overflow: 'visible', zIndex: 5, pointerEvents: 'none' }}>
+            {wireGeom.map(({ w, pts: raw }) => {
+              const pts = soloWire === w.id && editPts ? editPts : raw
+              if (pts.length < 2) return null
+              const selected = sel.wires.has(w.id)
+              const onHotNet = highlightNet >= 0 && netModel.wireToNet.get(w.id) === highlightNet
+              const core = w.color || '#2fa46a'
+              const d = roundedPath(pts)
+              return (
+                <g
+                  key={w.id}
+                  style={{ cursor: editable ? 'pointer' : 'default', pointerEvents: 'stroke' }}
+                  onPointerEnter={() => setHoverWire(w.id)}
+                  onPointerLeave={() => setHoverWire((h) => (h === w.id ? null : h))}
+                  onClick={(e) => onWireClick(e, w.id)}
+                  onDoubleClick={(e) => onWireDoubleClick(e, w.id)}
+                >
+                  {onHotNet && (
+                    <path d={d} fill="none" stroke={NET_GLOW} strokeWidth={WIRE_GLOW_W} strokeLinejoin="round" strokeLinecap="round" />
+                  )}
+                  <path d={d} fill="none" stroke={darken(core)} strokeWidth={WIRE_OUTLINE_W} strokeLinejoin="round" strokeLinecap="round" />
+                  <path d={d} fill="none" stroke={core} strokeWidth={WIRE_W} strokeLinejoin="round" strokeLinecap="round" />
+                  {selected && (
+                    <path d={d} fill="none" stroke="rgba(255,255,255,0.85)" strokeWidth={1} strokeDasharray="4 4" strokeLinejoin="round">
+                      <animate attributeName="stroke-dashoffset" from="0" to="-8" dur="0.5s" repeatCount="indefinite" />
+                    </path>
+                  )}
+                </g>
+              )
+            })}
+
+            {junctionDots.map((j) => (
+              <circle key={j.key} cx={j.pt.x} cy={j.pt.y} r={3} fill={j.color} />
+            ))}
+
+            {previewPts && (
+              <path d={roundedPath(previewPts)} fill="none" stroke={wireColor} strokeWidth={WIRE_W} strokeLinejoin="round" strokeLinecap="round" opacity={0.6} />
+            )}
+
+            {/* handles on the solo-selected wire */}
+            {editable && soloWire && editPts && (
+              <g style={{ pointerEvents: 'auto' }}>
+                {editPts.slice(0, -1).map((p, i) => {
+                  const q = editPts[i + 1]
+                  const m = { x: (p.x + q.x) / 2, y: (p.y + q.y) / 2 }
+                  const horizontal = Math.abs(p.y - q.y) < 0.001
+                  return (
+                    <rect
+                      key={`s${i}`}
+                      x={m.x - 3.5}
+                      y={m.y - 3.5}
+                      width={7}
+                      height={7}
+                      rx={1.5}
+                      fill="var(--brand)"
+                      stroke="#fff"
+                      strokeWidth={1}
+                      style={{ cursor: horizontal ? 'ns-resize' : 'ew-resize' }}
+                      onPointerDown={(e) => startHandleDrag(e, 'edge', i)}
+                    />
+                  )
+                })}
+                {editPts.slice(1, -1).map((p, i) => (
+                  <circle
+                    key={`v${i}`}
+                    cx={p.x}
+                    cy={p.y}
+                    r={4}
+                    fill="var(--brand)"
+                    stroke="#fff"
+                    strokeWidth={1.2}
+                    style={{ cursor: 'move' }}
+                    onPointerDown={(e) => startHandleDrag(e, 'vertex', i + 1)}
+                  />
+                ))}
+                {[0, 1].map((end) => {
+                  const p = end === 0 ? editPts[0] : editPts[editPts.length - 1]
+                  return (
+                    <circle
+                      key={`e${end}`}
+                      cx={p.x}
+                      cy={p.y}
+                      r={4.5}
+                      fill="var(--surface-card)"
+                      stroke="var(--brand)"
+                      strokeWidth={2}
+                      style={{ cursor: 'grab' }}
+                      onPointerDown={(e) => startHandleDrag(e, 'endpoint', 0, end as 0 | 1)}
+                    />
+                  )
+                })}
+              </g>
+            )}
+
+            {/* marquee */}
+            {marquee && (
+              <rect
+                x={Math.min(marquee.a.x, marquee.b.x)}
+                y={Math.min(marquee.a.y, marquee.b.y)}
+                width={Math.abs(marquee.b.x - marquee.a.x)}
+                height={Math.abs(marquee.b.y - marquee.a.y)}
+                fill="rgba(66,165,245,0.08)"
+                stroke="var(--brand)"
+                strokeWidth={1 / scale}
+                strokeDasharray={`${4 / scale} ${3 / scale}`}
+              />
+            )}
+          </svg>
+
+          {/* parts */}
+          {doc.parts.map((part) => {
+            const pl = placementOf(part.id)
+            if (!pl) return null
+            const vis = bbVisual(part.type)
+            if (!vis) {
+              return (
+                <div
+                  key={part.id}
+                  style={{ position: 'absolute', left: pl.x, top: pl.y, zIndex: 2 }}
+                  className="px-2 py-1 rounded bg-surface-card border border-border-default text-[10px] text-text-faint"
+                >
+                  {part.type}…
+                </div>
+              )
+            }
+            const selected = sel.parts.has(part.id)
+            const labelOff = pl.labelOffset || [0, 0]
+            return (
+              <div
+                key={part.id}
+                style={{
+                  position: 'absolute',
+                  left: pl.x,
+                  top: pl.y,
+                  width: vis.v.w,
+                  height: vis.v.h,
+                  zIndex: 2,
+                  transform: pl.rotate ? `rotate(${pl.rotate}deg)` : undefined,
+                  transformOrigin: 'center',
+                  outline: selected ? '2px solid var(--brand)' : 'none',
+                  outlineOffset: 4,
+                  borderRadius: 6,
+                  cursor: editable ? 'move' : 'default'
+                }}
+                onPointerDown={(e) => onPartDown(e, part.id)}
+                onClick={(e) => e.stopPropagation()}
+                onContextMenu={(e) => {
+                  if (!editable) return
+                  e.preventDefault()
+                  const cur = doc.parts.find((p) => p.id === part.id)?.bb
+                  if (!cur) return
+                  const next = ((((cur.rotate ?? 0) + 90) % 360) + 360) % 360 as 0 | 90 | 180 | 270
+                  const frozen = collectFrozen(doc, new Set([part.id]))
+                  const placements = new Map([[part.id, { ...cur, rotate: next || undefined }]])
+                  store.dispatch(
+                    cmd.placePart(part.id, 'bb', placements.get(part.id), reroutesFor(doc, frozen, placements, { x: 0, y: 0 }))
+                  )
+                }}
+              >
+                <div
+                  className="size-full [&>svg]:size-full [&>svg]:block pointer-events-none select-none"
+                  dangerouslySetInnerHTML={{ __html: vis.v.svg }}
+                />
+                {editable &&
+                  Object.keys(vis.v.pins).map((pin) => {
+                    const [px, py] = vis.v.pins[pin]
+                    const armedHere = armed?.from === `${part.id}:${pin}`
+                    const hovered = hoverPin?.id === part.id && hoverPin?.pin === pin
+                    const onHotNet =
+                      highlightNet >= 0 && netModel.pinToNet.get(`${part.id}:${pin}`) === highlightNet
+                    const on = armedHere || hovered
+                    return (
+                      <div
+                        key={pin}
+                        className="pin-hit"
+                        title={pin}
+                        style={{
+                          position: 'absolute',
+                          left: px - 8,
+                          top: py - 8,
+                          width: 16,
+                          height: 16,
+                          zIndex: 3,
+                          cursor: 'crosshair'
+                        }}
+                        onPointerDown={(e) => e.stopPropagation()}
+                        onPointerEnter={() => setHoverPin({ id: part.id, pin })}
+                        onPointerLeave={() => setHoverPin((h) => (h?.id === part.id && h?.pin === pin ? null : h))}
+                        onClick={(e) => onPinClick(e, part.id, pin)}
+                      >
+                        <svg width="16" height="16">
+                          {onHotNet && !on && <circle cx="8" cy="8" r="5.5" fill="var(--yellow)" fillOpacity={0.4} />}
+                          <circle
+                            cx="8"
+                            cy="8"
+                            r={on ? 3.4 : 2.6}
+                            fill={on ? 'var(--brand)' : 'var(--yellow)'}
+                            stroke={on ? 'var(--brand)' : 'var(--border-strong)'}
+                            strokeWidth="1"
+                          />
+                        </svg>
+                      </div>
+                    )
+                  })}
+                <div
+                  className="absolute text-[11px] whitespace-nowrap select-none"
+                  style={{
+                    left: labelOff[0],
+                    top: vis.v.h + 4 + labelOff[1],
+                    transform: pl.rotate ? `rotate(${-pl.rotate}deg)` : undefined,
+                    transformOrigin: 'left top',
+                    color: selected ? 'var(--brand)' : 'var(--text-muted)',
+                    cursor: editable ? 'move' : 'default',
+                    pointerEvents: editable ? 'auto' : 'none'
+                  }}
+                  onPointerDown={(e) => onLabelDown(e, part.id)}
+                >
+                  {String(part.attrs?.label ?? part.id)}
+                </div>
+              </div>
+            )
+          })}
+
+          {doc.parts.length === 0 && (
+            <div
+              className="absolute flex flex-col items-center gap-2 text-text-faint text-sm text-center"
+              style={{ left: 200, top: 160, width: 320 }}
+            >
+              <CircuitBoard size={42} />
+              <div>
+                {editable
+                  ? 'Drag parts from the components rail — or double-click one to drop it here.'
+                  : 'Empty circuit — click edit to start placing parts.'}
+              </div>
+            </div>
+          )}
+        </div>
+      </div>
+
+      {/* status hint pill (bottom-left, next to the shell's counters) */}
+      <div className="absolute bottom-3 left-3 z-10 translate-x-[210px] hidden xl:block">
+        <span
+          className={`px-2.5 py-1 rounded-full bg-surface-card border text-[11px] flex items-center gap-1 ${
+            hint.hot ? 'border-brand/40 text-brand' : 'border-border-default text-text-muted'
+          }`}
+        >
+          {hint.icon} {hint.text}
+        </span>
+      </div>
+    </div>
+  )
+}
+
+export type { Armed }
diff --git a/src/renderer/src/circuit/views/inspector/Inspector.tsx b/src/renderer/src/circuit/views/inspector/Inspector.tsx
new file mode 100644
index 0000000..87e70a0
--- /dev/null
+++ b/src/renderer/src/circuit/views/inspector/Inspector.tsx
@@ -0,0 +1,366 @@
+/**
+ * circuit/views/inspector/Inspector — right-rail editing for the selection.
+ * Part: refdes (rename with uniqueness check), label, location, rotation,
+ * typed attrs. Wire: color, net info. Multi-select: summary + delete.
+ * All edits dispatch Commands (undoable); moves/rotations reroute wires with
+ * frozen bends like canvas drags do.
+ */
+
+import { CircuitBoard, Plus, RotateCw, Spline, Trash2 } from 'lucide-react'
+import React from 'react'
+import { getPart } from '../../../lib/partsLibrary'
+import * as cmd from '../../core/commands'
+import type { CircuitDoc, CircuitPart, CircuitWire, Placement } from '../../core/model'
+import type { NetModel } from '../../core/nets'
+import { isValidRefdes } from '../../core/refdes'
+import type { CircuitStore } from '../../core/store'
+import { collectFrozen, reroutesFor } from '../partsAdapter'
+import { WIRE_COLORS } from '../palette/Palette'
+import type { Selection } from '../canvas/Canvas'
+
+const field =
+  'bg-bg-sunken border border-border-default rounded px-2 py-1 text-text-strong outline-none focus:border-brand w-full'
+const rowLabel = 'text-[11px] text-text-muted'
+
+function titleCase(s: string): string {
+  return s
+    .toLowerCase()
+    .replace(/\b([a-z])/g, (m) => m.toUpperCase())
+    .replace(/\bIc\b/, 'IC')
+}
+
+export function InspectorRail({
+  doc,
+  store,
+  sel,
+  setSel,
+  netModel
+}: {
+  doc: CircuitDoc
+  store: CircuitStore
+  sel: Selection
+  setSel: (s: Selection) => void
+  netModel: NetModel
+}): React.JSX.Element {
+  const part =
+    sel.parts.size === 1 && sel.wires.size === 0
+      ? doc.parts.find((p) => p.id === [...sel.parts][0])
+      : undefined
+  const wire =
+    sel.wires.size === 1 && sel.parts.size === 0
+      ? doc.wires.find((w) => w.id === [...sel.wires][0])
+      : undefined
+  const multi = sel.parts.size + sel.wires.size > 1
+
+  return (
+    <div className="w-64 shrink-0 min-h-0 relative z-20 border-l border-border-default bg-bg-raised flex flex-col">
+      <div className="h-9 flex items-center px-3 border-b border-border-default shrink-0">
+        <span className="text-[13px] font-semibold text-text-body">Inspector</span>
+      </div>
+      <div className="flex-1 min-h-0 overflow-y-auto p-3 flex flex-col gap-3 text-xs">
+        {part ? (
+          <PartInspector key={part.id} part={part} doc={doc} store={store} setSel={setSel} />
+        ) : wire ? (
+          <WireInspector key={wire.id} wire={wire} store={store} setSel={setSel} netModel={netModel} />
+        ) : multi ? (
+          <MultiInspector sel={sel} store={store} setSel={setSel} />
+        ) : (
+          <div className="text-text-faint text-[11px] leading-relaxed">
+            Select a component to edit its refdes, location, rotation, and properties — or a wire
+            to recolor it. Shift-click or drag a marquee for multi-select.
+          </div>
+        )}
+      </div>
+    </div>
+  )
+}
+
+function PartInspector({
+  part,
+  doc,
+  store,
+  setSel
+}: {
+  part: CircuitPart
+  doc: CircuitDoc
+  store: CircuitStore
+  setSel: (s: Selection) => void
+}): React.JSX.Element {
+  const def = getPart(part.type)
+  const [refdes, setRefdes] = React.useState(part.id)
+  const [newAttr, setNewAttr] = React.useState('')
+  React.useEffect(() => setRefdes(part.id), [part.id])
+
+  const refdesTaken = refdes !== part.id && doc.parts.some((p) => p.id === refdes)
+  const refdesBad = !isValidRefdes(refdes) || refdesTaken
+
+  const commitRefdes = (): void => {
+    if (refdes === part.id) return
+    if (refdesBad) {
+      setRefdes(part.id)
+      return
+    }
+    store.dispatch(cmd.renamePart(part.id, refdes))
+    setSel({ parts: new Set([refdes]), wires: new Set() })
+  }
+
+  const moveTo = (x: number, y: number): void => {
+    if (!part.bb) return
+    const frozen = collectFrozen(doc, new Set([part.id]))
+    const pl: Placement = { ...part.bb, x, y }
+    const placements = new Map([[part.id, pl]])
+    store.dispatch(
+      cmd.placePart(part.id, 'bb', pl, reroutesFor(doc, frozen, placements, { x: x - part.bb.x, y: y - part.bb.y }))
+    )
+  }
+
+  const setRotation = (deg: number): void => {
+    if (!part.bb) return
+    const next = (((deg % 360) + 360) % 360) as 0 | 90 | 180 | 270
+    const frozen = collectFrozen(doc, new Set([part.id]))
+    const pl: Placement = { ...part.bb, rotate: next || undefined }
+    const placements = new Map([[part.id, pl]])
+    store.dispatch(cmd.placePart(part.id, 'bb', pl, reroutesFor(doc, frozen, placements, { x: 0, y: 0 })))
+  }
+
+  const wiresTouching = doc.wires.filter((w) =>
+    [w.from, w.to].some((e) => typeof e === 'string' && e.split(':')[0] === part.id)
+  ).length
+
+  const propRows = Object.entries(part.attrs || {}).filter(([k]) => k !== 'label')
+
+  return (
+    <>
+      <div className="flex items-center gap-2">
+        <CircuitBoard size={16} className="text-brand shrink-0" />
+        <input
+          className={`${field} font-semibold ${refdesBad ? 'border-status-error' : ''}`}
+          value={refdes}
+          title={refdesTaken ? 'That refdes is taken' : 'Reference designator (unique)'}
+          onChange={(e) => setRefdes(e.target.value)}
+          onBlur={commitRefdes}
+          onKeyDown={(e) => e.key === 'Enter' && commitRefdes()}
+        />
+      </div>
+      <div className="flex flex-col gap-1">
+        <span className={rowLabel}>Label (display)</span>
+        <input
+          className={field}
+          value={String(part.attrs?.label ?? '')}
+          placeholder={part.id}
+          onChange={(e) =>
+            store.dispatch(cmd.setPartAttr(part.id, 'label', e.target.value || undefined))
+          }
+        />
+      </div>
+      <div className="grid grid-cols-[auto_1fr] gap-x-2 gap-y-1 items-center text-text-muted">
+        <span className={rowLabel}>Type</span>
+        <span className="text-text-body truncate text-[11px]">{part.type}</span>
+        <span className={rowLabel}>Family</span>
+        <span className="text-text-body truncate">{def?.family ? titleCase(def.family) : '—'}</span>
+        <span className={rowLabel}>Wires</span>
+        <span className="text-text-body">{wiresTouching}</span>
+      </div>
+
+      {part.bb && (
+        <>
+          <div className="flex flex-col gap-1">
+            <span className={rowLabel}>Location (breadboard)</span>
+            <div className="flex gap-2">
+              <input
+                type="number"
+                className={field}
+                value={Math.round(part.bb.x)}
+                onChange={(e) => moveTo(parseFloat(e.target.value) || 0, part.bb!.y)}
+              />
+              <input
+                type="number"
+                className={field}
+                value={Math.round(part.bb.y)}
+                onChange={(e) => moveTo(part.bb!.x, parseFloat(e.target.value) || 0)}
+              />
+            </div>
+          </div>
+
+          <div className="flex items-center justify-between">
+            <span className={rowLabel}>Rotation</span>
+            <div className="flex items-center gap-1">
+              <select
+                className={`${field} w-auto`}
+                value={part.bb.rotate || 0}
+                onChange={(e) => setRotation(parseInt(e.target.value, 10))}
+              >
+                {[0, 90, 180, 270].map((d) => (
+                  <option key={d} value={d}>
+                    {d}°
+                  </option>
+                ))}
+              </select>
+              <button
+                className="tactile-bordered rounded-md p-1.5 bg-surface-card text-text-muted hover:text-brand"
+                title="Rotate 90°"
+                onClick={() => setRotation((part.bb!.rotate || 0) + 90)}
+              >
+                <RotateCw size={13} />
+              </button>
+            </div>
+          </div>
+        </>
+      )}
+
+      <div className="flex flex-col gap-1.5">
+        <span className={rowLabel}>Properties</span>
+        {propRows.length === 0 && (
+          <div className="text-[11px] text-text-faint">
+            No properties yet. Add one below — e.g. a resistor’s{' '}
+            <span className="text-text-body">value</span>.
+          </div>
+        )}
+        {propRows.map(([k, val]) => (
+          <div key={k} className="flex items-center gap-1.5">
+            <span className="text-[11px] text-text-muted w-16 truncate" title={k}>
+              {k}
+            </span>
+            <input
+              className={field}
+              value={String(val ?? '')}
+              onChange={(e) => store.dispatch(cmd.setPartAttr(part.id, k, e.target.value))}
+            />
+            <button
+              className="text-text-faint hover:text-status-error shrink-0"
+              title="Remove property"
+              onClick={() => store.dispatch(cmd.setPartAttr(part.id, k, undefined))}
+            >
+              <Trash2 size={13} />
+            </button>
+          </div>
+        ))}
+        <div className="flex items-center gap-1.5">
+          <input
+            className={field}
+            placeholder="new property…"
+            value={newAttr}
+            onChange={(e) => setNewAttr(e.target.value)}
+            onKeyDown={(e) => {
+              if (e.key === 'Enter' && newAttr.trim()) {
+                store.dispatch(cmd.setPartAttr(part.id, newAttr.trim(), ''))
+                setNewAttr('')
+              }
+            }}
+          />
+          <button
+            className="tactile-bordered rounded-md p-1.5 bg-surface-card text-text-muted hover:text-brand shrink-0"
+            title="Add property"
+            onClick={() => {
+              if (newAttr.trim()) {
+                store.dispatch(cmd.setPartAttr(part.id, newAttr.trim(), ''))
+                setNewAttr('')
+              }
+            }}
+          >
+            <Plus size={13} />
+          </button>
+        </div>
+      </div>
+
+      <button
+        className="mt-1 flex items-center justify-center gap-1.5 px-3 py-2 rounded-lg border border-border-default text-text-muted hover:text-status-error hover:border-status-error/40"
+        onClick={() => {
+          store.dispatch(cmd.deleteParts([part.id]))
+          setSel({ parts: new Set(), wires: new Set() })
+        }}
+      >
+        <Trash2 size={13} /> Delete component
+      </button>
+    </>
+  )
+}
+
+function WireInspector({
+  wire,
+  store,
+  setSel,
+  netModel
+}: {
+  wire: CircuitWire
+  store: CircuitStore
+  setSel: (s: Selection) => void
+  netModel: NetModel
+}): React.JSX.Element {
+  const netIdx = netModel.wireToNet.get(wire.id)
+  const netPins = netIdx != null ? (netModel.nets[netIdx]?.length ?? 0) : 0
+  const color = wire.color || '#2fa46a'
+  return (
+    <>
+      <div className="flex items-center gap-2">
+        <Spline size={16} className="text-brand shrink-0" />
+        <span className="text-text-strong font-semibold">Wire</span>
+      </div>
+      <div className="flex flex-col gap-1.5">
+        <span className={rowLabel}>Color</span>
+        <div className="flex items-center gap-2">
+          {WIRE_COLORS.map((c) => (
+            <button
+              key={c}
+              onClick={() => store.dispatch(cmd.recolorWire(wire.id, c))}
+              className="w-5 h-5 rounded-full border-2 transition-transform hover:scale-110"
+              style={{
+                background: c,
+                borderColor:
+                  c.toLowerCase() === color.toLowerCase() ? 'var(--brand)' : 'rgba(255,255,255,0.18)'
+              }}
+            />
+          ))}
+        </div>
+      </div>
+      <div className="grid grid-cols-[auto_1fr] gap-x-2 gap-y-1 items-center">
+        <span className={rowLabel}>Net pins</span>
+        <span className="text-text-body">{netPins}</span>
+      </div>
+      <button
+        className="mt-1 flex items-center justify-center gap-1.5 px-3 py-2 rounded-lg border border-border-default text-text-muted hover:text-status-error hover:border-status-error/40"
+        onClick={() => {
+          store.dispatch(cmd.deleteWires([wire.id]))
+          setSel({ parts: new Set(), wires: new Set() })
+        }}
+      >
+        <Trash2 size={13} /> Delete wire
+      </button>
+    </>
+  )
+}
+
+function MultiInspector({
+  sel,
+  store,
+  setSel
+}: {
+  sel: Selection
+  store: CircuitStore
+  setSel: (s: Selection) => void
+}): React.JSX.Element {
+  return (
+    <>
+      <div className="text-text-strong font-semibold">
+        {sel.parts.size} part{sel.parts.size === 1 ? '' : 's'} · {sel.wires.size} wire
+        {sel.wires.size === 1 ? '' : 's'} selected
+      </div>
+      <div className="text-text-faint text-[11px] leading-relaxed">
+        Drag to move together · R to rotate · arrows to nudge · Ctrl+C / Ctrl+D to copy or
+        duplicate · Del to remove.
+      </div>
+      <button
+        className="mt-1 flex items-center justify-center gap-1.5 px-3 py-2 rounded-lg border border-border-default text-text-muted hover:text-status-error hover:border-status-error/40"
+        onClick={() => {
+          const cmds: cmd.Command[] = []
+          if (sel.parts.size) cmds.push(cmd.deleteParts([...sel.parts]))
+          if (sel.wires.size) cmds.push(cmd.deleteWires([...sel.wires]))
+          store.dispatch(cmds.length === 1 ? cmds[0] : cmd.composite('Delete selection', cmds))
+          setSel({ parts: new Set(), wires: new Set() })
+        }}
+      >
+        <Trash2 size={13} /> Delete selection
+      </button>
+    </>
+  )
+}
diff --git a/src/renderer/src/circuit/views/palette/Palette.tsx b/src/renderer/src/circuit/views/palette/Palette.tsx
new file mode 100644
index 0000000..fe8354a
--- /dev/null
+++ b/src/renderer/src/circuit/views/palette/Palette.tsx
@@ -0,0 +1,131 @@
+/**
+ * circuit/views/palette/Palette — the Fritzing-style components rail (M1).
+ * Reads the LEGACY partsLibrary manifest (replaced by the pack registry in
+ * M2); drag a tile onto the canvas or double-click to drop it at centre.
+ */
+
+import { ChevronDown, ChevronRight, CircuitBoard, Pencil, Plus } from 'lucide-react'
+import React from 'react'
+import { partsByFamily, type PartMeta } from '../../../lib/partsLibrary'
+
+export const WIRE_COLORS = ['#2fa46a', '#e5544b', '#42a5f5', '#f3cb00', '#ffffff', '#79818c']
+
+function titleCase(s: string): string {
+  return s
+    .toLowerCase()
+    .replace(/\b([a-z])/g, (m) => m.toUpperCase())
+    .replace(/\bIc\b/, 'IC')
+}
+
+function Thumb({ svg, size = 40 }: { svg?: string; size?: number }): React.JSX.Element {
+  if (!svg)
+    return (
+      <div
+        className="shrink-0 rounded-md grid place-items-center"
+        style={{ width: size, height: size, background: 'var(--warm-150)' }}
+      >
+        <CircuitBoard size={20} style={{ color: '#79818c' }} />
+      </div>
+    )
+  return (
+    <div
+      className="shrink-0 rounded-md p-1 grid place-items-center [&>svg]:max-w-full [&>svg]:max-h-full [&>svg]:w-auto [&>svg]:h-auto"
+      style={{ width: size, height: size, background: 'var(--warm-150)' }}
+      dangerouslySetInnerHTML={{ __html: svg }}
+    />
+  )
+}
+
+export function Palette({
+  wireColor,
+  onPickColor,
+  onAdd,
+  onEditPart,
+  onNewPart
+}: {
+  wireColor: string
+  onPickColor: (c: string) => void
+  onAdd: (type: string) => void
+  onEditPart: (type: string) => void
+  onNewPart: () => void
+}): React.JSX.Element {
+  const [collapsed, setCollapsed] = React.useState<Set<string>>(new Set())
+  const families = partsByFamily()
+  const isOpen = (fam: string): boolean => !collapsed.has(fam)
+  const toggleFam = (fam: string): void =>
+    setCollapsed((s) => {
+      const n = new Set(s)
+      if (n.has(fam)) n.delete(fam)
+      else n.add(fam)
+      return n
+    })
+
+  return (
+    <div className="w-60 shrink-0 min-h-0 relative z-20 border-r border-border-default bg-bg-raised flex flex-col">
+      <div className="h-9 flex items-center justify-between px-3 border-b border-border-default shrink-0">
+        <span className="text-[13px] font-semibold text-text-body">Components</span>
+        <button className="text-text-muted hover:text-brand" title="New part…" onClick={onNewPart}>
+          <Plus size={15} />
+        </button>
+      </div>
+      <div className="flex items-center gap-1.5 px-3 py-2 border-b border-border-default shrink-0">
+        <span className="text-[11px] text-text-muted mr-1">Wire</span>
+        {WIRE_COLORS.map((c) => (
+          <button
+            key={c}
+            onClick={() => onPickColor(c)}
+            className="w-4 h-4 rounded-full border-2 transition-transform hover:scale-110"
+            style={{
+              background: c,
+              borderColor: wireColor === c ? 'var(--brand)' : 'rgba(255,255,255,0.18)'
+            }}
+            title="Set wire color (recolors the selected wire)"
+          />
+        ))}
+      </div>
+      <div className="flex-1 min-h-0 overflow-y-auto p-2 flex flex-col gap-2">
+        {families.map((group) => (
+          <div key={group.family}>
+            <button
+              className="w-full flex items-center gap-1 px-1 py-1 text-[11px] font-medium text-text-muted hover:text-text-body"
+              onClick={() => toggleFam(group.family)}
+            >
+              {isOpen(group.family) ? <ChevronDown size={12} /> : <ChevronRight size={12} />}
+              <span className="truncate">{titleCase(group.family)}</span>
+              <span className="ml-auto text-text-faint/70">{group.parts.length}</span>
+            </button>
+            {isOpen(group.family) && (
+              <div className="grid grid-cols-2 gap-1.5 pt-1 pb-1">
+                {group.parts.map((c: PartMeta) => (
+                  <div
+                    key={c.type}
+                    draggable
+                    onDragStart={(e) => e.dataTransfer.setData('text/tinystudio-part', c.type)}
+                    onDoubleClick={() => onAdd(c.type)}
+                    className="group relative flex flex-col items-center gap-1 p-2 rounded-lg border border-border-default bg-surface-card hover:bg-bg-sunken hover:-translate-y-px transition cursor-grab active:cursor-grabbing"
+                    title={`${c.label} · ${c.pins} pins — drag onto the canvas (or double-click)`}
+                  >
+                    <Thumb svg={c.icon} size={44} />
+                    <div className="text-[10px] text-text-body text-center leading-tight line-clamp-2 w-full">
+                      {c.label}
+                    </div>
+                    <button
+                      className="absolute top-1 right-1 opacity-0 group-hover:opacity-100 text-text-faint hover:text-brand"
+                      title="Edit this part"
+                      onClick={(e) => {
+                        e.stopPropagation()
+                        onEditPart(c.type)
+                      }}
+                    >
+                      <Pencil size={11} />
+                    </button>
+                  </div>
+                ))}
+              </div>
+            )}
+          </div>
+        ))}
+      </div>
+    </div>
+  )
+}
diff --git a/src/renderer/src/circuit/views/partsAdapter.ts b/src/renderer/src/circuit/views/partsAdapter.ts
new file mode 100644
index 0000000..8eb1399
--- /dev/null
+++ b/src/renderer/src/circuit/views/partsAdapter.ts
@@ -0,0 +1,230 @@
+/**
+ * circuit/views/partsAdapter — geometry glue between the v2 document and the
+ * LEGACY partsLibrary (breadboard view only). Temporary by design: the M2
+ * parts registry (`circuit/parts/registry.ts`) replaces every import of
+ * `lib/partsLibrary` in here without touching the canvas.
+ *
+ * Everything geometric the editor needs lives here so Canvas, Inspector and
+ * the image exporter share one implementation:
+ *   - pin world positions (rotation/flip/leg aware, via core/geometry)
+ *   - wire endpoint resolution (pins, junctions, pending v1 junctions)
+ *   - rendered wire polylines
+ *   - frozen-bend reroutes for part moves (the collectFrozen behavior)
+ */
+
+import { getPart, viewFor, type PartDef, type PartView } from '../../lib/partsLibrary'
+import { pinWorld, snapPlacementToPinGrid } from '../core/geometry'
+import {
+  GRID_BB,
+  isJunction,
+  isPendingJunction,
+  splitPinRef,
+  type CircuitDoc,
+  type CircuitPart,
+  type CircuitWire,
+  type Placement,
+  type Pt,
+  type WireEnd
+} from '../core/model'
+import {
+  bendsFromJourney,
+  buildWirePoints,
+  isStraightRoute,
+  journeyFromPoints,
+  pointAtT,
+  wirePoints
+} from '../core/routing'
+import type { WireReroute } from '../core/commands'
+
+export interface PartVisual {
+  def: PartDef
+  v: PartView
+}
+
+/** Breadboard visual for a part type, or null while its def is still loading. */
+export function bbVisual(type: string): PartVisual | null {
+  const def = getPart(type)
+  const v = def && viewFor(def, 'breadboard')
+  return def && v ? { def, v } : null
+}
+
+/** First pin's local coordinate (the snap-by-pin alignment reference). */
+export function firstPinLocal(type: string): [number, number] | undefined {
+  const vis = bbVisual(type)
+  if (!vis) return undefined
+  const first = Object.values(vis.v.pins)[0]
+  return first
+}
+
+/** Snap a bb placement so its pins land on-grid (Fritzing behavior). */
+export function snapBB(type: string, placement: Placement): Placement {
+  const vis = bbVisual(type)
+  if (!vis) return { ...placement, x: Math.round(placement.x / GRID_BB) * GRID_BB, y: Math.round(placement.y / GRID_BB) * GRID_BB }
+  const { x, y } = snapPlacementToPinGrid(placement, firstPinLocal(type), vis.v.w, vis.v.h, GRID_BB)
+  return { ...placement, x, y }
+}
+
+/** World position of a part's pin in the bb view (leg-tip aware). */
+export function pinWorldOf(part: CircuitPart, pin: string, placement?: Placement): Pt | null {
+  const pl = placement ?? part.bb
+  if (!pl) return null
+  const vis = bbVisual(part.type)
+  const local = vis?.v.pins[pin]
+  if (!vis || !local) return null
+  return pinWorld(local, pl, vis.v.w, vis.v.h, pl.legs?.[pin])
+}
+
+export type EndResolver = (end: WireEnd, seen?: Set<string>) => Pt | null
+
+/**
+ * Endpoint resolver over a doc, with optional per-part placement overrides
+ * (used mid-drag so wires track the moving part before the command commits).
+ * Pending v1 junctions resolve to their raw coordinate.
+ */
+export function makeEndResolver(
+  doc: CircuitDoc,
+  overrides?: Map<string, Placement>
+): EndResolver {
+  const wireById = new Map(doc.wires.map((w) => [w.id, w]))
+  const resolve: EndResolver = (end, seen = new Set()) => {
+    if (isJunction(end)) {
+      if (isPendingJunction(end)) return { x: end.x, y: end.y }
+      if (seen.has(end.wire)) return null
+      seen.add(end.wire)
+      const host = wireById.get(end.wire)
+      if (!host) return null
+      const s = resolve(host.from, seen)
+      const t = resolve(host.to, seen)
+      if (!s || !t) return null
+      return pointAtT(wirePoints(s, t, host.route), end.t)
+    }
+    const { part: partId, pin } = splitPinRef(end)
+    const part = doc.parts.find((p) => p.id === partId)
+    if (!part) return null
+    return pinWorldOf(part, pin, overrides?.get(partId) ?? part.bb)
+  }
+  return resolve
+}
+
+export interface ResolvedWire {
+  w: CircuitWire
+  pts: Pt[]
+}
+
+/** Rendered polylines for every bb wire (empty pts when unresolvable). */
+export function bbWireGeometry(doc: CircuitDoc, overrides?: Map<string, Placement>): ResolvedWire[] {
+  const resolve = makeEndResolver(doc, overrides)
+  return doc.wires
+    .filter((w) => w.view === 'bb')
+    .map((w) => {
+      const s = resolve(w.from)
+      const t = resolve(w.to)
+      return { w, pts: s && t ? wirePoints(s, t, w.route) : [] }
+    })
+}
+
+/** Topmost pin within `tol` world px of a world point. */
+export function pinAtWorld(
+  doc: CircuitDoc,
+  wx: number,
+  wy: number,
+  tol: number
+): { id: string; pin: string; pos: Pt } | null {
+  for (let i = doc.parts.length - 1; i >= 0; i--) {
+    const part = doc.parts[i]
+    if (!part.bb) continue
+    const vis = bbVisual(part.type)
+    if (!vis) continue
+    for (const pin of Object.keys(vis.v.pins)) {
+      const pos = pinWorldOf(part, pin)
+      if (pos && Math.hypot(pos.x - wx, pos.y - wy) < tol) return { id: part.id, pin, pos }
+    }
+  }
+  return null
+}
+
+/** Bounding box of everything placed in the bb view, or null when empty. */
+export function bbBounds(doc: CircuitDoc): { minX: number; minY: number; maxX: number; maxY: number } | null {
+  let minX = Infinity
+  let minY = Infinity
+  let maxX = -Infinity
+  let maxY = -Infinity
+  for (const part of doc.parts) {
+    if (!part.bb) continue
+    const vis = bbVisual(part.type)
+    if (!vis) continue
+    minX = Math.min(minX, part.bb.x)
+    minY = Math.min(minY, part.bb.y)
+    maxX = Math.max(maxX, part.bb.x + vis.v.w)
+    maxY = Math.max(maxY, part.bb.y + vis.v.h)
+  }
+  for (const { pts } of bbWireGeometry(doc)) {
+    for (const p of pts) {
+      minX = Math.min(minX, p.x)
+      minY = Math.min(minY, p.y)
+      maxX = Math.max(maxX, p.x)
+      maxY = Math.max(maxY, p.y)
+    }
+  }
+  return isFinite(minX) ? { minX, minY, maxX, maxY } : null
+}
+
+// ── frozen-bend part moves (the collectFrozen behavior, v2 flavor) ───────────
+
+export interface FrozenWire {
+  id: string
+  bends: Pt[]
+  straight: boolean
+  /** Both endpoints sit on moved parts — bends translate with the move. */
+  both: boolean
+}
+
+/** Snapshot the wires touching any of `ids` before a move begins. */
+export function collectFrozen(doc: CircuitDoc, ids: Set<string>): FrozenWire[] {
+  const resolve = makeEndResolver(doc)
+  const touches = (e: WireEnd): boolean =>
+    typeof e === 'string' && ids.has(splitPinRef(e).part)
+  const out: FrozenWire[] = []
+  for (const w of doc.wires) {
+    if (w.view !== 'bb') continue
+    const f = touches(w.from)
+    const t = touches(w.to)
+    if (!f && !t) continue
+    const s = resolve(w.from)
+    const e = resolve(w.to)
+    if (!s || !e) continue
+    out.push({
+      id: w.id,
+      bends: bendsFromJourney(w.route, s, e),
+      straight: isStraightRoute(w.route),
+      both: f && t
+    })
+  }
+  return out
+}
+
+/**
+ * New journeys for frozen wires given the moved parts' new placements.
+ * Single-anchored wires keep their bends fixed in world space; wires between
+ * two moved parts translate their bends by `delta`.
+ */
+export function reroutesFor(
+  doc: CircuitDoc,
+  frozen: FrozenWire[],
+  placements: Map<string, Placement>,
+  delta: Pt
+): WireReroute[] {
+  const resolve = makeEndResolver(doc, placements)
+  const wireById = new Map(doc.wires.map((w) => [w.id, w]))
+  const out: WireReroute[] = []
+  for (const f of frozen) {
+    const w = wireById.get(f.id)
+    if (!w) continue
+    const s = resolve(w.from)
+    const t = resolve(w.to)
+    if (!s || !t) continue
+    const bends = f.both ? f.bends.map((b) => ({ x: b.x + delta.x, y: b.y + delta.y })) : f.bends
+    out.push({ wireId: f.id, route: journeyFromPoints(buildWirePoints(s, bends, t, f.straight), f.straight) })
+  }
+  return out
+}

From af2cbc13041dfc8e294d719a542db8b8167361ce Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Fri, 3 Jul 2026 15:34:09 +0000
Subject: [PATCH 05/27] Circuit v2 M1: circuit.json adoption + save path
 integration; progress log
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

EditorPanel v2 branch: CircuitV2View migrates diagram.json → circuit.json
(+ diagram.json.bak) on first open, then mounts the editor on the
circuit.json hidden buffer with updateFileContent as the debounced sink.
diagram.json intentionally left in place until M4 (legacy editor still
default-on behind the flag).
---
 docs/circuit-editor-progress.md             | 38 +++++++++
 src/renderer/src/components/EditorPanel.tsx | 87 +++++++++++++++++++--
 2 files changed, 117 insertions(+), 8 deletions(-)

diff --git a/docs/circuit-editor-progress.md b/docs/circuit-editor-progress.md
index 70ea109..df72c33 100644
--- a/docs/circuit-editor-progress.md
+++ b/docs/circuit-editor-progress.md
@@ -57,3 +57,41 @@ This file is the running context for agents working on the Circuit View v2. Read
 6. Keyboard: undo/redo (Ctrl+Z/Y), delete, rotate R, nudge arrows, Esc.
 7. Multi-select, copy/paste (`application/x-tinystudio-circuit`), duplicate.
 8. SVG/PNG export with id-namespacing (B6) — namespacing helper belongs in `circuit/parts/svg.ts`.
+
+---
+
+## 2026-07-03 — M1: breadboard editor parity ✅
+
+### Added
+
+- `core/clipboard.ts` — copy/paste as pure doc logic: `buildClipboard` (wires kept only when every endpoint resolves inside the payload; junction riders filtered to a fixpoint), `parseClipboard` (shape-detected JSON on the system clipboard as text — custom MIME was unreliable across desktop/web), `materializePaste` (fresh refdes per prefix, endpoint/junction-host rewrite, placement offset).
+- `commands.composite(label, cmds, mergeKey?)` — composites can merge, so multi-part drags collapse into one undo step.
+- `model.ts` — `PendingJunctionEnd` / `isPendingJunction` formalize the v1-migration pending state.
+- `parts/svg.ts` — `namespaceSvgIds` (B6), `svgNs`, `stripSvgSize`, `escapeXml`. Full sanitizer is M2.
+- `views/partsAdapter.ts` — ALL geometry glue over the legacy partsLibrary (pin world positions, endpoint resolver incl. junction chains + pending, `collectFrozen`/`reroutesFor` for frozen-bend moves, `snapBB` = snap-by-first-pin per §6.3). The M2 registry replaces only this file's imports.
+- `views/canvas/Canvas.tsx` — the M1 editor: camera (wheel-zoom-at-cursor, middle/Alt pan, left-pan in view mode, fit), marquee + shift multi-select, wire drawing (pin→pin, junction taps store `{wire,t}` via `tAtPoint`, Shift straight, click bends, Esc), selected-wire handles (segment ⊥-drag, vertex, endpoint; endpoint drop must land on a pin or wire — reverts on empty space since v2 has no free endpoints), double-click add/remove bend, part drag (multi-part; wires between two moved parts translate their bends, others hold world-space), label drag → `Placement.labelOffset`, right-click/R rotate, arrow nudge (Shift=5×), Del cascade, Ctrl+Z/Y, Ctrl+C/X/V/D. Pending junctions resolve to `{wire,t}` on first render once part defs load (one undoable "Resolve migrated junctions" step; unresolvable ones stay pending and render at their raw coordinate).
+- `views/palette/Palette.tsx`, `views/inspector/Inspector.tsx` — ported rail + inspector; inspector edits refdes (rename validated + wires rewritten), display label (attrs.label), location/rotation (with reroutes), attrs; wire color/net info; multi-select summary.
+- `views/CircuitView.tsx` — shell owns the store; **save path**: revision subscription → debounced 250 ms `store.serialize()` → `onChange` → Redux `updateFileContent` (disk write stays on Ctrl+S like all buffers). External Code-tab edits fold in as an undoable step; the echo guard + a `skipSaveRev` marker prevent both loops and reformat-under-cursor.
+- `views/exportImage.ts` — standalone scene SVG (id-namespaced per instance), `.svg` download + `.png` @2×, watermark.
+- `EditorPanel.tsx` — v2 branch split into `CircuitV2View` (adoption) → `CircuitV2Inner` (buffer): on first open with only `diagram.json`, writes migrated `circuit.json` + verbatim `diagram.json.bak`, refreshes the tree, then opens `circuit.json` as the hidden buffer. **Deviation from spec §4:** `diagram.json` is left in place (not renamed) until M4 removes the legacy editor, so flipping the flag off keeps working.
+- Tests: +18 (53 total) — clipboard rules/paste re-iding, svg namespacing, composite mergeKey collapse, placePart reroutes, pending-junction typing/resolution.
+
+### State / verification
+
+- `npm run test:circuit` → **53/53**. `npm run typecheck` (node + web) → clean.
+- Committed as 4 chunks: core (f12699a), svg/export (61d3c9a), views (9a98df9), integration+log (this commit).
+
+### Known gaps / notes for the next agent
+
+- Camera is NOT persisted to `doc.camera` (writing it would dirty the file on pan; needs a non-undo side channel — decide in M3 when the second view needs per-view cameras anyway).
+- Pin hit targets are fixed 16 world px (legacy parity), not the B23 min-10-screen-px rule — revisit with the M2 registry.
+- Legacy `partsLibrary` has no `buses`, so `buildNets` runs without `busesFor` in the view (bus seams are wired in core and tested; M2 turns them on).
+- Clipboard rides `text/plain` JSON with a format marker instead of `application/x-tinystudio-circuit` (Chromium custom-type restrictions in the web build); cross-project paste works.
+- PartsEditor still saves via `registerPart` (in-memory, B7) — persistence is an M2 item.
+- Wire-end plug-into-hole (wire-end as male pin) needs real breadboard parts — M2 drop-to-connect.
+- **Tooling (this session, worse than last time):** Write/Edit through the Cowork mount truncated files to their PREVIOUS byte length whenever an edit GREW a file (commands.ts, model.ts, index.ts, EditorPanel.tsx, CircuitView.tsx all hit; one NUL-padded). `.git/index` also corrupted once (`bad signature 0x00000000` → `rm .git/index && git reset`). Reliable path: write files from the LINUX side (bash heredoc / python replace), verify with a NUL+tail scan, keep typecheck as the gate.
+
+### Next up (M2 or M3 — parallelizable per spec §15)
+
+- M2: procedural breadboards + drop-to-connect + legs; `.fzpz` import; Part Editor v2 persistence; pack manager + GitHub index install; regenerate default pack (buses/pinType/legs).
+- M3: schematic view (needs M0/M1 only): view toggle, symbols, unplaced tray + ratsnest, net labels/ground, flip/mirror, ERC panel.
diff --git a/src/renderer/src/components/EditorPanel.tsx b/src/renderer/src/components/EditorPanel.tsx
index f441628..b6d058a 100644
--- a/src/renderer/src/components/EditorPanel.tsx
+++ b/src/renderer/src/components/EditorPanel.tsx
@@ -34,7 +34,7 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { notify as toast } from '@renderer/lib/notify'
 import { BlocklyEditor } from './BlocklyEditor'
 import { DiagramEditor } from './DiagramEditor'
-import { circuitV2Enabled } from '../circuit'
+import { circuitV2Enabled, emptyDoc, parseCircuitFile, serializeDoc } from '../circuit'
 import { CircuitViewV2 } from '../circuit/views/CircuitView'
 import { MonacoEditor, MonacoEditorRef } from './MonacoEditor'
 import {
@@ -361,9 +361,18 @@ function CodeView(): React.JSX.Element {
   )
 }
 
-// ── Circuit view: full-window interactive diagram.json ──────────────────────
+// ── Circuit view: full-window interactive diagram.json / circuit.json ───────
 
 function CircuitView(): React.JSX.Element {
+  // Circuit View v2 (docs/circuit-view-tech-spec.md) — same window slot, both
+  // desktop and web builds. Enable: localStorage.setItem('tinystudio.circuitV2','1')
+  // The flag is stable for the app session, so branching to components with
+  // different hooks is safe here.
+  if (circuitV2Enabled()) return <CircuitV2View />
+  return <CircuitV1View />
+}
+
+function CircuitV1View(): React.JSX.Element {
   const workspace = useAppSelector((s) => s.file.workspace)
   const dispatch = useAppDispatch()
   const file = useProjectFile('diagram.json', () => DEFAULT_DIAGRAM)
@@ -371,12 +380,6 @@ function CircuitView(): React.JSX.Element {
   if (!workspace) return <EmptyHint icon="circuit" label="Open a project to design its circuit." />
   if (!file) return <LoadingHint label="Loading circuit…" />
 
-  // Circuit View v2 (docs/circuit-view-tech-spec.md) — same window slot, both
-  // desktop and web builds. Enable: localStorage.setItem('tinystudio.circuitV2','1')
-  if (circuitV2Enabled()) {
-    return <CircuitViewV2 content={file.content} />
-  }
-
   return (
     <DiagramEditor
       content={file.content}
@@ -393,6 +396,74 @@ function CircuitView(): React.JSX.Element {
   )
 }
 
+/**
+ * v2 adoption (spec §4, §13): the native file is `circuit.json`. On first
+ * open of a project that only has a v1 `diagram.json`, migrate it on disk:
+ * write `circuit.json` (converted) and `diagram.json.bak` (verbatim copy).
+ * `diagram.json` itself is left in place until M4 removes the legacy editor —
+ * flipping the flag off must keep working during the preview period.
+ */
+function CircuitV2View(): React.JSX.Element {
+  const workspace = useAppSelector((s) => s.file.workspace)
+  const [ready, setReady] = useState(false)
+  const adopting = useRef(false)
+
+  useEffect(() => {
+    setReady(false)
+    if (!workspace || adopting.current) return
+    if (findInTree(workspace.root, (i) => i.name === 'circuit.json')) {
+      setReady(true)
+      return
+    }
+    const diagram = findInTree(workspace.root, (i) => i.name === 'diagram.json')
+    if (!diagram) {
+      setReady(true) // fresh project — useProjectFile seeds an empty circuit.json
+      return
+    }
+    adopting.current = true
+    ;(async () => {
+      try {
+        const old = await fileSystem.readFile(diagram.path!)
+        const { doc } = parseCircuitFile(old)
+        await fileSystem.writeFile(`${workspace.path}/circuit.json`, serializeDoc(doc))
+        await fileSystem.writeFile(`${workspace.path}/diagram.json.bak`, old)
+        await new RefreshWorkspaceCommand(workspace).execute()
+      } catch (e) {
+        console.error('circuit.json adoption failed:', e)
+      } finally {
+        adopting.current = false
+        setReady(true)
+      }
+    })()
+  }, [workspace])
+
+  if (!workspace) return <EmptyHint icon="circuit" label="Open a project to design its circuit." />
+  if (!ready) return <LoadingHint label="Preparing circuit…" />
+  return <CircuitV2Inner />
+}
+
+function CircuitV2Inner(): React.JSX.Element {
+  const dispatch = useAppDispatch()
+  const makeDefault = useCallback(() => serializeDoc(emptyDoc()), [])
+  const file = useProjectFile('circuit.json', makeDefault)
+
+  if (!file) return <LoadingHint label="Loading circuit…" />
+
+  return (
+    <CircuitViewV2
+      content={file.content}
+      onChange={(content) => dispatch(updateFileContent({ id: file.id, content }))}
+      onOpenCode={() => {
+        dispatch(revealFile(file.id))
+        dispatch(setEditorView('code'))
+      }}
+      onEditChange={(editing) => {
+        if (editing) dispatch(setPanelOpen({ panel: 'docs', isOpen: false }))
+      }}
+    />
+  )
+}
+
 // ── Visual view: full-window p5 sketch with an Edit-code button ─────────────
 
 function VisualView(): React.JSX.Element {

From 90c3e10718cbdd361582e71f078d2a079f636038 Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Fri, 3 Jul 2026 11:18:11 -0600
Subject: [PATCH 06/27] Circuit v2 M1 fix: valid standalone SVG/PNG export
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fritzing part roots carry x=0px/y=0px + width/height; injecting placement
attributes duplicated them, making the composed SVG invalid XML — inline
DOM rendering tolerated it, the standalone .svg and the PNG rasterizer's
<img> load did not. prepareSvgForEmbed strips prolog/doctype and root
geometry attrs (viewBox kept). Also: #id selectors in <style> blocks are
now namespaced, and var(--token) colors are inlined at export time so
builtin board art survives outside the app stylesheet.
---
 docs/circuit-editor-progress.md               |  6 ++++
 .../src/circuit/__tests__/svg.test.ts         | 33 ++++++++++++++++++-
 src/renderer/src/circuit/parts/svg.ts         | 31 +++++++++++++++++
 src/renderer/src/circuit/views/exportImage.ts | 29 ++++++++++++----
 4 files changed, 92 insertions(+), 7 deletions(-)

diff --git a/docs/circuit-editor-progress.md b/docs/circuit-editor-progress.md
index df72c33..6f048d6 100644
--- a/docs/circuit-editor-progress.md
+++ b/docs/circuit-editor-progress.md
@@ -95,3 +95,9 @@ This file is the running context for agents working on the Circuit View v2. Read
 
 - M2: procedural breadboards + drop-to-connect + legs; `.fzpz` import; Part Editor v2 persistence; pack manager + GitHub index install; regenerate default pack (buses/pinType/legs).
 - M3: schematic view (needs M0/M1 only): view toggle, symbols, unplaced tray + ratsnest, net labels/ground, flip/mirror, ERC panel.
+
+---
+
+## 2026-07-03 (later) — M1 fix: image export
+
+Geoff's testing found SVG export rendering symbols wrong and PNG export dead. Root cause (probed in Node with the Blink demo): Fritzing part SVG roots carry their own `x="0px" y="0px"` (and width/height) — the composer's injected placement attributes duplicated them → **invalid XML**. The in-app canvas tolerates it (lenient HTML parser); the standalone `.svg` and the PNG rasterizer's strict XML parse both fail. Fixes: `prepareSvgForEmbed` (strips prolog/doctype + root x/y/width/height, keeps viewBox) replaces `stripSvgSize` in the exporter; `namespaceSvgIds` now also rewrites `#id` selectors in `<style>` blocks; `resolveCssVars` inlines `var(--…)` design tokens (builtin board art) at export time; PNG rasterize failure logs instead of dying silently. Probe validates the composed scene parses clean. 56/56 tests.
diff --git a/src/renderer/src/circuit/__tests__/svg.test.ts b/src/renderer/src/circuit/__tests__/svg.test.ts
index fd15e78..b3afcba 100644
--- a/src/renderer/src/circuit/__tests__/svg.test.ts
+++ b/src/renderer/src/circuit/__tests__/svg.test.ts
@@ -2,7 +2,7 @@
 
 import assert from 'node:assert/strict'
 import { test } from 'node:test'
-import { escapeXml, namespaceSvgIds, stripSvgSize, svgNs } from '../parts/svg'
+import { escapeXml, namespaceSvgIds, prepareSvgForEmbed, stripSvgSize, svgNs } from '../parts/svg'
 
 test('namespaceSvgIds prefixes defined ids and their references', () => {
   const svg =
@@ -47,3 +47,34 @@ test('stripSvgSize removes root width/height only', () => {
 test('escapeXml escapes the five specials', () => {
   assert.equal(escapeXml(`<a href="x">R&D's</a>`), '&lt;a href=&quot;x&quot;&gt;R&amp;D&apos;s&lt;/a&gt;')
 })
+
+test('prepareSvgForEmbed strips prolog/doctype and root x/y/width/height (Fritzing exports)', () => {
+  const fritzing =
+    '<?xml version="1.0" encoding="utf-8"?>\n<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "x.dtd">\n' +
+    '<svg version="1.2" baseProfile="tiny" xmlns="http://www.w3.org/2000/svg" x="0px" y="0px" ' +
+    'width="41.2px" height="9.32px" viewBox="0 0 42.917 9.71"><g id="g"/></svg>'
+  const out = prepareSvgForEmbed(fritzing)
+  assert.ok(!out.includes('<?xml'))
+  assert.ok(!out.includes('DOCTYPE'))
+  const root = /<svg\b[^>]*>/.exec(out)![0]
+  assert.ok(!/\s[xy]\s*=/.test(root), 'root x/y removed')
+  assert.ok(!/\s(width|height)\s*=/.test(root), 'root size removed')
+  assert.ok(root.includes('viewBox="0 0 42.917 9.71"'), 'viewBox kept')
+  // composer can now inject placement without duplicate attributes
+  const placed = out.replace('<svg', '<svg x="10" y="20" width="41.2" height="9.32"')
+  const attrs = /<svg\b[^>]*>/.exec(placed)![0].match(/\s(x|y|width|height)\s*=/g)!
+  assert.equal(attrs.length, 4)
+})
+
+test('prepareSvgForEmbed keeps inner-element geometry attributes', () => {
+  const out = prepareSvgForEmbed('<svg width="10" viewBox="0 0 10 10"><rect x="1" y="2" width="3" height="4"/></svg>')
+  assert.ok(out.includes('<rect x="1" y="2" width="3" height="4"/>'))
+})
+
+test('namespaceSvgIds rewrites #id selectors inside style blocks', () => {
+  const svg = '<svg><style>.a{fill:red}#body{fill:blue}#other{}</style><g id="body"/></svg>'
+  const out = namespaceSvgIds(svg, 'pR1')
+  assert.ok(out.includes('#pR1-body{fill:blue}'))
+  assert.ok(out.includes('#other{}')) // not defined as an id here — untouched
+  assert.ok(out.includes('id="pR1-body"'))
+})
diff --git a/src/renderer/src/circuit/parts/svg.ts b/src/renderer/src/circuit/parts/svg.ts
index 220a0d2..e6d2daa 100644
--- a/src/renderer/src/circuit/parts/svg.ts
+++ b/src/renderer/src/circuit/parts/svg.ts
@@ -21,6 +21,15 @@ export function namespaceSvgIds(svg: string, ns: string): string {
   if (ids.size === 0) return svg
   const has = (id: string): boolean => ids.has(id)
 
+  // rewrite #id selectors inside <style> blocks first (rare but real in
+  // Fritzing exports; attribute passes below don't reach CSS text)
+  svg = svg.replace(/(<style[^>]*>)([\s\S]*?)(<\/style>)/g, (_all, open, css, close) => {
+    const fixed = css.replace(/#([A-Za-z_][\w-]*)/g, (m: string, id: string) =>
+      has(id) ? `#${ns}-${id}` : m
+    )
+    return `${open}${fixed}${close}`
+  })
+
   return svg
     .replace(/\bid\s*=\s*"([^"]+)"/g, (all, id) => (has(id) ? `id="${ns}-${id}"` : all))
     .replace(/\bid\s*=\s*'([^']+)'/g, (all, id) => (has(id) ? `id='${ns}-${id}'` : all))
@@ -45,6 +54,28 @@ export function stripSvgSize(svg: string): string {
     .replace(/<svg([^>]*?)\sheight\s*=\s*"[^"]*"/i, '<svg$1')
 }
 
+/**
+ * Prepare a part's SVG for embedding as a NESTED <svg> element in a composed
+ * scene: strip the XML prolog / doctype (illegal mid-document — they killed
+ * the whole exported file's parse), and remove any root-level x/y/width/height
+ * attributes (Fritzing exports carry x="0px" y="0px", which collided with the
+ * composer's placement attributes → duplicate-attribute XML errors). The
+ * root's viewBox is kept — it's what makes the injected width/height scale.
+ */
+export function prepareSvgForEmbed(svg: string): string {
+  let s = svg
+    .replace(/<\?xml[\s\S]*?\?>/g, '')
+    .replace(/<!DOCTYPE[^>]*>/gi, '')
+    .trim()
+  const m = /<svg\b[^>]*>/i.exec(s)
+  if (!m) return s
+  let root = m[0]
+  root = root
+    .replace(/\s(?:x|y|width|height)\s*=\s*"[^"]*"/gi, '')
+    .replace(/\s(?:x|y|width|height)\s*=\s*'[^']*'/gi, '')
+  return s.slice(0, m.index) + root + s.slice(m.index + m[0].length)
+}
+
 /** Escape text for inclusion in generated SVG markup. */
 export function escapeXml(s: string): string {
   return s.replace(
diff --git a/src/renderer/src/circuit/views/exportImage.ts b/src/renderer/src/circuit/views/exportImage.ts
index afd8d0f..c55bd6b 100644
--- a/src/renderer/src/circuit/views/exportImage.ts
+++ b/src/renderer/src/circuit/views/exportImage.ts
@@ -4,7 +4,7 @@
  * instance (fixes B6: two parts sharing `id="g"` corrupted exports).
  */
 
-import { escapeXml, namespaceSvgIds, stripSvgSize, svgNs } from '../parts/svg'
+import { escapeXml, namespaceSvgIds, prepareSvgForEmbed, svgNs } from '../parts/svg'
 import { isJunction, type CircuitDoc } from '../core/model'
 import { bbBounds, bbVisual, bbWireGeometry, makeEndResolver } from './partsAdapter'
 
@@ -77,7 +77,7 @@ export function composeSceneSvg(doc: CircuitDoc, bg: string): string | null {
       const vis = bbVisual(part.type)
       if (!vis) return ''
       const { x, y } = part.bb
-      const inner = stripSvgSize(namespaceSvgIds(vis.v.svg, svgNs(part.id))).replace(
+      const inner = prepareSvgForEmbed(namespaceSvgIds(vis.v.svg, svgNs(part.id))).replace(
         '<svg',
         `<svg x="${x}" y="${y}" width="${vis.v.w}" height="${vis.v.h}"`
       )
@@ -95,6 +95,19 @@ export function composeSceneSvg(doc: CircuitDoc, bg: string): string | null {
   return `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="${W}" height="${H}" viewBox="${minX} ${minY} ${W} ${H}"><rect x="${minX}" y="${minY}" width="${W}" height="${H}" fill="${bg}"/>${wires}${dots}${partsSvg}${watermark}</svg>`
 }
 
+/**
+ * Inline every var(--token) with its computed value — builtin board art uses
+ * design-system variables that only resolve inside the app's stylesheet, not
+ * in a standalone .svg / rasterized .png.
+ */
+function resolveCssVars(svg: string): string {
+  const cs = getComputedStyle(document.documentElement)
+  return svg.replace(/var\((--[A-Za-z0-9_-]+)\)/g, (all, name) => {
+    const v = cs.getPropertyValue(name).trim()
+    return v || all
+  })
+}
+
 function download(blob: Blob, name: string): void {
   const a = document.createElement('a')
   const href = URL.createObjectURL(blob)
@@ -108,13 +121,14 @@ export function exportSvg(doc: CircuitDoc): void {
   const bg = (getComputedStyle(document.documentElement).getPropertyValue('--bg-sunken') || '#1e1f22').trim()
   const svg = composeSceneSvg(doc, bg)
   if (!svg) return
-  download(new Blob([svg], { type: 'image/svg+xml;charset=utf-8' }), 'circuit.svg')
+  download(new Blob([resolveCssVars(svg)], { type: 'image/svg+xml;charset=utf-8' }), 'circuit.svg')
 }
 
 export function exportPng(doc: CircuitDoc): void {
   const bg = (getComputedStyle(document.documentElement).getPropertyValue('--bg-sunken') || '#1e1f22').trim()
-  const svg = composeSceneSvg(doc, bg)
-  if (!svg) return
+  const raw = composeSceneSvg(doc, bg)
+  if (!raw) return
+  const svg = resolveCssVars(raw)
   const m = /width="(\d+)" height="(\d+)"/.exec(svg)
   const W = m ? parseInt(m[1], 10) : 800
   const H = m ? parseInt(m[2], 10) : 600
@@ -137,6 +151,9 @@ export function exportPng(doc: CircuitDoc): void {
       if (png) download(png, 'circuit.png')
     }, 'image/png')
   }
-  img.onerror = () => URL.revokeObjectURL(url)
+  img.onerror = () => {
+    URL.revokeObjectURL(url)
+    console.error('circuit PNG export: SVG failed to rasterize')
+  }
   img.src = url
 }

From a0f3ccd89bd869cff76aba936f3c55cfed3398aa Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Fri, 3 Jul 2026 23:39:34 -0600
Subject: [PATCH 07/27] Circuit v2 M2 core: procedural breadboards +
 drop-to-connect
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- parts/breadboard.ts: parametric generator (mini 17 / half+ 30 / full+ 63
  cols), every hole on the GRID_BB pitch so snap-by-first-pin placement
  makes seating an exact coordinate match; per-column bank buses + rail
  buses via breadboardBuses(); crisp generated SVG (body, channel, rail
  stripes, row letters, column numbers)
- partsAdapter: implicitSeats() derives pin-in-hole connections (never
  stored, spec §4/§7.3) via SpatialHash; seatedPartsOn() for sticky
  boards; holeAt() nearest-hole lookup
- CircuitView: registers breadboards as builtins pre-parse; net model now
  runs with busesFor + implicit seats
- Canvas: breadboards skip per-pin hit divs (>60 pins) — press-without-
  displacement on a board is a hole interaction (arm/finalize wires on
  holes), drag moves the board WITH its seated parts, hover shows a hole
  highlight + tooltip (hole name · net members), green seat marks render
  for every derived connection; wire preview snaps to hovered holes
- 4 new test groups (60 total): hole grid alignment, pin counts/naming,
  bus shapes, bus+implicit net integration
---
 .../src/circuit/__tests__/breadboard.test.ts  |  67 ++++++
 src/renderer/src/circuit/parts/breadboard.ts  | 194 ++++++++++++++++++
 .../src/circuit/views/CircuitView.tsx         |  22 +-
 .../src/circuit/views/canvas/Canvas.tsx       | 116 +++++++++--
 .../src/circuit/views/partsAdapter.ts         |  88 ++++++++
 5 files changed, 472 insertions(+), 15 deletions(-)
 create mode 100644 src/renderer/src/circuit/__tests__/breadboard.test.ts
 create mode 100644 src/renderer/src/circuit/parts/breadboard.ts

diff --git a/src/renderer/src/circuit/__tests__/breadboard.test.ts b/src/renderer/src/circuit/__tests__/breadboard.test.ts
new file mode 100644
index 0000000..949b416
--- /dev/null
+++ b/src/renderer/src/circuit/__tests__/breadboard.test.ts
@@ -0,0 +1,67 @@
+/** Tests for parts/breadboard — generator geometry, buses, net integration. */
+
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { GRID_BB, emptyDoc } from '../core/model'
+import { buildNets } from '../core/nets'
+import { BREADBOARDS, breadboardBuses, generateBreadboard, isBreadboard } from '../parts/breadboard'
+
+test('every hole sits on a GRID_BB multiple (snap-by-first-pin keeps holes on grid)', () => {
+  for (const spec of BREADBOARDS) {
+    const { def } = generateBreadboard(spec)
+    const pins = def.views.breadboard!.pins
+    for (const [name, [x, y]] of Object.entries(pins)) {
+      assert.ok(Math.abs(x / GRID_BB - Math.round(x / GRID_BB)) < 1e-9, `${spec.type} ${name} x=${x}`)
+      assert.ok(Math.abs(y / GRID_BB - Math.round(y / GRID_BB)) < 1e-9, `${spec.type} ${name} y=${y}`)
+    }
+  }
+})
+
+test('pin counts and naming', () => {
+  const { def } = generateBreadboard(BREADBOARDS[1]) // half+, 30 cols, rails
+  const pins = def.views.breadboard!.pins
+  assert.equal(Object.keys(pins).length, 30 * 10 + 30 * 4)
+  assert.ok(pins['a1'] && pins['j30'] && pins['t+7'] && pins['b-30'])
+  const mini = generateBreadboard(BREADBOARDS[0]).def.views.breadboard!.pins
+  assert.equal(Object.keys(mini).length, 17 * 10)
+})
+
+test('buses: per-column banks + one bus per rail', () => {
+  const buses = breadboardBuses('breadboard-half')!
+  assert.equal(buses.length, 30 * 2 + 4)
+  const colBus = buses.find((b) => b.includes('a5'))!
+  assert.deepEqual(colBus, ['a5', 'b5', 'c5', 'd5', 'e5'])
+  const railBus = buses.find((b) => b.includes('t+1'))!
+  assert.equal(railBus.length, 30)
+  assert.equal(breadboardBuses('resistor'), undefined)
+  assert.ok(isBreadboard('breadboard-mini') && !isBreadboard('resistor'))
+})
+
+test('two pins seated in one column share a net (buses + implicit)', () => {
+  const doc = emptyDoc()
+  doc.parts = [
+    { id: 'BB1', type: 'breadboard-half', bb: { x: 0, y: 0 } },
+    { id: 'R1', type: 'resistor', bb: { x: 100, y: 100 } },
+    { id: 'LED1', type: 'led', bb: { x: 200, y: 100 } }
+  ]
+  const nets = buildNets(doc, {
+    busesFor: breadboardBuses,
+    implicit: [
+      ['R1:2', 'BB1:a5'],
+      ['LED1:anode', 'BB1:e5'] // same column, different row → same bus
+    ]
+  })
+  const r = nets.pinToNet.get('R1:2')
+  const l = nets.pinToNet.get('LED1:anode')
+  assert.ok(r != null && l != null)
+  assert.equal(r, l)
+  // rails span the board
+  const nets2 = buildNets(doc, {
+    busesFor: breadboardBuses,
+    implicit: [
+      ['R1:2', 'BB1:t+1'],
+      ['LED1:anode', 'BB1:t+30']
+    ]
+  })
+  assert.equal(nets2.pinToNet.get('R1:2'), nets2.pinToNet.get('LED1:anode'))
+})
diff --git a/src/renderer/src/circuit/parts/breadboard.ts b/src/renderer/src/circuit/parts/breadboard.ts
new file mode 100644
index 0000000..a22c93e
--- /dev/null
+++ b/src/renderer/src/circuit/parts/breadboard.ts
@@ -0,0 +1,194 @@
+/**
+ * circuit/parts/breadboard — procedural breadboard PartDefs (spec §5.1).
+ *
+ * Generates crisp SVG + pin maps for three sizes; sizes are parametric so a
+ * new size is one line. Hole pitch is GRID_BB (2.54 mm @ 96 DPI) and the
+ * FIRST PIN sits exactly on a pitch multiple, so snap-by-first-pin placement
+ * puts every hole on the canvas grid — which is what makes drop-to-connect
+ * degenerate to exact coordinate matches.
+ *
+ * Pin naming: main grid `a1…j63` (rows a–e top bank, f–j bottom bank, column
+ * numbers 1..N). Power rails: `t+1…`, `t-1…` (top), `b+1…`, `b-1…` (bottom).
+ * Buses (internally common groups): each column's [a…e] and [f…j], plus one
+ * bus per rail — consumed by buildNets via `busesFor`.
+ *
+ * Registered into the (legacy, M1-era) partsLibrary at Circuit View mount;
+ * the M2+ pack registry will take over ownership without changing geometry.
+ */
+
+import type { PartDef } from '../../lib/partsLibrary'
+import { GRID_BB } from '../core/model'
+
+const P = GRID_BB // 9.6 px hole pitch
+
+export interface BreadboardSpec {
+  type: string
+  label: string
+  cols: number
+  rails: boolean
+}
+
+export const BREADBOARDS: BreadboardSpec[] = [
+  { type: 'breadboard-mini', label: 'Breadboard (mini)', cols: 17, rails: false },
+  { type: 'breadboard-half', label: 'Breadboard (half+)', cols: 30, rails: true },
+  { type: 'breadboard-full', label: 'Breadboard (full+)', cols: 63, rails: true }
+]
+
+export function isBreadboard(type: string): boolean {
+  return type.startsWith('breadboard-')
+}
+
+const ROWS_TOP = ['a', 'b', 'c', 'd', 'e']
+const ROWS_BOT = ['f', 'g', 'h', 'i', 'j']
+
+interface Layout {
+  w: number
+  h: number
+  holeX: (col: number) => number
+  mainY: (rowIdx: number, bank: 'top' | 'bot') => number
+  railY: Record<'t-' | 't+' | 'b+' | 'b-', number> | null
+}
+
+function layout(spec: BreadboardSpec): Layout {
+  const holeX = (col: number): number => P * 2 + (col - 1) * P
+  const w = P * 2 + spec.cols * P + P // margin + columns + margin
+  if (!spec.rails) {
+    // mini: rows a–e at 1P..5P, channel, f–j at 7P..11P
+    return {
+      w,
+      h: P * 12.5,
+      holeX,
+      mainY: (i, bank) => (bank === 'top' ? P * (1 + i) : P * (7 + i)),
+      railY: null
+    }
+  }
+  // railed: t- 1P, t+ 2P · a–e 4P..8P · channel · f–j 10P..14P · b+ 16P, b- 17P
+  return {
+    w,
+    h: P * 18.5,
+    holeX,
+    mainY: (i, bank) => (bank === 'top' ? P * (4 + i) : P * (10 + i)),
+    railY: { 't-': P * 1, 't+': P * 2, 'b+': P * 16, 'b-': P * 17 }
+  }
+}
+
+export interface GeneratedBreadboard {
+  def: PartDef
+  buses: string[][]
+}
+
+export function generateBreadboard(spec: BreadboardSpec): GeneratedBreadboard {
+  const L = layout(spec)
+  const pins: Record<string, [number, number]> = {}
+  const buses: string[][] = []
+
+  for (let c = 1; c <= spec.cols; c++) {
+    const topBus: string[] = []
+    const botBus: string[] = []
+    ROWS_TOP.forEach((r, i) => {
+      pins[`${r}${c}`] = [L.holeX(c), L.mainY(i, 'top')]
+      topBus.push(`${r}${c}`)
+    })
+    ROWS_BOT.forEach((r, i) => {
+      pins[`${r}${c}`] = [L.holeX(c), L.mainY(i, 'bot')]
+      botBus.push(`${r}${c}`)
+    })
+    buses.push(topBus, botBus)
+  }
+  if (L.railY) {
+    for (const rail of ['t-', 't+', 'b+', 'b-'] as const) {
+      const bus: string[] = []
+      for (let c = 1; c <= spec.cols; c++) {
+        const name = `${rail[0]}${rail[1]}${c}` // "t-3", "b+12"
+        pins[name] = [L.holeX(c), L.railY[rail]]
+        bus.push(name)
+      }
+      buses.push(bus)
+    }
+  }
+
+  const def: PartDef = {
+    type: spec.type,
+    label: spec.label,
+    family: 'Breadboards',
+    builtin: true,
+    views: { breadboard: { svg: renderSvg(spec, L), w: L.w, h: L.h, pins } }
+  }
+  return { def, buses }
+}
+
+/** buses per breadboard type (memoized), for buildNets({ busesFor }). */
+const busCache = new Map<string, string[][]>()
+export function breadboardBuses(type: string): string[][] | undefined {
+  if (!isBreadboard(type)) return undefined
+  if (!busCache.has(type)) {
+    const spec = BREADBOARDS.find((s) => s.type === type)
+    if (!spec) return undefined
+    busCache.set(type, generateBreadboard(spec).buses)
+  }
+  return busCache.get(type)
+}
+
+// ── SVG ──────────────────────────────────────────────────────────────────────
+
+function renderSvg(spec: BreadboardSpec, L: Layout): string {
+  const parts: string[] = []
+  const hole = (x: number, y: number): string =>
+    `<rect x="${(x - 2.1).toFixed(2)}" y="${(y - 2.1).toFixed(2)}" width="4.2" height="4.2" rx="0.9" fill="#1f2125" stroke="#494e57" stroke-width="0.7"/>`
+
+  // body
+  parts.push(
+    `<rect x="0.5" y="0.5" width="${L.w - 1}" height="${L.h - 1}" rx="4" fill="#e4e1da" stroke="#b9b4aa" stroke-width="1"/>`
+  )
+  // center channel
+  const chTop = L.mainY(4, 'top') + P * 0.55
+  const chBot = L.mainY(0, 'bot') - P * 0.55
+  parts.push(
+    `<rect x="1.5" y="${chTop.toFixed(2)}" width="${L.w - 3}" height="${(chBot - chTop).toFixed(2)}" fill="#d4d0c8"/>`,
+    `<line x1="1.5" y1="${chTop.toFixed(2)}" x2="${L.w - 1.5}" y2="${chTop.toFixed(2)}" stroke="#c0bbb1" stroke-width="0.8"/>`,
+    `<line x1="1.5" y1="${chBot.toFixed(2)}" x2="${L.w - 1.5}" y2="${chBot.toFixed(2)}" stroke="#c0bbb1" stroke-width="0.8"/>`
+  )
+  // rail stripes + rail holes
+  if (L.railY) {
+    const stripe = (y: number, color: string): string =>
+      `<line x1="${P * 1.1}" y1="${y}" x2="${L.w - P * 1.1}" y2="${y}" stroke="${color}" stroke-width="1.4"/>`
+    parts.push(
+      stripe(L.railY['t-'] - P * 0.55, '#3b6fd4'),
+      stripe(L.railY['t+'] + P * 0.55, '#d84a44'),
+      stripe(L.railY['b+'] - P * 0.55, '#d84a44'),
+      stripe(L.railY['b-'] + P * 0.55, '#3b6fd4')
+    )
+    for (let c = 1; c <= spec.cols; c++) {
+      for (const rail of ['t-', 't+', 'b+', 'b-'] as const) {
+        parts.push(hole(L.holeX(c), L.railY[rail]))
+      }
+    }
+  }
+  // main holes
+  for (let c = 1; c <= spec.cols; c++) {
+    ROWS_TOP.forEach((_, i) => parts.push(hole(L.holeX(c), L.mainY(i, 'top'))))
+    ROWS_BOT.forEach((_, i) => parts.push(hole(L.holeX(c), L.mainY(i, 'bot'))))
+  }
+  // row letters
+  const letterY: [string, number][] = [
+    ...ROWS_TOP.map((r, i): [string, number] => [r, L.mainY(i, 'top')]),
+    ...ROWS_BOT.map((r, i): [string, number] => [r, L.mainY(i, 'bot')])
+  ]
+  for (const [r, y] of letterY) {
+    parts.push(
+      `<text x="${P * 0.9}" y="${y + 2.4}" fill="#8d8779" font-family="monospace" font-size="5.6" text-anchor="middle">${r}</text>`
+    )
+  }
+  // column numbers every 5
+  for (let c = 1; c <= spec.cols; c++) {
+    if (c !== 1 && c % 5 !== 0) continue
+    const x = L.holeX(c)
+    const yTop = L.mainY(0, 'top') - P * 0.75
+    const yBot = L.mainY(4, 'bot') + P * 0.95
+    parts.push(
+      `<text x="${x}" y="${yTop}" fill="#8d8779" font-family="monospace" font-size="5.6" text-anchor="middle">${c}</text>`,
+      `<text x="${x}" y="${yBot}" fill="#8d8779" font-family="monospace" font-size="5.6" text-anchor="middle">${c}</text>`
+    )
+  }
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${L.w} ${L.h}">${parts.join('')}</svg>`
+}
diff --git a/src/renderer/src/circuit/views/CircuitView.tsx b/src/renderer/src/circuit/views/CircuitView.tsx
index 12a22ef..6b28833 100644
--- a/src/renderer/src/circuit/views/CircuitView.tsx
+++ b/src/renderer/src/circuit/views/CircuitView.tsx
@@ -38,11 +38,12 @@ import { type Pt } from '../core/model'
 import { buildNets } from '../core/nets'
 import { nextRefdes, prefixForFamily } from '../core/refdes'
 import { CircuitStore } from '../core/store'
+import { BREADBOARDS, generateBreadboard } from '../parts/breadboard'
 import { Canvas, emptySel, type Cam, type CanvasHandle, type Selection } from './canvas/Canvas'
 import { exportPng, exportSvg } from './exportImage'
 import { InspectorRail } from './inspector/Inspector'
 import { Palette, WIRE_COLORS } from './palette/Palette'
-import { snapBB } from './partsAdapter'
+import { circuitBuses, implicitSeats, snapBB } from './partsAdapter'
 
 export function CircuitViewV2({
   content,
@@ -55,7 +56,12 @@ export function CircuitViewV2({
   onOpenCode?: () => void
   onEditChange?: (editing: boolean) => void
 }): React.JSX.Element {
-  const [{ store, migrated, warnings }] = React.useState(() => CircuitStore.fromFile(content))
+  const [{ store, migrated, warnings }] = React.useState(() => {
+    // procedural breadboards live in the legacy registry until the M2+ pack
+    // registry replaces it — register once, before first geometry pass
+    for (const s of BREADBOARDS) if (!getPart(s.type)) registerPart(generateBreadboard(s).def)
+    return CircuitStore.fromFile(content)
+  })
   const revision = React.useSyncExternalStore(store.subscribe, store.getRevision)
   const doc = store.getDoc()
 
@@ -104,7 +110,16 @@ export function CircuitViewV2({
     })
   }, [doc, sel])
 
-  const netModel = React.useMemo(() => buildNets(doc), [doc])
+  // derived breadboard seating (drop-to-connect) + bus-aware net model
+  const seats = React.useMemo(() => implicitSeats(doc), [doc, defsTick])
+  const netModel = React.useMemo(
+    () =>
+      buildNets(doc, {
+        busesFor: circuitBuses,
+        implicit: seats.map((s): [string, string] => [s.pin, s.hole])
+      }),
+    [doc, seats]
+  )
 
   // ── actions ─────────────────────────────────────────────────────────────────
 
@@ -260,6 +275,7 @@ export function CircuitViewV2({
           setSel={setSel}
           wireColor={wireColor}
           netModel={netModel}
+          seats={seats}
           defsTick={defsTick}
           cam={cam}
           setCam={setCam}
diff --git a/src/renderer/src/circuit/views/canvas/Canvas.tsx b/src/renderer/src/circuit/views/canvas/Canvas.tsx
index 2cde9c9..3e6109d 100644
--- a/src/renderer/src/circuit/views/canvas/Canvas.tsx
+++ b/src/renderer/src/circuit/views/canvas/Canvas.tsx
@@ -24,7 +24,8 @@ import {
   type Pt,
   type WireEnd
 } from '../../core/model'
-import type { NetModel } from '../../core/nets'
+import { describeNet, type NetModel } from '../../core/nets'
+import { isBreadboard } from '../../parts/breadboard'
 import {
   calculateOrthogonalPath,
   clampOntoSegment,
@@ -43,11 +44,14 @@ import {
   bbBounds,
   bbWireGeometry,
   collectFrozen,
+  holeAt,
   makeEndResolver,
   pinAtWorld,
   reroutesFor,
+  seatedPartsOn,
   snapBB,
-  type FrozenWire
+  type FrozenWire,
+  type Seat
 } from '../partsAdapter'
 
 // wire look (identical to DiagramEditor / tinySchematic)
@@ -122,6 +126,7 @@ export function Canvas({
   setSel,
   wireColor,
   netModel,
+  seats,
   defsTick,
   cam,
   setCam,
@@ -136,6 +141,8 @@ export function Canvas({
   setSel: (s: Selection) => void
   wireColor: string
   netModel: NetModel
+  /** derived breadboard seating (drop-to-connect), for seat marks + sticky */
+  seats: Seat[]
   /** bumps when lazy part defs finish loading (geometry depends on them) */
   defsTick: number
   cam: Cam
@@ -150,6 +157,7 @@ export function Canvas({
   const [armed, setArmed] = React.useState<Armed | null>(null)
   const [straight, setStraight] = React.useState(false)
   const [hoverPin, setHoverPin] = React.useState<{ id: string; pin: string } | null>(null)
+  const [hoverHole, setHoverHole] = React.useState<{ id: string; pin: string; pos: Pt } | null>(null)
   const [hoverWire, setHoverWire] = React.useState<string | null>(null)
   const [mouse, setMouse] = React.useState<Pt>({ x: 0, y: 0 })
   const [editPts, setEditPts] = React.useState<Pt[] | null>(null)
@@ -165,6 +173,8 @@ export function Canvas({
     offY: number
     orig: Map<string, Placement>
     frozen: FrozenWire[]
+    /** set once the pointer actually displaces — distinguishes board-hole clicks */
+    moved: boolean
   } | null>(null)
   const handleDrag = React.useRef<{ kind: HandleKind } | null>(null)
   const labelDrag = React.useRef<{ id: string; ox: number; oy: number } | null>(null)
@@ -319,7 +329,11 @@ export function Canvas({
       setSel({ parts, wires: new Set() })
       return
     }
-    const moveIds = sel.parts.has(partId) ? [...sel.parts] : [partId]
+    const part = doc.parts.find((p) => p.id === partId)
+    // sticky boards: dragging a breadboard takes its seated parts along
+    const stickyIds =
+      part && isBreadboard(part.type) ? [partId, ...seatedPartsOn(partId, seats)] : [partId]
+    const moveIds = sel.parts.has(partId) ? [...sel.parts] : stickyIds
     if (!sel.parts.has(partId)) setSel({ parts: new Set([partId]), wires: new Set() })
 
     const grabbedPl = placementOf(partId)
@@ -336,7 +350,8 @@ export function Canvas({
       offX: (e.clientX - r.left) / scale - grabbedPl.x,
       offY: (e.clientY - r.top) / scale - grabbedPl.y,
       orig,
-      frozen: collectFrozen(doc, new Set(orig.keys()))
+      frozen: collectFrozen(doc, new Set(orig.keys())),
+      moved: false
     }
     window.addEventListener('pointermove', onPartMove)
     window.addEventListener('pointerup', onPartUp)
@@ -356,6 +371,8 @@ export function Canvas({
     }
     const snapped = snapBB(part.type, raw)
     const delta = { x: snapped.x - grabbedOrig.x, y: snapped.y - grabbedOrig.y }
+    if (delta.x !== 0 || delta.y !== 0) d.moved = true
+    if (!d.moved) return
 
     const placements = new Map<string, Placement>()
     for (const [id, pl] of d.orig) {
@@ -376,11 +393,21 @@ export function Canvas({
     )
   }
 
-  const onPartUp = (): void => {
+  const onPartUp = (e: PointerEvent): void => {
+    const d = partDrag.current
     partDrag.current = null
     setDragOverrides(null)
     window.removeEventListener('pointermove', onPartMove)
     window.removeEventListener('pointerup', onPartUp)
+    // a press on a breadboard that never displaced = a hole interaction
+    if (d && !d.moved && editable) {
+      const part = doc.parts.find((p) => p.id === d.grabbed)
+      if (part && isBreadboard(part.type)) {
+        const cp = canvasPoint(e)
+        const hole = holeAt(doc, d.grabbed, cp.x, cp.y, 8 / scale)
+        if (hole) pinInteract(`${d.grabbed}:${hole.pin}`, hole.pos)
+      }
+    }
   }
 
   // drag a part's title label (offset stored on the bb placement)
@@ -434,12 +461,9 @@ export function Canvas({
     )
   }
 
-  const onPinClick = (e: React.MouseEvent, partId: string, pin: string): void => {
-    if (!editable) return
-    e.stopPropagation()
-    const ref = `${partId}:${pin}`
-    const pos = resolve(ref)
-    if (!pos) return
+  /** Shared pin gesture: arm on first pin, finalize on second (also used by
+   * breadboard holes, which have no per-pin hit divs). */
+  const pinInteract = (ref: string, pos: Pt): void => {
     if (!armed) {
       setArmed({ from: ref, points: [pos], straight: false })
       setSel(emptySel())
@@ -454,6 +478,14 @@ export function Canvas({
     setArmed(null)
   }
 
+  const onPinClick = (e: React.MouseEvent, partId: string, pin: string): void => {
+    if (!editable) return
+    e.stopPropagation()
+    const ref = `${partId}:${pin}`
+    const pos = resolve(ref)
+    if (pos) pinInteract(ref, pos)
+  }
+
   // tap a junction onto an existing wire at the click point → {wire, t}
   const tapJunction = (hit: WireHit): void => {
     const host = geomForHit.find((g) => g.id === hit.id)
@@ -853,10 +885,13 @@ export function Canvas({
         target = pos
         clean = true
       }
+    } else if (hoverHole) {
+      target = hoverHole.pos
+      clean = true
     }
     if (armed.straight || straight) return [...armed.points, target]
     return [...armed.points, ...calculateOrthogonalPath(last.x, last.y, target.x, target.y, clean).slice(1)]
-  }, [armed, mouse, hoverPin, straight, resolve])
+  }, [armed, mouse, hoverPin, hoverHole, straight, resolve])
 
   // junction solder dots (junction endpoints take the host wire's color)
   const junctionDots = React.useMemo(() => {
@@ -1017,6 +1052,33 @@ export function Canvas({
               </g>
             )}
 
+            {/* drop-to-connect seat marks (green) + hovered hole */}
+            {editable &&
+              seats.map((s) => (
+                <rect
+                  key={`seat:${s.pin}`}
+                  x={s.pos.x - 3.1}
+                  y={s.pos.y - 3.1}
+                  width={6.2}
+                  height={6.2}
+                  rx={1.2}
+                  fill="none"
+                  stroke="#37b26b"
+                  strokeWidth={1.1}
+                />
+              ))}
+            {hoverHole && (
+              <circle
+                cx={hoverHole.pos.x}
+                cy={hoverHole.pos.y}
+                r={4}
+                fill="var(--yellow)"
+                fillOpacity={0.45}
+                stroke="var(--yellow)"
+                strokeWidth={1}
+              />
+            )}
+
             {/* marquee */}
             {marquee && (
               <rect
@@ -1068,6 +1130,13 @@ export function Canvas({
                   cursor: editable ? 'move' : 'default'
                 }}
                 onPointerDown={(e) => onPartDown(e, part.id)}
+                onPointerMove={(e) => {
+                  if (!editable || !isBreadboard(part.type) || partDrag.current) return
+                  const cp = canvasPoint(e)
+                  const hole = holeAt(doc, part.id, cp.x, cp.y, 6 / Math.min(scale, 1))
+                  setHoverHole(hole ? { id: part.id, pin: hole.pin, pos: hole.pos } : null)
+                }}
+                onPointerLeave={() => setHoverHole((h) => (h?.id === part.id ? null : h))}
                 onClick={(e) => e.stopPropagation()}
                 onContextMenu={(e) => {
                   if (!editable) return
@@ -1087,6 +1156,7 @@ export function Canvas({
                   dangerouslySetInnerHTML={{ __html: vis.v.svg }}
                 />
                 {editable &&
+                  Object.keys(vis.v.pins).length <= 60 &&
                   Object.keys(vis.v.pins).map((pin) => {
                     const [px, py] = vis.v.pins[pin]
                     const armedHere = armed?.from === `${part.id}:${pin}`
@@ -1146,6 +1216,28 @@ export function Canvas({
             )
           })}
 
+          {/* hole tooltip: name + net members */}
+          {hoverHole && (
+            <div
+              style={{
+                position: 'absolute',
+                left: hoverHole.pos.x + 8,
+                top: hoverHole.pos.y - 10,
+                zIndex: 6,
+                transform: `scale(${1 / scale})`,
+                transformOrigin: 'left bottom',
+                pointerEvents: 'none'
+              }}
+              className="px-2 py-1 rounded-md bg-surface-card border border-border-default text-[11px] text-text-body whitespace-nowrap shadow"
+            >
+              {hoverHole.pin}
+              {(() => {
+                const idx = netModel.pinToNet.get(`${hoverHole.id}:${hoverHole.pin}`)
+                return idx != null ? ` · net: ${describeNet(netModel, idx)}` : ''
+              })()}
+            </div>
+          )}
+
           {doc.parts.length === 0 && (
             <div
               className="absolute flex flex-col items-center gap-2 text-text-faint text-sm text-center"
diff --git a/src/renderer/src/circuit/views/partsAdapter.ts b/src/renderer/src/circuit/views/partsAdapter.ts
index 8eb1399..a3dde33 100644
--- a/src/renderer/src/circuit/views/partsAdapter.ts
+++ b/src/renderer/src/circuit/views/partsAdapter.ts
@@ -228,3 +228,91 @@ export function reroutesFor(
   }
   return out
 }
+
+// ── M2: breadboard seating (drop-to-connect, derived — never stored) ─────────
+
+import { SpatialHash } from '../core/geometry'
+import { breadboardBuses, isBreadboard } from '../parts/breadboard'
+
+/** Seat radius: half a hole pitch (spec §7.3). */
+const SEAT_RADIUS = GRID_BB / 2
+
+/** buses resolver for buildNets — breadboards today, PartDef v2 packs later. */
+export function circuitBuses(type: string): string[][] | undefined {
+  return breadboardBuses(type)
+}
+
+export interface Seat {
+  /** part pin ref sitting in the hole, e.g. "R1:2" */
+  pin: string
+  /** breadboard hole pin ref, e.g. "BB1:e12" */
+  hole: string
+  pos: Pt
+}
+
+/**
+ * Derive implicit pin-in-hole connections: every placed non-breadboard pin
+ * within SEAT_RADIUS of a breadboard hole. Grid-snapped placement makes the
+ * common case an exact coordinate match.
+ */
+export function implicitSeats(doc: CircuitDoc): Seat[] {
+  const hash = new SpatialHash<string>()
+  let holes = 0
+  for (const part of doc.parts) {
+    if (!part.bb || !isBreadboard(part.type)) continue
+    const vis = bbVisual(part.type)
+    if (!vis) continue
+    for (const pin of Object.keys(vis.v.pins)) {
+      const p = pinWorldOf(part, pin)
+      if (p) {
+        hash.insert(p, `${part.id}:${pin}`)
+        holes++
+      }
+    }
+  }
+  if (!holes) return []
+  const seats: Seat[] = []
+  for (const part of doc.parts) {
+    if (!part.bb || isBreadboard(part.type)) continue
+    const vis = bbVisual(part.type)
+    if (!vis) continue
+    for (const pin of Object.keys(vis.v.pins)) {
+      const p = pinWorldOf(part, pin)
+      if (!p) continue
+      const hit = hash.nearest(p, SEAT_RADIUS)
+      if (hit) seats.push({ pin: `${part.id}:${pin}`, hole: hit.v, pos: hit.p })
+    }
+  }
+  return seats
+}
+
+/** Ids of parts seated on `boardId` (sticky-board moves, spec §7.3). */
+export function seatedPartsOn(boardId: string, seats: Seat[]): string[] {
+  const out = new Set<string>()
+  for (const s of seats) {
+    if (splitPinRef(s.hole).part === boardId) out.add(splitPinRef(s.pin).part)
+  }
+  return [...out]
+}
+
+/** Nearest hole of a specific breadboard part to a world point. */
+export function holeAt(
+  doc: CircuitDoc,
+  boardId: string,
+  wx: number,
+  wy: number,
+  tol: number
+): { pin: string; pos: Pt } | null {
+  const part = doc.parts.find((p) => p.id === boardId)
+  if (!part?.bb) return null
+  const vis = bbVisual(part.type)
+  if (!vis) return null
+  let best: { pin: string; pos: Pt; d: number } | null = null
+  for (const pin of Object.keys(vis.v.pins)) {
+    const p = pinWorldOf(part, pin)
+    if (!p) continue
+    const d = Math.hypot(p.x - wx, p.y - wy)
+    if (d < tol && (!best || d < best.d)) best = { pin, pos: p, d }
+  }
+  return best ? { pin: best.pin, pos: best.pos } : null
+}

From 43f5e4663e81b7f34fce857303f80ed3a99890cc Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Fri, 3 Jul 2026 23:46:52 -0600
Subject: [PATCH 08/27] =?UTF-8?q?Circuit=20v2=20M3=20core:=20schematic=20v?=
 =?UTF-8?q?iew=20=E2=80=94=20dual-view=20editing=20over=20one=20net=20mode?=
 =?UTF-8?q?l?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- parts/symbols.ts: generated IC-box symbols so schematic never blocks on
  missing art (authored art preferred, cached, pins on the major grid)
- partsAdapter goes view-generic (ViewId param, bb defaults + aliases);
  ratsnest() bridges nets connected globally but unrouted in the active
  view (bb treats breadboard seating as routed)
- Canvas: view prop — per-view placements/wires/snap grids, ink orthogonal
  schematic wires, flip (F/Inspector, sch), dashed ratsnest layer, bb-only
  seating UI; remounts per view so gesture state can't leak
- Shell: Breadboard|Schematic toggle, unplaced-parts tray (click to place),
  routed-here status counter, per-view part placement; Inspector edits the
  active view's placement incl. mirror
- 63/63 tests, typecheck clean
---
 docs/circuit-editor-progress.md               |  27 +++
 .../src/circuit/__tests__/symbols.test.ts     |  54 ++++++
 src/renderer/src/circuit/parts/symbols.ts     |  91 +++++++++
 .../src/circuit/views/CircuitView.tsx         | 114 +++++++++--
 .../src/circuit/views/canvas/Canvas.tsx       | 175 +++++++++++------
 .../src/circuit/views/inspector/Inspector.tsx |  64 +++++--
 .../src/circuit/views/partsAdapter.ts         | 180 ++++++++++++++----
 7 files changed, 568 insertions(+), 137 deletions(-)
 create mode 100644 src/renderer/src/circuit/__tests__/symbols.test.ts
 create mode 100644 src/renderer/src/circuit/parts/symbols.ts

diff --git a/docs/circuit-editor-progress.md b/docs/circuit-editor-progress.md
index 6f048d6..792f876 100644
--- a/docs/circuit-editor-progress.md
+++ b/docs/circuit-editor-progress.md
@@ -101,3 +101,30 @@ This file is the running context for agents working on the Circuit View v2. Read
 ## 2026-07-03 (later) — M1 fix: image export
 
 Geoff's testing found SVG export rendering symbols wrong and PNG export dead. Root cause (probed in Node with the Blink demo): Fritzing part SVG roots carry their own `x="0px" y="0px"` (and width/height) — the composer's injected placement attributes duplicated them → **invalid XML**. The in-app canvas tolerates it (lenient HTML parser); the standalone `.svg` and the PNG rasterizer's strict XML parse both fail. Fixes: `prepareSvgForEmbed` (strips prolog/doctype + root x/y/width/height, keeps viewBox) replaces `stripSvgSize` in the exporter; `namespaceSvgIds` now also rewrites `#id` selectors in `<style>` blocks; `resolveCssVars` inlines `var(--…)` design tokens (builtin board art) at export time; PNG rasterize failure logs instead of dying silently. Probe validates the composed scene parses clean. 56/56 tests.
+
+---
+
+## 2026-07-03 (later) — M2 core + M3 core ✅ (breadboards, drop-to-connect, schematic view)
+
+### M2 core (commit a0f3ccd)
+
+- `parts/breadboard.ts` — parametric generator (`breadboard-mini`/`-half`/`-full`), holes on the GRID_BB pitch, per-column bank buses + rail buses (`breadboardBuses`), generated SVG. Registered into the legacy partsLibrary at view mount.
+- `partsAdapter.implicitSeats()` — derived pin-in-hole seating (SpatialHash, radius = ½ pitch); `seatedPartsOn` (sticky boards); `holeAt`.
+- Canvas: boards skip per-pin divs (>60 pins) — press-without-displacement = hole interaction (wires can start/end on holes), board drags carry seated parts, hole hover shows highlight + `hole · net members` tooltip, green seat marks. Net model runs with `busesFor` + implicit seats.
+
+### M3 core (this commit)
+
+- `parts/symbols.ts` — generated IC-box schematic symbols (label on top, pins left/right in definition order, 9.6 grid, ink = `var(--text-strong)`); `schematicVisual` prefers authored art.
+- `partsAdapter` is now **view-generic**: `visualFor/pinWorldOf/makeEndResolver/wireGeometry/viewBounds/collectFrozen/reroutesFor/snapBB/pinAtWorld` all take a `ViewId` (default `'bb'`; `bbVisual`/`bbWireGeometry`/`bbBounds` kept as aliases). `ratsnest()` computes unrouted-here bridges: global net groups by this-view-only connectivity (bb counts seating as routed), greedy nearest-group bridging.
+- Canvas takes `view`: per-view placements/wires/snap (sch wires bend on the 4.8 fine grid, parts snap pins to 9.6), sch wires ink + orthogonal-only (Shift-straight is bb-only), junction dots ink in sch, flip (F key + Inspector mirror button, sch only, CSS `scaleX(-1)` matching `transformLocalPoint`), ratsnest dashed layer, seats/holes gated to bb. Canvas is remounted per view (`key={view}`) so gesture state can't leak across views.
+- Shell: **Breadboard | Schematic** toggle (top-center), **unplaced tray** (chips for parts placed only in the other view; click = place at viewport centre — spec wants attach-to-cursor, simplified for now), status pill gains `routed here: k/n`, per-view part adds (palette/drop place into the active view), exports hidden in sch (composer is bb-only for now). Inspector is view-aware (location/rotation/flip act on the active view's placement).
+- Tests: 63 total (breadboard geometry/buses/net integration; symbol grid/split/caching).
+
+### Deferred (still open from M2/M3 scope)
+
+- M2: `.fzpz` drop-import, pack manager + GitHub index install, Part Editor v2 persistence (B7), bendable legs, default-pack regeneration, "all pins must seat" rigid-translation rule (we seat per-pin on grid match).
+- M3: net labels / ground symbols UI (nets engine + model support already exist and are tested — needs palette entries, canvas rendering of `netLabels`, label pin wiring), ERC panel, attach-to-cursor tray placement, schematic-styled canvas background (currently same dot grid), sch-view image export.
+
+### Verification
+
+- `npm run test:circuit` → **63/63** · `npm run typecheck` → clean · NUL scan clean (all writes done Linux-side per the tooling note above).
diff --git a/src/renderer/src/circuit/__tests__/symbols.test.ts b/src/renderer/src/circuit/__tests__/symbols.test.ts
new file mode 100644
index 0000000..4bb41ff
--- /dev/null
+++ b/src/renderer/src/circuit/__tests__/symbols.test.ts
@@ -0,0 +1,54 @@
+/** Tests for parts/symbols — generated IC-box schematic symbols. */
+
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { GRID_BB } from '../core/model'
+import { generateBoxSymbol, schematicVisual } from '../parts/symbols'
+import type { PartDef } from '../../lib/partsLibrary'
+
+const def: PartDef = {
+  type: 'testpart',
+  label: 'Test Part',
+  views: {
+    breadboard: {
+      svg: '<svg/>',
+      w: 50,
+      h: 20,
+      pins: { VCC: [0, 0], GND: [0, 10], SDA: [50, 0], SCL: [50, 10], INT: [25, 20] }
+    }
+  }
+}
+
+test('generated symbol: every pin on the 9.6 major grid, left/right split by order', () => {
+  const v = generateBoxSymbol(def)
+  assert.equal(Object.keys(v.pins).length, 5)
+  for (const [name, [x, y]] of Object.entries(v.pins)) {
+    assert.ok(Math.abs(x / GRID_BB - Math.round(x / GRID_BB)) < 1e-9, `${name} x=${x}`)
+    assert.ok(Math.abs(y / GRID_BB - Math.round(y / GRID_BB)) < 1e-9, `${name} y=${y}`)
+  }
+  // first ceil(5/2)=3 pins on the left edge (x=0), rest on the right edge
+  assert.equal(v.pins['VCC'][0], 0)
+  assert.equal(v.pins['GND'][0], 0)
+  assert.equal(v.pins['SDA'][0], 0)
+  assert.equal(v.pins['SCL'][0], v.w)
+  assert.equal(v.pins['INT'][0], v.w)
+})
+
+test('generated symbol SVG carries the label and ink strokes', () => {
+  const v = generateBoxSymbol(def)
+  assert.ok(v.svg.includes('Test Part'))
+  assert.ok(v.svg.includes('var(--text-strong)'))
+  assert.ok(v.svg.includes('viewBox'))
+})
+
+test('schematicVisual prefers authored art and caches generated symbols', () => {
+  const authored: PartDef = {
+    ...def,
+    type: 'authored',
+    views: { ...def.views, schematic: { svg: '<svg>real</svg>', w: 10, h: 10, pins: { VCC: [0, 0] } } }
+  }
+  assert.equal(schematicVisual(authored).svg, '<svg>real</svg>')
+  const a = schematicVisual(def)
+  const b = schematicVisual(def)
+  assert.equal(a, b) // cached instance
+})
diff --git a/src/renderer/src/circuit/parts/symbols.ts b/src/renderer/src/circuit/parts/symbols.ts
new file mode 100644
index 0000000..030e851
--- /dev/null
+++ b/src/renderer/src/circuit/parts/symbols.ts
@@ -0,0 +1,91 @@
+/**
+ * circuit/parts/symbols — generated schematic symbols (spec §5.1).
+ *
+ * Parts whose PartDef lacks schematic art get an auto-generated IC-style box
+ * symbol: type label on top, pins distributed left/right in definition order,
+ * pin names inked inside the body. This guarantees the schematic view (and,
+ * later, KiCad export) never blocks on missing artwork.
+ *
+ * Ink is `var(--text-strong)` so symbols follow the tinyStudio theme; the
+ * image exporter inlines the variable at export time (resolveCssVars).
+ *
+ * Pin positions land on the 9.6 px major grid (spec §4 pin-on-grid contract).
+ */
+
+import type { PartDef, PartView } from '../../lib/partsLibrary'
+import { GRID_BB } from '../core/model'
+
+const P = GRID_BB // 9.6 — schematic major grid
+const INK = 'var(--text-strong)'
+const STROKE = 2
+
+const cache = new Map<string, PartView>()
+
+/** Schematic view for a part: authored art if present, else a generated box. */
+export function schematicVisual(def: PartDef): PartView {
+  if (def.views.schematic) return def.views.schematic
+  let v = cache.get(def.type)
+  if (!v) {
+    v = generateBoxSymbol(def)
+    cache.set(def.type, v)
+  }
+  return v
+}
+
+export function generateBoxSymbol(def: PartDef): PartView {
+  const source = def.views.breadboard?.pins ?? {}
+  const names = Object.keys(source)
+  // pin order: definition order; left gets the first half, right the rest
+  const nLeft = Math.ceil(names.length / 2)
+  const left = names.slice(0, nLeft)
+  const right = names.slice(nLeft)
+  const rows = Math.max(left.length, right.length, 1)
+
+  const stub = P // lead length from body to pin tip
+  const bodyW = P * Math.max(4, Math.min(10, 2 + Math.ceil(longest(names) * 0.62)))
+  const bodyH = P * (rows + 1)
+  const w = bodyW + stub * 2
+  const h = bodyH + P // headroom for the label
+
+  const pins: Record<string, [number, number]> = {}
+  const parts: string[] = []
+  const bodyX = stub
+  const bodyY = P
+
+  parts.push(
+    `<rect x="${bodyX}" y="${bodyY}" width="${bodyW}" height="${bodyH}" rx="2" fill="none" stroke="${INK}" stroke-width="${STROKE}"/>`,
+    `<text x="${w / 2}" y="${bodyY - 3}" fill="${INK}" font-family="monospace" font-size="8" text-anchor="middle">${escape(def.label || def.type)}</text>`
+  )
+
+  left.forEach((name, i) => {
+    const y = bodyY + P * (i + 1)
+    pins[name] = [0, y]
+    parts.push(
+      `<line x1="0" y1="${y}" x2="${bodyX}" y2="${y}" stroke="${INK}" stroke-width="${STROKE}"/>`,
+      `<text x="${bodyX + 3}" y="${y + 2.6}" fill="${INK}" font-family="monospace" font-size="7">${escape(name)}</text>`
+    )
+  })
+  right.forEach((name, i) => {
+    const y = bodyY + P * (i + 1)
+    pins[name] = [w, y]
+    parts.push(
+      `<line x1="${bodyX + bodyW}" y1="${y}" x2="${w}" y2="${y}" stroke="${INK}" stroke-width="${STROKE}"/>`,
+      `<text x="${bodyX + bodyW - 3}" y="${y + 2.6}" fill="${INK}" font-family="monospace" font-size="7" text-anchor="end">${escape(name)}</text>`
+    )
+  })
+
+  return {
+    svg: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${w} ${h}">${parts.join('')}</svg>`,
+    w,
+    h,
+    pins
+  }
+}
+
+function longest(names: string[]): number {
+  return names.reduce((m, n) => Math.max(m, n.length), 0)
+}
+
+function escape(s: string): string {
+  return s.replace(/[<>&]/g, (c) => ({ '<': '&lt;', '>': '&gt;', '&': '&amp;' })[c] as string)
+}
diff --git a/src/renderer/src/circuit/views/CircuitView.tsx b/src/renderer/src/circuit/views/CircuitView.tsx
index 6b28833..778f806 100644
--- a/src/renderer/src/circuit/views/CircuitView.tsx
+++ b/src/renderer/src/circuit/views/CircuitView.tsx
@@ -29,12 +29,11 @@ import {
   getPart,
   loadPart,
   registerPart,
-  viewFor,
   type PartDef
 } from '../../lib/partsLibrary'
 import { PartsEditor } from '../../components/PartsEditor'
 import * as cmd from '../core/commands'
-import { type Pt } from '../core/model'
+import { type Pt, type ViewId } from '../core/model'
 import { buildNets } from '../core/nets'
 import { nextRefdes, prefixForFamily } from '../core/refdes'
 import { CircuitStore } from '../core/store'
@@ -43,7 +42,7 @@ import { Canvas, emptySel, type Cam, type CanvasHandle, type Selection } from '.
 import { exportPng, exportSvg } from './exportImage'
 import { InspectorRail } from './inspector/Inspector'
 import { Palette, WIRE_COLORS } from './palette/Palette'
-import { circuitBuses, implicitSeats, snapBB } from './partsAdapter'
+import { circuitBuses, implicitSeats, ratsnest, snapBB, visualFor } from './partsAdapter'
 
 export function CircuitViewV2({
   content,
@@ -66,6 +65,7 @@ export function CircuitViewV2({
   const doc = store.getDoc()
 
   const [editable, setEditable] = React.useState(false)
+  const [view, setView] = React.useState<ViewId>('bb')
   const [grid, setGrid] = React.useState(true)
   const [sel, setSel] = React.useState<Selection>(emptySel())
   const [wireColor, setWireColor] = React.useState(WIRE_COLORS[0])
@@ -120,6 +120,39 @@ export function CircuitViewV2({
       }),
     [doc, seats]
   )
+  // nets satisfied elsewhere but unrouted here → dashed guidance (spec §8.2)
+  const rats = React.useMemo(() => ratsnest(doc, view, netModel), [doc, view, netModel, defsTick])
+  const routedHere = React.useMemo(() => {
+    const unrouted = new Set(rats.map((r) => r.net))
+    return netModel.meaningful - unrouted.size
+  }, [rats, netModel])
+  // parts with no placement in the current view live in the tray
+  const trayParts = React.useMemo(
+    () => doc.parts.filter((p) => !p[view] && (view === 'bb' ? p.sch : p.bb)),
+    [doc, view]
+  )
+
+  // switching views: selection is per-view state, wires especially
+  const switchView = (v: ViewId): void => {
+    if (v === view) return
+    setView(v)
+    setSel(emptySel())
+    requestAnimationFrame(() => canvasRef.current?.fit())
+  }
+
+  const placeFromTray = (partId: string): void => {
+    const part = doc.parts.find((p) => p.id === partId)
+    if (!part) return
+    const vis = visualFor(part.type, view)
+    const c = canvasRef.current?.centerWorld() ?? { x: 300, y: 200 }
+    const pl = snapBB(
+      part.type,
+      { x: Math.round(c.x - (vis?.v.w ?? 80) / 2), y: Math.round(c.y - (vis?.v.h ?? 40) / 2) },
+      view
+    )
+    store.dispatch(cmd.placePart(partId, view, pl))
+    setSel({ parts: new Set([partId]), wires: new Set() })
+  }
 
   // ── actions ─────────────────────────────────────────────────────────────────
 
@@ -127,13 +160,13 @@ export function CircuitViewV2({
     const def = getPart(type) || (await loadPart(type))
     if (!def) return
     bumpDefs()
-    const v = viewFor(def, 'breadboard')
-    const w = v?.w || 80
-    const h = v?.h || 40
+    const vis = visualFor(type, view)
+    const w = vis?.v.w || 80
+    const h = vis?.v.h || 40
     const p = at ?? canvasRef.current?.centerWorld() ?? { x: 300, y: 200 }
     const id = nextRefdes(store.getDoc(), prefixForFamily(`${def.family ?? ''} ${def.type}`))
-    const bb = snapBB(type, { x: Math.round(p.x - w / 2), y: Math.round(p.y - h / 2) })
-    store.dispatch(cmd.addPart({ id, type, bb }))
+    const pl = snapBB(type, { x: Math.round(p.x - w / 2), y: Math.round(p.y - h / 2) }, view)
+    store.dispatch(cmd.addPart({ id, type, [view]: pl }))
     setSel({ parts: new Set([id]), wires: new Set() })
   }
 
@@ -200,14 +233,57 @@ export function CircuitViewV2({
           )}
         </div>
 
+        {/* view toggle: Breadboard | Schematic */}
+        <div className="absolute top-3 left-1/2 -translate-x-1/2 z-10 flex rounded-md overflow-hidden tactile-bordered">
+          {(
+            [
+              ['bb', 'Breadboard'],
+              ['sch', 'Schematic']
+            ] as [ViewId, string][]
+          ).map(([v, label]) => (
+            <button
+              key={v}
+              className={`h-8 px-3 text-xs font-medium ${
+                view === v
+                  ? 'bg-brand/15 text-brand'
+                  : 'bg-surface-card text-text-muted hover:text-text-body'
+              }`}
+              onClick={() => switchView(v)}
+            >
+              {label}
+            </button>
+          ))}
+        </div>
+
+        {/* unplaced tray: parts that only exist in the other view */}
+        {trayParts.length > 0 && (
+          <div className="absolute top-14 left-1/2 -translate-x-1/2 z-10 flex gap-1.5 items-center flex-wrap max-w-[70%] justify-center">
+            <span className="text-[10px] text-text-faint">unplaced here:</span>
+            {trayParts.map((part) => (
+              <button
+                key={part.id}
+                className="px-2 py-0.5 rounded-full bg-surface-card border border-dashed border-border-strong text-[11px] text-text-body hover:border-brand hover:text-brand"
+                title={`${part.type} — click to place in this view`}
+                onClick={() => placeFromTray(part.id)}
+              >
+                {part.id}
+              </button>
+            ))}
+          </div>
+        )}
+
         {/* right toolbar: export / grid / code */}
         <div className="absolute top-3 right-3.5 z-10 flex gap-1.5">
-          <button className={`${tool} w-8 justify-center px-0`} onClick={() => exportPng(doc)} title="Export as PNG">
-            <ImageDown size={15} />
-          </button>
-          <button className={`${tool} w-8 justify-center px-0`} onClick={() => exportSvg(doc)} title="Export as SVG">
-            <FileCode2 size={15} />
-          </button>
+          {view === 'bb' && (
+            <>
+              <button className={`${tool} w-8 justify-center px-0`} onClick={() => exportPng(doc)} title="Export as PNG">
+                <ImageDown size={15} />
+              </button>
+              <button className={`${tool} w-8 justify-center px-0`} onClick={() => exportSvg(doc)} title="Export as SVG">
+                <FileCode2 size={15} />
+              </button>
+            </>
+          )}
           <button
             className={`${tool} w-8 justify-center px-0 ${grid ? 'text-brand' : ''}`}
             onClick={() => setGrid((g) => !g)}
@@ -249,7 +325,8 @@ export function CircuitViewV2({
         {/* status pills */}
         <div className="absolute bottom-3 left-3 z-10 flex flex-wrap gap-2 text-[11px] max-w-[60%]">
           <span className="px-2.5 py-1 rounded-full bg-surface-card border border-border-default text-text-body">
-            Parts: {doc.parts.length} · Wires: {doc.wires.length} · Nets: {netModel.meaningful}
+            Parts: {doc.parts.length} · Wires: {doc.wires.filter((w) => w.view === view).length} ·
+            Nets: {netModel.meaningful} · routed here: {routedHere}/{netModel.meaningful}
           </span>
           {migrated && (
             <span className="px-2.5 py-1 rounded-full bg-surface-card border border-brand/40 text-brand">
@@ -267,8 +344,10 @@ export function CircuitViewV2({
         </div>
 
         <Canvas
+          key={view}
           store={store}
           doc={doc}
+          view={view}
           editable={editable}
           grid={grid}
           sel={sel}
@@ -276,6 +355,7 @@ export function CircuitViewV2({
           wireColor={wireColor}
           netModel={netModel}
           seats={seats}
+          rats={rats}
           defsTick={defsTick}
           cam={cam}
           setCam={setCam}
@@ -289,7 +369,9 @@ export function CircuitViewV2({
         </div>
       </div>
 
-      {editable && <InspectorRail doc={doc} store={store} sel={sel} setSel={setSel} netModel={netModel} />}
+      {editable && (
+        <InspectorRail doc={doc} store={store} sel={sel} setSel={setSel} netModel={netModel} view={view} />
+      )}
 
       {editorPart !== undefined && (
         <PartsEditor
diff --git a/src/renderer/src/circuit/views/canvas/Canvas.tsx b/src/renderer/src/circuit/views/canvas/Canvas.tsx
index 3e6109d..4089058 100644
--- a/src/renderer/src/circuit/views/canvas/Canvas.tsx
+++ b/src/renderer/src/circuit/views/canvas/Canvas.tsx
@@ -17,11 +17,13 @@ import { buildClipboard, materializePaste, parseClipboard } from '../../core/cli
 import * as cmd from '../../core/commands'
 import {
   GRID_BB,
+  GRID_SCH,
   isJunction,
   isPendingJunction,
   type CircuitDoc,
   type Placement,
   type Pt,
+  type ViewId,
   type WireEnd
 } from '../../core/model'
 import { describeNet, type NetModel } from '../../core/nets'
@@ -40,9 +42,6 @@ import {
 } from '../../core/routing'
 import type { CircuitStore } from '../../core/store'
 import {
-  bbVisual,
-  bbBounds,
-  bbWireGeometry,
   collectFrozen,
   holeAt,
   makeEndResolver,
@@ -50,7 +49,11 @@ import {
   reroutesFor,
   seatedPartsOn,
   snapBB,
+  viewBounds,
+  visualFor,
+  wireGeometry,
   type FrozenWire,
+  type RatsnestSegment,
   type Seat
 } from '../partsAdapter'
 
@@ -61,8 +64,6 @@ const WIRE_GLOW_W = WIRE_W + 5
 const WIRE_CORNER = 4
 const NET_GLOW = 'rgba(243, 203, 0, 0.30)'
 
-const snap = (v: number): number => Math.round(v / GRID_BB) * GRID_BB
-
 export interface Selection {
   parts: Set<string>
   wires: Set<string>
@@ -120,6 +121,7 @@ function roundedPath(points: Pt[], r = WIRE_CORNER): string {
 export function Canvas({
   store,
   doc,
+  view,
   editable,
   grid,
   sel,
@@ -127,6 +129,7 @@ export function Canvas({
   wireColor,
   netModel,
   seats,
+  rats,
   defsTick,
   cam,
   setCam,
@@ -135,6 +138,7 @@ export function Canvas({
 }: {
   store: CircuitStore
   doc: CircuitDoc
+  view: ViewId
   editable: boolean
   grid: boolean
   sel: Selection
@@ -143,6 +147,8 @@ export function Canvas({
   netModel: NetModel
   /** derived breadboard seating (drop-to-connect), for seat marks + sticky */
   seats: Seat[]
+  /** unrouted-in-this-view net bridges (dashed guidance lines) */
+  rats: RatsnestSegment[]
   /** bumps when lazy part defs finish loading (geometry depends on them) */
   defsTick: number
   cam: Cam
@@ -151,6 +157,10 @@ export function Canvas({
   onDropPart: (type: string, at: Pt) => void
 }): React.JSX.Element {
   const scale = cam.scale
+  // schematic wires bend on the fine grid; parts still snap pins to major
+  const wireGrid = view === 'sch' ? GRID_SCH : GRID_BB
+  const snap = (v: number): number => Math.round(v / wireGrid) * wireGrid
+  const ink = 'var(--text-strong)'
   const viewRef = React.useRef<HTMLDivElement>(null)
   const innerRef = React.useRef<HTMLDivElement>(null)
 
@@ -183,12 +193,12 @@ export function Canvas({
   // ── geometry ────────────────────────────────────────────────────────────────
 
   const resolve = React.useMemo(
-    () => makeEndResolver(doc, dragOverrides ?? undefined),
-    [doc, dragOverrides, defsTick]
+    () => makeEndResolver(doc, dragOverrides ?? undefined, view),
+    [doc, dragOverrides, defsTick, view]
   )
   const wireGeom = React.useMemo(
-    () => bbWireGeometry(doc, dragOverrides ?? undefined),
-    [doc, dragOverrides, defsTick]
+    () => wireGeometry(doc, view, dragOverrides ?? undefined),
+    [doc, dragOverrides, defsTick, view]
   )
   const geomForHit = React.useMemo(
     () => wireGeom.filter((g) => g.pts.length >= 2).map((g) => ({ id: g.w.id, points: g.pts })),
@@ -200,7 +210,7 @@ export function Canvas({
     return { x: (e.clientX - r.left) / scale, y: (e.clientY - r.top) / scale }
   }
   const placementOf = (id: string): Placement | undefined =>
-    dragOverrides?.get(id) ?? doc.parts.find((p) => p.id === id)?.bb
+    dragOverrides?.get(id) ?? doc.parts.find((p) => p.id === id)?.[view]
 
   // selected wire edit buffer stays in sync with the doc (undo, external edits)
   const soloWire = sel.wires.size === 1 && sel.parts.size === 0 ? [...sel.wires][0] : null
@@ -217,6 +227,7 @@ export function Canvas({
   // resolve v1-migrated *pending junctions* once geometry exists (M0 gap)
   const pendingDone = React.useRef(false)
   React.useEffect(() => {
+    if (view !== 'bb') return // v1 migration produced bb wires only
     if (pendingDone.current) return
     const pending = doc.wires.filter(
       (w) => isPendingJunction(w.from) || isPendingJunction(w.to)
@@ -225,7 +236,7 @@ export function Canvas({
       pendingDone.current = true
       return
     }
-    if (doc.parts.some((p) => p.bb && !bbVisual(p.type))) return // defs still loading
+    if (doc.parts.some((p) => p.bb && !visualFor(p.type, 'bb'))) return // defs still loading
     const fixes: cmd.Command[] = []
     for (const w of pending) {
       const fix = (end: WireEnd): WireEnd => {
@@ -264,7 +275,7 @@ export function Canvas({
   const fit = React.useCallback((): void => {
     const el = viewRef.current
     if (!el) return
-    const b = bbBounds(doc)
+    const b = viewBounds(doc, view)
     if (!b) return
     const pad = 48
     const bw = b.maxX - b.minX + pad * 2
@@ -275,7 +286,7 @@ export function Canvas({
       tx: (el.clientWidth - bw * f) / 2 - (b.minX - pad) * f,
       ty: (el.clientHeight - bh * f) / 2 - (b.minY - pad) * f
     })
-  }, [doc, setCam])
+  }, [doc, setCam, view])
 
   const zoomAt = (factor: number, sx: number, sy: number): void =>
     setCam((c) => {
@@ -307,7 +318,7 @@ export function Canvas({
   const didFit = React.useRef(false)
   React.useEffect(() => {
     if (didFit.current) return
-    if (doc.parts.length === 0 || doc.parts.every((p) => !p.bb || bbVisual(p.type))) {
+    if (doc.parts.length === 0 || doc.parts.every((p) => !p[view] || visualFor(p.type, view))) {
       fit()
       didFit.current = true
     }
@@ -330,9 +341,11 @@ export function Canvas({
       return
     }
     const part = doc.parts.find((p) => p.id === partId)
-    // sticky boards: dragging a breadboard takes its seated parts along
+    // sticky boards: dragging a breadboard takes its seated parts along (bb)
     const stickyIds =
-      part && isBreadboard(part.type) ? [partId, ...seatedPartsOn(partId, seats)] : [partId]
+      view === 'bb' && part && isBreadboard(part.type)
+        ? [partId, ...seatedPartsOn(partId, seats)]
+        : [partId]
     const moveIds = sel.parts.has(partId) ? [...sel.parts] : stickyIds
     if (!sel.parts.has(partId)) setSel({ parts: new Set([partId]), wires: new Set() })
 
@@ -341,7 +354,7 @@ export function Canvas({
     const r = innerRef.current!.getBoundingClientRect()
     const orig = new Map<string, Placement>()
     for (const id of moveIds) {
-      const pl = doc.parts.find((p) => p.id === id)?.bb
+      const pl = doc.parts.find((p) => p.id === id)?.[view]
       if (pl) orig.set(id, pl)
     }
     partDrag.current = {
@@ -350,7 +363,7 @@ export function Canvas({
       offX: (e.clientX - r.left) / scale - grabbedPl.x,
       offY: (e.clientY - r.top) / scale - grabbedPl.y,
       orig,
-      frozen: collectFrozen(doc, new Set(orig.keys())),
+      frozen: collectFrozen(doc, new Set(orig.keys()), view),
       moved: false
     }
     window.addEventListener('pointermove', onPartMove)
@@ -369,7 +382,7 @@ export function Canvas({
       x: (e.clientX - r.left) / scale - d.offX,
       y: (e.clientY - r.top) / scale - d.offY
     }
-    const snapped = snapBB(part.type, raw)
+    const snapped = snapBB(part.type, raw, view)
     const delta = { x: snapped.x - grabbedOrig.x, y: snapped.y - grabbedOrig.y }
     if (delta.x !== 0 || delta.y !== 0) d.moved = true
     if (!d.moved) return
@@ -380,15 +393,15 @@ export function Canvas({
     }
     setDragOverrides(placements)
 
-    const reroutes = reroutesFor(doc, d.frozen, placements, delta)
+    const reroutes = reroutesFor(doc, d.frozen, placements, delta, view)
     const cmds = [...placements.entries()].map(([id, pl], i) =>
-      cmd.placePart(id, 'bb', pl, i === 0 ? reroutes : [])
+      cmd.placePart(id, view, pl, i === 0 ? reroutes : [])
     )
     store.dispatch(
       cmd.composite(
         d.ids.length === 1 ? `Move ${d.grabbed}` : `Move ${d.ids.length} parts`,
         cmds,
-        `movebb:${d.ids.slice().sort().join(',')}`
+        `move:${view}:${d.ids.slice().sort().join(',')}`
       )
     )
   }
@@ -400,7 +413,7 @@ export function Canvas({
     window.removeEventListener('pointermove', onPartMove)
     window.removeEventListener('pointerup', onPartUp)
     // a press on a breadboard that never displaced = a hole interaction
-    if (d && !d.moved && editable) {
+    if (d && !d.moved && editable && view === 'bb') {
       const part = doc.parts.find((p) => p.id === d.grabbed)
       if (part && isBreadboard(part.type)) {
         const cp = canvasPoint(e)
@@ -423,11 +436,11 @@ export function Canvas({
     const move = (ev: PointerEvent): void => {
       const ld = labelDrag.current
       if (!ld) return
-      const cur = doc.parts.find((p) => p.id === ld.id)?.bb
+      const cur = doc.parts.find((p) => p.id === ld.id)?.[view]
       if (!cur) return
       const cp = canvasPoint(ev)
       const offset: [number, number] = [Math.round(ld.ox + cp.x), Math.round(ld.oy + cp.y)]
-      store.dispatch(cmd.placePart(ld.id, 'bb', { ...cur, labelOffset: offset }, [], true))
+      store.dispatch(cmd.placePart(ld.id, view, { ...cur, labelOffset: offset }, [], true))
     }
     const up = (): void => {
       labelDrag.current = null
@@ -443,7 +456,7 @@ export function Canvas({
   const finalizeSegment = (target: Pt, clean: boolean): { pts: Pt[]; str: boolean } => {
     const pts = [...armed!.points]
     const last = pts[pts.length - 1]
-    const str = armed!.straight || straight
+    const str = view === 'bb' && (armed!.straight || straight) // sch: orthogonal only
     if (str) pts.push(target)
     else pts.push(...calculateOrthogonalPath(last.x, last.y, target.x, target.y, clean).slice(1))
     return { pts: simplifyWirePoints(pts), str }
@@ -454,8 +467,8 @@ export function Canvas({
       cmd.addWire({
         from,
         to,
-        view: 'bb',
-        color: wireColor,
+        view,
+        ...(view === 'bb' ? { color: wireColor } : {}), // schematic wires are ink
         route: journeyFromPoints(pts, str)
       })
     )
@@ -528,7 +541,7 @@ export function Canvas({
   // ── selected-wire editing (segment / vertex / endpoint handles) ─────────────
 
   const resolveEndpointTarget = (wx: number, wy: number, selfId: string): WireEnd | null => {
-    const pin = pinAtWorld(doc, wx, wy, 8 / scale)
+    const pin = pinAtWorld(doc, wx, wy, 8 / scale, view)
     if (pin) return `${pin.id}:${pin.pin}`
     const others = geomForHit.filter((g) => g.id !== selfId)
     const hit = hitWire(wx, wy, others, scale)
@@ -685,10 +698,11 @@ export function Canvas({
         suppressClick.current = true
         const parts = new Set(additive ? sel.parts : [])
         for (const part of doc.parts) {
-          if (!part.bb) continue
-          const vis = bbVisual(part.type)
+          const pl = part[view]
+          if (!pl) continue
+          const vis = visualFor(part.type, view)
           if (!vis) continue
-          if (part.bb.x < x1 && part.bb.x + vis.v.w > x0 && part.bb.y < y1 && part.bb.y + vis.v.h > y0)
+          if (pl.x < x1 && pl.x + vis.v.w > x0 && pl.y < y1 && pl.y + vis.v.h > y0)
             parts.add(part.id)
         }
         const wires = new Set(additive ? sel.wires : [])
@@ -717,45 +731,45 @@ export function Canvas({
   const rotateSelection = React.useCallback((): void => {
     const ids = [...sel.parts]
     if (!ids.length) return
-    const frozen = collectFrozen(doc, new Set(ids))
+    const frozen = collectFrozen(doc, new Set(ids), view)
     const placements = new Map<string, Placement>()
     const cmds: cmd.Command[] = []
     for (const id of ids) {
-      const cur = doc.parts.find((p) => p.id === id)?.bb
+      const cur = doc.parts.find((p) => p.id === id)?.[view]
       if (!cur) continue
       const next = (((((cur.rotate ?? 0) + 90) % 360) + 360) % 360) as 0 | 90 | 180 | 270
       placements.set(id, { ...cur, rotate: next || undefined })
     }
-    const reroutes = reroutesFor(doc, frozen, placements, { x: 0, y: 0 })
+    const reroutes = reroutesFor(doc, frozen, placements, { x: 0, y: 0 }, view)
     let first = true
     for (const [id, pl] of placements) {
-      cmds.push(cmd.placePart(id, 'bb', pl, first ? reroutes : []))
+      cmds.push(cmd.placePart(id, view, pl, first ? reroutes : []))
       first = false
     }
     if (cmds.length) store.dispatch(cmd.composite(`Rotate ${ids.length > 1 ? `${ids.length} parts` : ids[0]}`, cmds))
-  }, [doc, sel, store])
+  }, [doc, sel, store, view])
 
   const nudgeSelection = React.useCallback(
     (dx: number, dy: number): void => {
       const ids = [...sel.parts]
       if (!ids.length) return
-      const frozen = collectFrozen(doc, new Set(ids))
+      const frozen = collectFrozen(doc, new Set(ids), view)
       const placements = new Map<string, Placement>()
       for (const id of ids) {
-        const cur = doc.parts.find((p) => p.id === id)?.bb
+        const cur = doc.parts.find((p) => p.id === id)?.[view]
         if (cur) placements.set(id, { ...cur, x: cur.x + dx, y: cur.y + dy })
       }
-      const reroutes = reroutesFor(doc, frozen, placements, { x: dx, y: dy })
+      const reroutes = reroutesFor(doc, frozen, placements, { x: dx, y: dy }, view)
       let first = true
       const cmds: cmd.Command[] = []
       for (const [id, pl] of placements) {
-        cmds.push(cmd.placePart(id, 'bb', pl, first ? reroutes : []))
+        cmds.push(cmd.placePart(id, view, pl, first ? reroutes : []))
         first = false
       }
       if (cmds.length)
         store.dispatch(cmd.composite('Nudge', cmds, `nudge:${ids.slice().sort().join(',')}`))
     },
-    [doc, sel, store]
+    [doc, sel, store, view]
   )
 
   const deleteSelection = React.useCallback((): void => {
@@ -845,13 +859,33 @@ export function Canvas({
         }
         return
       }
+      if ((e.key === 'f' || e.key === 'F') && view === 'sch' && sel.parts.size) {
+        // horizontal mirror — schematic only (spec §6.3 / B13)
+        e.preventDefault()
+        const ids = [...sel.parts]
+        const frozen = collectFrozen(doc, new Set(ids), view)
+        const placements = new Map<string, Placement>()
+        for (const id of ids) {
+          const cur = doc.parts.find((p) => p.id === id)?.[view]
+          if (cur) placements.set(id, { ...cur, flip: cur.flip ? undefined : true })
+        }
+        const reroutes = reroutesFor(doc, frozen, placements, { x: 0, y: 0 }, view)
+        let first = true
+        const cmds: cmd.Command[] = []
+        for (const [id, pl] of placements) {
+          cmds.push(cmd.placePart(id, view, pl, first ? reroutes : []))
+          first = false
+        }
+        if (cmds.length) store.dispatch(cmd.composite('Flip', cmds))
+        return
+      }
       if (e.key === 'Delete' || e.key === 'Backspace') {
         deleteSelection()
         return
       }
       if (e.key.startsWith('Arrow') && sel.parts.size) {
         e.preventDefault()
-        const step = GRID_BB * (e.shiftKey ? 5 : 1)
+        const step = (view === 'sch' ? GRID_SCH : GRID_BB) * (e.shiftKey ? 5 : 1)
         const d = {
           ArrowLeft: [-step, 0],
           ArrowRight: [step, 0],
@@ -870,7 +904,7 @@ export function Canvas({
       window.removeEventListener('keydown', down)
       window.removeEventListener('keyup', up)
     }
-  }, [editable, sel, doc, store, setSel, copySelection, pastePayload, deleteSelection, rotateSelection, nudgeSelection])
+  }, [editable, sel, doc, store, setSel, view, copySelection, pastePayload, deleteSelection, rotateSelection, nudgeSelection])
 
   // ── derived render bits ─────────────────────────────────────────────────────
 
@@ -896,17 +930,18 @@ export function Canvas({
   // junction solder dots (junction endpoints take the host wire's color)
   const junctionDots = React.useMemo(() => {
     const out: { key: string; pt: Pt; color: string }[] = []
-    const colorOf = new Map(doc.wires.map((w) => [w.id, w.color || '#2fa46a']))
+    const fallback = view === 'sch' ? ink : '#2fa46a'
+    const colorOf = new Map(doc.wires.map((w) => [w.id, w.color || fallback]))
     doc.wires
-      .filter((w) => w.view === 'bb')
+      .filter((w) => w.view === view)
       .forEach((w) =>
         [w.from, w.to].forEach((end, i) => {
           if (!isJunction(end)) return
           const p = resolve(end)
           if (!p) return
           const color = isPendingJunction(end)
-            ? w.color || '#2fa46a'
-            : colorOf.get(end.wire) || w.color || '#2fa46a'
+            ? w.color || fallback
+            : colorOf.get(end.wire) || w.color || fallback
           out.push({ key: `${w.id}:${i}`, pt: p, color })
         })
       )
@@ -959,12 +994,27 @@ export function Canvas({
         >
           {/* wires */}
           <svg style={{ position: 'absolute', inset: 0, overflow: 'visible', zIndex: 5, pointerEvents: 'none' }}>
+            {/* ratsnest: connected elsewhere, not yet drawn here (spec §8.2) */}
+            {rats.map((r, i) => (
+              <line
+                key={`rat${i}`}
+                x1={r.a.x}
+                y1={r.a.y}
+                x2={r.b.x}
+                y2={r.b.y}
+                stroke="var(--text-faint)"
+                strokeWidth={1.2}
+                strokeDasharray="5 4"
+                opacity={0.75}
+              />
+            ))}
             {wireGeom.map(({ w, pts: raw }) => {
               const pts = soloWire === w.id && editPts ? editPts : raw
               if (pts.length < 2) return null
               const selected = sel.wires.has(w.id)
               const onHotNet = highlightNet >= 0 && netModel.wireToNet.get(w.id) === highlightNet
-              const core = w.color || '#2fa46a'
+              const core = view === 'sch' ? ink : w.color || '#2fa46a'
+              const outline = view === 'sch' ? 'rgba(0,0,0,0.45)' : darken(w.color || '#2fa46a')
               const d = roundedPath(pts)
               return (
                 <g
@@ -978,7 +1028,7 @@ export function Canvas({
                   {onHotNet && (
                     <path d={d} fill="none" stroke={NET_GLOW} strokeWidth={WIRE_GLOW_W} strokeLinejoin="round" strokeLinecap="round" />
                   )}
-                  <path d={d} fill="none" stroke={darken(core)} strokeWidth={WIRE_OUTLINE_W} strokeLinejoin="round" strokeLinecap="round" />
+                  <path d={d} fill="none" stroke={outline} strokeWidth={WIRE_OUTLINE_W} strokeLinejoin="round" strokeLinecap="round" />
                   <path d={d} fill="none" stroke={core} strokeWidth={WIRE_W} strokeLinejoin="round" strokeLinecap="round" />
                   {selected && (
                     <path d={d} fill="none" stroke="rgba(255,255,255,0.85)" strokeWidth={1} strokeDasharray="4 4" strokeLinejoin="round">
@@ -994,7 +1044,7 @@ export function Canvas({
             ))}
 
             {previewPts && (
-              <path d={roundedPath(previewPts)} fill="none" stroke={wireColor} strokeWidth={WIRE_W} strokeLinejoin="round" strokeLinecap="round" opacity={0.6} />
+              <path d={roundedPath(previewPts)} fill="none" stroke={view === 'sch' ? ink : wireColor} strokeWidth={WIRE_W} strokeLinejoin="round" strokeLinecap="round" opacity={0.6} />
             )}
 
             {/* handles on the solo-selected wire */}
@@ -1054,6 +1104,7 @@ export function Canvas({
 
             {/* drop-to-connect seat marks (green) + hovered hole */}
             {editable &&
+              view === 'bb' &&
               seats.map((s) => (
                 <rect
                   key={`seat:${s.pin}`}
@@ -1067,7 +1118,7 @@ export function Canvas({
                   strokeWidth={1.1}
                 />
               ))}
-            {hoverHole && (
+            {hoverHole && view === 'bb' && (
               <circle
                 cx={hoverHole.pos.x}
                 cy={hoverHole.pos.y}
@@ -1098,7 +1149,7 @@ export function Canvas({
           {doc.parts.map((part) => {
             const pl = placementOf(part.id)
             if (!pl) return null
-            const vis = bbVisual(part.type)
+            const vis = visualFor(part.type, view)
             if (!vis) {
               return (
                 <div
@@ -1122,7 +1173,10 @@ export function Canvas({
                   width: vis.v.w,
                   height: vis.v.h,
                   zIndex: 2,
-                  transform: pl.rotate ? `rotate(${pl.rotate}deg)` : undefined,
+                  transform:
+                    pl.rotate || pl.flip
+                      ? `${pl.rotate ? `rotate(${pl.rotate}deg)` : ''}${pl.flip ? ' scaleX(-1)' : ''}`
+                      : undefined,
                   transformOrigin: 'center',
                   outline: selected ? '2px solid var(--brand)' : 'none',
                   outlineOffset: 4,
@@ -1131,7 +1185,7 @@ export function Canvas({
                 }}
                 onPointerDown={(e) => onPartDown(e, part.id)}
                 onPointerMove={(e) => {
-                  if (!editable || !isBreadboard(part.type) || partDrag.current) return
+                  if (!editable || view !== 'bb' || !isBreadboard(part.type) || partDrag.current) return
                   const cp = canvasPoint(e)
                   const hole = holeAt(doc, part.id, cp.x, cp.y, 6 / Math.min(scale, 1))
                   setHoverHole(hole ? { id: part.id, pin: hole.pin, pos: hole.pos } : null)
@@ -1141,13 +1195,13 @@ export function Canvas({
                 onContextMenu={(e) => {
                   if (!editable) return
                   e.preventDefault()
-                  const cur = doc.parts.find((p) => p.id === part.id)?.bb
+                  const cur = doc.parts.find((p) => p.id === part.id)?.[view]
                   if (!cur) return
                   const next = ((((cur.rotate ?? 0) + 90) % 360) + 360) % 360 as 0 | 90 | 180 | 270
-                  const frozen = collectFrozen(doc, new Set([part.id]))
+                  const frozen = collectFrozen(doc, new Set([part.id]), view)
                   const placements = new Map([[part.id, { ...cur, rotate: next || undefined }]])
                   store.dispatch(
-                    cmd.placePart(part.id, 'bb', placements.get(part.id), reroutesFor(doc, frozen, placements, { x: 0, y: 0 }))
+                    cmd.placePart(part.id, view, placements.get(part.id), reroutesFor(doc, frozen, placements, { x: 0, y: 0 }, view))
                   )
                 }}
               >
@@ -1202,7 +1256,10 @@ export function Canvas({
                   style={{
                     left: labelOff[0],
                     top: vis.v.h + 4 + labelOff[1],
-                    transform: pl.rotate ? `rotate(${-pl.rotate}deg)` : undefined,
+                    transform:
+                      pl.rotate || pl.flip
+                        ? `${pl.flip ? 'scaleX(-1) ' : ''}${pl.rotate ? `rotate(${-pl.rotate}deg)` : ''}`
+                        : undefined,
                     transformOrigin: 'left top',
                     color: selected ? 'var(--brand)' : 'var(--text-muted)',
                     cursor: editable ? 'move' : 'default',
diff --git a/src/renderer/src/circuit/views/inspector/Inspector.tsx b/src/renderer/src/circuit/views/inspector/Inspector.tsx
index 87e70a0..096a629 100644
--- a/src/renderer/src/circuit/views/inspector/Inspector.tsx
+++ b/src/renderer/src/circuit/views/inspector/Inspector.tsx
@@ -6,11 +6,11 @@
  * frozen bends like canvas drags do.
  */
 
-import { CircuitBoard, Plus, RotateCw, Spline, Trash2 } from 'lucide-react'
+import { CircuitBoard, FlipHorizontal2, Plus, RotateCw, Spline, Trash2 } from 'lucide-react'
 import React from 'react'
 import { getPart } from '../../../lib/partsLibrary'
 import * as cmd from '../../core/commands'
-import type { CircuitDoc, CircuitPart, CircuitWire, Placement } from '../../core/model'
+import type { CircuitDoc, CircuitPart, CircuitWire, Placement, ViewId } from '../../core/model'
 import type { NetModel } from '../../core/nets'
 import { isValidRefdes } from '../../core/refdes'
 import type { CircuitStore } from '../../core/store'
@@ -34,13 +34,15 @@ export function InspectorRail({
   store,
   sel,
   setSel,
-  netModel
+  netModel,
+  view
 }: {
   doc: CircuitDoc
   store: CircuitStore
   sel: Selection
   setSel: (s: Selection) => void
   netModel: NetModel
+  view: ViewId
 }): React.JSX.Element {
   const part =
     sel.parts.size === 1 && sel.wires.size === 0
@@ -59,7 +61,7 @@ export function InspectorRail({
       </div>
       <div className="flex-1 min-h-0 overflow-y-auto p-3 flex flex-col gap-3 text-xs">
         {part ? (
-          <PartInspector key={part.id} part={part} doc={doc} store={store} setSel={setSel} />
+          <PartInspector key={`${part.id}:${view}`} part={part} doc={doc} store={store} setSel={setSel} view={view} />
         ) : wire ? (
           <WireInspector key={wire.id} wire={wire} store={store} setSel={setSel} netModel={netModel} />
         ) : multi ? (
@@ -79,12 +81,14 @@ function PartInspector({
   part,
   doc,
   store,
-  setSel
+  setSel,
+  view
 }: {
   part: CircuitPart
   doc: CircuitDoc
   store: CircuitStore
   setSel: (s: Selection) => void
+  view: ViewId
 }): React.JSX.Element {
   const def = getPart(part.type)
   const [refdes, setRefdes] = React.useState(part.id)
@@ -104,23 +108,32 @@ function PartInspector({
     setSel({ parts: new Set([refdes]), wires: new Set() })
   }
 
+  const pv = part[view]
   const moveTo = (x: number, y: number): void => {
-    if (!part.bb) return
-    const frozen = collectFrozen(doc, new Set([part.id]))
-    const pl: Placement = { ...part.bb, x, y }
+    if (!pv) return
+    const frozen = collectFrozen(doc, new Set([part.id]), view)
+    const pl: Placement = { ...pv, x, y }
     const placements = new Map([[part.id, pl]])
     store.dispatch(
-      cmd.placePart(part.id, 'bb', pl, reroutesFor(doc, frozen, placements, { x: x - part.bb.x, y: y - part.bb.y }))
+      cmd.placePart(part.id, view, pl, reroutesFor(doc, frozen, placements, { x: x - pv.x, y: y - pv.y }, view))
     )
   }
 
   const setRotation = (deg: number): void => {
-    if (!part.bb) return
+    if (!pv) return
     const next = (((deg % 360) + 360) % 360) as 0 | 90 | 180 | 270
-    const frozen = collectFrozen(doc, new Set([part.id]))
-    const pl: Placement = { ...part.bb, rotate: next || undefined }
+    const frozen = collectFrozen(doc, new Set([part.id]), view)
+    const pl: Placement = { ...pv, rotate: next || undefined }
+    const placements = new Map([[part.id, pl]])
+    store.dispatch(cmd.placePart(part.id, view, pl, reroutesFor(doc, frozen, placements, { x: 0, y: 0 }, view)))
+  }
+
+  const toggleFlip = (): void => {
+    if (!pv) return
+    const frozen = collectFrozen(doc, new Set([part.id]), view)
+    const pl: Placement = { ...pv, flip: pv.flip ? undefined : true }
     const placements = new Map([[part.id, pl]])
-    store.dispatch(cmd.placePart(part.id, 'bb', pl, reroutesFor(doc, frozen, placements, { x: 0, y: 0 })))
+    store.dispatch(cmd.placePart(part.id, view, pl, reroutesFor(doc, frozen, placements, { x: 0, y: 0 }, view)))
   }
 
   const wiresTouching = doc.wires.filter((w) =>
@@ -162,22 +175,22 @@ function PartInspector({
         <span className="text-text-body">{wiresTouching}</span>
       </div>
 
-      {part.bb && (
+      {pv && (
         <>
           <div className="flex flex-col gap-1">
-            <span className={rowLabel}>Location (breadboard)</span>
+            <span className={rowLabel}>Location ({view === 'bb' ? 'breadboard' : 'schematic'})</span>
             <div className="flex gap-2">
               <input
                 type="number"
                 className={field}
-                value={Math.round(part.bb.x)}
-                onChange={(e) => moveTo(parseFloat(e.target.value) || 0, part.bb!.y)}
+                value={Math.round(pv.x)}
+                onChange={(e) => moveTo(parseFloat(e.target.value) || 0, pv.y)}
               />
               <input
                 type="number"
                 className={field}
-                value={Math.round(part.bb.y)}
-                onChange={(e) => moveTo(part.bb!.x, parseFloat(e.target.value) || 0)}
+                value={Math.round(pv.y)}
+                onChange={(e) => moveTo(pv.x, parseFloat(e.target.value) || 0)}
               />
             </div>
           </div>
@@ -187,7 +200,7 @@ function PartInspector({
             <div className="flex items-center gap-1">
               <select
                 className={`${field} w-auto`}
-                value={part.bb.rotate || 0}
+                value={pv.rotate || 0}
                 onChange={(e) => setRotation(parseInt(e.target.value, 10))}
               >
                 {[0, 90, 180, 270].map((d) => (
@@ -199,10 +212,19 @@ function PartInspector({
               <button
                 className="tactile-bordered rounded-md p-1.5 bg-surface-card text-text-muted hover:text-brand"
                 title="Rotate 90°"
-                onClick={() => setRotation((part.bb!.rotate || 0) + 90)}
+                onClick={() => setRotation((pv.rotate || 0) + 90)}
               >
                 <RotateCw size={13} />
               </button>
+              {view === 'sch' && (
+                <button
+                  className={`tactile-bordered rounded-md p-1.5 bg-surface-card hover:text-brand ${pv.flip ? 'text-brand' : 'text-text-muted'}`}
+                  title="Mirror horizontally (F)"
+                  onClick={toggleFlip}
+                >
+                  <FlipHorizontal2 size={13} />
+                </button>
+              )}
             </div>
           </div>
         </>
diff --git a/src/renderer/src/circuit/views/partsAdapter.ts b/src/renderer/src/circuit/views/partsAdapter.ts
index a3dde33..63b87ea 100644
--- a/src/renderer/src/circuit/views/partsAdapter.ts
+++ b/src/renderer/src/circuit/views/partsAdapter.ts
@@ -13,6 +13,7 @@
  */
 
 import { getPart, viewFor, type PartDef, type PartView } from '../../lib/partsLibrary'
+import { schematicVisual } from '../parts/symbols'
 import { pinWorld, snapPlacementToPinGrid } from '../core/geometry'
 import {
   GRID_BB,
@@ -24,6 +25,7 @@ import {
   type CircuitWire,
   type Placement,
   type Pt,
+  type ViewId,
   type WireEnd
 } from '../core/model'
 import {
@@ -41,37 +43,50 @@ export interface PartVisual {
   v: PartView
 }
 
-/** Breadboard visual for a part type, or null while its def is still loading. */
-export function bbVisual(type: string): PartVisual | null {
+/** Visual for a part type in a view, or null while its def is still loading.
+ * Schematic falls back to a generated IC-box symbol (spec §5.1). */
+export function visualFor(type: string, view: ViewId): PartVisual | null {
   const def = getPart(type)
-  const v = def && viewFor(def, 'breadboard')
-  return def && v ? { def, v } : null
+  if (!def) return null
+  if (view === 'sch') return { def, v: schematicVisual(def) }
+  const v = viewFor(def, 'breadboard')
+  return v ? { def, v } : null
+}
+
+/** Breadboard visual (bb-fixed callers: seats, breadboard holes, exports). */
+export function bbVisual(type: string): PartVisual | null {
+  return visualFor(type, 'bb')
 }
 
 /** First pin's local coordinate (the snap-by-pin alignment reference). */
-export function firstPinLocal(type: string): [number, number] | undefined {
-  const vis = bbVisual(type)
+export function firstPinLocal(type: string, view: ViewId = 'bb'): [number, number] | undefined {
+  const vis = visualFor(type, view)
   if (!vis) return undefined
-  const first = Object.values(vis.v.pins)[0]
-  return first
+  return Object.values(vis.v.pins)[0]
 }
 
-/** Snap a bb placement so its pins land on-grid (Fritzing behavior). */
-export function snapBB(type: string, placement: Placement): Placement {
-  const vis = bbVisual(type)
+/** Snap a placement so its PINS land on the 9.6 px major grid (both views —
+ * spec §4 pin-on-grid contract; Fritzing behavior). */
+export function snapBB(type: string, placement: Placement, view: ViewId = 'bb'): Placement {
+  const vis = visualFor(type, view)
   if (!vis) return { ...placement, x: Math.round(placement.x / GRID_BB) * GRID_BB, y: Math.round(placement.y / GRID_BB) * GRID_BB }
-  const { x, y } = snapPlacementToPinGrid(placement, firstPinLocal(type), vis.v.w, vis.v.h, GRID_BB)
+  const { x, y } = snapPlacementToPinGrid(placement, firstPinLocal(type, view), vis.v.w, vis.v.h, GRID_BB)
   return { ...placement, x, y }
 }
 
-/** World position of a part's pin in the bb view (leg-tip aware). */
-export function pinWorldOf(part: CircuitPart, pin: string, placement?: Placement): Pt | null {
-  const pl = placement ?? part.bb
+/** World position of a part's pin in a view (leg-tip aware in bb). */
+export function pinWorldOf(
+  part: CircuitPart,
+  pin: string,
+  placement?: Placement,
+  view: ViewId = 'bb'
+): Pt | null {
+  const pl = placement ?? part[view]
   if (!pl) return null
-  const vis = bbVisual(part.type)
+  const vis = visualFor(part.type, view)
   const local = vis?.v.pins[pin]
   if (!vis || !local) return null
-  return pinWorld(local, pl, vis.v.w, vis.v.h, pl.legs?.[pin])
+  return pinWorld(local, pl, vis.v.w, vis.v.h, view === 'bb' ? pl.legs?.[pin] : undefined)
 }
 
 export type EndResolver = (end: WireEnd, seen?: Set<string>) => Pt | null
@@ -83,7 +98,8 @@ export type EndResolver = (end: WireEnd, seen?: Set<string>) => Pt | null
  */
 export function makeEndResolver(
   doc: CircuitDoc,
-  overrides?: Map<string, Placement>
+  overrides?: Map<string, Placement>,
+  view: ViewId = 'bb'
 ): EndResolver {
   const wireById = new Map(doc.wires.map((w) => [w.id, w]))
   const resolve: EndResolver = (end, seen = new Set()) => {
@@ -101,7 +117,7 @@ export function makeEndResolver(
     const { part: partId, pin } = splitPinRef(end)
     const part = doc.parts.find((p) => p.id === partId)
     if (!part) return null
-    return pinWorldOf(part, pin, overrides?.get(partId) ?? part.bb)
+    return pinWorldOf(part, pin, overrides?.get(partId) ?? part[view], view)
   }
   return resolve
 }
@@ -111,11 +127,15 @@ export interface ResolvedWire {
   pts: Pt[]
 }
 
-/** Rendered polylines for every bb wire (empty pts when unresolvable). */
-export function bbWireGeometry(doc: CircuitDoc, overrides?: Map<string, Placement>): ResolvedWire[] {
-  const resolve = makeEndResolver(doc, overrides)
+/** Rendered polylines for every wire of a view (empty pts when unresolvable). */
+export function wireGeometry(
+  doc: CircuitDoc,
+  view: ViewId,
+  overrides?: Map<string, Placement>
+): ResolvedWire[] {
+  const resolve = makeEndResolver(doc, overrides, view)
   return doc.wires
-    .filter((w) => w.view === 'bb')
+    .filter((w) => w.view === view)
     .map((w) => {
       const s = resolve(w.from)
       const t = resolve(w.to)
@@ -128,37 +148,42 @@ export function pinAtWorld(
   doc: CircuitDoc,
   wx: number,
   wy: number,
-  tol: number
+  tol: number,
+  view: ViewId = 'bb'
 ): { id: string; pin: string; pos: Pt } | null {
   for (let i = doc.parts.length - 1; i >= 0; i--) {
     const part = doc.parts[i]
-    if (!part.bb) continue
-    const vis = bbVisual(part.type)
+    if (!part[view]) continue
+    const vis = visualFor(part.type, view)
     if (!vis) continue
     for (const pin of Object.keys(vis.v.pins)) {
-      const pos = pinWorldOf(part, pin)
+      const pos = pinWorldOf(part, pin, undefined, view)
       if (pos && Math.hypot(pos.x - wx, pos.y - wy) < tol) return { id: part.id, pin, pos }
     }
   }
   return null
 }
 
-/** Bounding box of everything placed in the bb view, or null when empty. */
-export function bbBounds(doc: CircuitDoc): { minX: number; minY: number; maxX: number; maxY: number } | null {
+/** Bounding box of everything placed in a view, or null when empty. */
+export function viewBounds(
+  doc: CircuitDoc,
+  view: ViewId = 'bb'
+): { minX: number; minY: number; maxX: number; maxY: number } | null {
   let minX = Infinity
   let minY = Infinity
   let maxX = -Infinity
   let maxY = -Infinity
   for (const part of doc.parts) {
-    if (!part.bb) continue
-    const vis = bbVisual(part.type)
+    const pl = part[view]
+    if (!pl) continue
+    const vis = visualFor(part.type, view)
     if (!vis) continue
-    minX = Math.min(minX, part.bb.x)
-    minY = Math.min(minY, part.bb.y)
-    maxX = Math.max(maxX, part.bb.x + vis.v.w)
-    maxY = Math.max(maxY, part.bb.y + vis.v.h)
+    minX = Math.min(minX, pl.x)
+    minY = Math.min(minY, pl.y)
+    maxX = Math.max(maxX, pl.x + vis.v.w)
+    maxY = Math.max(maxY, pl.y + vis.v.h)
   }
-  for (const { pts } of bbWireGeometry(doc)) {
+  for (const { pts } of wireGeometry(doc, view)) {
     for (const p of pts) {
       minX = Math.min(minX, p.x)
       minY = Math.min(minY, p.y)
@@ -180,13 +205,13 @@ export interface FrozenWire {
 }
 
 /** Snapshot the wires touching any of `ids` before a move begins. */
-export function collectFrozen(doc: CircuitDoc, ids: Set<string>): FrozenWire[] {
-  const resolve = makeEndResolver(doc)
+export function collectFrozen(doc: CircuitDoc, ids: Set<string>, view: ViewId = 'bb'): FrozenWire[] {
+  const resolve = makeEndResolver(doc, undefined, view)
   const touches = (e: WireEnd): boolean =>
     typeof e === 'string' && ids.has(splitPinRef(e).part)
   const out: FrozenWire[] = []
   for (const w of doc.wires) {
-    if (w.view !== 'bb') continue
+    if (w.view !== view) continue
     const f = touches(w.from)
     const t = touches(w.to)
     if (!f && !t) continue
@@ -212,9 +237,10 @@ export function reroutesFor(
   doc: CircuitDoc,
   frozen: FrozenWire[],
   placements: Map<string, Placement>,
-  delta: Pt
+  delta: Pt,
+  view: ViewId = 'bb'
 ): WireReroute[] {
-  const resolve = makeEndResolver(doc, placements)
+  const resolve = makeEndResolver(doc, placements, view)
   const wireById = new Map(doc.wires.map((w) => [w.id, w]))
   const out: WireReroute[] = []
   for (const f of frozen) {
@@ -229,6 +255,14 @@ export function reroutesFor(
   return out
 }
 
+/** bb-fixed aliases (exportImage & friends). */
+export function bbWireGeometry(doc: CircuitDoc, overrides?: Map<string, Placement>): ResolvedWire[] {
+  return wireGeometry(doc, 'bb', overrides)
+}
+export function bbBounds(doc: CircuitDoc): { minX: number; minY: number; maxX: number; maxY: number } | null {
+  return viewBounds(doc, 'bb')
+}
+
 // ── M2: breadboard seating (drop-to-connect, derived — never stored) ─────────
 
 import { SpatialHash } from '../core/geometry'
@@ -316,3 +350,67 @@ export function holeAt(
   }
   return best ? { pin: best.pin, pos: best.pos } : null
 }
+
+// ── M3: ratsnest (dual-view contract, spec §8.2) ─────────────────────────────
+
+import { buildNets, type NetModel } from '../core/nets'
+
+export interface RatsnestSegment {
+  a: Pt
+  b: Pt
+  /** index into the GLOBAL net model (for status counting). */
+  net: number
+}
+
+/**
+ * Dashed helper lines for nets that are electrically connected (globally —
+ * either view, buses, seating) but not yet drawn in `view`: for each global
+ * net, group its placed pins by this-view-only connectivity, then greedily
+ * bridge groups between their nearest pins.
+ */
+export function ratsnest(doc: CircuitDoc, view: ViewId, global: NetModel): RatsnestSegment[] {
+  // this-view connectivity: only this view's wires (+ physical buses; bb also
+  // gets derived seating — a seated pin needs no wire)
+  const viewDoc: CircuitDoc = { ...doc, wires: doc.wires.filter((w) => w.view === view) }
+  const viewNets = buildNets(viewDoc, {
+    busesFor: circuitBuses,
+    implicit:
+      view === 'bb' ? implicitSeats(doc).map((s): [string, string] => [s.pin, s.hole]) : undefined
+  })
+
+  const out: RatsnestSegment[] = []
+  global.nets.forEach((pins, netIdx) => {
+    if (pins.length < 2) return
+    // placed, resolvable pins grouped by view-local component
+    const groups = new Map<string, { pin: string; pos: Pt }[]>()
+    for (const pin of pins) {
+      const { part: partId } = splitPinRef(pin)
+      const part = doc.parts.find((p) => p.id === partId)
+      if (!part || !part[view]) continue
+      const pos = pinWorldOf(part, splitPinRef(pin).pin, undefined, view)
+      if (!pos) continue
+      const comp = viewNets.pinToNet.has(pin) ? `n${viewNets.pinToNet.get(pin)}` : `solo:${pin}`
+      if (!groups.has(comp)) groups.set(comp, [])
+      groups.get(comp)!.push({ pin, pos })
+    }
+    if (groups.size < 2) return
+    // greedy nearest-group bridging (MST-ish, fine for editor guidance)
+    const remaining = [...groups.values()]
+    const connected = [remaining.shift()!]
+    while (remaining.length) {
+      let best: { gi: number; a: Pt; b: Pt; d: number } | null = null
+      remaining.forEach((group, gi) => {
+        for (const g of group)
+          for (const c of connected.flat()) {
+            const d = Math.hypot(g.pos.x - c.pos.x, g.pos.y - c.pos.y)
+            if (!best || d < best.d) best = { gi, a: c.pos, b: g.pos, d }
+          }
+      })
+      if (!best) break
+      const chosen = best as { gi: number; a: Pt; b: Pt; d: number }
+      out.push({ a: chosen.a, b: chosen.b, net: netIdx })
+      connected.push(remaining.splice(chosen.gi, 1)[0])
+    }
+  })
+  return out
+}

From 37fc36f687be078bc66d1a1513b9bb00bae3289e Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Sun, 5 Jul 2026 23:06:11 -0600
Subject: [PATCH 09/27] Added Milestones 0-3

---
 demo/Joystick Example/circuit.json            | 102 ++++
 demo/Joystick Example/diagram.json            |  85 ---
 docs/circuit-editor-progress.md               |  91 ++++
 src/renderer/src/App.tsx                      |  63 ++-
 .../src/circuit/__tests__/erc.test.ts         |  53 ++
 .../src/circuit/__tests__/exportSch.test.ts   |  45 ++
 .../src/circuit/__tests__/netLabels.test.ts   |  34 ++
 .../src/circuit/__tests__/store.test.ts       |   3 +
 src/renderer/src/circuit/core/commands.ts     |  47 +-
 src/renderer/src/circuit/core/erc.ts          |  83 +++
 src/renderer/src/circuit/core/refdes.ts       |   4 +-
 src/renderer/src/circuit/parts/netLabels.ts   | 122 +++++
 .../src/circuit/views/CircuitView.tsx         | 265 +++++++---
 .../src/circuit/views/canvas/Canvas.tsx       | 489 +++++++++++++++---
 src/renderer/src/circuit/views/exportImage.ts | 123 +++--
 .../src/circuit/views/inspector/Inspector.tsx | 136 ++++-
 .../src/circuit/views/palette/Palette.tsx     |  43 +-
 .../src/circuit/views/partsAdapter.ts         | 214 +++++++-
 src/renderer/src/components/EditorPanel.tsx   |   7 +-
 src/renderer/src/components/PartsEditor.tsx   | 137 +++--
 src/renderer/src/components/Toolbar.tsx       |   5 +-
 src/renderer/src/components/ui/Resizable.tsx  |  10 +-
 22 files changed, 1832 insertions(+), 329 deletions(-)
 create mode 100644 demo/Joystick Example/circuit.json
 delete mode 100644 demo/Joystick Example/diagram.json
 create mode 100644 src/renderer/src/circuit/__tests__/erc.test.ts
 create mode 100644 src/renderer/src/circuit/__tests__/exportSch.test.ts
 create mode 100644 src/renderer/src/circuit/__tests__/netLabels.test.ts
 create mode 100644 src/renderer/src/circuit/core/erc.ts
 create mode 100644 src/renderer/src/circuit/parts/netLabels.ts

diff --git a/demo/Joystick Example/circuit.json b/demo/Joystick Example/circuit.json
new file mode 100644
index 0000000..856ced8
--- /dev/null
+++ b/demo/Joystick Example/circuit.json	
@@ -0,0 +1,102 @@
+{
+  "format": "tinystudio-circuit",
+  "version": 2,
+  "meta": {
+    "created": "2026-07-03T17:07:26.415Z"
+  },
+  "parts": [
+    {
+      "id": "potentiometer-rotary-16mm-5_g9d",
+      "type": "potentiometer-rotary-16mm-5",
+      "attrs": {
+        "label": "Potentiometer"
+      },
+      "bb": {
+        "x": 710.4,
+        "y": -124.8,
+        "labelOffset": [
+          65,
+          -68
+        ]
+      }
+    },
+    {
+      "id": "battery-aa_2dp",
+      "type": "battery-aa",
+      "bb": {
+        "x": 329,
+        "y": -27
+      }
+    },
+    {
+      "id": "led-generic-5mm_fsn",
+      "type": "led-generic-5mm",
+      "bb": {
+        "x": 637,
+        "y": -57.6,
+        "labelOffset": [
+          -42,
+          -67
+        ]
+      }
+    },
+    {
+      "id": "resistor_hwt",
+      "type": "resistor",
+      "bb": {
+        "x": 643.2,
+        "y": 63
+      }
+    }
+  ],
+  "wires": [
+    {
+      "id": "w_5m58u96x",
+      "from": "battery-aa_2dp:+",
+      "to": "led-generic-5mm_fsn:cathode",
+      "view": "bb",
+      "color": "#e5544b",
+      "route": [
+        "h98.21",
+        "v-41.56",
+        "h-0.16"
+      ]
+    },
+    {
+      "id": "w_hw4el0vi",
+      "from": "led-generic-5mm_fsn:anode",
+      "to": "potentiometer-rotary-16mm-5_g9d:leg1",
+      "view": "bb",
+      "color": "#42a5f5",
+      "route": [
+        "v6.07",
+        "h66.91"
+      ]
+    },
+    {
+      "id": "w_1laeiu0i",
+      "from": "potentiometer-rotary-16mm-5_g9d:wiper",
+      "to": "resistor_hwt:Pin 1",
+      "view": "bb",
+      "color": "#42a5f5",
+      "route": [
+        "v84.36",
+        "h-28.32",
+        "v-0.27",
+        "h-26.96"
+      ]
+    },
+    {
+      "id": "w_oggo6jgz",
+      "from": "resistor_hwt:Pin 0",
+      "to": "battery-aa_2dp:-",
+      "view": "bb",
+      "color": "#79818c",
+      "route": [
+        "h-39.36",
+        "v-30.35",
+        "h-59.81"
+      ]
+    }
+  ]
+}
diff --git a/demo/Joystick Example/diagram.json b/demo/Joystick Example/diagram.json
deleted file mode 100644
index c99d803..0000000
--- a/demo/Joystick Example/diagram.json	
+++ /dev/null
@@ -1,85 +0,0 @@
-{
-  "version": 1,
-  "editor": "tinystudio",
-  "parts": [
-    {
-      "type": "potentiometer-rotary-16mm-5",
-      "id": "potentiometer-rotary-16mm-5_g9d",
-      "left": 710.4,
-      "top": -124.8,
-      "attrs": {
-        "labelOffset": [
-          65,
-          -68
-        ],
-        "label": "Potentiometer"
-      }
-    },
-    {
-      "type": "battery-aa",
-      "id": "battery-aa_2dp",
-      "left": 329,
-      "top": -27
-    },
-    {
-      "type": "led-generic-5mm",
-      "id": "led-generic-5mm_fsn",
-      "left": 637,
-      "top": -57.599999999999994,
-      "attrs": {
-        "labelOffset": [
-          -42,
-          -67
-        ]
-      }
-    },
-    {
-      "type": "resistor",
-      "id": "resistor_hwt",
-      "left": 643.1999999999999,
-      "top": 63
-    }
-  ],
-  "connections": [
-    [
-      "battery-aa_2dp:+",
-      "led-generic-5mm_fsn:cathode",
-      "#e5544b",
-      [
-        "h98.21",
-        "v-41.56",
-        "h-0.16"
-      ]
-    ],
-    [
-      "led-generic-5mm_fsn:anode",
-      "potentiometer-rotary-16mm-5_g9d:leg1",
-      "#42a5f5",
-      [
-        "v6.07",
-        "h66.91"
-      ]
-    ],
-    [
-      "potentiometer-rotary-16mm-5_g9d:wiper",
-      "resistor_hwt:Pin 1",
-      "#42a5f5",
-      [
-        "v84.36",
-        "h-28.32",
-        "v-0.27",
-        "h-26.96"
-      ]
-    ],
-    [
-      "resistor_hwt:Pin 0",
-      "battery-aa_2dp:-",
-      "#79818c",
-      [
-        "h-39.36",
-        "v-30.35",
-        "h-59.81"
-      ]
-    ]
-  ]
-}
\ No newline at end of file
diff --git a/docs/circuit-editor-progress.md b/docs/circuit-editor-progress.md
index 792f876..1ede9b3 100644
--- a/docs/circuit-editor-progress.md
+++ b/docs/circuit-editor-progress.md
@@ -128,3 +128,94 @@ Geoff's testing found SVG export rendering symbols wrong and PNG export dead. Ro
 ### Verification
 
 - `npm run test:circuit` → **63/63** · `npm run typecheck` → clean · NUL scan clean (all writes done Linux-side per the tooling note above).
+
+---
+
+## 2026-07-05 — bug-fix pass (Geoff's testing feedback)
+
+Five fixes, all in the editor layer (no core/model changes). `npm run typecheck` clean · `npm run test:circuit` → 63/63.
+
+- **Breadboards are transparent on the schematic.** They no longer appear as a placeable/`U1` part in the schematic — only their row/rail buses still merge nets globally. Three-part fix: `refdes.ts` now matches `FAMILY_PREFIX` keys longest-first so `breadboard` wins over `board` (`BB1`, not `U1`); `CircuitView` drops breadboards from the "unplaced here" tray in the sch view; `Canvas` render loop skips `isBreadboard` parts when `view === 'sch'`. Added a `prefixForFamily` guard test.
+- **Rigid breadboard rotation.** Rotating a breadboard (right-click, or `R` with a lone board selected) now turns the board, its seated parts, and the wires *between* seated parts as one rigid assembly about the board's centre — layout is preserved instead of the wires rerouting. Uses `reroutesFor`'s `transformBoth` hook (rot90-about-centre) for both-ends-on-board wires; seated parts get their centres rotated + `rotate += 90`. Grid-aligned seating means holes map to holes, so pins re-seat exactly. New `rotateBoardAssembly` helper in `Canvas`; `rotateSelection` and the board context-menu delegate to it. (Wires with only one end on the board still reroute — expected, that end left the assembly.)
+- **Straight-wire modifier moved Shift → Space.** Shift is now free for shift-select while drawing on a breadboard. Space was previously bound to rotate; rotate is now `R`/right-click only. Keydown on Space `preventDefault`s to stop page scroll; status hint updated ("hold Space for straight", bb only).
+- **Schematic wires thinned, glow/border removed.** New `WIRE_SCH_W = 1` (was the shared `2.8`, ~3× too thick). In the sch view the color-outline path and the persistent border are dropped — a single thin ink stroke. A transparent fat stroke is layered under every wire so the thin line stays clickable. The net-highlight glow is kept but slimmed in sch.
+- **Connected pins drop their yellow "open lead" dot.** A pin whose net has ≥2 members (wired or seated) is `connected`; its dot is hidden unless armed/hovered (then brand-colored) or its net is highlighted. Open leads still show yellow. Hit target is unchanged, so connected pins remain clickable to re-wire.
+
+### Known gaps / notes for the next agent
+
+- The **Inspector's** rotate button/dropdown still rotates a breadboard in place (it has no `seats` context), so it will reroute wires the way the canvas gestures no longer do. Low-traffic path; wire it through `rotateBoardAssembly` (or lift the helper to the shell) if it comes up.
+- **Tooling (unchanged, still biting):** Write/Edit through the Cowork mount truncated `Canvas.tsx` and `store.test.ts` to their previous byte length when an edit grew them — the Windows-side file tool showed the full file while the Linux mount (where tsc/tests/git run) was cut off mid-block. Reliable path confirmed again: reconstruct the whole file from `git show HEAD:<path>` + Python `.replace()` written **Linux-side** with `newline='\n'`, then verify with `awk 'END{print NR}'` + `tail`. Also hit a stale `.git/index.lock` (`unable to unlink … Operation not permitted`) that made `git diff` go silent — diff against `git show HEAD:` instead.
+
+---
+
+## 2026-07-05 (later) — M3 complete: net labels, ERC, schematic polish ✅
+
+Closes the remaining M3 scope (schematic view). All work is in `circuit/` behind the flag. `npm run typecheck` clean · `npm run test:circuit` → **71/71**.
+
+### Net labels / ground (spec §8.4)
+
+- `parts/netLabels.ts` — generated glyphs for the three kinds: `ground` (three-bar), `power` (up-flag with rail name, e.g. 5V/3V3), `net` (named tag). Single connection pin `"<id>:1"`, pin-on-grid via `snapNetLabel`, cached. `NET_LABEL_KINDS` drives the palette.
+- The net engine already merged same-named labels (`core/nets.ts` §4) — this session added the geometry/UI: `commands.moveNetLabel` / `updateNetLabel`; `makeEndResolver` now resolves label pins in the schematic (labels are wire-connectable like any pin); `Canvas` renders the glyphs (sch only), starts/ends wires on a label pin, drags a label with live wire reroutes, selects (new optional `Selection.labels`) and deletes them.
+- Palette gained a **Net Labels** section (sch only) — drag or double-click to add. `Inspector` shows a label editor (net name + kind, delete) when a label is selected. Add flow in `CircuitView.addNetLabel`; drop routes through `Canvas.onDropNetLabel`.
+
+### ERC (spec §9)
+
+- `core/erc.ts` — net-model rule checks (pure, tested): **rail short** (two named rails/grounds on one net → error), **floating net label** (placed but unwired → info), **missing ground** (power rails but no GND → info), **dangling junction host** (error, reuses `danglingJunctions`).
+- `partsAdapter.ercFloatingPins` — view-side floating-pin finding (needs pin geometry); only flags *partially* connected parts to avoid noise.
+- `CircuitView` — an **ERC pill** in the status row (clean / err·warn·info counts) toggles a non-blocking findings panel; clicking a row selects the offending part/wire/label.
+
+### Schematic polish
+
+- Canvas background is now paper (`--bg`) with a finer dot grid in the schematic (spec §8.1); breadboard view unchanged.
+- **Attach-to-cursor tray:** clicking an "unplaced here" chip arms placement (chip highlights, hint changes) and the next canvas click drops the part at the cursor — replaces the old drop-at-centre. `Canvas` gained `placingId` / `onCanvasPlace`.
+- **Schematic image export:** `exportImage.composeSceneSvg` is now view-generic — ink single-stroke wires, generated symbols, net-label glyphs, part flip; breadboards omitted in sch. Export buttons show in both views (`exportSvg/exportPng(doc, view)`), filenames `circuit-schematic.{svg,png}`.
+
+### Tests (+8, 71 total)
+
+- `netLabels.test.ts` (glyph pins, grid snap), `erc.test.ts` (rail short, floating label, missing ground), `exportSch.test.ts` (sch compose: ink wires + label glyphs, balanced SVG tags, graceful null).
+
+### Deferred (out of M3 scope → M4/M5)
+
+- Solder-dot rendering at genuine T-junctions is via the existing junction-dot layer; 4-way-crossing "never auto-join" hygiene (spec §8.1) is not specially enforced yet.
+- ERC's `erc` pin-type rules (shorted `power-out`↔`power-out`, LED-without-series-R heuristic) need typed pins from the M2 parts pipeline — current pins carry no `erc` metadata, so those checks are stubbed out (not emitted) rather than guessed.
+- Net-label rotation is supported in the model/geometry but has no keyboard/inspector control yet (drag + delete only).
+
+### Notes for the next agent
+
+- `Selection` grew an optional `labels: Set<string>`; most construction sites omit it (treated empty). Marquee/rubber-band does **not** yet grab labels — click / shift-click only.
+- Pre-existing lint: `Canvas.tsx` (`emptySel`) and `Palette.tsx` (`WIRE_COLORS`) trip `react-refresh/only-export-components` (colocated helpers) — unchanged by this work; gates remain typecheck + `test:circuit`.
+- Tooling: same Cowork-mount truncation gremlin — every file this session was written Linux-side (bash heredoc / Python `.replace`, `newline='\n'`) and verified with `awk NR` + `tail`. The stale `.git/index.lock` is still unremovable from the sandbox, so this work is **uncommitted** on `circuit-editor` (see file list below).
+
+---
+
+## 2026-07-05 (later) — editor UX pass (Geoff's feedback round 2)
+
+Eleven fixes across the circuit editor + app shell. `npm run typecheck` clean · `npm run test:circuit` → 71/71.
+
+### Placement & interaction
+
+- **Collision-avoidance placement** (`partsAdapter.occupiedBoxes` / `findFreePlacement` / `freePasteOffset`): new parts, tray placements, and copy/paste all spiral out on the grid to a slot that clears existing parts, net labels, and wire segments — parity with the pre-rewrite editor. `addPartAt` and paste now route through these.
+- **Unplaced tray auto-places** (reverting the click-then-click attach-to-cursor): clicking a tray chip drops the part straight onto a free slot *and* flips the view into edit mode so it can be dragged immediately.
+- **Double-click any component → edit mode** (`Canvas.onRequestEdit`, wired to `CircuitView.enterEdit`): double-clicking a part or net label in view-only mode enters edit mode.
+
+### Visuals
+
+- **View-aware palette icons** (`Palette.iconFor`): the components rail shows schematic symbols in the schematic view, breadboard art in the breadboard view.
+- **Black part legs** (`partsAdapter.blackenLegs`): Fritzing legs are baked into the art as `<line id="connectorNleg" … stroke="#8C8C8C"/>`; we recolor those leg strokes to ink (`#1A1A1A`) at render time (cached). Only leg elements are touched.
+- **Bigger watermark** (canvas + image export): ~5× larger, thin `tiny` + bold `Studio` to match the header wordmark; export uses `<tspan>` weights and extra bottom padding.
+- **Cleaner status area**: dropped the persistent "Parts/Wires/Nets" pill and the idle "Scroll to zoom" / "View-only" hint bubbles. One compact warning bubble appears only when there's something to fix (unplaced parts · unwired nets · ERC err/warn) and opens the ERC panel; the contextual wiring hint now shows only while actively drawing/reshaping.
+
+### Part editor
+
+- **Dual-view authoring** (`PartsEditor`): a Breadboard | Schematic toggle; each view keeps its own art, size, and pin positions (pin names are the shared cross-view key). Save writes both populated views; palette icon prefers the breadboard art. A dot next to a toggle label marks which views have pins.
+
+### App shell
+
+- **Stable left panel** (`App`): the Files panel no longer gets shoved around when the right (docs) or bottom (serial) panel toggles. We remember a manual drag (`ResizableHandle onDragging` → `manualFilePct`) and otherwise the toolbar-divider alignment, and re-assert that width via the imperative panel handle after any panel toggle. So it only changes when *you* drag it.
+- **Docs panel reopens on view mode** (`EditorPanel.onEditChange`): entering circuit edit mode still closes the docs panel to free space; returning to view mode reopens it (`isOpen: !editing`).
+
+### Notes for the next agent
+
+- Marquee/rubber-band still selects parts + wires only, not net labels (click / shift-click for labels).
+- Leg recolor is render-time and keyed by svg string; if a part with a different (non-`connectorNleg`) leg convention shows up, extend `blackenLegs`.
+- Tooling: `PartsEditor.tsx` hit the Cowork-mount truncation bug when written via the file tool (cut at line 399 mid-word) — rewritten Linux-side and verified. Everything else this round was written Linux-side. The stale `.git/index.lock` is still unremovable from the sandbox, so this round is **uncommitted** on `circuit-editor`.
diff --git a/src/renderer/src/App.tsx b/src/renderer/src/App.tsx
index 4f1c42c..3fdfcdf 100644
--- a/src/renderer/src/App.tsx
+++ b/src/renderer/src/App.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useRef, useState } from 'react'
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react'
 import { notify as toast } from './lib/notify'
 import { BackendPrompt } from './components/BackendPrompt'
 import { LoadGitHubProjectCommand, OpenWorkspaceCommand } from './commands/fileCommands'
@@ -12,6 +12,7 @@ import { SerialMonitor } from './components/SerialMonitor'
 import { StatusBar } from './components/StatusBar'
 import { Toolbar } from './components/Toolbar'
 import { ResizableHandle, ResizablePanel, ResizablePanelGroup } from './components/ui/Resizable'
+import { getPanelGroupElement, type ImperativePanelHandle } from 'react-resizable-panels'
 import { ArduinoProvider } from './contexts/ArduinoContext'
 import { SerialProvider } from './contexts/SerialContext'
 import { fileSystem } from './lib/fileSystem'
@@ -31,6 +32,48 @@ export default function App(): React.JSX.Element {
   const dispatch = useAppDispatch()
   const [editorSize, setEditorSize] = useState(50)
 
+  // The Files panel starts at the width of the toolbar divider (the rule
+  // between the Upload/Save group and the board/port group). That position is
+  // content-driven, so we measure it at runtime and size the panel to match.
+  const filePanelRef = useRef<ImperativePanelHandle>(null)
+  // once the user drags the divider we honor their width; until then we align to
+  // the toolbar divider. Either way the width is re-asserted after panel toggles
+  // (react-resizable-panels would otherwise redistribute it).
+  const manualFilePct = useRef<number | null>(null)
+  const applyFilePanelWidth = useCallback((): void => {
+    const panel = filePanelRef.current
+    if (!panel) return
+    if (manualFilePct.current != null) {
+      panel.resize(manualFilePct.current)
+      return
+    }
+    const divider = document.querySelector('[data-toolbar-divider]')
+    const group = getPanelGroupElement('workspace-cols')
+    if (!divider || !group) return
+    const groupRect = group.getBoundingClientRect()
+    if (groupRect.width === 0) return
+    const target = divider.getBoundingClientRect().left - groupRect.left
+    const pct = (target / groupRect.width) * 100
+    panel.resize(Math.max(8, Math.min(40, pct)))
+  }, [])
+
+  useLayoutEffect(() => {
+    if (!isFileExplorerOpen) return
+    applyFilePanelWidth()
+    // re-measure once web fonts settle (button widths shift the divider)
+    document.fonts?.ready?.then(applyFilePanelWidth).catch(() => {})
+    window.addEventListener('resize', applyFilePanelWidth)
+    return () => window.removeEventListener('resize', applyFilePanelWidth)
+  }, [isFileExplorerOpen, applyFilePanelWidth])
+
+  // Re-assert the left panel width whenever the right (docs) or bottom (serial)
+  // panel toggles, so those don't shove the Files panel around.
+  useLayoutEffect(() => {
+    if (!isFileExplorerOpen) return
+    const id = requestAnimationFrame(applyFilePanelWidth)
+    return () => cancelAnimationFrame(id)
+  }, [isDocsPanelOpen, isSerialMonitorOpen, isFileExplorerOpen, applyFilePanelWidth])
+
   // The serial monitor / output dock only makes sense while coding — close it
   // when switching to the full-window Circuit or Visual views, reopen on Code.
   useEffect(() => {
@@ -106,13 +149,25 @@ export default function App(): React.JSX.Element {
         <div className="h-screen flex flex-col bg-background text-foreground overflow-hidden">
           <Header />
           <Toolbar />
-          <ResizablePanelGroup direction="horizontal" className="flex-1">
+          <ResizablePanelGroup id="workspace-cols" direction="horizontal" className="flex-1">
             {isFileExplorerOpen && (
               <>
-                <ResizablePanel defaultSize={25} minSize={12} maxSize={40} className="bg-muted">
+                <ResizablePanel
+                  ref={filePanelRef}
+                  defaultSize={16}
+                  minSize={8}
+                  maxSize={40}
+                  className="bg-muted"
+                >
                   <FileExplorer />
                 </ResizablePanel>
-                <ResizableHandle />
+                <ResizableHandle
+                  onDragging={(dragging) => {
+                    if (!dragging)
+                      manualFilePct.current =
+                        filePanelRef.current?.getSize() ?? manualFilePct.current
+                  }}
+                />
               </>
             )}
             <ResizablePanel defaultSize={50} className="flex flex-col">
diff --git a/src/renderer/src/circuit/__tests__/erc.test.ts b/src/renderer/src/circuit/__tests__/erc.test.ts
new file mode 100644
index 0000000..9d4744b
--- /dev/null
+++ b/src/renderer/src/circuit/__tests__/erc.test.ts
@@ -0,0 +1,53 @@
+/** Tests for core/erc — net-model rule checks. */
+import { strict as assert } from 'node:assert'
+import { test } from 'node:test'
+import { runErc } from '../core/erc'
+import { emptyDoc, type CircuitDoc, type NetLabel } from '../core/model'
+import { buildNets } from '../core/nets'
+import { journeyFromPoints } from '../core/routing'
+
+const wire = (id: string, from: string, to: string): CircuitDoc['wires'][number] => ({
+  id,
+  from,
+  to,
+  view: 'sch',
+  route: journeyFromPoints(
+    [
+      { x: 0, y: 0 },
+      { x: 48, y: 0 }
+    ],
+    true
+  )
+})
+
+test('rail short: GND and 5V on the same net is an error', () => {
+  const doc = emptyDoc()
+  const labels: NetLabel[] = [
+    { id: 'nl1', name: 'GND', kind: 'ground', sch: { x: 0, y: 0 } },
+    { id: 'nl2', name: '5V', kind: 'power', sch: { x: 48, y: 0 } }
+  ]
+  doc.netLabels = labels
+  doc.wires = [wire('w1', 'nl1:1', 'nl2:1')]
+  const issues = runErc(doc, buildNets(doc))
+  assert.ok(issues.some((i) => i.severity === 'error' && /Rail short/.test(i.message)))
+})
+
+test('floating net label is flagged (info) until wired', () => {
+  const doc = emptyDoc()
+  doc.netLabels = [{ id: 'nl1', name: 'GND', kind: 'ground', sch: { x: 0, y: 0 } }]
+  let issues = runErc(doc, buildNets(doc))
+  assert.ok(issues.some((i) => i.id === 'floatlabel:nl1' && i.severity === 'info'))
+  // wiring it to a second label clears the floating flag
+  doc.netLabels.push({ id: 'nl2', name: 'GND', kind: 'ground', sch: { x: 48, y: 0 } })
+  doc.wires = [wire('w1', 'nl1:1', 'nl2:1')]
+  issues = runErc(doc, buildNets(doc))
+  assert.ok(!issues.some((i) => i.id === 'floatlabel:nl1'))
+})
+
+test('missing ground info fires only when power exists without ground', () => {
+  const doc = emptyDoc()
+  doc.netLabels = [{ id: 'nl1', name: '5V', kind: 'power', sch: { x: 0, y: 0 } }]
+  assert.ok(runErc(doc, buildNets(doc)).some((i) => i.id === 'noground'))
+  doc.netLabels.push({ id: 'nl2', name: 'GND', kind: 'ground', sch: { x: 48, y: 0 } })
+  assert.ok(!runErc(doc, buildNets(doc)).some((i) => i.id === 'noground'))
+})
diff --git a/src/renderer/src/circuit/__tests__/exportSch.test.ts b/src/renderer/src/circuit/__tests__/exportSch.test.ts
new file mode 100644
index 0000000..4eaa160
--- /dev/null
+++ b/src/renderer/src/circuit/__tests__/exportSch.test.ts
@@ -0,0 +1,45 @@
+/** Tests for schematic image export — ink wires + net-label glyphs, valid XML shape. */
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { emptyDoc, type CircuitDoc } from '../core/model'
+import { journeyFromPoints } from '../core/routing'
+import { composeSceneSvg } from '../views/exportImage'
+
+test('composeSceneSvg (sch) renders ink wires + net labels with balanced svg tags', () => {
+  const doc: CircuitDoc = emptyDoc()
+  doc.netLabels = [
+    { id: 'nl1', name: 'GND', kind: 'ground', sch: { x: 0, y: 0 } },
+    { id: 'nl2', name: 'GND', kind: 'ground', sch: { x: 96, y: 0 } }
+  ]
+  doc.wires = [
+    {
+      id: 'w1',
+      from: 'nl1:1',
+      to: 'nl2:1',
+      view: 'sch',
+      route: journeyFromPoints(
+        [
+          { x: 0, y: 0 },
+          { x: 96, y: 0 }
+        ],
+        true
+      )
+    }
+  ]
+  const svg = composeSceneSvg(doc, '#ffffff', 'sch')
+  assert.ok(svg, 'expected a scene svg')
+  assert.ok(svg!.includes('stroke-width="1"'), 'schematic ink wire present')
+  assert.ok(svg!.includes('Studio'), 'watermark present')
+  const opens = (svg!.match(/<svg/g) || []).length
+  const closes = (svg!.match(/<\/svg>/g) || []).length
+  assert.equal(opens, closes, 'svg tags balanced')
+  assert.ok(opens >= 3, 'outer + two net-label glyphs')
+})
+
+test('composeSceneSvg (sch) omits breadboards but keeps their absence graceful', () => {
+  const doc: CircuitDoc = emptyDoc()
+  doc.parts = [{ id: 'BB1', type: 'breadboard-mini', bb: { x: 0, y: 0 }, sch: { x: 0, y: 0 } }]
+  // no sch-renderable geometry ⇒ bounds null ⇒ null (nothing to export), no throw
+  const svg = composeSceneSvg(doc, '#ffffff', 'sch')
+  assert.equal(svg, null)
+})
diff --git a/src/renderer/src/circuit/__tests__/netLabels.test.ts b/src/renderer/src/circuit/__tests__/netLabels.test.ts
new file mode 100644
index 0000000..46d0137
--- /dev/null
+++ b/src/renderer/src/circuit/__tests__/netLabels.test.ts
@@ -0,0 +1,34 @@
+/** Tests for parts/netLabels — glyph geometry, single pin, grid snapping. */
+import { strict as assert } from 'node:assert'
+import { test } from 'node:test'
+import { GRID_BB, type NetLabel } from '../core/model'
+import { NET_LABEL_KINDS, netLabelPinWorld, netLabelView, snapNetLabel } from '../parts/netLabels'
+
+const onGrid = (v: number): boolean => Math.abs(v / GRID_BB - Math.round(v / GRID_BB)) < 1e-6
+
+test('every net-label kind renders one pin named "1"', () => {
+  for (const k of NET_LABEL_KINDS) {
+    const v = netLabelView(k.kind, k.name)
+    assert.deepEqual(Object.keys(v.pins), ['1'])
+    assert.ok(v.w > 0 && v.h > 0)
+    assert.ok(v.svg.includes('<line') || v.svg.includes('<rect'))
+  }
+})
+
+test('snapNetLabel lands the pin on the major grid', () => {
+  for (const start of [
+    { x: 103, y: 57 },
+    { x: 0, y: 0 },
+    { x: -41, y: 88 }
+  ]) {
+    const pl = snapNetLabel('ground', 'GND', start)
+    const label: NetLabel = { id: 'nl1', name: 'GND', kind: 'ground', sch: pl }
+    const p = netLabelPinWorld(label)
+    assert.ok(onGrid(p.x) && onGrid(p.y), `pin off grid: ${p.x},${p.y}`)
+  }
+})
+
+test('ground pin is at the top, power pin at the bottom', () => {
+  assert.equal(netLabelView('ground', 'GND').pins['1'][1], 0)
+  assert.equal(netLabelView('power', '5V').pins['1'][1], 2 * GRID_BB)
+})
diff --git a/src/renderer/src/circuit/__tests__/store.test.ts b/src/renderer/src/circuit/__tests__/store.test.ts
index c51910f..7404328 100644
--- a/src/renderer/src/circuit/__tests__/store.test.ts
+++ b/src/renderer/src/circuit/__tests__/store.test.ts
@@ -149,4 +149,7 @@ test('refdes assignment', () => {
   assert.equal(nextRefdes(d, 'U'), 'U1')
   assert.equal(prefixForFamily('Diode LED'), 'D') // 'diode' matches first
   assert.equal(prefixForFamily(undefined, 'Q'), 'Q')
+  // longest-key-first: a breadboard is BB, not U (it contains 'board')
+  assert.equal(prefixForFamily('breadboard'), 'BB')
+  assert.equal(prefixForFamily('Custom Board'), 'U')
 })
diff --git a/src/renderer/src/circuit/core/commands.ts b/src/renderer/src/circuit/core/commands.ts
index f91d5cf..ce01cf8 100644
--- a/src/renderer/src/circuit/core/commands.ts
+++ b/src/renderer/src/circuit/core/commands.ts
@@ -61,15 +61,17 @@ export function placePart(
     mergeKey: merge ? `place:${view}:${id}` : undefined,
     apply: (doc) => ({
       ...doc,
-      parts: doc.parts.map((p) =>
-        p.id === id ? { ...p, [view]: placement } : p
-      ),
+      parts: doc.parts.map((p) => (p.id === id ? { ...p, [view]: placement } : p)),
       wires: applyReroutes(doc.wires, reroutes)
     })
   }
 }
 
-export function setPartAttr(id: string, key: string, value: string | number | boolean | undefined): Command {
+export function setPartAttr(
+  id: string,
+  key: string,
+  value: string | number | boolean | undefined
+): Command {
   return {
     label: `Set ${id}.${key}`,
     mergeKey: `attr:${id}:${key}`,
@@ -160,7 +162,12 @@ export function rerouteWire(id: string, route: string[], merge = false): Command
   }
 }
 
-export function setWireEnds(id: string, from: WireEnd | undefined, to: WireEnd | undefined, route?: string[]): Command {
+export function setWireEnds(
+  id: string,
+  from: WireEnd | undefined,
+  to: WireEnd | undefined,
+  route?: string[]
+): Command {
   return {
     label: 'Reconnect wire',
     apply: (doc) => ({
@@ -221,6 +228,36 @@ export function deleteNetLabel(id: string): Command {
   }
 }
 
+export function moveNetLabel(
+  id: string,
+  sch: Placement,
+  reroutes: WireReroute[] = [],
+  merge = false
+): Command {
+  return {
+    label: `Move ${id}`,
+    mergeKey: merge ? `label:${id}` : undefined,
+    apply: (doc) => ({
+      ...doc,
+      netLabels: (doc.netLabels ?? []).map((l) => (l.id === id ? { ...l, sch } : l)),
+      wires: applyReroutes(doc.wires, reroutes)
+    })
+  }
+}
+
+export function updateNetLabel(
+  id: string,
+  patch: Partial<Pick<NetLabel, 'name' | 'kind'>>
+): Command {
+  return {
+    label: `Edit ${id}`,
+    apply: (doc) => ({
+      ...doc,
+      netLabels: (doc.netLabels ?? []).map((l) => (l.id === id ? { ...l, ...patch } : l))
+    })
+  }
+}
+
 // ── sim ──────────────────────────────────────────────────────────────────────
 
 export function setAnalyses(analyses: Analysis[]): Command {
diff --git a/src/renderer/src/circuit/core/erc.ts b/src/renderer/src/circuit/core/erc.ts
new file mode 100644
index 0000000..d7547c5
--- /dev/null
+++ b/src/renderer/src/circuit/core/erc.ts
@@ -0,0 +1,83 @@
+/**
+ * circuit/core/erc — lightweight electrical-rule checks over the net model
+ * (spec §9). Non-blocking: every finding is a severity-tagged ErcIssue the UI
+ * renders in a panel. Pure + registry-free (component floating-pin checks that
+ * need pin geometry live in the view layer and are merged in there).
+ */
+
+import { splitPinRef, type CircuitDoc } from './model'
+import { danglingJunctions, type NetModel } from './nets'
+
+export type ErcSeverity = 'error' | 'warning' | 'info'
+
+export interface ErcIssue {
+  id: string
+  severity: ErcSeverity
+  message: string
+  ref?: { part?: string; wire?: string; label?: string; pin?: string }
+}
+
+/** Net-model rule checks (rail shorts, floating labels, dangling junctions, ground). */
+export function runErc(doc: CircuitDoc, net: NetModel): ErcIssue[] {
+  const out: ErcIssue[] = []
+  const labels = doc.netLabels ?? []
+
+  // dangling junction hosts — a rider references a wire that no longer exists.
+  for (const wid of danglingJunctions(doc)) {
+    out.push({
+      id: `dangling:${wid}`,
+      severity: 'error',
+      message: `Wire ${wid} rides a junction on a missing wire.`,
+      ref: { wire: wid }
+    })
+  }
+
+  // rail short — one net carries two different named rails/grounds (GND + 5V…).
+  const railsByNet = new Map<number, Set<string>>()
+  for (const l of labels) {
+    if (l.kind === 'net') continue
+    const idx = net.pinToNet.get(`${l.id}:1`)
+    if (idx === undefined) continue
+    let set = railsByNet.get(idx)
+    if (!set) railsByNet.set(idx, (set = new Set()))
+    set.add(l.name)
+  }
+  for (const [, names] of railsByNet) {
+    if (names.size > 1) {
+      const list = [...names].sort().join(' / ')
+      out.push({
+        id: `short:${list}`,
+        severity: 'error',
+        message: `Rail short — ${list} are tied to the same net.`
+      })
+    }
+  }
+
+  // floating net label — placed but nothing is wired to it.
+  const wiredParts = new Set<string>()
+  for (const w of doc.wires) {
+    for (const e of [w.from, w.to]) if (typeof e === 'string') wiredParts.add(splitPinRef(e).part)
+  }
+  for (const l of labels) {
+    if (!wiredParts.has(l.id)) {
+      out.push({
+        id: `floatlabel:${l.id}`,
+        severity: 'info',
+        message: `Net label “${l.name}” isn't wired to anything.`,
+        ref: { label: l.id }
+      })
+    }
+  }
+
+  // missing ground — power rails present but no ground reference for node 0.
+  const kinds = new Set(labels.map((l) => l.kind))
+  if (kinds.has('power') && !kinds.has('ground')) {
+    out.push({
+      id: 'noground',
+      severity: 'info',
+      message: 'No ground (GND) reference — add a Ground label for a complete schematic.'
+    })
+  }
+
+  return out
+}
diff --git a/src/renderer/src/circuit/core/refdes.ts b/src/renderer/src/circuit/core/refdes.ts
index 88dbc2c..7b44468 100644
--- a/src/renderer/src/circuit/core/refdes.ts
+++ b/src/renderer/src/circuit/core/refdes.ts
@@ -31,7 +31,9 @@ export function prefixForFamily(family?: string, explicit?: string): string {
   if (explicit) return explicit
   if (!family) return 'P'
   const f = family.toLowerCase()
-  for (const key of Object.keys(FAMILY_PREFIX)) {
+  // longest key first: "breadboard" must win over "board" (BB1, not U1)
+  const keys = Object.keys(FAMILY_PREFIX).sort((a, b) => b.length - a.length)
+  for (const key of keys) {
     if (f.includes(key)) return FAMILY_PREFIX[key]
   }
   return 'P'
diff --git a/src/renderer/src/circuit/parts/netLabels.ts b/src/renderer/src/circuit/parts/netLabels.ts
new file mode 100644
index 0000000..a903231
--- /dev/null
+++ b/src/renderer/src/circuit/parts/netLabels.ts
@@ -0,0 +1,122 @@
+/**
+ * circuit/parts/netLabels — generated glyphs for schematic net labels (§8.4).
+ *
+ * A net label is a 1-pin entity whose virtual pin is "<id>:1"; labels sharing a
+ * name merge into one net (the mechanism in core/nets.ts). `ground` is just the
+ * name 'GND' drawn with the classic three-bar glyph; `power` is an up-flag with
+ * the rail name (5V, 3V3, VCC…); `net` is a named tag (SDA, OUT…). Ink follows
+ * the theme via var(--text-strong); the image exporter inlines it at export.
+ *
+ * Pins land on the 9.6 px major grid after snapNetLabel (spec §4).
+ */
+
+import type { PartView } from '../../lib/partsLibrary'
+import { pinWorld, snapPlacementToPinGrid } from '../core/geometry'
+import { GRID_BB, type NetLabel, type NetLabelKind, type Placement, type Pt } from '../core/model'
+
+const P = GRID_BB // 9.6
+const INK = 'var(--text-strong)'
+const STROKE = 2
+export const NET_LABEL_PIN = '1'
+
+export interface NetLabelKindSpec {
+  kind: NetLabelKind
+  /** default net name assigned on placement */
+  name: string
+  /** palette label */
+  label: string
+}
+
+/** Palette entries for the "Net Labels" section. */
+export const NET_LABEL_KINDS: NetLabelKindSpec[] = [
+  { kind: 'ground', name: 'GND', label: 'Ground' },
+  { kind: 'power', name: '5V', label: 'Power 5V' },
+  { kind: 'power', name: '3V3', label: 'Power 3V3' },
+  { kind: 'net', name: 'NET', label: 'Named net' }
+]
+
+const cache = new Map<string, PartView>()
+
+export function netLabelView(kind: NetLabelKind, name: string): PartView {
+  const key = `${kind}:${name}`
+  const hit = cache.get(key)
+  if (hit) return hit
+  const v = kind === 'ground' ? groundGlyph() : kind === 'power' ? powerGlyph(name) : netGlyph(name)
+  cache.set(key, v)
+  return v
+}
+
+export function netLabelVisualOf(label: NetLabel): PartView {
+  return netLabelView(label.kind, label.name)
+}
+
+/** World position of a label's single connection pin. */
+export function netLabelPinWorld(label: NetLabel, placement?: Placement): Pt {
+  const pl = placement ?? label.sch
+  const v = netLabelVisualOf(label)
+  return pinWorld(v.pins[NET_LABEL_PIN], pl, v.w, v.h)
+}
+
+/** Snap a label placement so its pin lands on the major grid. */
+export function snapNetLabel(kind: NetLabelKind, name: string, pl: Placement): Placement {
+  const v = netLabelView(kind, name)
+  const { x, y } = snapPlacementToPinGrid(pl, v.pins[NET_LABEL_PIN], v.w, v.h, GRID_BB)
+  return { ...pl, x, y }
+}
+
+function wrap(inner: string, w: number, h: number, pin: [number, number]): PartView {
+  return {
+    svg: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${w} ${h}">${inner}</svg>`,
+    w,
+    h,
+    pins: { [NET_LABEL_PIN]: pin }
+  }
+}
+
+function groundGlyph(): PartView {
+  const w = 2 * P
+  const h = 2 * P
+  const cx = w / 2
+  const bars: [number, number][] = [
+    [7, P],
+    [4.5, P + 3.4],
+    [2, P + 6.8]
+  ]
+  const inner =
+    `<line x1="${cx}" y1="0" x2="${cx}" y2="${P}" stroke="${INK}" stroke-width="${STROKE}"/>` +
+    bars
+      .map(
+        ([hw, y]) =>
+          `<line x1="${cx - hw}" y1="${y}" x2="${cx + hw}" y2="${y}" stroke="${INK}" stroke-width="${STROKE}" stroke-linecap="round"/>`
+      )
+      .join('')
+  return wrap(inner, w, h, [cx, 0])
+}
+
+function powerGlyph(name: string): PartView {
+  const w = Math.max(2 * P, name.length * 6.2 + 10)
+  const h = 2 * P
+  const cx = w / 2
+  const inner =
+    `<text x="${cx}" y="${P - 5}" fill="${INK}" font-family="monospace" font-size="8" text-anchor="middle">${escape(name)}</text>` +
+    `<line x1="${cx - P}" y1="${P}" x2="${cx + P}" y2="${P}" stroke="${INK}" stroke-width="${STROKE}" stroke-linecap="round"/>` +
+    `<line x1="${cx}" y1="${P}" x2="${cx}" y2="${2 * P}" stroke="${INK}" stroke-width="${STROKE}"/>`
+  return wrap(inner, w, h, [cx, 2 * P])
+}
+
+function netGlyph(name: string): PartView {
+  const stub = P
+  const tagW = name.length * 6.2 + 12
+  const w = stub + tagW
+  const h = 2 * P
+  const cy = P
+  const inner =
+    `<line x1="0" y1="${cy}" x2="${stub}" y2="${cy}" stroke="${INK}" stroke-width="${STROKE}"/>` +
+    `<rect x="${stub}" y="${cy - 7}" width="${tagW - 2}" height="14" rx="3" fill="none" stroke="${INK}" stroke-width="${STROKE}"/>` +
+    `<text x="${stub + (tagW - 2) / 2}" y="${cy + 3}" fill="${INK}" font-family="monospace" font-size="8" text-anchor="middle">${escape(name)}</text>`
+  return wrap(inner, w, h, [0, cy])
+}
+
+function escape(s: string): string {
+  return s.replace(/[<>&]/g, (c) => ({ '<': '&lt;', '>': '&gt;', '&': '&amp;' })[c] as string)
+}
diff --git a/src/renderer/src/circuit/views/CircuitView.tsx b/src/renderer/src/circuit/views/CircuitView.tsx
index 778f806..b66ddf8 100644
--- a/src/renderer/src/circuit/views/CircuitView.tsx
+++ b/src/renderer/src/circuit/views/CircuitView.tsx
@@ -11,38 +11,45 @@
  */
 
 import {
+  CircleAlert,
   CodeXml,
   Eye,
   FileCode2,
   Grid3x3,
   ImageDown,
+  Info,
   Maximize,
   Pencil,
   Redo2,
+  ShieldCheck,
+  TriangleAlert,
   Undo2,
+  X,
   ZoomIn,
   ZoomOut
 } from 'lucide-react'
 import React from 'react'
-import {
-  ensureParts,
-  getPart,
-  loadPart,
-  registerPart,
-  type PartDef
-} from '../../lib/partsLibrary'
+import { ensureParts, getPart, loadPart, registerPart, type PartDef } from '../../lib/partsLibrary'
 import { PartsEditor } from '../../components/PartsEditor'
 import * as cmd from '../core/commands'
-import { type Pt, type ViewId } from '../core/model'
+import { newId, type NetLabelKind, type Pt, type ViewId } from '../core/model'
 import { buildNets } from '../core/nets'
+import { runErc, type ErcIssue, type ErcSeverity } from '../core/erc'
 import { nextRefdes, prefixForFamily } from '../core/refdes'
 import { CircuitStore } from '../core/store'
-import { BREADBOARDS, generateBreadboard } from '../parts/breadboard'
+import { BREADBOARDS, generateBreadboard, isBreadboard } from '../parts/breadboard'
+import { snapNetLabel } from '../parts/netLabels'
 import { Canvas, emptySel, type Cam, type CanvasHandle, type Selection } from './canvas/Canvas'
 import { exportPng, exportSvg } from './exportImage'
 import { InspectorRail } from './inspector/Inspector'
 import { Palette, WIRE_COLORS } from './palette/Palette'
-import { circuitBuses, implicitSeats, ratsnest, snapBB, visualFor } from './partsAdapter'
+import {
+  circuitBuses,
+  ercFloatingPins,
+  findFreePlacement,
+  implicitSeats,
+  ratsnest
+} from './partsAdapter'
 
 export function CircuitViewV2({
   content,
@@ -71,6 +78,7 @@ export function CircuitViewV2({
   const [wireColor, setWireColor] = React.useState(WIRE_COLORS[0])
   const [cam, setCam] = React.useState<Cam>({ scale: 1, tx: 40, ty: 40 })
   const [editorPart, setEditorPart] = React.useState<PartDef | null | undefined>(undefined)
+  const [showErc, setShowErc] = React.useState(false)
   const [defsTick, bumpDefs] = React.useReducer((n: number) => n + 1, 0)
   const canvasRef = React.useRef<CanvasHandle>(null)
 
@@ -102,7 +110,10 @@ export function CircuitViewV2({
   React.useEffect(() => {
     const partIds = new Set(doc.parts.map((p) => p.id))
     const wireIds = new Set(doc.wires.map((w) => w.id))
-    if ([...sel.parts].every((id) => partIds.has(id)) && [...sel.wires].every((id) => wireIds.has(id)))
+    if (
+      [...sel.parts].every((id) => partIds.has(id)) &&
+      [...sel.wires].every((id) => wireIds.has(id))
+    )
       return
     setSel({
       parts: new Set([...sel.parts].filter((id) => partIds.has(id))),
@@ -122,15 +133,40 @@ export function CircuitViewV2({
   )
   // nets satisfied elsewhere but unrouted here → dashed guidance (spec §8.2)
   const rats = React.useMemo(() => ratsnest(doc, view, netModel), [doc, view, netModel, defsTick])
-  const routedHere = React.useMemo(() => {
-    const unrouted = new Set(rats.map((r) => r.net))
-    return netModel.meaningful - unrouted.size
-  }, [rats, netModel])
-  // parts with no placement in the current view live in the tray
+  // ERC: net-model rules + view-side floating-pin findings (spec §9)
+  const erc = React.useMemo(
+    () => [...runErc(doc, netModel), ...ercFloatingPins(doc, netModel, view)],
+    [doc, netModel, view, defsTick]
+  )
+  const ercCount = React.useMemo(() => {
+    const c = { error: 0, warning: 0, info: 0 } as Record<ErcSeverity, number>
+    for (const i of erc) c[i.severity]++
+    return c
+  }, [erc])
+  const selectErc = (i: ErcIssue): void => {
+    if (i.ref?.part) setSel({ parts: new Set([i.ref.part]), wires: new Set(), labels: new Set() })
+    else if (i.ref?.wire)
+      setSel({ parts: new Set(), wires: new Set([i.ref.wire]), labels: new Set() })
+    else if (i.ref?.label)
+      setSel({ parts: new Set(), wires: new Set(), labels: new Set([i.ref.label]) })
+  }
+  // parts with no placement in the current view live in the tray.
+  // Breadboards are excluded from the schematic entirely (spec §10.2: they
+  // are transparent — their row/rail buses still merge nets globally).
   const trayParts = React.useMemo(
-    () => doc.parts.filter((p) => !p[view] && (view === 'bb' ? p.sch : p.bb)),
+    () =>
+      doc.parts.filter((p) => !p[view] && (view === 'bb' ? p.sch : p.bb && !isBreadboard(p.type))),
     [doc, view]
   )
+  // one compact warning bubble: unplaced parts, unwired nets, ERC err/warn
+  const problems = React.useMemo(() => {
+    const bits: string[] = []
+    if (trayParts.length) bits.push(`${trayParts.length} unplaced`)
+    if (rats.length) bits.push(`${rats.length} unwired net${rats.length > 1 ? 's' : ''}`)
+    const ercN = ercCount.error + ercCount.warning
+    if (ercN) bits.push(`${ercN} ERC`)
+    return bits
+  }, [trayParts, rats, ercCount])
 
   // switching views: selection is per-view state, wires especially
   const switchView = (v: ViewId): void => {
@@ -140,18 +176,21 @@ export function CircuitViewV2({
     requestAnimationFrame(() => canvasRef.current?.fit())
   }
 
+  const enterEdit = (): void => {
+    if (editable) return
+    setEditable(true)
+    onEditChange?.(true)
+  }
+
+  // Placing an unplaced part: drop it straight onto a free slot (no second
+  // click) and flip into edit mode so it can be dragged immediately.
   const placeFromTray = (partId: string): void => {
     const part = doc.parts.find((p) => p.id === partId)
     if (!part) return
-    const vis = visualFor(part.type, view)
     const c = canvasRef.current?.centerWorld() ?? { x: 300, y: 200 }
-    const pl = snapBB(
-      part.type,
-      { x: Math.round(c.x - (vis?.v.w ?? 80) / 2), y: Math.round(c.y - (vis?.v.h ?? 40) / 2) },
-      view
-    )
-    store.dispatch(cmd.placePart(partId, view, pl))
+    store.dispatch(cmd.placePart(partId, view, findFreePlacement(doc, part.type, view, c)))
     setSel({ parts: new Set([partId]), wires: new Set() })
+    enterEdit()
   }
 
   // ── actions ─────────────────────────────────────────────────────────────────
@@ -160,16 +199,21 @@ export function CircuitViewV2({
     const def = getPart(type) || (await loadPart(type))
     if (!def) return
     bumpDefs()
-    const vis = visualFor(type, view)
-    const w = vis?.v.w || 80
-    const h = vis?.v.h || 40
     const p = at ?? canvasRef.current?.centerWorld() ?? { x: 300, y: 200 }
     const id = nextRefdes(store.getDoc(), prefixForFamily(`${def.family ?? ''} ${def.type}`))
-    const pl = snapBB(type, { x: Math.round(p.x - w / 2), y: Math.round(p.y - h / 2) }, view)
+    const pl = findFreePlacement(store.getDoc(), type, view, p)
     store.dispatch(cmd.addPart({ id, type, [view]: pl }))
     setSel({ parts: new Set([id]), wires: new Set() })
   }
 
+  const addNetLabel = (kind: NetLabelKind, name: string, at?: Pt): void => {
+    const c = at ?? canvasRef.current?.centerWorld() ?? { x: 300, y: 200 }
+    const id = newId('nl')
+    const sch = snapNetLabel(kind, name, { x: Math.round(c.x), y: Math.round(c.y) })
+    store.dispatch(cmd.addNetLabel({ id, name, kind, sch }))
+    setSel({ parts: new Set(), wires: new Set(), labels: new Set([id]) })
+  }
+
   const pickColor = (c: string): void => {
     setWireColor(c)
     if (sel.wires.size === 1 && sel.parts.size === 0)
@@ -188,9 +232,11 @@ export function CircuitViewV2({
     <div className="size-full relative flex bg-bg overflow-hidden pb-7">
       {editable && (
         <Palette
+          view={view}
           wireColor={wireColor}
           onPickColor={pickColor}
           onAdd={(type) => void addPartAt(type)}
+          onAddNetLabel={(kind, name) => addNetLabel(kind as NetLabelKind, name)}
           onEditPart={(type) => void editExisting(type)}
           onNewPart={() => setEditorPart(null)}
         />
@@ -263,7 +309,7 @@ export function CircuitViewV2({
               <button
                 key={part.id}
                 className="px-2 py-0.5 rounded-full bg-surface-card border border-dashed border-border-strong text-[11px] text-text-body hover:border-brand hover:text-brand"
-                title={`${part.type} — click to place in this view`}
+                title={`${part.type} — click to place it in this view`}
                 onClick={() => placeFromTray(part.id)}
               >
                 {part.id}
@@ -274,16 +320,20 @@ export function CircuitViewV2({
 
         {/* right toolbar: export / grid / code */}
         <div className="absolute top-3 right-3.5 z-10 flex gap-1.5">
-          {view === 'bb' && (
-            <>
-              <button className={`${tool} w-8 justify-center px-0`} onClick={() => exportPng(doc)} title="Export as PNG">
-                <ImageDown size={15} />
-              </button>
-              <button className={`${tool} w-8 justify-center px-0`} onClick={() => exportSvg(doc)} title="Export as SVG">
-                <FileCode2 size={15} />
-              </button>
-            </>
-          )}
+          <button
+            className={`${tool} w-8 justify-center px-0`}
+            onClick={() => exportPng(doc, view)}
+            title="Export as PNG"
+          >
+            <ImageDown size={15} />
+          </button>
+          <button
+            className={`${tool} w-8 justify-center px-0`}
+            onClick={() => exportSvg(doc, view)}
+            title="Export as SVG"
+          >
+            <FileCode2 size={15} />
+          </button>
           <button
             className={`${tool} w-8 justify-center px-0 ${grid ? 'text-brand' : ''}`}
             onClick={() => setGrid((g) => !g)}
@@ -292,7 +342,11 @@ export function CircuitViewV2({
             <Grid3x3 size={15} />
           </button>
           {onOpenCode && (
-            <button className={`${tool} w-8 justify-center px-0`} onClick={onOpenCode} title="Edit circuit.json as code">
+            <button
+              className={`${tool} w-8 justify-center px-0`}
+              onClick={onOpenCode}
+              title="Edit circuit.json as code"
+            >
               <CodeXml size={15} />
             </button>
           )}
@@ -317,31 +371,73 @@ export function CircuitViewV2({
           >
             <ZoomIn size={15} />
           </button>
-          <button className={`${tool} w-8 justify-center px-0`} onClick={() => canvasRef.current?.fit()} title="Fit to view">
+          <button
+            className={`${tool} w-8 justify-center px-0`}
+            onClick={() => canvasRef.current?.fit()}
+            title="Fit to view"
+          >
             <Maximize size={15} />
           </button>
         </div>
 
-        {/* status pills */}
-        <div className="absolute bottom-3 left-3 z-10 flex flex-wrap gap-2 text-[11px] max-w-[60%]">
-          <span className="px-2.5 py-1 rounded-full bg-surface-card border border-border-default text-text-body">
-            Parts: {doc.parts.length} · Wires: {doc.wires.filter((w) => w.view === view).length} ·
-            Nets: {netModel.meaningful} · routed here: {routedHere}/{netModel.meaningful}
-          </span>
-          {migrated && (
-            <span className="px-2.5 py-1 rounded-full bg-surface-card border border-brand/40 text-brand">
-              migrated from diagram.json
-            </span>
-          )}
-          {warnings.length > 0 && (
-            <span
-              className="px-2.5 py-1 rounded-full bg-surface-card border border-status-warning/40 text-status-warning"
-              title={warnings.join('\n')}
-            >
-              {warnings.length} migration note{warnings.length > 1 ? 's' : ''}
-            </span>
-          )}
-        </div>
+        {/* only surfaces when something needs attention: unwired nets / unplaced
+            parts / ERC (click for details), plus the one-time migration note. */}
+        {(problems.length > 0 || migrated || warnings.length > 0) && (
+          <div className="absolute bottom-3 left-3 z-10 flex flex-wrap gap-2 text-[11px] max-w-[60%]">
+            {problems.length > 0 && (
+              <button
+                className={`px-2.5 py-1 rounded-full bg-surface-card border flex items-center gap-1.5 ${
+                  ercCount.error
+                    ? 'border-status-danger/40 text-status-danger'
+                    : 'border-status-warning/40 text-status-warning'
+                }`}
+                onClick={() => setShowErc((v) => !v)}
+                title="Show issues"
+              >
+                <TriangleAlert size={12} /> {problems.join(' · ')}
+              </button>
+            )}
+            {migrated && (
+              <span className="px-2.5 py-1 rounded-full bg-surface-card border border-brand/40 text-brand">
+                migrated from diagram.json
+              </span>
+            )}
+            {warnings.length > 0 && (
+              <span
+                className="px-2.5 py-1 rounded-full bg-surface-card border border-status-warning/40 text-status-warning"
+                title={warnings.join('\n')}
+              >
+                {warnings.length} migration note{warnings.length > 1 ? 's' : ''}
+              </span>
+            )}
+          </div>
+        )}
+
+        {/* ERC panel (spec §9): non-blocking findings list */}
+        {showErc && (
+          <div className="absolute bottom-12 left-3 z-20 w-80 max-h-[45%] flex flex-col rounded-lg border border-border-default bg-surface-card shadow-lg overflow-hidden">
+            <div className="h-8 shrink-0 flex items-center justify-between px-3 border-b border-border-default">
+              <span className="text-[12px] font-semibold text-text-body">
+                Electrical rule check
+              </span>
+              <button
+                className="text-text-muted hover:text-text-body"
+                onClick={() => setShowErc(false)}
+              >
+                <X size={13} />
+              </button>
+            </div>
+            <div className="flex-1 min-h-0 overflow-y-auto p-2 flex flex-col gap-1 text-[11px]">
+              {erc.length === 0 ? (
+                <div className="flex items-center gap-1.5 text-status-ok px-1 py-2">
+                  <ShieldCheck size={13} /> No issues found.
+                </div>
+              ) : (
+                erc.map((i) => <ErcRow key={i.id} issue={i} onSelect={selectErc} />)
+              )}
+            </div>
+          </div>
+        )}
 
         <Canvas
           key={view}
@@ -361,16 +457,26 @@ export function CircuitViewV2({
           setCam={setCam}
           handleRef={canvasRef}
           onDropPart={(type, at) => void addPartAt(type, at)}
+          onDropNetLabel={(kind, name, at) => addNetLabel(kind, name, at)}
+          onRequestEdit={enterEdit}
         />
 
-        {/* watermark */}
-        <div className="absolute bottom-12 right-4 z-0 pointer-events-none select-none text-[12px] font-semibold text-text-faint/70">
-          tinyStudio
+        {/* watermark — matches the header wordmark: thin 'tiny', bold 'Studio' */}
+        <div className="absolute bottom-8 right-6 z-0 pointer-events-none select-none text-[60px] leading-none tracking-[-0.02em] text-text-faint/25">
+          <span className="font-light">tiny</span>
+          <span className="font-extrabold">Studio</span>
         </div>
       </div>
 
       {editable && (
-        <InspectorRail doc={doc} store={store} sel={sel} setSel={setSel} netModel={netModel} view={view} />
+        <InspectorRail
+          doc={doc}
+          store={store}
+          sel={sel}
+          setSel={setSel}
+          netModel={netModel}
+          view={view}
+        />
       )}
 
       {editorPart !== undefined && (
@@ -387,3 +493,32 @@ export function CircuitViewV2({
     </div>
   )
 }
+
+function ErcRow({
+  issue,
+  onSelect
+}: {
+  issue: ErcIssue
+  onSelect: (i: ErcIssue) => void
+}): React.JSX.Element {
+  const color =
+    issue.severity === 'error'
+      ? 'text-status-danger'
+      : issue.severity === 'warning'
+        ? 'text-status-warning'
+        : 'text-text-muted'
+  const Icon =
+    issue.severity === 'error' ? CircleAlert : issue.severity === 'warning' ? TriangleAlert : Info
+  const clickable = !!(issue.ref?.part || issue.ref?.wire || issue.ref?.label)
+  return (
+    <button
+      className={`flex items-start gap-1.5 text-left px-1.5 py-1 rounded hover:bg-bg-sunken ${
+        clickable ? '' : 'cursor-default'
+      }`}
+      onClick={() => clickable && onSelect(issue)}
+    >
+      <Icon size={13} className={`mt-px shrink-0 ${color}`} />
+      <span className="text-text-body leading-snug">{issue.message}</span>
+    </button>
+  )
+}
diff --git a/src/renderer/src/circuit/views/canvas/Canvas.tsx b/src/renderer/src/circuit/views/canvas/Canvas.tsx
index 4089058..7483969 100644
--- a/src/renderer/src/circuit/views/canvas/Canvas.tsx
+++ b/src/renderer/src/circuit/views/canvas/Canvas.tsx
@@ -11,7 +11,7 @@
  * (camera, hover, armed wire, marquee, edit buffer) never touches the doc.
  */
 
-import { CircuitBoard, MousePointer2, Zap } from 'lucide-react'
+import { CircuitBoard, Zap } from 'lucide-react'
 import React from 'react'
 import { buildClipboard, materializePaste, parseClipboard } from '../../core/clipboard'
 import * as cmd from '../../core/commands'
@@ -21,6 +21,7 @@ import {
   isJunction,
   isPendingJunction,
   type CircuitDoc,
+  type NetLabelKind,
   type Placement,
   type Pt,
   type ViewId,
@@ -28,6 +29,7 @@ import {
 } from '../../core/model'
 import { describeNet, type NetModel } from '../../core/nets'
 import { isBreadboard } from '../../parts/breadboard'
+import { netLabelVisualOf, snapNetLabel } from '../../parts/netLabels'
 import {
   calculateOrthogonalPath,
   clampOntoSegment,
@@ -43,6 +45,7 @@ import {
 import type { CircuitStore } from '../../core/store'
 import {
   collectFrozen,
+  freePasteOffset,
   holeAt,
   makeEndResolver,
   pinAtWorld,
@@ -59,6 +62,7 @@ import {
 
 // wire look (identical to DiagramEditor / tinySchematic)
 const WIRE_W = 2.8
+const WIRE_SCH_W = 1 // schematic ink: thin single stroke (no outline/glow)
 const WIRE_OUTLINE_W = WIRE_W + 1.8
 const WIRE_GLOW_W = WIRE_W + 5
 const WIRE_CORNER = 4
@@ -67,8 +71,14 @@ const NET_GLOW = 'rgba(243, 203, 0, 0.30)'
 export interface Selection {
   parts: Set<string>
   wires: Set<string>
+  /** selected net-label ids (schematic) */
+  labels?: Set<string>
 }
-export const emptySel = (): Selection => ({ parts: new Set(), wires: new Set() })
+export const emptySel = (): Selection => ({
+  parts: new Set(),
+  wires: new Set(),
+  labels: new Set()
+})
 
 export interface Cam {
   scale: number
@@ -134,7 +144,9 @@ export function Canvas({
   cam,
   setCam,
   handleRef,
-  onDropPart
+  onDropPart,
+  onDropNetLabel,
+  onRequestEdit
 }: {
   store: CircuitStore
   doc: CircuitDoc
@@ -155,6 +167,10 @@ export function Canvas({
   setCam: React.Dispatch<React.SetStateAction<Cam>>
   handleRef: React.Ref<CanvasHandle>
   onDropPart: (type: string, at: Pt) => void
+  onDropNetLabel: (kind: NetLabelKind, name: string, at: Pt) => void
+  /** tray "attach to cursor" placement: id being placed + drop callback */
+  /** double-clicking a component asks the shell to enter edit mode */
+  onRequestEdit: () => void
 }): React.JSX.Element {
   const scale = cam.scale
   // schematic wires bend on the fine grid; parts still snap pins to major
@@ -167,7 +183,9 @@ export function Canvas({
   const [armed, setArmed] = React.useState<Armed | null>(null)
   const [straight, setStraight] = React.useState(false)
   const [hoverPin, setHoverPin] = React.useState<{ id: string; pin: string } | null>(null)
-  const [hoverHole, setHoverHole] = React.useState<{ id: string; pin: string; pos: Pt } | null>(null)
+  const [hoverHole, setHoverHole] = React.useState<{ id: string; pin: string; pos: Pt } | null>(
+    null
+  )
   const [hoverWire, setHoverWire] = React.useState<string | null>(null)
   const [mouse, setMouse] = React.useState<Pt>({ x: 0, y: 0 })
   const [editPts, setEditPts] = React.useState<Pt[] | null>(null)
@@ -188,6 +206,13 @@ export function Canvas({
   } | null>(null)
   const handleDrag = React.useRef<{ kind: HandleKind } | null>(null)
   const labelDrag = React.useRef<{ id: string; ox: number; oy: number } | null>(null)
+  const netLabelDrag = React.useRef<{
+    id: string
+    offX: number
+    offY: number
+    frozen: FrozenWire[]
+    moved: boolean
+  } | null>(null)
   const suppressClick = React.useRef(false)
 
   // ── geometry ────────────────────────────────────────────────────────────────
@@ -229,9 +254,7 @@ export function Canvas({
   React.useEffect(() => {
     if (view !== 'bb') return // v1 migration produced bb wires only
     if (pendingDone.current) return
-    const pending = doc.wires.filter(
-      (w) => isPendingJunction(w.from) || isPendingJunction(w.to)
-    )
+    const pending = doc.wires.filter((w) => isPendingJunction(w.from) || isPendingJunction(w.to))
     if (pending.length === 0) {
       pendingDone.current = true
       return
@@ -451,6 +474,59 @@ export function Canvas({
     window.addEventListener('pointerup', up)
   }
 
+  // drag / select a schematic net label (moves its sch placement + reroutes wires)
+  const onNetLabelDown = (e: React.PointerEvent, id: string): void => {
+    if ((e.target as HTMLElement).closest('.pin-hit')) return
+    e.stopPropagation()
+    if (!editable) {
+      setSel({ parts: new Set(), wires: new Set(), labels: new Set([id]) })
+      return
+    }
+    if (e.shiftKey) {
+      const labels = new Set(sel.labels ?? [])
+      if (labels.has(id)) labels.delete(id)
+      else labels.add(id)
+      setSel({ parts: new Set(), wires: new Set(), labels })
+      return
+    }
+    setSel({ parts: new Set(), wires: new Set(), labels: new Set([id]) })
+    const label = doc.netLabels?.find((l) => l.id === id)
+    if (!label) return
+    const start = canvasPoint(e)
+    netLabelDrag.current = {
+      id,
+      offX: start.x - label.sch.x,
+      offY: start.y - label.sch.y,
+      frozen: collectFrozen(doc, new Set([id]), 'sch'),
+      moved: false
+    }
+    const move = (ev: PointerEvent): void => {
+      const d = netLabelDrag.current
+      if (!d) return
+      const cur = doc.netLabels?.find((l) => l.id === d.id)
+      if (!cur) return
+      const cp = canvasPoint(ev)
+      const snapped = snapNetLabel(cur.kind, cur.name, {
+        ...cur.sch,
+        x: cp.x - d.offX,
+        y: cp.y - d.offY
+      })
+      if (snapped.x !== cur.sch.x || snapped.y !== cur.sch.y) d.moved = true
+      const overrides = new Map<string, Placement>([[d.id, snapped]])
+      setDragOverrides(overrides)
+      const reroutes = reroutesFor(doc, d.frozen, overrides, { x: 0, y: 0 }, 'sch')
+      store.dispatch(cmd.moveNetLabel(d.id, snapped, reroutes, true))
+    }
+    const up = (): void => {
+      netLabelDrag.current = null
+      setDragOverrides(null)
+      window.removeEventListener('pointermove', move)
+      window.removeEventListener('pointerup', up)
+    }
+    window.addEventListener('pointermove', move)
+    window.addEventListener('pointerup', up)
+  }
+
   // ── wire drawing ────────────────────────────────────────────────────────────
 
   const finalizeSegment = (target: Pt, clean: boolean): { pts: Pt[]; str: boolean } => {
@@ -553,7 +629,12 @@ export function Canvas({
     return null // v2 has no free-point endpoints — caller reverts
   }
 
-  const startHandleDrag = (e: React.PointerEvent, kind: HandleKind, idx: number, end?: 0 | 1): void => {
+  const startHandleDrag = (
+    e: React.PointerEvent,
+    kind: HandleKind,
+    idx: number,
+    end?: 0 | 1
+  ): void => {
     if (!editable || !soloWire || !editPts) return
     e.stopPropagation()
     const wireId = soloWire
@@ -637,7 +718,12 @@ export function Canvas({
     if (armed) {
       const cp = canvasPoint(e)
       setMouse(cp)
-      const hit = hitWire(cp.x, cp.y, geomForHit.filter((g) => g.id === wireId), scale)
+      const hit = hitWire(
+        cp.x,
+        cp.y,
+        geomForHit.filter((g) => g.id === wireId),
+        scale
+      )
       if (hit) tapJunction(hit)
       return
     }
@@ -654,7 +740,8 @@ export function Canvas({
   // ── background: pan / marquee ───────────────────────────────────────────────
 
   const onViewPointerDown = (e: React.PointerEvent): void => {
-    const panButton = e.button === 1 || (e.button === 0 && e.altKey) || (e.button === 0 && !editable)
+    const panButton =
+      e.button === 1 || (e.button === 0 && e.altKey) || (e.button === 0 && !editable)
     if (panButton) {
       e.preventDefault()
       pan.current = { x: e.clientX, y: e.clientY }
@@ -723,14 +810,79 @@ export function Canvas({
   const onDrop = (e: React.DragEvent): void => {
     e.preventDefault()
     const type = e.dataTransfer.getData('text/tinystudio-part')
-    if (type) onDropPart(type, canvasPoint(e))
+    if (type) {
+      onDropPart(type, canvasPoint(e))
+      return
+    }
+    const nl = e.dataTransfer.getData('text/tinystudio-netlabel')
+    if (nl && view === 'sch') {
+      const idx = nl.indexOf(':')
+      onDropNetLabel(nl.slice(0, idx) as NetLabelKind, nl.slice(idx + 1), canvasPoint(e))
+    }
   }
 
   // ── keyboard: undo/redo, delete, rotate, nudge, clipboard, Esc, Shift ───────
 
+  /**
+   * Rotate a breadboard as a rigid assembly (bb only): the board, its seated
+   * parts, and the wires between them all turn 90 deg about the board's centre,
+   * so the whole layout is preserved rather than the wires rerouting. Seating is
+   * grid-aligned, so a 90 deg turn about centre maps holes->holes and pins re-seat.
+   */
+  const rotateBoardAssembly = React.useCallback(
+    (boardId: string): void => {
+      const board = doc.parts.find((p) => p.id === boardId)
+      const bpl = board?.bb
+      const bvis = board && visualFor(board.type, 'bb')
+      if (!board || !bpl || !bvis) return
+      const c = { x: bpl.x + bvis.v.w / 2, y: bpl.y + bvis.v.h / 2 }
+      // 90 deg CW about c, matching transformLocalPoint's rotation sense.
+      const rot90 = (p: Pt): Pt => ({ x: c.x - (p.y - c.y), y: c.y + (p.x - c.x) })
+      const ids = [boardId, ...seatedPartsOn(boardId, seats)]
+      const placements = new Map<string, Placement>()
+      for (const id of ids) {
+        const part = doc.parts.find((p) => p.id === id)
+        const cur = part?.bb
+        const vis = part && visualFor(part.type, 'bb')
+        if (!part || !cur || !vis) continue
+        const nr = (((((cur.rotate ?? 0) + 90) % 360) + 360) % 360) as 0 | 90 | 180 | 270
+        if (id === boardId) {
+          placements.set(id, { ...cur, rotate: nr || undefined })
+        } else {
+          const nc = rot90({ x: cur.x + vis.v.w / 2, y: cur.y + vis.v.h / 2 })
+          placements.set(id, {
+            ...cur,
+            x: nc.x - vis.v.w / 2,
+            y: nc.y - vis.v.h / 2,
+            rotate: nr || undefined
+          })
+        }
+      }
+      const frozen = collectFrozen(doc, new Set(ids), 'bb')
+      const reroutes = reroutesFor(doc, frozen, placements, { x: 0, y: 0 }, 'bb', rot90)
+      let first = true
+      const cmds: cmd.Command[] = []
+      for (const [id, pl] of placements) {
+        cmds.push(cmd.placePart(id, 'bb', pl, first ? reroutes : []))
+        first = false
+      }
+      if (cmds.length) store.dispatch(cmd.composite(`Rotate ${boardId}`, cmds))
+    },
+    [doc, store, seats]
+  )
+
   const rotateSelection = React.useCallback((): void => {
     const ids = [...sel.parts]
     if (!ids.length) return
+    // a lone breadboard rotates as a rigid assembly (carries seated parts + wires)
+    if (
+      view === 'bb' &&
+      ids.length === 1 &&
+      isBreadboard(doc.parts.find((p) => p.id === ids[0])?.type ?? '')
+    ) {
+      rotateBoardAssembly(ids[0])
+      return
+    }
     const frozen = collectFrozen(doc, new Set(ids), view)
     const placements = new Map<string, Placement>()
     const cmds: cmd.Command[] = []
@@ -746,8 +898,11 @@ export function Canvas({
       cmds.push(cmd.placePart(id, view, pl, first ? reroutes : []))
       first = false
     }
-    if (cmds.length) store.dispatch(cmd.composite(`Rotate ${ids.length > 1 ? `${ids.length} parts` : ids[0]}`, cmds))
-  }, [doc, sel, store, view])
+    if (cmds.length)
+      store.dispatch(
+        cmd.composite(`Rotate ${ids.length > 1 ? `${ids.length} parts` : ids[0]}`, cmds)
+      )
+  }, [doc, sel, store, view, rotateBoardAssembly])
 
   const nudgeSelection = React.useCallback(
     (dx: number, dy: number): void => {
@@ -776,6 +931,7 @@ export function Canvas({
     const cmds: cmd.Command[] = []
     if (sel.parts.size) cmds.push(cmd.deleteParts([...sel.parts]))
     if (sel.wires.size) cmds.push(cmd.deleteWires([...sel.wires]))
+    if (sel.labels?.size) for (const id of sel.labels) cmds.push(cmd.deleteNetLabel(id))
     if (!cmds.length) return
     store.dispatch(cmds.length === 1 ? cmds[0] : cmd.composite('Delete selection', cmds))
     setSel(emptySel())
@@ -794,7 +950,11 @@ export function Canvas({
 
   const pastePayload = React.useCallback(
     (payload: NonNullable<ReturnType<typeof parseClipboard>>): void => {
-      const { parts, wires, idMap } = materializePaste(doc, payload, { x: GRID_BB * 2, y: GRID_BB * 2 })
+      const { parts, wires, idMap } = materializePaste(
+        doc,
+        payload,
+        freePasteOffset(doc, payload.parts, view)
+      )
       if (!parts.length && !wires.length) return
       store.dispatch(
         cmd.composite(`Paste ${parts.length} part${parts.length === 1 ? '' : 's'}`, [
@@ -809,8 +969,14 @@ export function Canvas({
 
   React.useEffect(() => {
     const down = (e: KeyboardEvent): void => {
-      if (document.activeElement && /INPUT|TEXTAREA|SELECT/.test(document.activeElement.tagName)) return
-      if (e.key === 'Shift') setStraight(true)
+      if (document.activeElement && /INPUT|TEXTAREA|SELECT/.test(document.activeElement.tagName))
+        return
+      // Space = straight-wire modifier (Shift is reserved for shift-select).
+      if (e.key === ' ') {
+        setStraight(true)
+        e.preventDefault()
+        return
+      }
       if (e.key === 'Escape') {
         setArmed(null)
         setSel(emptySel())
@@ -852,7 +1018,7 @@ export function Canvas({
         if (payload) pastePayload(payload)
         return
       }
-      if (e.key === 'r' || e.key === 'R' || e.key === ' ') {
+      if (e.key === 'r' || e.key === 'R') {
         if (sel.parts.size) {
           e.preventDefault()
           rotateSelection()
@@ -896,7 +1062,7 @@ export function Canvas({
       }
     }
     const up = (e: KeyboardEvent): void => {
-      if (e.key === 'Shift') setStraight(false)
+      if (e.key === ' ') setStraight(false)
     }
     window.addEventListener('keydown', down)
     window.addEventListener('keyup', up)
@@ -904,7 +1070,19 @@ export function Canvas({
       window.removeEventListener('keydown', down)
       window.removeEventListener('keyup', up)
     }
-  }, [editable, sel, doc, store, setSel, view, copySelection, pastePayload, deleteSelection, rotateSelection, nudgeSelection])
+  }, [
+    editable,
+    sel,
+    doc,
+    store,
+    setSel,
+    view,
+    copySelection,
+    pastePayload,
+    deleteSelection,
+    rotateSelection,
+    nudgeSelection
+  ])
 
   // ── derived render bits ─────────────────────────────────────────────────────
 
@@ -924,7 +1102,10 @@ export function Canvas({
       clean = true
     }
     if (armed.straight || straight) return [...armed.points, target]
-    return [...armed.points, ...calculateOrthogonalPath(last.x, last.y, target.x, target.y, clean).slice(1)]
+    return [
+      ...armed.points,
+      ...calculateOrthogonalPath(last.x, last.y, target.x, target.y, clean).slice(1)
+    ]
   }, [armed, mouse, hoverPin, hoverHole, straight, resolve])
 
   // junction solder dots (junction endpoints take the host wire's color)
@@ -948,13 +1129,20 @@ export function Canvas({
     return out
   }, [doc, resolve])
 
-  const hint = !editable
-    ? { icon: <MousePointer2 size={12} />, text: 'View-only · hover a wire to light its net · click edit to change', hot: false }
-    : armed
-      ? { icon: <Zap size={12} />, text: 'Click a pin or wire to connect · click for a bend · hold Shift for straight · Esc to cancel', hot: true }
-      : soloWire
-        ? { icon: null, text: 'Drag a handle to reshape · double-click to add/remove a bend · Del to remove', hot: true }
-        : { icon: <MousePointer2 size={12} />, text: 'Scroll to zoom · drag to marquee-select · middle/Alt-drag to pan · click a pin to wire', hot: false }
+  // Contextual hint only while actively wiring/editing — no idle 'scroll to
+  // zoom' / 'view-only' bubbles cluttering the canvas.
+  const hint: { icon: React.JSX.Element | null; text: string } | null =
+    editable && armed
+      ? {
+          icon: <Zap size={12} />,
+          text: `Click a pin or wire to connect · click for a bend${view === 'bb' ? ' · hold Space for straight' : ''} · Esc to cancel`
+        }
+      : editable && soloWire
+        ? {
+            icon: null,
+            text: 'Drag a handle to reshape · double-click to add/remove a bend · Del to remove'
+          }
+        : null
 
   return (
     <div className="flex-1 relative min-w-0 overflow-hidden">
@@ -964,9 +1152,12 @@ export function Canvas({
         style={{
           touchAction: 'none',
           cursor: armed ? 'crosshair' : 'default',
-          backgroundColor: 'var(--bg-sunken)',
-          backgroundImage: grid ? 'radial-gradient(var(--dot-color) 1.1px, transparent 1.1px)' : 'none',
-          backgroundSize: `${GRID_BB * scale}px ${GRID_BB * scale}px`,
+          // schematic reads as paper (lighter surface, finer dot grid — spec §8.1)
+          backgroundColor: view === 'sch' ? 'var(--bg)' : 'var(--bg-sunken)',
+          backgroundImage: grid
+            ? `radial-gradient(var(--dot-color) ${view === 'sch' ? 0.9 : 1.1}px, transparent ${view === 'sch' ? 0.9 : 1.1}px)`
+            : 'none',
+          backgroundSize: `${(view === 'sch' ? GRID_SCH : GRID_BB) * scale}px ${(view === 'sch' ? GRID_SCH : GRID_BB) * scale}px`,
           backgroundPosition: `${cam.tx}px ${cam.ty}px`
         }}
         onWheel={(e) => {
@@ -993,7 +1184,15 @@ export function Canvas({
           }}
         >
           {/* wires */}
-          <svg style={{ position: 'absolute', inset: 0, overflow: 'visible', zIndex: 5, pointerEvents: 'none' }}>
+          <svg
+            style={{
+              position: 'absolute',
+              inset: 0,
+              overflow: 'visible',
+              zIndex: 5,
+              pointerEvents: 'none'
+            }}
+          >
             {/* ratsnest: connected elsewhere, not yet drawn here (spec §8.2) */}
             {rats.map((r, i) => (
               <line
@@ -1015,6 +1214,8 @@ export function Canvas({
               const onHotNet = highlightNet >= 0 && netModel.wireToNet.get(w.id) === highlightNet
               const core = view === 'sch' ? ink : w.color || '#2fa46a'
               const outline = view === 'sch' ? 'rgba(0,0,0,0.45)' : darken(w.color || '#2fa46a')
+              // schematic ink is a single thin stroke — no color outline, no glow.
+              const coreW = view === 'sch' ? WIRE_SCH_W : WIRE_W
               const d = roundedPath(pts)
               return (
                 <g
@@ -1025,14 +1226,59 @@ export function Canvas({
                   onClick={(e) => onWireClick(e, w.id)}
                   onDoubleClick={(e) => onWireDoubleClick(e, w.id)}
                 >
+                  {/* transparent fat stroke keeps thin schematic lines clickable */}
+                  <path
+                    d={d}
+                    fill="none"
+                    stroke="transparent"
+                    strokeWidth={Math.max(coreW + 10, 12)}
+                    strokeLinejoin="round"
+                    strokeLinecap="round"
+                  />
                   {onHotNet && (
-                    <path d={d} fill="none" stroke={NET_GLOW} strokeWidth={WIRE_GLOW_W} strokeLinejoin="round" strokeLinecap="round" />
+                    <path
+                      d={d}
+                      fill="none"
+                      stroke={NET_GLOW}
+                      strokeWidth={view === 'sch' ? coreW + 3 : WIRE_GLOW_W}
+                      strokeLinejoin="round"
+                      strokeLinecap="round"
+                    />
                   )}
-                  <path d={d} fill="none" stroke={outline} strokeWidth={WIRE_OUTLINE_W} strokeLinejoin="round" strokeLinecap="round" />
-                  <path d={d} fill="none" stroke={core} strokeWidth={WIRE_W} strokeLinejoin="round" strokeLinecap="round" />
+                  {view !== 'sch' && (
+                    <path
+                      d={d}
+                      fill="none"
+                      stroke={outline}
+                      strokeWidth={WIRE_OUTLINE_W}
+                      strokeLinejoin="round"
+                      strokeLinecap="round"
+                    />
+                  )}
+                  <path
+                    d={d}
+                    fill="none"
+                    stroke={core}
+                    strokeWidth={coreW}
+                    strokeLinejoin="round"
+                    strokeLinecap="round"
+                  />
                   {selected && (
-                    <path d={d} fill="none" stroke="rgba(255,255,255,0.85)" strokeWidth={1} strokeDasharray="4 4" strokeLinejoin="round">
-                      <animate attributeName="stroke-dashoffset" from="0" to="-8" dur="0.5s" repeatCount="indefinite" />
+                    <path
+                      d={d}
+                      fill="none"
+                      stroke="rgba(255,255,255,0.85)"
+                      strokeWidth={1}
+                      strokeDasharray="4 4"
+                      strokeLinejoin="round"
+                    >
+                      <animate
+                        attributeName="stroke-dashoffset"
+                        from="0"
+                        to="-8"
+                        dur="0.5s"
+                        repeatCount="indefinite"
+                      />
                     </path>
                   )}
                 </g>
@@ -1044,7 +1290,15 @@ export function Canvas({
             ))}
 
             {previewPts && (
-              <path d={roundedPath(previewPts)} fill="none" stroke={view === 'sch' ? ink : wireColor} strokeWidth={WIRE_W} strokeLinejoin="round" strokeLinecap="round" opacity={0.6} />
+              <path
+                d={roundedPath(previewPts)}
+                fill="none"
+                stroke={view === 'sch' ? ink : wireColor}
+                strokeWidth={view === 'sch' ? WIRE_SCH_W : WIRE_W}
+                strokeLinejoin="round"
+                strokeLinecap="round"
+                opacity={0.6}
+              />
             )}
 
             {/* handles on the solo-selected wire */}
@@ -1149,6 +1403,9 @@ export function Canvas({
           {doc.parts.map((part) => {
             const pl = placementOf(part.id)
             if (!pl) return null
+            // breadboards are transparent on the schematic — their row/rail
+            // buses still merge nets globally, but they render as no part here.
+            if (view === 'sch' && isBreadboard(part.type)) return null
             const vis = visualFor(part.type, view)
             if (!vis) {
               return (
@@ -1184,8 +1441,13 @@ export function Canvas({
                   cursor: editable ? 'move' : 'default'
                 }}
                 onPointerDown={(e) => onPartDown(e, part.id)}
+                onDoubleClick={(e) => {
+                  e.stopPropagation()
+                  if (!editable) onRequestEdit()
+                }}
                 onPointerMove={(e) => {
-                  if (!editable || view !== 'bb' || !isBreadboard(part.type) || partDrag.current) return
+                  if (!editable || view !== 'bb' || !isBreadboard(part.type) || partDrag.current)
+                    return
                   const cp = canvasPoint(e)
                   const hole = holeAt(doc, part.id, cp.x, cp.y, 6 / Math.min(scale, 1))
                   setHoverHole(hole ? { id: part.id, pin: hole.pin, pos: hole.pos } : null)
@@ -1195,13 +1457,28 @@ export function Canvas({
                 onContextMenu={(e) => {
                   if (!editable) return
                   e.preventDefault()
+                  // breadboards rotate as a rigid assembly (seated parts + wires
+                  // turn with the board); other parts rotate in place.
+                  if (view === 'bb' && isBreadboard(part.type)) {
+                    rotateBoardAssembly(part.id)
+                    return
+                  }
                   const cur = doc.parts.find((p) => p.id === part.id)?.[view]
                   if (!cur) return
-                  const next = ((((cur.rotate ?? 0) + 90) % 360) + 360) % 360 as 0 | 90 | 180 | 270
+                  const next = (((((cur.rotate ?? 0) + 90) % 360) + 360) % 360) as
+                    | 0
+                    | 90
+                    | 180
+                    | 270
                   const frozen = collectFrozen(doc, new Set([part.id]), view)
                   const placements = new Map([[part.id, { ...cur, rotate: next || undefined }]])
                   store.dispatch(
-                    cmd.placePart(part.id, view, placements.get(part.id), reroutesFor(doc, frozen, placements, { x: 0, y: 0 }, view))
+                    cmd.placePart(
+                      part.id,
+                      view,
+                      placements.get(part.id),
+                      reroutesFor(doc, frozen, placements, { x: 0, y: 0 }, view)
+                    )
                   )
                 }}
               >
@@ -1215,9 +1492,14 @@ export function Canvas({
                     const [px, py] = vis.v.pins[pin]
                     const armedHere = armed?.from === `${part.id}:${pin}`
                     const hovered = hoverPin?.id === part.id && hoverPin?.pin === pin
-                    const onHotNet =
-                      highlightNet >= 0 && netModel.pinToNet.get(`${part.id}:${pin}`) === highlightNet
+                    const netIdx = netModel.pinToNet.get(`${part.id}:${pin}`)
+                    const onHotNet = highlightNet >= 0 && netIdx === highlightNet
+                    // a pin sharing a net with anything else is connected — its
+                    // "open lead" dot disappears (still clickable to re-wire).
+                    const connected =
+                      netIdx !== undefined && (netModel.nets[netIdx]?.length ?? 0) >= 2
                     const on = armedHere || hovered
+                    const showDot = on || onHotNet || !connected
                     return (
                       <div
                         key={pin}
@@ -1234,19 +1516,25 @@ export function Canvas({
                         }}
                         onPointerDown={(e) => e.stopPropagation()}
                         onPointerEnter={() => setHoverPin({ id: part.id, pin })}
-                        onPointerLeave={() => setHoverPin((h) => (h?.id === part.id && h?.pin === pin ? null : h))}
+                        onPointerLeave={() =>
+                          setHoverPin((h) => (h?.id === part.id && h?.pin === pin ? null : h))
+                        }
                         onClick={(e) => onPinClick(e, part.id, pin)}
                       >
                         <svg width="16" height="16">
-                          {onHotNet && !on && <circle cx="8" cy="8" r="5.5" fill="var(--yellow)" fillOpacity={0.4} />}
-                          <circle
-                            cx="8"
-                            cy="8"
-                            r={on ? 3.4 : 2.6}
-                            fill={on ? 'var(--brand)' : 'var(--yellow)'}
-                            stroke={on ? 'var(--brand)' : 'var(--border-strong)'}
-                            strokeWidth="1"
-                          />
+                          {onHotNet && !on && (
+                            <circle cx="8" cy="8" r="5.5" fill="var(--yellow)" fillOpacity={0.4} />
+                          )}
+                          {showDot && (
+                            <circle
+                              cx="8"
+                              cy="8"
+                              r={on ? 3.4 : 2.6}
+                              fill={on || connected ? 'var(--brand)' : 'var(--yellow)'}
+                              stroke={on || connected ? 'var(--brand)' : 'var(--border-strong)'}
+                              strokeWidth="1"
+                            />
+                          )}
                         </svg>
                       </div>
                     )
@@ -1273,6 +1561,85 @@ export function Canvas({
             )
           })}
 
+          {/* schematic net labels (GND / power / named) */}
+          {view === 'sch' &&
+            (doc.netLabels ?? []).map((label) => {
+              const pl = dragOverrides?.get(label.id) ?? label.sch
+              const v = netLabelVisualOf(label)
+              const selected = sel.labels?.has(label.id) ?? false
+              const [px, py] = v.pins['1']
+              const armedHere = armed?.from === `${label.id}:1`
+              const hovered = hoverPin?.id === label.id && hoverPin?.pin === '1'
+              const netIdx = netModel.pinToNet.get(`${label.id}:1`)
+              const connected = netIdx !== undefined && (netModel.nets[netIdx]?.length ?? 0) >= 2
+              const on = armedHere || hovered
+              const showDot = on || !connected
+              return (
+                <div
+                  key={label.id}
+                  style={{
+                    position: 'absolute',
+                    left: pl.x,
+                    top: pl.y,
+                    width: v.w,
+                    height: v.h,
+                    zIndex: 2,
+                    transform: pl.rotate ? `rotate(${pl.rotate}deg)` : undefined,
+                    transformOrigin: 'center',
+                    outline: selected ? '2px solid var(--brand)' : 'none',
+                    outlineOffset: 3,
+                    borderRadius: 4,
+                    cursor: editable ? 'move' : 'default'
+                  }}
+                  onPointerDown={(e) => onNetLabelDown(e, label.id)}
+                  onClick={(e) => e.stopPropagation()}
+                  onDoubleClick={(e) => {
+                    e.stopPropagation()
+                    if (!editable) onRequestEdit()
+                  }}
+                >
+                  <div
+                    className="size-full [&>svg]:size-full [&>svg]:block pointer-events-none select-none"
+                    dangerouslySetInnerHTML={{ __html: v.svg }}
+                  />
+                  {editable && (
+                    <div
+                      className="pin-hit"
+                      title={label.name}
+                      style={{
+                        position: 'absolute',
+                        left: px - 8,
+                        top: py - 8,
+                        width: 16,
+                        height: 16,
+                        zIndex: 3,
+                        cursor: 'crosshair'
+                      }}
+                      onPointerDown={(e) => e.stopPropagation()}
+                      onPointerEnter={() => setHoverPin({ id: label.id, pin: '1' })}
+                      onPointerLeave={() =>
+                        setHoverPin((h) => (h?.id === label.id && h?.pin === '1' ? null : h))
+                      }
+                      onClick={(e) => onPinClick(e, label.id, '1')}
+                    >
+                      <svg width="16" height="16">
+                        {showDot && (
+                          <circle
+                            cx="8"
+                            cy="8"
+                            r={on ? 3.4 : 2.6}
+                            fill={on || connected ? 'var(--brand)' : 'var(--yellow)'}
+                            stroke={on || connected ? 'var(--brand)' : 'var(--border-strong)'}
+                            strokeWidth="1"
+                          />
+                        )}
+                      </svg>
+                    </div>
+                  )}
+                </div>
+              )
+            })}
+
           {/* hole tooltip: name + net members */}
           {hoverHole && (
             <div
@@ -1311,16 +1678,14 @@ export function Canvas({
         </div>
       </div>
 
-      {/* status hint pill (bottom-left, next to the shell's counters) */}
-      <div className="absolute bottom-3 left-3 z-10 translate-x-[210px] hidden xl:block">
-        <span
-          className={`px-2.5 py-1 rounded-full bg-surface-card border text-[11px] flex items-center gap-1 ${
-            hint.hot ? 'border-brand/40 text-brand' : 'border-border-default text-text-muted'
-          }`}
-        >
-          {hint.icon} {hint.text}
-        </span>
-      </div>
+      {/* transient action hint (only while wiring/reshaping) */}
+      {hint && (
+        <div className="absolute bottom-3 left-1/2 -translate-x-1/2 z-10 hidden xl:block">
+          <span className="px-2.5 py-1 rounded-full bg-surface-card border border-brand/40 text-brand text-[11px] flex items-center gap-1">
+            {hint.icon} {hint.text}
+          </span>
+        </div>
+      )}
     </div>
   )
 }
diff --git a/src/renderer/src/circuit/views/exportImage.ts b/src/renderer/src/circuit/views/exportImage.ts
index c55bd6b..5661e0b 100644
--- a/src/renderer/src/circuit/views/exportImage.ts
+++ b/src/renderer/src/circuit/views/exportImage.ts
@@ -1,15 +1,20 @@
 /**
- * circuit/views/exportImage — compose the bb scene into a standalone SVG and
- * download it as .svg or rasterized .png @2×. Part SVG ids are namespaced per
- * instance (fixes B6: two parts sharing `id="g"` corrupted exports).
+ * circuit/views/exportImage — compose a scene (breadboard OR schematic) into a
+ * standalone SVG and download it as .svg or rasterized .png @2×. Part SVG ids
+ * are namespaced per instance (fixes B6). Schematic wires are single ink
+ * strokes; net labels are rendered from their glyphs.
  */
 
+import { isBreadboard } from '../parts/breadboard'
+import { netLabelVisualOf } from '../parts/netLabels'
 import { escapeXml, namespaceSvgIds, prepareSvgForEmbed, svgNs } from '../parts/svg'
-import { isJunction, type CircuitDoc } from '../core/model'
-import { bbBounds, bbVisual, bbWireGeometry, makeEndResolver } from './partsAdapter'
+import { isJunction, type CircuitDoc, type ViewId } from '../core/model'
+import { makeEndResolver, viewBounds, visualFor, wireGeometry } from './partsAdapter'
 
 const WIRE_W = 2.8
 const WIRE_OUTLINE_W = WIRE_W + 1.8
+const WIRE_SCH_W = 1
+const INK = 'var(--text-strong)'
 
 function darken(hex: string, f = 0.55): string {
   const m = /^#?([0-9a-fA-F]{6})$/.exec(hex.trim())
@@ -38,67 +43,97 @@ function roundedPath(points: { x: number; y: number }[], r = 4): string {
   return d
 }
 
-/** Build the standalone scene SVG (exported for tests). */
-export function composeSceneSvg(doc: CircuitDoc, bg: string): string | null {
-  const bounds = bbBounds(doc)
+/** Embed one part/label svg at a placement, ids namespaced, rotate+flip applied. */
+function embed(
+  svg: string,
+  ns: string,
+  x: number,
+  y: number,
+  w: number,
+  h: number,
+  rotate?: number,
+  flip?: boolean
+): string {
+  const inner = prepareSvgForEmbed(namespaceSvgIds(svg, svgNs(ns))).replace(
+    '<svg',
+    `<svg x="${x}" y="${y}" width="${w}" height="${h}"`
+  )
+  const cx = x + w / 2
+  const cy = y + h / 2
+  let tf = ''
+  if (rotate) tf += `rotate(${rotate} ${cx} ${cy}) `
+  if (flip) tf += `translate(${2 * cx} 0) scale(-1 1) `
+  return tf ? `<g transform="${tf.trim()}">${inner}</g>` : `<g>${inner}</g>`
+}
+
+/** Build the standalone scene SVG for a view (exported for tests; default bb). */
+export function composeSceneSvg(doc: CircuitDoc, bg: string, view: ViewId = 'bb'): string | null {
+  const bounds = viewBounds(doc, view)
   if (!bounds) return null
+  const sch = view === 'sch'
   const pad = 36
   const minX = bounds.minX - pad
   const minY = bounds.minY - pad
-  const maxX = bounds.maxX + pad + 60 // room for labels
-  const maxY = bounds.maxY + pad + 16 // room for the watermark
+  const maxX = bounds.maxX + pad + 60
+  const maxY = bounds.maxY + pad + 48 // room for the larger watermark
   const W = Math.round(maxX - minX)
   const H = Math.round(maxY - minY)
 
-  const geom = bbWireGeometry(doc)
-  const wires = geom
+  const wires = wireGeometry(doc, view)
     .map(({ w, pts }) => {
       if (pts.length < 2) return ''
-      const core = w.color || '#2fa46a'
       const d = roundedPath(pts)
+      if (sch)
+        return `<path d="${d}" fill="none" stroke="${INK}" stroke-width="${WIRE_SCH_W}" stroke-linejoin="round" stroke-linecap="round"/>`
+      const core = w.color || '#2fa46a'
       return `<path d="${d}" fill="none" stroke="${darken(core)}" stroke-width="${WIRE_OUTLINE_W}" stroke-linejoin="round" stroke-linecap="round"/><path d="${d}" fill="none" stroke="${core}" stroke-width="${WIRE_W}" stroke-linejoin="round" stroke-linecap="round"/>`
     })
     .join('')
 
-  const resolve = makeEndResolver(doc)
+  const resolve = makeEndResolver(doc, undefined, view)
   const dots = doc.wires
-    .filter((w) => w.view === 'bb')
+    .filter((w) => w.view === view)
     .flatMap((w) =>
       [w.from, w.to].filter(isJunction).map((j) => {
         const p = resolve(j)
-        return p ? `<circle cx="${p.x}" cy="${p.y}" r="3" fill="${w.color || '#c9ced6'}"/>` : ''
+        return p
+          ? `<circle cx="${p.x}" cy="${p.y}" r="3" fill="${sch ? INK : w.color || '#c9ced6'}"/>`
+          : ''
       })
     )
     .join('')
 
   const partsSvg = doc.parts
     .map((part) => {
-      if (!part.bb) return ''
-      const vis = bbVisual(part.type)
+      const pl = part[view]
+      if (!pl) return ''
+      if (sch && isBreadboard(part.type)) return '' // breadboards are transparent in sch
+      const vis = visualFor(part.type, view)
       if (!vis) return ''
-      const { x, y } = part.bb
-      const inner = prepareSvgForEmbed(namespaceSvgIds(vis.v.svg, svgNs(part.id))).replace(
-        '<svg',
-        `<svg x="${x}" y="${y}" width="${vis.v.w}" height="${vis.v.h}"`
-      )
-      const rot = part.bb.rotate
-        ? ` transform="rotate(${part.bb.rotate} ${x + vis.v.w / 2} ${y + vis.v.h / 2})"`
-        : ''
-      const off = part.bb.labelOffset || [0, 0]
+      const g = embed(vis.v.svg, part.id, pl.x, pl.y, vis.v.w, vis.v.h, pl.rotate, sch && pl.flip)
+      const off = pl.labelOffset || [0, 0]
       const labelText = String(part.attrs?.label ?? part.id)
-      const label = `<text x="${x + off[0]}" y="${y + vis.v.h + 13 + off[1]}" fill="#969ba3" font-family="Plus Jakarta Sans, sans-serif" font-size="11">${escapeXml(labelText)}</text>`
-      return `<g${rot}>${inner}</g>${label}`
+      const label = `<text x="${pl.x + off[0]}" y="${pl.y + vis.v.h + 13 + off[1]}" fill="#969ba3" font-family="Plus Jakarta Sans, sans-serif" font-size="11">${escapeXml(labelText)}</text>`
+      return `${g}${label}`
     })
     .join('')
 
-  const watermark = `<text x="${maxX - 10}" y="${maxY - 10}" text-anchor="end" fill="#79818c" fill-opacity="0.75" font-family="Plus Jakarta Sans, sans-serif" font-size="13" font-weight="600">tinyStudio</text>`
-  return `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="${W}" height="${H}" viewBox="${minX} ${minY} ${W} ${H}"><rect x="${minX}" y="${minY}" width="${W}" height="${H}" fill="${bg}"/>${wires}${dots}${partsSvg}${watermark}</svg>`
+  const labelsSvg = sch
+    ? (doc.netLabels ?? [])
+        .map((label) => {
+          const v = netLabelVisualOf(label)
+          return embed(v.svg, label.id, label.sch.x, label.sch.y, v.w, v.h, label.sch.rotate)
+        })
+        .join('')
+    : ''
+
+  const watermark = `<text x="${maxX - 14}" y="${maxY - 16}" text-anchor="end" fill="#79818c" fill-opacity="0.4" font-family="Plus Jakarta Sans, sans-serif" font-size="46" letter-spacing="-1"><tspan font-weight="300">tiny</tspan><tspan font-weight="800">Studio</tspan></text>`
+  return `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="${W}" height="${H}" viewBox="${minX} ${minY} ${W} ${H}"><rect x="${minX}" y="${minY}" width="${W}" height="${H}" fill="${bg}"/>${wires}${dots}${partsSvg}${labelsSvg}${watermark}</svg>`
 }
 
 /**
- * Inline every var(--token) with its computed value — builtin board art uses
- * design-system variables that only resolve inside the app's stylesheet, not
- * in a standalone .svg / rasterized .png.
+ * Inline every var(--token) with its computed value — builtin art and schematic
+ * ink use design-system variables that only resolve inside the app stylesheet.
  */
 function resolveCssVars(svg: string): string {
   const cs = getComputedStyle(document.documentElement)
@@ -117,16 +152,20 @@ function download(blob: Blob, name: string): void {
   setTimeout(() => URL.revokeObjectURL(href), 1000)
 }
 
-export function exportSvg(doc: CircuitDoc): void {
-  const bg = (getComputedStyle(document.documentElement).getPropertyValue('--bg-sunken') || '#1e1f22').trim()
-  const svg = composeSceneSvg(doc, bg)
+function bgFor(view: ViewId): string {
+  const token = view === 'sch' ? '--bg' : '--bg-sunken'
+  return (getComputedStyle(document.documentElement).getPropertyValue(token) || '#1e1f22').trim()
+}
+
+export function exportSvg(doc: CircuitDoc, view: ViewId = 'bb'): void {
+  const svg = composeSceneSvg(doc, bgFor(view), view)
   if (!svg) return
-  download(new Blob([resolveCssVars(svg)], { type: 'image/svg+xml;charset=utf-8' }), 'circuit.svg')
+  const name = view === 'sch' ? 'circuit-schematic.svg' : 'circuit.svg'
+  download(new Blob([resolveCssVars(svg)], { type: 'image/svg+xml;charset=utf-8' }), name)
 }
 
-export function exportPng(doc: CircuitDoc): void {
-  const bg = (getComputedStyle(document.documentElement).getPropertyValue('--bg-sunken') || '#1e1f22').trim()
-  const raw = composeSceneSvg(doc, bg)
+export function exportPng(doc: CircuitDoc, view: ViewId = 'bb'): void {
+  const raw = composeSceneSvg(doc, bgFor(view), view)
   if (!raw) return
   const svg = resolveCssVars(raw)
   const m = /width="(\d+)" height="(\d+)"/.exec(svg)
@@ -148,7 +187,7 @@ export function exportPng(doc: CircuitDoc): void {
     ctx.drawImage(img, 0, 0)
     URL.revokeObjectURL(url)
     canvas.toBlob((png) => {
-      if (png) download(png, 'circuit.png')
+      if (png) download(png, view === 'sch' ? 'circuit-schematic.png' : 'circuit.png')
     }, 'image/png')
   }
   img.onerror = () => {
diff --git a/src/renderer/src/circuit/views/inspector/Inspector.tsx b/src/renderer/src/circuit/views/inspector/Inspector.tsx
index 096a629..ba56fe0 100644
--- a/src/renderer/src/circuit/views/inspector/Inspector.tsx
+++ b/src/renderer/src/circuit/views/inspector/Inspector.tsx
@@ -10,7 +10,15 @@ import { CircuitBoard, FlipHorizontal2, Plus, RotateCw, Spline, Trash2 } from 'l
 import React from 'react'
 import { getPart } from '../../../lib/partsLibrary'
 import * as cmd from '../../core/commands'
-import type { CircuitDoc, CircuitPart, CircuitWire, Placement, ViewId } from '../../core/model'
+import type {
+  CircuitDoc,
+  CircuitPart,
+  CircuitWire,
+  NetLabel,
+  NetLabelKind,
+  Placement,
+  ViewId
+} from '../../core/model'
 import type { NetModel } from '../../core/nets'
 import { isValidRefdes } from '../../core/refdes'
 import type { CircuitStore } from '../../core/store'
@@ -53,6 +61,10 @@ export function InspectorRail({
       ? doc.wires.find((w) => w.id === [...sel.wires][0])
       : undefined
   const multi = sel.parts.size + sel.wires.size > 1
+  const label =
+    sel.parts.size === 0 && sel.wires.size === 0 && (sel.labels?.size ?? 0) === 1
+      ? doc.netLabels?.find((l) => l.id === [...(sel.labels ?? [])][0])
+      : undefined
 
   return (
     <div className="w-64 shrink-0 min-h-0 relative z-20 border-l border-border-default bg-bg-raised flex flex-col">
@@ -61,15 +73,30 @@ export function InspectorRail({
       </div>
       <div className="flex-1 min-h-0 overflow-y-auto p-3 flex flex-col gap-3 text-xs">
         {part ? (
-          <PartInspector key={`${part.id}:${view}`} part={part} doc={doc} store={store} setSel={setSel} view={view} />
+          <PartInspector
+            key={`${part.id}:${view}`}
+            part={part}
+            doc={doc}
+            store={store}
+            setSel={setSel}
+            view={view}
+          />
         ) : wire ? (
-          <WireInspector key={wire.id} wire={wire} store={store} setSel={setSel} netModel={netModel} />
+          <WireInspector
+            key={wire.id}
+            wire={wire}
+            store={store}
+            setSel={setSel}
+            netModel={netModel}
+          />
         ) : multi ? (
           <MultiInspector sel={sel} store={store} setSel={setSel} />
+        ) : label ? (
+          <LabelInspector key={label.id} label={label} store={store} setSel={setSel} />
         ) : (
           <div className="text-text-faint text-[11px] leading-relaxed">
-            Select a component to edit its refdes, location, rotation, and properties — or a wire
-            to recolor it. Shift-click or drag a marquee for multi-select.
+            Select a component to edit its refdes, location, rotation, and properties — or a wire to
+            recolor it. Shift-click or drag a marquee for multi-select.
           </div>
         )}
       </div>
@@ -115,7 +142,12 @@ function PartInspector({
     const pl: Placement = { ...pv, x, y }
     const placements = new Map([[part.id, pl]])
     store.dispatch(
-      cmd.placePart(part.id, view, pl, reroutesFor(doc, frozen, placements, { x: x - pv.x, y: y - pv.y }, view))
+      cmd.placePart(
+        part.id,
+        view,
+        pl,
+        reroutesFor(doc, frozen, placements, { x: x - pv.x, y: y - pv.y }, view)
+      )
     )
   }
 
@@ -125,7 +157,9 @@ function PartInspector({
     const frozen = collectFrozen(doc, new Set([part.id]), view)
     const pl: Placement = { ...pv, rotate: next || undefined }
     const placements = new Map([[part.id, pl]])
-    store.dispatch(cmd.placePart(part.id, view, pl, reroutesFor(doc, frozen, placements, { x: 0, y: 0 }, view)))
+    store.dispatch(
+      cmd.placePart(part.id, view, pl, reroutesFor(doc, frozen, placements, { x: 0, y: 0 }, view))
+    )
   }
 
   const toggleFlip = (): void => {
@@ -133,7 +167,9 @@ function PartInspector({
     const frozen = collectFrozen(doc, new Set([part.id]), view)
     const pl: Placement = { ...pv, flip: pv.flip ? undefined : true }
     const placements = new Map([[part.id, pl]])
-    store.dispatch(cmd.placePart(part.id, view, pl, reroutesFor(doc, frozen, placements, { x: 0, y: 0 }, view)))
+    store.dispatch(
+      cmd.placePart(part.id, view, pl, reroutesFor(doc, frozen, placements, { x: 0, y: 0 }, view))
+    )
   }
 
   const wiresTouching = doc.wires.filter((w) =>
@@ -178,7 +214,9 @@ function PartInspector({
       {pv && (
         <>
           <div className="flex flex-col gap-1">
-            <span className={rowLabel}>Location ({view === 'bb' ? 'breadboard' : 'schematic'})</span>
+            <span className={rowLabel}>
+              Location ({view === 'bb' ? 'breadboard' : 'schematic'})
+            </span>
             <div className="flex gap-2">
               <input
                 type="number"
@@ -329,7 +367,9 @@ function WireInspector({
               style={{
                 background: c,
                 borderColor:
-                  c.toLowerCase() === color.toLowerCase() ? 'var(--brand)' : 'rgba(255,255,255,0.18)'
+                  c.toLowerCase() === color.toLowerCase()
+                    ? 'var(--brand)'
+                    : 'rgba(255,255,255,0.18)'
               }}
             />
           ))}
@@ -368,8 +408,8 @@ function MultiInspector({
         {sel.wires.size === 1 ? '' : 's'} selected
       </div>
       <div className="text-text-faint text-[11px] leading-relaxed">
-        Drag to move together · R to rotate · arrows to nudge · Ctrl+C / Ctrl+D to copy or
-        duplicate · Del to remove.
+        Drag to move together · R to rotate · arrows to nudge · Ctrl+C / Ctrl+D to copy or duplicate
+        · Del to remove.
       </div>
       <button
         className="mt-1 flex items-center justify-center gap-1.5 px-3 py-2 rounded-lg border border-border-default text-text-muted hover:text-status-error hover:border-status-error/40"
@@ -386,3 +426,75 @@ function MultiInspector({
     </>
   )
 }
+
+function LabelInspector({
+  label,
+  store,
+  setSel
+}: {
+  label: NetLabel
+  store: CircuitStore
+  setSel: (s: Selection) => void
+}): React.JSX.Element {
+  const [name, setName] = React.useState(label.name)
+  React.useEffect(() => setName(label.name), [label.id, label.name])
+
+  const commitName = (): void => {
+    const n = name.trim()
+    if (!n || n === label.name) {
+      setName(label.name)
+      return
+    }
+    store.dispatch(cmd.updateNetLabel(label.id, { name: n }))
+  }
+
+  const setKind = (kind: NetLabelKind): void => {
+    const patch = kind === 'ground' ? { kind, name: 'GND' } : { kind }
+    store.dispatch(cmd.updateNetLabel(label.id, patch))
+  }
+
+  return (
+    <div className="flex flex-col gap-3">
+      <div className="flex items-center gap-2">
+        <Spline size={14} className="text-brand" />
+        <span className="font-semibold text-text-strong">Net label</span>
+      </div>
+      <label className="flex flex-col gap-1">
+        <span className={rowLabel}>Net name</span>
+        <input
+          className={field}
+          value={name}
+          disabled={label.kind === 'ground'}
+          onChange={(e) => setName(e.target.value)}
+          onBlur={commitName}
+          onKeyDown={(e) => e.key === 'Enter' && commitName()}
+        />
+      </label>
+      <label className="flex flex-col gap-1">
+        <span className={rowLabel}>Kind</span>
+        <select
+          className={field}
+          value={label.kind}
+          onChange={(e) => setKind(e.target.value as NetLabelKind)}
+        >
+          <option value="ground">Ground (GND)</option>
+          <option value="power">Power rail</option>
+          <option value="net">Named net</option>
+        </select>
+      </label>
+      <p className="text-[11px] text-text-faint leading-relaxed">
+        Labels sharing a name join the same net — a clean way to wire power and ground without long
+        wires.
+      </p>
+      <button
+        className="mt-1 flex items-center justify-center gap-1.5 h-8 rounded-md bg-surface-card border border-border-default text-status-danger hover:border-status-danger/50"
+        onClick={() => {
+          store.dispatch(cmd.deleteNetLabel(label.id))
+          setSel({ parts: new Set(), wires: new Set(), labels: new Set() })
+        }}
+      >
+        <Trash2 size={13} /> Delete label
+      </button>
+    </div>
+  )
+}
diff --git a/src/renderer/src/circuit/views/palette/Palette.tsx b/src/renderer/src/circuit/views/palette/Palette.tsx
index fe8354a..1a5f329 100644
--- a/src/renderer/src/circuit/views/palette/Palette.tsx
+++ b/src/renderer/src/circuit/views/palette/Palette.tsx
@@ -6,10 +6,21 @@
 
 import { ChevronDown, ChevronRight, CircuitBoard, Pencil, Plus } from 'lucide-react'
 import React from 'react'
-import { partsByFamily, type PartMeta } from '../../../lib/partsLibrary'
+import { getPart, partsByFamily, type PartMeta } from '../../../lib/partsLibrary'
+import type { ViewId } from '../../core/model'
+import { NET_LABEL_KINDS, netLabelView } from '../../parts/netLabels'
+import { schematicVisual } from '../../parts/symbols'
 
 export const WIRE_COLORS = ['#2fa46a', '#e5544b', '#42a5f5', '#f3cb00', '#ffffff', '#79818c']
 
+function iconFor(meta: PartMeta, view: ViewId): string | undefined {
+  if (view === 'sch') {
+    const def = getPart(meta.type)
+    if (def) return schematicVisual(def).svg
+  }
+  return meta.icon
+}
+
 function titleCase(s: string): string {
   return s
     .toLowerCase()
@@ -37,15 +48,19 @@ function Thumb({ svg, size = 40 }: { svg?: string; size?: number }): React.JSX.E
 }
 
 export function Palette({
+  view,
   wireColor,
   onPickColor,
   onAdd,
+  onAddNetLabel,
   onEditPart,
   onNewPart
 }: {
+  view: ViewId
   wireColor: string
   onPickColor: (c: string) => void
   onAdd: (type: string) => void
+  onAddNetLabel: (kind: string, name: string) => void
   onEditPart: (type: string) => void
   onNewPart: () => void
 }): React.JSX.Element {
@@ -84,6 +99,30 @@ export function Palette({
         ))}
       </div>
       <div className="flex-1 min-h-0 overflow-y-auto p-2 flex flex-col gap-2">
+        {view === 'sch' && (
+          <div>
+            <div className="px-1 py-1 text-[11px] font-medium text-text-muted">Net Labels</div>
+            <div className="grid grid-cols-2 gap-1.5 pt-1 pb-1">
+              {NET_LABEL_KINDS.map((k) => (
+                <div
+                  key={`${k.kind}:${k.name}`}
+                  draggable
+                  onDragStart={(e) =>
+                    e.dataTransfer.setData('text/tinystudio-netlabel', `${k.kind}:${k.name}`)
+                  }
+                  onDoubleClick={() => onAddNetLabel(k.kind, k.name)}
+                  className="group relative flex flex-col items-center gap-1 p-2 rounded-lg border border-border-default bg-surface-card hover:bg-bg-sunken hover:-translate-y-px transition cursor-grab active:cursor-grabbing"
+                  title={`${k.label} — drag onto the schematic (or double-click)`}
+                >
+                  <Thumb svg={netLabelView(k.kind, k.name).svg} size={44} />
+                  <div className="text-[10px] text-text-body text-center leading-tight w-full">
+                    {k.label}
+                  </div>
+                </div>
+              ))}
+            </div>
+          </div>
+        )}
         {families.map((group) => (
           <div key={group.family}>
             <button
@@ -105,7 +144,7 @@ export function Palette({
                     className="group relative flex flex-col items-center gap-1 p-2 rounded-lg border border-border-default bg-surface-card hover:bg-bg-sunken hover:-translate-y-px transition cursor-grab active:cursor-grabbing"
                     title={`${c.label} · ${c.pins} pins — drag onto the canvas (or double-click)`}
                   >
-                    <Thumb svg={c.icon} size={44} />
+                    <Thumb svg={iconFor(c, view)} size={44} />
                     <div className="text-[10px] text-text-body text-center leading-tight line-clamp-2 w-full">
                       {c.label}
                     </div>
diff --git a/src/renderer/src/circuit/views/partsAdapter.ts b/src/renderer/src/circuit/views/partsAdapter.ts
index 63b87ea..4155683 100644
--- a/src/renderer/src/circuit/views/partsAdapter.ts
+++ b/src/renderer/src/circuit/views/partsAdapter.ts
@@ -14,6 +14,7 @@
 
 import { getPart, viewFor, type PartDef, type PartView } from '../../lib/partsLibrary'
 import { schematicVisual } from '../parts/symbols'
+import { netLabelPinWorld, netLabelVisualOf } from '../parts/netLabels'
 import { pinWorld, snapPlacementToPinGrid } from '../core/geometry'
 import {
   GRID_BB,
@@ -43,6 +44,21 @@ export interface PartVisual {
   v: PartView
 }
 
+// Fritzing part legs are baked into the breadboard art as
+// `<line id="connectorNleg" … stroke="#8C8C8C"/>` (grey). Recolor those leg
+// strokes to ink so bendable legs read as black, matching the part body.
+const legCache = new Map<string, string>()
+function blackenLegs(svg: string): string {
+  if (!svg.includes('leg"')) return svg
+  const hit = legCache.get(svg)
+  if (hit !== undefined) return hit
+  const out = svg.replace(/<line\b[^>]*\bid="connector\d+leg"[^>]*>/gi, (m) =>
+    m.replace(/stroke="#[0-9a-fA-F]{6}"/g, 'stroke="#1A1A1A"')
+  )
+  legCache.set(svg, out)
+  return out
+}
+
 /** Visual for a part type in a view, or null while its def is still loading.
  * Schematic falls back to a generated IC-box symbol (spec §5.1). */
 export function visualFor(type: string, view: ViewId): PartVisual | null {
@@ -50,7 +66,7 @@ export function visualFor(type: string, view: ViewId): PartVisual | null {
   if (!def) return null
   if (view === 'sch') return { def, v: schematicVisual(def) }
   const v = viewFor(def, 'breadboard')
-  return v ? { def, v } : null
+  return v ? { def, v: { ...v, svg: blackenLegs(v.svg) } } : null
 }
 
 /** Breadboard visual (bb-fixed callers: seats, breadboard holes, exports). */
@@ -69,8 +85,19 @@ export function firstPinLocal(type: string, view: ViewId = 'bb'): [number, numbe
  * spec §4 pin-on-grid contract; Fritzing behavior). */
 export function snapBB(type: string, placement: Placement, view: ViewId = 'bb'): Placement {
   const vis = visualFor(type, view)
-  if (!vis) return { ...placement, x: Math.round(placement.x / GRID_BB) * GRID_BB, y: Math.round(placement.y / GRID_BB) * GRID_BB }
-  const { x, y } = snapPlacementToPinGrid(placement, firstPinLocal(type, view), vis.v.w, vis.v.h, GRID_BB)
+  if (!vis)
+    return {
+      ...placement,
+      x: Math.round(placement.x / GRID_BB) * GRID_BB,
+      y: Math.round(placement.y / GRID_BB) * GRID_BB
+    }
+  const { x, y } = snapPlacementToPinGrid(
+    placement,
+    firstPinLocal(type, view),
+    vis.v.w,
+    vis.v.h,
+    GRID_BB
+  )
   return { ...placement, x, y }
 }
 
@@ -116,7 +143,12 @@ export function makeEndResolver(
     }
     const { part: partId, pin } = splitPinRef(end)
     const part = doc.parts.find((p) => p.id === partId)
-    if (!part) return null
+    if (!part) {
+      // net labels are wire-connectable in the schematic (their virtual pin is
+      // "<id>:1"); resolve to the glyph's connection point.
+      const label = view === 'sch' ? doc.netLabels?.find((l) => l.id === partId) : undefined
+      return label ? netLabelPinWorld(label, overrides?.get(partId) ?? label.sch) : null
+    }
     return pinWorldOf(part, pin, overrides?.get(partId) ?? part[view], view)
   }
   return resolve
@@ -205,10 +237,13 @@ export interface FrozenWire {
 }
 
 /** Snapshot the wires touching any of `ids` before a move begins. */
-export function collectFrozen(doc: CircuitDoc, ids: Set<string>, view: ViewId = 'bb'): FrozenWire[] {
+export function collectFrozen(
+  doc: CircuitDoc,
+  ids: Set<string>,
+  view: ViewId = 'bb'
+): FrozenWire[] {
   const resolve = makeEndResolver(doc, undefined, view)
-  const touches = (e: WireEnd): boolean =>
-    typeof e === 'string' && ids.has(splitPinRef(e).part)
+  const touches = (e: WireEnd): boolean => typeof e === 'string' && ids.has(splitPinRef(e).part)
   const out: FrozenWire[] = []
   for (const w of doc.wires) {
     if (w.view !== view) continue
@@ -238,7 +273,10 @@ export function reroutesFor(
   frozen: FrozenWire[],
   placements: Map<string, Placement>,
   delta: Pt,
-  view: ViewId = 'bb'
+  view: ViewId = 'bb',
+  /** rigid-assembly moves (board rotation): applied to both-ends-moved wires'
+   * bends instead of the delta translation. */
+  transformBoth?: (p: Pt) => Pt
 ): WireReroute[] {
   const resolve = makeEndResolver(doc, placements, view)
   const wireById = new Map(doc.wires.map((w) => [w.id, w]))
@@ -249,17 +287,29 @@ export function reroutesFor(
     const s = resolve(w.from)
     const t = resolve(w.to)
     if (!s || !t) continue
-    const bends = f.both ? f.bends.map((b) => ({ x: b.x + delta.x, y: b.y + delta.y })) : f.bends
-    out.push({ wireId: f.id, route: journeyFromPoints(buildWirePoints(s, bends, t, f.straight), f.straight) })
+    const bends = f.both
+      ? f.bends.map((b) =>
+          transformBoth ? transformBoth(b) : { x: b.x + delta.x, y: b.y + delta.y }
+        )
+      : f.bends
+    out.push({
+      wireId: f.id,
+      route: journeyFromPoints(buildWirePoints(s, bends, t, f.straight), f.straight)
+    })
   }
   return out
 }
 
 /** bb-fixed aliases (exportImage & friends). */
-export function bbWireGeometry(doc: CircuitDoc, overrides?: Map<string, Placement>): ResolvedWire[] {
+export function bbWireGeometry(
+  doc: CircuitDoc,
+  overrides?: Map<string, Placement>
+): ResolvedWire[] {
   return wireGeometry(doc, 'bb', overrides)
 }
-export function bbBounds(doc: CircuitDoc): { minX: number; minY: number; maxX: number; maxY: number } | null {
+export function bbBounds(
+  doc: CircuitDoc
+): { minX: number; minY: number; maxX: number; maxY: number } | null {
   return viewBounds(doc, 'bb')
 }
 
@@ -414,3 +464,143 @@ export function ratsnest(doc: CircuitDoc, view: ViewId, global: NetModel): Ratsn
   })
   return out
 }
+
+// ── ERC (view-side floating-pin check; merged with core/erc net rules) ────────
+
+import type { ErcIssue } from '../core/erc'
+
+/**
+ * Info-level floating-pin findings that need pin geometry (hence view-side).
+ * Only parts that are PARTIALLY connected are reported — a fully-unwired part
+ * is just not placed yet and would only add noise.
+ */
+export function ercFloatingPins(doc: CircuitDoc, net: NetModel, view: ViewId): ErcIssue[] {
+  const out: ErcIssue[] = []
+  for (const part of doc.parts) {
+    const pl = part[view]
+    if (!pl || isBreadboard(part.type)) continue
+    const vis = visualFor(part.type, view)
+    if (!vis) continue
+    const floating: string[] = []
+    let connected = 0
+    for (const pin of Object.keys(vis.v.pins)) {
+      const idx = net.pinToNet.get(`${part.id}:${pin}`)
+      if (idx !== undefined && net.nets[idx].length >= 2) connected++
+      else floating.push(pin)
+    }
+    if (connected === 0) continue
+    for (const pin of floating) {
+      out.push({
+        id: `float:${part.id}:${pin}`,
+        severity: 'info',
+        message: `${part.id}.${pin} is unconnected.`,
+        ref: { part: part.id, pin }
+      })
+    }
+  }
+  return out
+}
+
+// ── collision-avoidance placement (parity with the pre-rewrite editor) ────────
+
+interface Box {
+  x: number
+  y: number
+  w: number
+  h: number
+}
+
+function overlaps(a: Box, b: Box, gap = 0): boolean {
+  return (
+    a.x < b.x + b.w + gap && a.x + a.w + gap > b.x && a.y < b.y + b.h + gap && a.y + a.h + gap > b.y
+  )
+}
+
+/** AABBs of everything already on the canvas in this view: parts, net labels,
+ * and thin boxes along wire segments (so drops don't land on top of wires). */
+export function occupiedBoxes(doc: CircuitDoc, view: ViewId, exclude?: Set<string>): Box[] {
+  const out: Box[] = []
+  for (const part of doc.parts) {
+    if (exclude?.has(part.id)) continue
+    const pl = part[view]
+    if (!pl) continue
+    const vis = visualFor(part.type, view)
+    if (!vis) continue
+    out.push({ x: pl.x, y: pl.y, w: vis.v.w, h: vis.v.h })
+  }
+  if (view === 'sch') {
+    for (const l of doc.netLabels ?? []) {
+      if (exclude?.has(l.id)) continue
+      const v = netLabelVisualOf(l)
+      out.push({ x: l.sch.x, y: l.sch.y, w: v.w, h: v.h })
+    }
+  }
+  for (const { pts } of wireGeometry(doc, view)) {
+    for (let i = 0; i < pts.length - 1; i++) {
+      const a = pts[i]
+      const b = pts[i + 1]
+      const x = Math.min(a.x, b.x)
+      const y = Math.min(a.y, b.y)
+      out.push({ x, y, w: Math.abs(a.x - b.x) || 1, h: Math.abs(a.y - b.y) || 1 })
+    }
+  }
+  return out
+}
+
+/** Grid-snapped placement for a new `type` near `preferred` that clears the
+ * existing scene. Spirals outward on the major grid until a free slot is found. */
+export function findFreePlacement(
+  doc: CircuitDoc,
+  type: string,
+  view: ViewId,
+  preferred: Pt,
+  exclude?: Set<string>
+): Placement {
+  const vis = visualFor(type, view)
+  const w = vis?.v.w ?? 80
+  const h = vis?.v.h ?? 40
+  const boxes = occupiedBoxes(doc, view, exclude)
+  const base = snapBB(
+    type,
+    { x: Math.round(preferred.x - w / 2), y: Math.round(preferred.y - h / 2) },
+    view
+  )
+  const step = Math.max(GRID_BB, Math.ceil(Math.max(w, h) / GRID_BB / 2) * GRID_BB)
+  const gap = GRID_BB
+  for (let ring = 0; ring < 60; ring++) {
+    for (let dx = -ring; dx <= ring; dx++) {
+      for (let dy = -ring; dy <= ring; dy++) {
+        if (ring > 0 && Math.max(Math.abs(dx), Math.abs(dy)) !== ring) continue
+        const cand = { x: base.x + dx * step, y: base.y + dy * step }
+        const box = { x: cand.x, y: cand.y, w, h }
+        if (!boxes.some((b) => overlaps(box, b, gap))) return { ...base, x: cand.x, y: cand.y }
+      }
+    }
+  }
+  return base
+}
+
+/** A paste offset (applied to every pasted placement) that clears the scene. */
+export function freePasteOffset(
+  doc: CircuitDoc,
+  parts: { type: string; bb?: Placement; sch?: Placement }[],
+  view: ViewId,
+  step = GRID_BB * 2
+): Pt {
+  const boxes = occupiedBoxes(doc, view)
+  const items: Box[] = []
+  for (const p of parts) {
+    const pl = p[view]
+    if (!pl) continue
+    const vis = visualFor(p.type, view)
+    if (!vis) continue
+    items.push({ x: pl.x, y: pl.y, w: vis.v.w, h: vis.v.h })
+  }
+  if (!items.length) return { x: step, y: step }
+  for (let k = 1; k <= 60; k++) {
+    const off = { x: step * k, y: step * k }
+    const moved = items.map((b) => ({ x: b.x + off.x, y: b.y + off.y, w: b.w, h: b.h }))
+    if (!moved.some((m) => boxes.some((b) => overlaps(m, b, GRID_BB)))) return off
+  }
+  return { x: step, y: step }
+}
diff --git a/src/renderer/src/components/EditorPanel.tsx b/src/renderer/src/components/EditorPanel.tsx
index b6d058a..36016d1 100644
--- a/src/renderer/src/components/EditorPanel.tsx
+++ b/src/renderer/src/components/EditorPanel.tsx
@@ -389,8 +389,9 @@ function CircuitV1View(): React.JSX.Element {
         dispatch(setEditorView('code'))
       }}
       onEditChange={(editing) => {
-        // entering edit mode: free horizontal space by closing the docs panel
-        if (editing) dispatch(setPanelOpen({ panel: 'docs', isOpen: false }))
+        // entering edit mode frees horizontal space by closing the docs panel;
+        // returning to view mode reopens it.
+        dispatch(setPanelOpen({ panel: 'docs', isOpen: !editing }))
       }}
     />
   )
@@ -458,7 +459,7 @@ function CircuitV2Inner(): React.JSX.Element {
         dispatch(setEditorView('code'))
       }}
       onEditChange={(editing) => {
-        if (editing) dispatch(setPanelOpen({ panel: 'docs', isOpen: false }))
+        dispatch(setPanelOpen({ panel: 'docs', isOpen: !editing }))
       }}
     />
   )
diff --git a/src/renderer/src/components/PartsEditor.tsx b/src/renderer/src/components/PartsEditor.tsx
index d37f699..c51776c 100644
--- a/src/renderer/src/components/PartsEditor.tsx
+++ b/src/renderer/src/components/PartsEditor.tsx
@@ -5,13 +5,17 @@
  * in the same schema as Fritzing-imported parts (pixel coords @ 96 DPI), so a
  * hand-made part wires up exactly like an imported one.
  *
+ * Both the breadboard and schematic views are editable via the view toggle —
+ * each keeps its own art, size, and pin positions (pin NAMES are the cross-view
+ * join key, so keep them consistent between views).
+ *
  * Styled with the tinyStudio design system: cold neutral surfaces, soft-elevation
  * floating dialog, dot-grid preview, brand-blue accents, sentence-case copy.
  */
 
 import { Plus, Trash2, UploadCloud, X } from 'lucide-react'
 import React from 'react'
-import type { PartDef } from '../lib/partsLibrary'
+import type { PartDef, PartView, ViewKind } from '../lib/partsLibrary'
 
 const PX_PER_MM = 96 / 25.4
 
@@ -27,9 +31,26 @@ interface Pin {
   y: number
 }
 
+interface ViewBuf {
+  svg: string
+  w: number
+  h: number
+  pins: Pin[]
+}
+
 const blankSvg = (w: number, h: number): string =>
   `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${w} ${h}"><rect x="0.5" y="0.5" width="${w - 1}" height="${h - 1}" rx="4" fill="#383A40" stroke="#4A4D54"/></svg>`
 
+const seedView = (v: PartView | undefined, fallbackW = 80, fallbackH = 40): ViewBuf =>
+  v
+    ? {
+        svg: v.svg,
+        w: v.w,
+        h: v.h,
+        pins: Object.entries(v.pins).map(([n, [x, y]]) => ({ name: n, x, y }))
+      }
+    : { svg: blankSvg(fallbackW, fallbackH), w: fallbackW, h: fallbackH, pins: [] }
+
 export function PartsEditor({
   initial,
   onClose,
@@ -39,21 +60,27 @@ export function PartsEditor({
   onClose: () => void
   onSave: (def: PartDef) => void
 }): React.JSX.Element {
-  // when editing an existing part, seed from its (breadboard) view
-  const seed =
-    initial &&
-    (initial.views.breadboard || initial.views.schematic || Object.values(initial.views)[0])
   const [name, setName] = React.useState(initial?.label || 'My Part')
-  const [w, setW] = React.useState(seed?.w || 80)
-  const [h, setH] = React.useState(seed?.h || 40)
-  const [svg, setSvg] = React.useState(seed?.svg || blankSvg(80, 40))
-  const [pins, setPins] = React.useState<Pin[]>(
-    seed ? Object.entries(seed.pins).map(([n, [x, y]]) => ({ name: n, x, y })) : []
-  )
+  const [bb, setBb] = React.useState<ViewBuf>(() => seedView(initial?.views.breadboard))
+  const [sch, setSch] = React.useState<ViewBuf>(() => seedView(initial?.views.schematic))
+  const [editView, setEditView] = React.useState<ViewKind>('breadboard')
   const [sel, setSel] = React.useState<number>(-1)
   const surfaceRef = React.useRef<HTMLDivElement>(null)
   const dragRef = React.useRef<number>(-1)
 
+  const buf = editView === 'breadboard' ? bb : sch
+  const setBuf = editView === 'breadboard' ? setBb : setSch
+  const { svg, w, h, pins } = buf
+
+  const patch = (p: Partial<ViewBuf>): void => setBuf((b) => ({ ...b, ...p }))
+  const setPins = (fn: (ps: Pin[]) => Pin[]): void => setBuf((b) => ({ ...b, pins: fn(b.pins) }))
+
+  const switchView = (v: ViewKind): void => {
+    if (v === editView) return
+    setEditView(v)
+    setSel(-1)
+  }
+
   // fit the part into the preview area (cap zoom so tiny parts stay visible)
   const scale = Math.min(440 / w, 320 / h, 14)
 
@@ -131,15 +158,14 @@ export function PartsEditor({
         nw = nw ?? vb[2]
         nh = nh ?? vb[3]
       }
-      if (nw && nh) {
-        setW(Math.round(nw))
-        setH(Math.round(nh))
-      }
+      if (!el.getAttribute('xmlns')) el.setAttribute('xmlns', 'http://www.w3.org/2000/svg')
       el.removeAttribute('width')
       el.removeAttribute('height')
-      if (!el.getAttribute('xmlns')) el.setAttribute('xmlns', 'http://www.w3.org/2000/svg')
       if (!el.getAttribute('viewBox') && nw && nh) el.setAttribute('viewBox', `0 0 ${nw} ${nh}`)
-      setSvg(el.outerHTML)
+      patch({
+        svg: el.outerHTML,
+        ...(nw && nh ? { w: Math.round(nw), h: Math.round(nh) } : {})
+      })
     }
     reader.readAsText(file)
   }
@@ -169,22 +195,36 @@ export function PartsEditor({
     }
     window.addEventListener('keydown', onKey)
     return () => window.removeEventListener('keydown', onKey)
-  }, [sel, w, h])
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [sel, w, h, editView])
 
-  const save = (): void => {
-    const pinMap: Record<string, [number, number]> = {}
-    pins.forEach((p) => {
-      pinMap[p.name] = [p.x, p.y]
+  const toMap = (ps: Pin[]): Record<string, [number, number]> => {
+    const m: Record<string, [number, number]> = {}
+    ps.forEach((p) => {
+      m[p.name] = [p.x, p.y]
     })
+    return m
+  }
+
+  const canSave = bb.pins.length > 0 || sch.pins.length > 0
+
+  const save = (): void => {
+    const views: Partial<Record<ViewKind, PartView>> = {}
+    if (bb.pins.length || initial?.views.breadboard)
+      views.breadboard = { svg: bb.svg, w: bb.w, h: bb.h, pins: toMap(bb.pins) }
+    if (sch.pins.length || initial?.views.schematic)
+      views.schematic = { svg: sch.svg, w: sch.w, h: sch.h, pins: toMap(sch.pins) }
+    if (!views.breadboard && !views.schematic)
+      views.breadboard = { svg: bb.svg, w: bb.w, h: bb.h, pins: toMap(bb.pins) }
     onSave({
       // editing keeps the original identity so it updates in place (not a copy)
       type: initial ? initial.type : slug(name),
       label: name,
       family: initial?.family || 'Custom',
       builtin: initial?.builtin,
-      // regenerate the palette icon from the current art so the thumbnail updates
-      icon: svg,
-      views: { breadboard: { svg, w, h, pins: pinMap } }
+      // palette icon prefers the breadboard art, falls back to schematic
+      icon: bb.pins.length ? bb.svg : sch.svg,
+      views
     })
   }
 
@@ -209,7 +249,29 @@ export function PartsEditor({
             {initial ? `editing “${initial.label}”` : 'author a custom part'}
           </span>
           <div className="flex-1" />
-          <button className="text-text-muted hover:text-text-strong" onClick={onClose}>
+          {/* view toggle: edit breadboard art or schematic symbol */}
+          <div className="flex rounded-md overflow-hidden border border-border-default">
+            {(
+              [
+                ['breadboard', 'Breadboard'],
+                ['schematic', 'Schematic']
+              ] as [ViewKind, string][]
+            ).map(([v, label]) => (
+              <button
+                key={v}
+                className={`h-7 px-2.5 text-xs font-medium ${
+                  editView === v
+                    ? 'bg-brand/15 text-brand'
+                    : 'bg-surface-card text-text-muted hover:text-text-body'
+                }`}
+                onClick={() => switchView(v)}
+              >
+                {label}
+                {(v === 'breadboard' ? bb.pins.length : sch.pins.length) > 0 ? ' •' : ''}
+              </button>
+            ))}
+          </div>
+          <button className="text-text-muted hover:text-text-strong ml-1" onClick={onClose}>
             <X size={18} />
           </button>
         </div>
@@ -270,6 +332,9 @@ export function PartsEditor({
                   onChange={(e) => setName(e.target.value)}
                 />
               </label>
+              <div className="text-[11px] text-text-faint -mt-1">
+                Editing the <span className="text-text-muted">{editView}</span> view.
+              </div>
               <div className="flex gap-3">
                 <label className="flex flex-col gap-1">
                   <span className="text-[11px] text-text-muted">Width (px)</span>
@@ -279,8 +344,12 @@ export function PartsEditor({
                     value={w}
                     onChange={(e) => {
                       const nv = Math.max(1, parseInt(e.target.value, 10) || 1)
-                      setW(nv)
-                      if (svg.startsWith('<svg') && svg.includes('rx="4"')) setSvg(blankSvg(nv, h))
+                      patch({
+                        w: nv,
+                        ...(svg.startsWith('<svg') && svg.includes('rx="4"')
+                          ? { svg: blankSvg(nv, h) }
+                          : {})
+                      })
                     }}
                   />
                 </label>
@@ -292,8 +361,12 @@ export function PartsEditor({
                     value={h}
                     onChange={(e) => {
                       const nv = Math.max(1, parseInt(e.target.value, 10) || 1)
-                      setH(nv)
-                      if (svg.startsWith('<svg') && svg.includes('rx="4"')) setSvg(blankSvg(w, nv))
+                      patch({
+                        h: nv,
+                        ...(svg.startsWith('<svg') && svg.includes('rx="4"')
+                          ? { svg: blankSvg(w, nv) }
+                          : {})
+                      })
                     }}
                   />
                 </label>
@@ -366,7 +439,7 @@ export function PartsEditor({
                 ))}
                 {pins.length === 0 && (
                   <div className="text-[11px] text-text-faint py-2">
-                    Click the preview to drop pins.
+                    Click the preview to drop pins for the {editView} view.
                   </div>
                 )}
               </div>
@@ -381,7 +454,7 @@ export function PartsEditor({
               </button>
               <button
                 className="flex-1 px-3 py-2 rounded-lg bg-brand border border-brand text-sm text-brand-contrast font-medium hover:brightness-105 disabled:opacity-40"
-                disabled={pins.length === 0}
+                disabled={!canSave}
                 onClick={save}
               >
                 Save to library
diff --git a/src/renderer/src/components/Toolbar.tsx b/src/renderer/src/components/Toolbar.tsx
index de1cab0..d93ea01 100644
--- a/src/renderer/src/components/Toolbar.tsx
+++ b/src/renderer/src/components/Toolbar.tsx
@@ -54,7 +54,10 @@ export function Toolbar(): React.JSX.Element {
         </Tooltip>
       </div>
 
-      <span className="w-[1.5px] h-[26px] bg-[var(--border-default)] mx-0.5 shrink-0" />
+      <span
+        data-toolbar-divider
+        className="w-[1.5px] h-[26px] bg-[var(--border-default)] mx-0.5 shrink-0"
+      />
 
       <div className="flex items-center gap-2">
         <BoardManager />
diff --git a/src/renderer/src/components/ui/Resizable.tsx b/src/renderer/src/components/ui/Resizable.tsx
index 7cf7857..4c9db54 100644
--- a/src/renderer/src/components/ui/Resizable.tsx
+++ b/src/renderer/src/components/ui/Resizable.tsx
@@ -4,6 +4,7 @@
 import * as React from 'react'
 import { GripVerticalIcon } from 'lucide-react'
 import * as ResizablePrimitive from 'react-resizable-panels'
+import type { ImperativePanelHandle } from 'react-resizable-panels'
 import { cn } from '@renderer/lib/utils'
 
 function ResizablePanelGroup({
@@ -19,9 +20,12 @@ function ResizablePanelGroup({
   )
 }
 
-function ResizablePanel({ ...props }: React.ComponentProps<typeof ResizablePrimitive.Panel>) {
-  return <ResizablePrimitive.Panel data-slot="resizable-panel" {...props} />
-}
+const ResizablePanel = React.forwardRef<
+  ImperativePanelHandle,
+  React.ComponentProps<typeof ResizablePrimitive.Panel>
+>(function ResizablePanel(props, ref) {
+  return <ResizablePrimitive.Panel ref={ref} data-slot="resizable-panel" {...props} />
+})
 
 function ResizableHandle({
   withHandle,

From 7b98564064b297a4b7f77668e1ee03bea02e8445 Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Sat, 11 Jul 2026 12:16:31 -0600
Subject: [PATCH 10/27] Circuit v2: marquee selects net labels; Inspector board
 rotate is rigid; net-label rotation (R key + inspector)

---
 .../src/circuit/views/canvas/Canvas.tsx       | 63 ++++++--------
 .../src/circuit/views/inspector/Inspector.tsx | 62 +++++++++++++-
 .../src/circuit/views/partsAdapter.ts         | 84 ++++++++++++++++++-
 3 files changed, 167 insertions(+), 42 deletions(-)

diff --git a/src/renderer/src/circuit/views/canvas/Canvas.tsx b/src/renderer/src/circuit/views/canvas/Canvas.tsx
index 7483969..d7693b7 100644
--- a/src/renderer/src/circuit/views/canvas/Canvas.tsx
+++ b/src/renderer/src/circuit/views/canvas/Canvas.tsx
@@ -50,6 +50,8 @@ import {
   makeEndResolver,
   pinAtWorld,
   reroutesFor,
+  rotateBoardAssemblyCmd,
+  rotateNetLabelCmd,
   seatedPartsOn,
   snapBB,
   viewBounds,
@@ -796,7 +798,15 @@ export function Canvas({
         for (const g of wireGeom) {
           if (g.pts.some((p) => p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1)) wires.add(g.w.id)
         }
-        setSel({ parts, wires })
+        const labels = new Set(additive ? (sel.labels ?? []) : [])
+        if (view === 'sch') {
+          for (const label of doc.netLabels ?? []) {
+            const pl = label.sch
+            const v = netLabelVisualOf(label)
+            if (pl.x < x1 && pl.x + v.w > x0 && pl.y < y1 && pl.y + v.h > y0) labels.add(label.id)
+          }
+        }
+        setSel({ parts, wires, labels })
       }
       window.addEventListener('pointermove', move)
       window.addEventListener('pointerup', up)
@@ -831,49 +841,26 @@ export function Canvas({
    */
   const rotateBoardAssembly = React.useCallback(
     (boardId: string): void => {
-      const board = doc.parts.find((p) => p.id === boardId)
-      const bpl = board?.bb
-      const bvis = board && visualFor(board.type, 'bb')
-      if (!board || !bpl || !bvis) return
-      const c = { x: bpl.x + bvis.v.w / 2, y: bpl.y + bvis.v.h / 2 }
-      // 90 deg CW about c, matching transformLocalPoint's rotation sense.
-      const rot90 = (p: Pt): Pt => ({ x: c.x - (p.y - c.y), y: c.y + (p.x - c.x) })
-      const ids = [boardId, ...seatedPartsOn(boardId, seats)]
-      const placements = new Map<string, Placement>()
-      for (const id of ids) {
-        const part = doc.parts.find((p) => p.id === id)
-        const cur = part?.bb
-        const vis = part && visualFor(part.type, 'bb')
-        if (!part || !cur || !vis) continue
-        const nr = (((((cur.rotate ?? 0) + 90) % 360) + 360) % 360) as 0 | 90 | 180 | 270
-        if (id === boardId) {
-          placements.set(id, { ...cur, rotate: nr || undefined })
-        } else {
-          const nc = rot90({ x: cur.x + vis.v.w / 2, y: cur.y + vis.v.h / 2 })
-          placements.set(id, {
-            ...cur,
-            x: nc.x - vis.v.w / 2,
-            y: nc.y - vis.v.h / 2,
-            rotate: nr || undefined
-          })
-        }
-      }
-      const frozen = collectFrozen(doc, new Set(ids), 'bb')
-      const reroutes = reroutesFor(doc, frozen, placements, { x: 0, y: 0 }, 'bb', rot90)
-      let first = true
-      const cmds: cmd.Command[] = []
-      for (const [id, pl] of placements) {
-        cmds.push(cmd.placePart(id, 'bb', pl, first ? reroutes : []))
-        first = false
-      }
-      if (cmds.length) store.dispatch(cmd.composite(`Rotate ${boardId}`, cmds))
+      const c = rotateBoardAssemblyCmd(doc, boardId, seats)
+      if (c) store.dispatch(c)
     },
     [doc, store, seats]
   )
 
   const rotateSelection = React.useCallback((): void => {
     const ids = [...sel.parts]
-    if (!ids.length) return
+    if (!ids.length) {
+      // schematic: R rotates selected net labels (90° steps, wires reroute)
+      if (view !== 'sch') return
+      const cmds: cmd.Command[] = []
+      for (const id of sel.labels ?? []) {
+        const c = rotateNetLabelCmd(doc, id)
+        if (c) cmds.push(c)
+      }
+      if (cmds.length)
+        store.dispatch(cmds.length === 1 ? cmds[0] : cmd.composite('Rotate labels', cmds))
+      return
+    }
     // a lone breadboard rotates as a rigid assembly (carries seated parts + wires)
     if (
       view === 'bb' &&
diff --git a/src/renderer/src/circuit/views/inspector/Inspector.tsx b/src/renderer/src/circuit/views/inspector/Inspector.tsx
index ba56fe0..ad3bd84 100644
--- a/src/renderer/src/circuit/views/inspector/Inspector.tsx
+++ b/src/renderer/src/circuit/views/inspector/Inspector.tsx
@@ -22,7 +22,14 @@ import type {
 import type { NetModel } from '../../core/nets'
 import { isValidRefdes } from '../../core/refdes'
 import type { CircuitStore } from '../../core/store'
-import { collectFrozen, reroutesFor } from '../partsAdapter'
+import { isBreadboard } from '../../parts/breadboard'
+import {
+  collectFrozen,
+  implicitSeats,
+  reroutesFor,
+  rotateBoardAssemblyCmd,
+  rotateNetLabelCmd
+} from '../partsAdapter'
 import { WIRE_COLORS } from '../palette/Palette'
 import type { Selection } from '../canvas/Canvas'
 
@@ -92,7 +99,7 @@ export function InspectorRail({
         ) : multi ? (
           <MultiInspector sel={sel} store={store} setSel={setSel} />
         ) : label ? (
-          <LabelInspector key={label.id} label={label} store={store} setSel={setSel} />
+          <LabelInspector key={label.id} label={label} doc={doc} store={store} setSel={setSel} />
         ) : (
           <div className="text-text-faint text-[11px] leading-relaxed">
             Select a component to edit its refdes, location, rotation, and properties — or a wire to
@@ -154,6 +161,14 @@ function PartInspector({
   const setRotation = (deg: number): void => {
     if (!pv) return
     const next = (((deg % 360) + 360) % 360) as 0 | 90 | 180 | 270
+    // Breadboards rotate as a rigid assembly (board + seated parts + wires
+    // between them) — same path as the canvas R / right-click gesture.
+    if (view === 'bb' && isBreadboard(part.type)) {
+      const steps = ((next - (pv.rotate ?? 0)) / 90 + 4) % 4
+      const c = rotateBoardAssemblyCmd(doc, part.id, implicitSeats(doc), steps)
+      if (c) store.dispatch(c)
+      return
+    }
     const frozen = collectFrozen(doc, new Set([part.id]), view)
     const pl: Placement = { ...pv, rotate: next || undefined }
     const placements = new Map([[part.id, pl]])
@@ -429,10 +444,12 @@ function MultiInspector({
 
 function LabelInspector({
   label,
+  doc,
   store,
   setSel
 }: {
   label: NetLabel
+  doc: CircuitDoc
   store: CircuitStore
   setSel: (s: Selection) => void
 }): React.JSX.Element {
@@ -482,6 +499,47 @@ function LabelInspector({
           <option value="net">Named net</option>
         </select>
       </label>
+      <label className="flex flex-col gap-1">
+        <span className={rowLabel}>Rotation</span>
+        <div className="flex items-center gap-1.5">
+          <select
+            className={field}
+            value={label.sch.rotate || 0}
+            onChange={(e) => {
+              const target = Number(e.target.value)
+              let c: ReturnType<typeof rotateNetLabelCmd> = null
+              let d = doc
+              // rotateNetLabelCmd is a single 90° step; compose to reach target
+              const steps = (((target - (label.sch.rotate || 0)) / 90 + 4) % 4 + 4) % 4
+              const cmds: cmd.Command[] = []
+              for (let i = 0; i < steps; i++) {
+                c = rotateNetLabelCmd(d, label.id)
+                if (!c) break
+                cmds.push(c)
+                d = c.apply(d)
+              }
+              if (cmds.length)
+                store.dispatch(cmds.length === 1 ? cmds[0] : cmd.composite('Rotate label', cmds))
+            }}
+          >
+            {[0, 90, 180, 270].map((r) => (
+              <option key={r} value={r}>
+                {r}°
+              </option>
+            ))}
+          </select>
+          <button
+            className="h-[26px] px-2 rounded border border-border-default bg-surface-card text-text-body hover:border-brand"
+            title="Rotate 90°"
+            onClick={() => {
+              const c = rotateNetLabelCmd(doc, label.id)
+              if (c) store.dispatch(c)
+            }}
+          >
+            <RotateCw size={13} />
+          </button>
+        </div>
+      </label>
       <p className="text-[11px] text-text-faint leading-relaxed">
         Labels sharing a name join the same net — a clean way to wire power and ground without long
         wires.
diff --git a/src/renderer/src/circuit/views/partsAdapter.ts b/src/renderer/src/circuit/views/partsAdapter.ts
index 4155683..0544b2b 100644
--- a/src/renderer/src/circuit/views/partsAdapter.ts
+++ b/src/renderer/src/circuit/views/partsAdapter.ts
@@ -14,7 +14,7 @@
 
 import { getPart, viewFor, type PartDef, type PartView } from '../../lib/partsLibrary'
 import { schematicVisual } from '../parts/symbols'
-import { netLabelPinWorld, netLabelVisualOf } from '../parts/netLabels'
+import { netLabelPinWorld, netLabelVisualOf, snapNetLabel } from '../parts/netLabels'
 import { pinWorld, snapPlacementToPinGrid } from '../core/geometry'
 import {
   GRID_BB,
@@ -37,7 +37,13 @@ import {
   pointAtT,
   wirePoints
 } from '../core/routing'
-import type { WireReroute } from '../core/commands'
+import {
+  composite,
+  moveNetLabel,
+  placePart,
+  type Command,
+  type WireReroute
+} from '../core/commands'
 
 export interface PartVisual {
   def: PartDef
@@ -604,3 +610,77 @@ export function freePasteOffset(
   }
   return { x: step, y: step }
 }
+
+// ── rigid rotations (shared by Canvas gestures and the Inspector) ────────────
+
+/**
+ * Rigid 90°-step rotation of a breadboard assembly (bb view): the board, its
+ * seated parts, and the wires *between* seated parts all turn about the
+ * board's centre, so the layout is preserved instead of the wires rerouting.
+ * Grid-aligned seating means holes map to holes, so pins re-seat exactly.
+ * Returns one undoable composite Command, or null if the board is unknown.
+ */
+export function rotateBoardAssemblyCmd(
+  doc: CircuitDoc,
+  boardId: string,
+  seats: Seat[],
+  steps = 1
+): Command | null {
+  const n = ((steps % 4) + 4) % 4
+  if (!n) return null
+  const board = doc.parts.find((p) => p.id === boardId)
+  const bpl = board?.bb
+  const bvis = board && visualFor(board.type, 'bb')
+  if (!board || !bpl || !bvis) return null
+  const c = { x: bpl.x + bvis.v.w / 2, y: bpl.y + bvis.v.h / 2 }
+  // 90° CW about c (matching transformLocalPoint's rotation sense), n times.
+  const rot90 = (p: Pt): Pt => ({ x: c.x - (p.y - c.y), y: c.y + (p.x - c.x) })
+  const rot = (p: Pt): Pt => {
+    let q = p
+    for (let i = 0; i < n; i++) q = rot90(q)
+    return q
+  }
+  const ids = [boardId, ...seatedPartsOn(boardId, seats)]
+  const placements = new Map<string, Placement>()
+  for (const id of ids) {
+    const part = doc.parts.find((p) => p.id === id)
+    const cur = part?.bb
+    const vis = part && visualFor(part.type, 'bb')
+    if (!part || !cur || !vis) continue
+    const nr = ((((cur.rotate ?? 0) + 90 * n) % 360) + 360) % 360
+    const rotate = (nr || undefined) as Placement['rotate']
+    if (id === boardId) {
+      placements.set(id, { ...cur, rotate })
+    } else {
+      const nc = rot({ x: cur.x + vis.v.w / 2, y: cur.y + vis.v.h / 2 })
+      placements.set(id, { ...cur, x: nc.x - vis.v.w / 2, y: nc.y - vis.v.h / 2, rotate })
+    }
+  }
+  const frozen = collectFrozen(doc, new Set(ids), 'bb')
+  const reroutes = reroutesFor(doc, frozen, placements, { x: 0, y: 0 }, 'bb', rot)
+  const cmds: Command[] = []
+  let first = true
+  for (const [id, pl] of placements) {
+    cmds.push(placePart(id, 'bb', pl, first ? reroutes : []))
+    first = false
+  }
+  return cmds.length ? composite(`Rotate ${boardId}`, cmds) : null
+}
+
+/**
+ * Rotate a schematic net label 90° about its centre, snapping its pin back to
+ * the major grid and rerouting attached wires (frozen bends). Returns an
+ * undoable Command, or null if the label is unknown.
+ */
+export function rotateNetLabelCmd(doc: CircuitDoc, labelId: string): Command | null {
+  const label = doc.netLabels?.find((l) => l.id === labelId)
+  if (!label) return null
+  const nr = ((((label.sch.rotate ?? 0) + 90) % 360) + 360) % 360
+  const snapped = snapNetLabel(label.kind, label.name, {
+    ...label.sch,
+    rotate: (nr || undefined) as Placement['rotate']
+  })
+  const frozen = collectFrozen(doc, new Set([labelId]), 'sch')
+  const reroutes = reroutesFor(doc, frozen, new Map([[labelId, snapped]]), { x: 0, y: 0 }, 'sch')
+  return moveNetLabel(labelId, snapped, reroutes)
+}

From fba3c8207d7c853c275e4946a0d372563d2f1ef8 Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Sat, 11 Jul 2026 16:36:30 -0600
Subject: [PATCH 11/27] =?UTF-8?q?Circuit=20v2=20M2:=20Part=20Editor=20pers?=
 =?UTF-8?q?istence=20(B7)=20=E2=80=94=20user=20parts=20persist=20via=20Ind?=
 =?UTF-8?q?exedDB,=20restored=20on=20mount?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../src/circuit/views/CircuitView.tsx         |  13 +-
 src/renderer/src/components/DiagramEditor.tsx |  11 +-
 src/renderer/src/lib/userParts.ts             | 162 ++++++++++++++++++
 3 files changed, 178 insertions(+), 8 deletions(-)
 create mode 100644 src/renderer/src/lib/userParts.ts

diff --git a/src/renderer/src/circuit/views/CircuitView.tsx b/src/renderer/src/circuit/views/CircuitView.tsx
index b66ddf8..f624225 100644
--- a/src/renderer/src/circuit/views/CircuitView.tsx
+++ b/src/renderer/src/circuit/views/CircuitView.tsx
@@ -30,6 +30,7 @@ import {
 } from 'lucide-react'
 import React from 'react'
 import { ensureParts, getPart, loadPart, registerPart, type PartDef } from '../../lib/partsLibrary'
+import { initUserParts, saveUserPart } from '../../lib/userParts'
 import { PartsEditor } from '../../components/PartsEditor'
 import * as cmd from '../core/commands'
 import { newId, type NetLabelKind, type Pt, type ViewId } from '../core/model'
@@ -100,10 +101,14 @@ export function CircuitViewV2({
     return () => clearTimeout(t)
   }, [revision, store, onChange])
 
-  // lazy-load part defs through the legacy adapter
+  // restore persisted user parts (B7), then lazy-load part defs through the
+  // legacy adapter — user parts must land first so custom types resolve
   React.useEffect(() => {
-    const missing = doc.parts.map((p) => p.type).filter((t) => !getPart(t))
-    if (missing.length) void ensureParts(missing).then(bumpDefs)
+    void initUserParts().then((n) => {
+      const missing = doc.parts.map((p) => p.type).filter((t) => !getPart(t))
+      if (missing.length) void ensureParts(missing).then(bumpDefs)
+      else if (n) bumpDefs()
+    })
   }, [doc.parts])
 
   // drop selection entries that no longer exist (undo, delete, external edit)
@@ -484,7 +489,7 @@ export function CircuitViewV2({
           initial={editorPart}
           onClose={() => setEditorPart(undefined)}
           onSave={(def: PartDef) => {
-            registerPart(def)
+            void saveUserPart(def)
             bumpDefs()
             setEditorPart(undefined)
           }}
diff --git a/src/renderer/src/components/DiagramEditor.tsx b/src/renderer/src/components/DiagramEditor.tsx
index eed0063..190b2a8 100644
--- a/src/renderer/src/components/DiagramEditor.tsx
+++ b/src/renderer/src/components/DiagramEditor.tsx
@@ -45,7 +45,6 @@ import {
   getPart,
   loadPart,
   partsByFamily,
-  registerPart,
   viewFor,
   type PartDef,
   type PartMeta,
@@ -68,6 +67,7 @@ import {
   type Pt
 } from '../lib/wireRouting'
 import { buildNets, meaningfulNetCount } from '../lib/circuitNets'
+import { initUserParts, saveUserPart } from '../lib/userParts'
 import { PartsEditor } from './PartsEditor'
 
 const CANVAS_W = 1100
@@ -313,8 +313,11 @@ export function DiagramEditor({
   const didInit = React.useRef(false)
 
   React.useEffect(() => {
-    const types = diagram.parts.map((p) => p.type).filter((t) => !getPart(t))
-    if (types.length) ensureParts(types).then(force)
+    void initUserParts().then((n) => {
+      const types = diagram.parts.map((p) => p.type).filter((t) => !getPart(t))
+      if (types.length) ensureParts(types).then(force)
+      else if (n) force()
+    })
   }, [diagram.parts])
 
   const write = (d: Partial<Diagram>): void => {
@@ -1779,7 +1782,7 @@ export function DiagramEditor({
           initial={editorPart}
           onClose={() => setEditorPart(undefined)}
           onSave={(def: PartDef) => {
-            registerPart(def)
+            void saveUserPart(def)
             force()
             setEditorPart(undefined)
           }}
diff --git a/src/renderer/src/lib/userParts.ts b/src/renderer/src/lib/userParts.ts
new file mode 100644
index 0000000..4f059b3
--- /dev/null
+++ b/src/renderer/src/lib/userParts.ts
@@ -0,0 +1,162 @@
+/**
+ * userParts — persistence for Parts-Editor-authored parts (B7).
+ *
+ * Custom parts used to live only in the in-memory registry (`registerPart`)
+ * and vanished on reload. They now persist in IndexedDB, which works in both
+ * the Electron renderer (stored under the app's userData) and the web build —
+ * one implementation, no main-process IPC. localStorage is the fallback for
+ * environments without IndexedDB (old WebViews, some test runners).
+ *
+ * Usage:
+ *   - `initUserParts()` — idempotent; loads every saved part into the live
+ *     registry. Call before first geometry pass (CircuitView / DiagramEditor
+ *     mount). Resolves with the number of parts restored.
+ *   - `saveUserPart(def)` — registers AND persists (the Parts Editor save path).
+ *   - `deleteUserPart(type)` — removes from storage (registry entries survive
+ *     until reload; the doc may still reference the type).
+ */
+
+import { registerPart, type PartDef } from './partsLibrary'
+
+const DB_NAME = 'tinystudio-user-parts'
+const STORE = 'parts'
+const LS_KEY = 'tinystudio.userParts'
+
+function idbAvailable(): boolean {
+  try {
+    return typeof indexedDB !== 'undefined'
+  } catch {
+    return false
+  }
+}
+
+function openDb(): Promise<IDBDatabase> {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(DB_NAME, 1)
+    req.onupgradeneeded = () => {
+      if (!req.result.objectStoreNames.contains(STORE)) {
+        req.result.createObjectStore(STORE, { keyPath: 'type' })
+      }
+    }
+    req.onsuccess = () => resolve(req.result)
+    req.onerror = () => reject(req.error ?? new Error('indexedDB open failed'))
+  })
+}
+
+async function idbGetAll(): Promise<PartDef[]> {
+  const db = await openDb()
+  try {
+    return await new Promise<PartDef[]>((resolve, reject) => {
+      const req = db.transaction(STORE, 'readonly').objectStore(STORE).getAll()
+      req.onsuccess = () => resolve((req.result ?? []) as PartDef[])
+      req.onerror = () => reject(req.error ?? new Error('getAll failed'))
+    })
+  } finally {
+    db.close()
+  }
+}
+
+async function idbPut(def: PartDef): Promise<void> {
+  const db = await openDb()
+  try {
+    await new Promise<void>((resolve, reject) => {
+      const tx = db.transaction(STORE, 'readwrite')
+      tx.objectStore(STORE).put(def)
+      tx.oncomplete = () => resolve()
+      tx.onerror = () => reject(tx.error ?? new Error('put failed'))
+    })
+  } finally {
+    db.close()
+  }
+}
+
+async function idbDelete(type: string): Promise<void> {
+  const db = await openDb()
+  try {
+    await new Promise<void>((resolve, reject) => {
+      const tx = db.transaction(STORE, 'readwrite')
+      tx.objectStore(STORE).delete(type)
+      tx.oncomplete = () => resolve()
+      tx.onerror = () => reject(tx.error ?? new Error('delete failed'))
+    })
+  } finally {
+    db.close()
+  }
+}
+
+// ── localStorage fallback ────────────────────────────────────────────────────
+
+function lsRead(): PartDef[] {
+  try {
+    const raw = localStorage.getItem(LS_KEY)
+    if (!raw) return []
+    const parsed = JSON.parse(raw)
+    return Array.isArray(parsed) ? (parsed as PartDef[]) : []
+  } catch {
+    return []
+  }
+}
+
+function lsWrite(defs: PartDef[]): void {
+  try {
+    localStorage.setItem(LS_KEY, JSON.stringify(defs))
+  } catch {
+    /* quota / privacy mode — parts stay session-only */
+  }
+}
+
+// ── public API ───────────────────────────────────────────────────────────────
+
+let initPromise: Promise<number> | null = null
+
+/** Load all persisted user parts into the live registry (idempotent). */
+export function initUserParts(): Promise<number> {
+  if (!initPromise) {
+    initPromise = (async () => {
+      let defs: PartDef[] = []
+      if (idbAvailable()) {
+        try {
+          defs = await idbGetAll()
+        } catch {
+          defs = lsRead()
+        }
+      } else {
+        defs = lsRead()
+      }
+      for (const def of defs) {
+        if (def && typeof def.type === 'string' && def.views) registerPart(def)
+      }
+      return defs.length
+    })()
+  }
+  return initPromise
+}
+
+/** Register a part into the live registry and persist it. */
+export async function saveUserPart(def: PartDef): Promise<void> {
+  registerPart(def)
+  if (idbAvailable()) {
+    try {
+      await idbPut(def)
+      return
+    } catch {
+      /* fall through to localStorage */
+    }
+  }
+  const defs = lsRead().filter((d) => d.type !== def.type)
+  defs.push(def)
+  lsWrite(defs)
+}
+
+/** Remove a part from persistent storage. */
+export async function deleteUserPart(type: string): Promise<void> {
+  if (idbAvailable()) {
+    try {
+      await idbDelete(type)
+      return
+    } catch {
+      /* fall through */
+    }
+  }
+  lsWrite(lsRead().filter((d) => d.type !== type))
+}

From a5104be0eecd5593fc36779251b1cb548dae65e7 Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Sat, 11 Jul 2026 16:41:02 -0600
Subject: [PATCH 12/27] =?UTF-8?q?Circuit=20v2=20M2:=20.fzpz=20drop-import?=
 =?UTF-8?q?=20=E2=80=94=20native-zip=20reader,=20in-app=20fzp->PartDef=20c?=
 =?UTF-8?q?onversion,=20drop-to-place=20+=20persist?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../src/circuit/__tests__/fzpz.test.ts        | 145 +++++++
 src/renderer/src/circuit/parts/fzpz.ts        | 364 ++++++++++++++++++
 src/renderer/src/circuit/parts/svgUnits.ts    |  99 +++++
 src/renderer/src/circuit/parts/zip.ts         |  68 ++++
 .../src/circuit/views/CircuitView.tsx         |  24 ++
 .../src/circuit/views/canvas/Canvas.tsx       |   8 +
 6 files changed, 708 insertions(+)
 create mode 100644 src/renderer/src/circuit/__tests__/fzpz.test.ts
 create mode 100644 src/renderer/src/circuit/parts/fzpz.ts
 create mode 100644 src/renderer/src/circuit/parts/svgUnits.ts
 create mode 100644 src/renderer/src/circuit/parts/zip.ts

diff --git a/src/renderer/src/circuit/__tests__/fzpz.test.ts b/src/renderer/src/circuit/__tests__/fzpz.test.ts
new file mode 100644
index 0000000..576e0b1
--- /dev/null
+++ b/src/renderer/src/circuit/__tests__/fzpz.test.ts
@@ -0,0 +1,145 @@
+/** Tests for the .fzpz import plumbing: the zip reader (built against real
+ * deflate streams from node:zlib) and the pure SVG unit/transform math.
+ * The DOM-dependent .fzp conversion itself is renderer-only (DOMParser). */
+
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { deflateRawSync } from 'node:zlib'
+import { unzip } from '../parts/zip'
+import { applyMat, matMul, minifySvg, parseTransform, toPx } from '../parts/svgUnits'
+
+// ── zip builder (stored + deflated entries, real central directory) ──────────
+
+function crc32(buf: Uint8Array): number {
+  let c = ~0
+  for (let i = 0; i < buf.length; i++) {
+    c ^= buf[i]
+    for (let k = 0; k < 8; k++) c = (c >>> 1) ^ (0xedb88320 & -(c & 1))
+  }
+  return ~c >>> 0
+}
+
+function buildZip(files: { name: string; data: Uint8Array; store?: boolean }[]): Uint8Array {
+  const chunks: Uint8Array[] = []
+  const central: Uint8Array[] = []
+  let offset = 0
+  const enc = new TextEncoder()
+
+  const u16 = (n: number): number[] => [n & 0xff, (n >> 8) & 0xff]
+  const u32 = (n: number): number[] => [n & 0xff, (n >> 8) & 0xff, (n >> 16) & 0xff, (n >> 24) & 0xff]
+
+  for (const f of files) {
+    const name = enc.encode(f.name)
+    const method = f.store ? 0 : 8
+    const comp = f.store ? f.data : new Uint8Array(deflateRawSync(f.data))
+    const crc = crc32(f.data)
+    const local = new Uint8Array([
+      ...u32(0x04034b50), ...u16(20), ...u16(0), ...u16(method), ...u16(0), ...u16(0),
+      ...u32(crc), ...u32(comp.length), ...u32(f.data.length), ...u16(name.length), ...u16(0)
+    ])
+    chunks.push(local, name, comp)
+    central.push(
+      new Uint8Array([
+        ...u32(0x02014b50), ...u16(20), ...u16(20), ...u16(0), ...u16(method), ...u16(0), ...u16(0),
+        ...u32(crc), ...u32(comp.length), ...u32(f.data.length), ...u16(name.length), ...u16(0),
+        ...u16(0), ...u16(0), ...u16(0), ...u32(0), ...u32(offset)
+      ]),
+      name
+    )
+    offset += local.length + name.length + comp.length
+  }
+  const cenStart = offset
+  let cenLen = 0
+  for (const c of central) cenLen += c.length
+  const eocd = new Uint8Array([
+    ...u32(0x06054b50), ...u16(0), ...u16(0), ...u16(files.length), ...u16(files.length),
+    ...u32(cenLen), ...u32(cenStart), ...u16(0)
+  ])
+  const total = offset + cenLen + eocd.length
+  const out = new Uint8Array(total)
+  let p = 0
+  for (const c of [...chunks, ...central, eocd]) {
+    out.set(c, p)
+    p += c.length
+  }
+  return out
+}
+
+// ── zip reader ───────────────────────────────────────────────────────────────
+
+test('unzip round-trips stored and deflated entries', async () => {
+  const enc = new TextEncoder()
+  const fzp = enc.encode('<module moduleId="x"><title>LED</title></module>')
+  const svg = enc.encode('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 10 10"/>')
+  const zip = buildZip([
+    { name: 'part.led.fzp', data: fzp },
+    { name: 'svg.breadboard.led.svg', data: svg, store: true }
+  ])
+  const entries = await unzip(zip)
+  assert.equal(entries.length, 2)
+  const dec = new TextDecoder()
+  assert.equal(dec.decode(entries.find((e) => e.name === 'part.led.fzp')!.data), dec.decode(fzp))
+  assert.equal(
+    dec.decode(entries.find((e) => e.name === 'svg.breadboard.led.svg')!.data),
+    dec.decode(svg)
+  )
+})
+
+test('unzip skips directory entries and rejects non-zip data', async () => {
+  const zip = buildZip([{ name: 'a/', data: new Uint8Array(0), store: true }])
+  assert.equal((await unzip(zip)).length, 0)
+  await assert.rejects(() => unzip(new TextEncoder().encode('not a zip at all — plain text')))
+})
+
+test('unzip survives a trailing comment after the EOCD', async () => {
+  const base = buildZip([{ name: 'x.txt', data: new TextEncoder().encode('hi'), store: true }])
+  // append junk as if a comment followed (scan must still find the EOCD)
+  const padded = new Uint8Array(base.length + 9)
+  padded.set(base, 0)
+  // fix the comment length field so the record stays valid
+  padded[base.length - 2] = 9
+  const entries = await unzip(padded)
+  assert.equal(entries.length, 1)
+})
+
+// ── svg units + transforms ───────────────────────────────────────────────────
+
+test('toPx converts SVG units at 96 DPI', () => {
+  assert.equal(toPx('96px'), 96)
+  assert.equal(toPx('1in'), 96)
+  assert.ok(Math.abs(toPx('25.4mm')! - 96) < 1e-9)
+  assert.ok(Math.abs(toPx('72pt')! - 96) < 1e-9)
+  assert.equal(toPx('42'), 42)
+  assert.equal(toPx('bogus'), null)
+  assert.equal(toPx(null), null)
+})
+
+test('parseTransform composes left-to-right like the SVG spec', () => {
+  // translate then scale: p' = T(10,20) · S(2) · p
+  const m = parseTransform('translate(10 20) scale(2)')
+  const p = applyMat(m, 3, 4)
+  assert.deepEqual(p, { x: 16, y: 28 })
+})
+
+test('rotate about a point maps the pivot to itself', () => {
+  const m = parseTransform('rotate(90 5 5)')
+  const pivot = applyMat(m, 5, 5)
+  assert.ok(Math.abs(pivot.x - 5) < 1e-9 && Math.abs(pivot.y - 5) < 1e-9)
+  const p = applyMat(m, 6, 5) // one unit right of pivot → one unit below (SVG y-down CW)
+  assert.ok(Math.abs(p.x - 5) < 1e-9 && Math.abs(p.y - 6) < 1e-9)
+})
+
+test('matMul is associative with applyMat', () => {
+  const a = parseTransform('translate(1 2)')
+  const b = parseTransform('scale(3)')
+  const p1 = applyMat(matMul(a, b), 4, 5)
+  const p2 = applyMat(a, applyMat(b, 4, 5).x, applyMat(b, 4, 5).y)
+  assert.deepEqual(p1, p2)
+})
+
+test('minifySvg strips prolog/doctype/comments and inter-tag whitespace', () => {
+  const out = minifySvg(
+    '<?xml version="1.0"?>\n<!DOCTYPE svg>\n<!-- hi -->\n<svg>\n  <g>\n  </g>\n</svg>'
+  )
+  assert.equal(out, '<svg><g></g></svg>')
+})
diff --git a/src/renderer/src/circuit/parts/fzpz.ts b/src/renderer/src/circuit/parts/fzpz.ts
new file mode 100644
index 0000000..a9ab7df
--- /dev/null
+++ b/src/renderer/src/circuit/parts/fzpz.ts
@@ -0,0 +1,364 @@
+/**
+ * circuit/parts/fzpz — in-app `.fzpz` drop-import (M2, spec §7).
+ *
+ * A .fzpz is a ZIP of one `part.<name>.fzp` (XML metadata + connector list)
+ * plus its view SVGs stored flat as `svg.<view>.<name>.svg`. Fritzing does not
+ * store pin coordinates in the .fzp — connectors name an svgId/terminalId and
+ * the real point lives *inside* the SVG, under an arbitrary transform stack.
+ * We resolve each connector by walking the SVG DOM, accumulating ancestor
+ * transforms, then scaling viewBox units to pixels @ 96 DPI (Wokwi space).
+ *
+ * The conversion mirrors scripts/fritzing-import.mjs (the offline bulk
+ * importer) — same anchors, same fallbacks — so a drop-imported part matches
+ * what a regenerated default pack would produce. Uses the browser DOMParser,
+ * so this module is renderer-only (don't import it from core/ or tests).
+ */
+
+import type { PartDef, PartView, ViewKind } from '../../lib/partsLibrary'
+import { applyMat, matMul, minifySvg, parseTransform, toPx, type Mat, type Pt2 } from './svgUnits'
+import { unzip } from './zip'
+
+export interface FzpzResult {
+  def: PartDef
+  /** connector ids we could not resolve to a point, per view */
+  warnings: string[]
+}
+
+interface FzpConnector {
+  id: string
+  name: string
+  views: Partial<Record<string, { svgId?: string; terminalId?: string }>>
+}
+
+interface Fzp {
+  moduleId: string
+  title: string
+  family: string
+  viewImage: Partial<Record<string, string>>
+  connectors: FzpConnector[]
+}
+
+const VIEW_TAG: Record<ViewKind, string> = {
+  breadboard: 'breadboardView',
+  schematic: 'schematicView'
+}
+
+const slug = (s: string): string =>
+  s
+    .normalize('NFKD')
+    .replace(/ModuleID$/i, '')
+    .replace(/[^a-zA-Z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .toLowerCase() || 'part'
+
+const round = (n: number): number => Math.round(n * 100) / 100
+
+// ── DOM walking (browser DOM, same shape as the script's xmldom walk) ────────
+
+function* walk(node: Element): Generator<Element> {
+  yield node
+  for (let c = node.firstElementChild; c; c = c.nextElementSibling) yield* walk(c)
+}
+
+function getById(root: Element, id: string): Element | null {
+  for (const el of walk(root)) if (el.getAttribute('id') === id) return el
+  return null
+}
+
+/** Cumulative transform matrix from the <svg> root down to (and incl.) el. */
+function ctmFor(el: Element): Mat {
+  const chain: Element[] = []
+  let n: Element | null = el
+  while (n && n.nodeType === 1) {
+    chain.push(n)
+    n = n.parentElement
+  }
+  let m: Mat = [1, 0, 0, 1, 0, 0]
+  for (let i = chain.length - 1; i >= 0; i--) {
+    const tf = chain[i].getAttribute('transform')
+    if (tf) m = matMul(m, parseTransform(tf))
+  }
+  return m
+}
+
+interface Anchor extends Pt2 {
+  line?: [Pt2, Pt2]
+}
+
+/** Local-space anchor point of a shape element (before transforms). */
+function localAnchor(el: Element): Anchor | null {
+  const tag = el.localName.toLowerCase()
+  const num = (a: string): number => parseFloat(el.getAttribute(a) ?? '')
+  if (tag === 'rect') {
+    const x = num('x') || 0
+    const y = num('y') || 0
+    const w = num('width') || 0
+    const h = num('height') || 0
+    return { x: x + w / 2, y: y + h / 2 }
+  }
+  if (tag === 'circle' || tag === 'ellipse') return { x: num('cx') || 0, y: num('cy') || 0 }
+  if (tag === 'line') {
+    const x1 = num('x1') || 0
+    const y1 = num('y1') || 0
+    const x2 = num('x2') || 0
+    const y2 = num('y2') || 0
+    return {
+      x: (x1 + x2) / 2,
+      y: (y1 + y2) / 2,
+      line: [
+        { x: x1, y: y1 },
+        { x: x2, y: y2 }
+      ]
+    }
+  }
+  if (tag === 'polygon' || tag === 'polyline') {
+    const pts = (el.getAttribute('points') || '').trim().split(/[\s,]+/).map(parseFloat)
+    if (pts.length >= 2) return bboxCenter(chunk(pts))
+  }
+  if (tag === 'path') {
+    const nums = (el.getAttribute('d') || '').match(/-?[\d.]+(?:e-?\d+)?/gi)
+    if (nums && nums.length >= 2) return bboxCenter(chunk(nums.map(parseFloat)))
+  }
+  if (tag === 'g') {
+    for (let c = el.firstElementChild; c; c = c.nextElementSibling) {
+      const a = localAnchor(c)
+      if (a) {
+        const m = parseTransform(c.getAttribute('transform'))
+        return applyMat(m, a.x, a.y)
+      }
+    }
+  }
+  return null
+}
+
+function chunk(arr: number[]): Pt2[] {
+  const out: Pt2[] = []
+  for (let i = 0; i + 1 < arr.length; i += 2) out.push({ x: arr[i], y: arr[i + 1] })
+  return out
+}
+
+function bboxCenter(pts: Pt2[]): Pt2 {
+  let minx = Infinity
+  let miny = Infinity
+  let maxx = -Infinity
+  let maxy = -Infinity
+  for (const p of pts) {
+    minx = Math.min(minx, p.x)
+    miny = Math.min(miny, p.y)
+    maxx = Math.max(maxx, p.x)
+    maxy = Math.max(maxy, p.y)
+  }
+  return { x: (minx + maxx) / 2, y: (miny + maxy) / 2 }
+}
+
+// ── fzp parsing ──────────────────────────────────────────────────────────────
+
+function parseFzp(xml: string): Fzp {
+  const doc = new DOMParser().parseFromString(xml, 'text/xml')
+  const mod = doc.getElementsByTagName('module')[0]
+  if (!mod) throw new Error('no <module> in .fzp')
+
+  let family = ''
+  const propsEl = mod.getElementsByTagName('properties')[0]
+  if (propsEl) {
+    for (const p of Array.from(propsEl.getElementsByTagName('property'))) {
+      if ((p.getAttribute('name') || '').toLowerCase() === 'family')
+        family = (p.textContent || '').trim()
+    }
+  }
+
+  const viewImage: Partial<Record<string, string>> = {}
+  for (const vname of ['breadboardView', 'schematicView', 'iconView']) {
+    const v = mod.getElementsByTagName(vname)[0]
+    if (!v) continue
+    const layers = v.getElementsByTagName('layers')[0]
+    if (layers) viewImage[vname] = layers.getAttribute('image') ?? undefined
+  }
+
+  const connectors: FzpConnector[] = []
+  const connsEl = mod.getElementsByTagName('connectors')[0]
+  if (connsEl) {
+    for (const c of Array.from(connsEl.getElementsByTagName('connector'))) {
+      const id = c.getAttribute('id') || ''
+      const views: FzpConnector['views'] = {}
+      for (const vname of ['breadboardView', 'schematicView']) {
+        const v = c.getElementsByTagName(vname)[0]
+        if (!v) continue
+        const p = v.getElementsByTagName('p')[0]
+        if (!p) continue
+        views[vname] = {
+          svgId: p.getAttribute('svgId') ?? undefined,
+          terminalId: p.getAttribute('terminalId') ?? undefined
+        }
+      }
+      connectors.push({ id, name: c.getAttribute('name') || id, views })
+    }
+  }
+
+  const title = (mod.getElementsByTagName('title')[0]?.textContent || '').trim()
+  return { moduleId: mod.getAttribute('moduleId') || '', title, family, viewImage, connectors }
+}
+
+// ── per-view SVG extraction ──────────────────────────────────────────────────
+
+function extractView(
+  fzp: Fzp,
+  view: ViewKind,
+  svgText: string
+): { view: PartView; unresolved: string[] } | null {
+  const doc = new DOMParser().parseFromString(svgText, 'image/svg+xml')
+  const svg = doc.getElementsByTagName('svg')[0]
+  if (!svg) return null
+
+  let vb = (svg.getAttribute('viewBox') || '').trim().split(/[\s,]+/).map(parseFloat)
+  const wPx = toPx(svg.getAttribute('width'))
+  const hPx = toPx(svg.getAttribute('height'))
+  if (vb.length !== 4 || vb.some(Number.isNaN)) {
+    if (wPx != null && hPx != null) vb = [0, 0, wPx, hPx]
+    else return null
+  }
+  const [vbx, vby, vbw, vbh] = vb
+  const sx = wPx != null && vbw ? wPx / vbw : 1
+  const sy = hPx != null && vbh ? hPx / vbh : sx
+  const center = { x: vbx + vbw / 2, y: vby + vbh / 2 }
+
+  const tag = VIEW_TAG[view]
+  const pins: Record<string, [number, number]> = {}
+  const unresolved: string[] = []
+  const usedNames = new Set<string>()
+  for (const c of fzp.connectors) {
+    const cv = c.views[tag]
+    if (!cv) {
+      unresolved.push(c.id)
+      continue
+    }
+    // terminal is the precise wire point in schematic; pin element in breadboard
+    const ids =
+      view === 'schematic' ? [cv.terminalId, cv.svgId] : [cv.svgId, cv.terminalId]
+    let pt: Pt2 | null = null
+    for (const id of ids) {
+      if (!id) continue
+      const el = getById(svg, id)
+      if (!el) continue
+      const local = localAnchor(el)
+      if (!local) continue
+      const m = ctmFor(el)
+      if (local.line) {
+        // pick the line end farther from drawing centre (the free/wire end)
+        const ends = local.line.map((p) => applyMat(m, p.x, p.y))
+        pt = ends.reduce((far, e) =>
+          (e.x - center.x) ** 2 + (e.y - center.y) ** 2 >
+          (far.x - center.x) ** 2 + (far.y - center.y) ** 2
+            ? e
+            : far
+        )
+      } else {
+        pt = applyMat(m, local.x, local.y)
+      }
+      break
+    }
+    if (!pt) {
+      unresolved.push(c.id)
+      continue
+    }
+    let name = c.name || c.id
+    let n = name
+    let i = 2
+    while (usedNames.has(n)) n = `${name}.${i++}`
+    usedNames.add(n)
+    pins[n] = [round((pt.x - vbx) * sx), round((pt.y - vby) * sy)]
+  }
+  if (!Object.keys(pins).length) return null
+
+  svg.removeAttribute('width')
+  svg.removeAttribute('height')
+  if (!svg.getAttribute('xmlns')) svg.setAttribute('xmlns', 'http://www.w3.org/2000/svg')
+  if (!svg.getAttribute('viewBox')) svg.setAttribute('viewBox', vb.join(' '))
+  const svgStr = minifySvg(new XMLSerializer().serializeToString(svg))
+
+  return {
+    view: {
+      svg: svgStr,
+      w: round(wPx != null ? wPx : vbw * sx),
+      h: round(hPx != null ? hPx : vbh * sy),
+      pins
+    },
+    unresolved: unresolved.map((id) => `${view}: ${id}`)
+  }
+}
+
+function extractIcon(svgText: string): string | null {
+  const doc = new DOMParser().parseFromString(svgText, 'image/svg+xml')
+  const svg = doc.getElementsByTagName('svg')[0]
+  if (!svg) return null
+  const w = toPx(svg.getAttribute('width'))
+  const h = toPx(svg.getAttribute('height'))
+  svg.removeAttribute('width')
+  svg.removeAttribute('height')
+  if (!svg.getAttribute('xmlns')) svg.setAttribute('xmlns', 'http://www.w3.org/2000/svg')
+  if (!svg.getAttribute('viewBox') && w != null && h != null)
+    svg.setAttribute('viewBox', `0 0 ${w} ${h}`)
+  return minifySvg(new XMLSerializer().serializeToString(svg))
+}
+
+// ── entry point ──────────────────────────────────────────────────────────────
+
+/** Convert a `.fzpz` archive into a registrable PartDef. Throws with a
+ * human-readable message when the archive is not a usable Fritzing part. */
+export async function importFzpz(bytes: Uint8Array, fileName?: string): Promise<FzpzResult> {
+  const entries = await unzip(bytes)
+  const byName = new Map(entries.map((e) => [e.name, e]))
+
+  const fzpEntry = entries.find((e) => e.name.toLowerCase().endsWith('.fzp'))
+  if (!fzpEntry) throw new Error('no .fzp inside the archive — is this a Fritzing part?')
+  const decoder = new TextDecoder()
+  const fzp = parseFzp(decoder.decode(fzpEntry.data))
+
+  // "part.<name>.fzp" → <name>; fall back to the dropped filename / title
+  const base =
+    /^part\.(.+)\.fzp$/i.exec(fzpEntry.name)?.[1] ??
+    fileName?.replace(/\.fzpz$/i, '') ??
+    fzp.title
+  const type = slug(base)
+
+  // view image "breadboard/foo.svg" is stored flat as "svg.breadboard.foo.svg"
+  const svgTextFor = (image: string | undefined): string | null => {
+    if (!image) return null
+    const flat = `svg.${image.replace(/\//g, '.')}`
+    const entry =
+      byName.get(flat) ??
+      entries.find((e) => e.name.toLowerCase() === flat.toLowerCase()) ??
+      entries.find((e) => e.name.toLowerCase().endsWith(image.split('/').pop()!.toLowerCase()))
+    return entry ? decoder.decode(entry.data) : null
+  }
+
+  const views: PartDef['views'] = {}
+  const warnings: string[] = []
+  for (const view of ['breadboard', 'schematic'] as ViewKind[]) {
+    const svgText = svgTextFor(fzp.viewImage[VIEW_TAG[view]])
+    if (!svgText) continue
+    const res = extractView(fzp, view, svgText)
+    if (!res) continue
+    views[view] = res.view
+    warnings.push(...res.unresolved)
+  }
+  if (!Object.keys(views).length)
+    throw new Error('no usable view (missing SVGs or unresolvable pins)')
+
+  const iconText = svgTextFor(fzp.viewImage.iconView)
+  const icon =
+    (iconText ? extractIcon(iconText) : null) ??
+    (views.breadboard?.svg && views.breadboard.svg.length < 4000
+      ? views.breadboard.svg
+      : undefined) ??
+    undefined
+
+  const def: PartDef = {
+    type,
+    label: fzp.title || type,
+    family: fzp.family || 'Imported',
+    icon,
+    views
+  }
+  return { def, warnings }
+}
diff --git a/src/renderer/src/circuit/parts/svgUnits.ts b/src/renderer/src/circuit/parts/svgUnits.ts
new file mode 100644
index 0000000..64c967e
--- /dev/null
+++ b/src/renderer/src/circuit/parts/svgUnits.ts
@@ -0,0 +1,99 @@
+/**
+ * circuit/parts/svgUnits — pure SVG unit + transform math for the .fzpz
+ * importer. Mirrors scripts/fritzing-import.mjs (the offline bulk importer);
+ * keep the two in sync. No DOM here so it runs under `node --test`.
+ */
+
+export type Mat = [number, number, number, number, number, number]
+export interface Pt2 {
+  x: number
+  y: number
+}
+
+const PX_PER_MM = 96 / 25.4 // 96 DPI, the Wokwi pixel convention
+
+/** Convert an SVG length attribute (with unit) to pixels @ 96 DPI. */
+export function toPx(value: string | null | undefined): number | null {
+  if (value == null) return null
+  const m = String(value)
+    .trim()
+    .match(/^(-?[\d.]+)\s*(px|pt|pc|mm|cm|in)?$/)
+  if (!m) return null
+  const n = parseFloat(m[1])
+  switch (m[2]) {
+    case 'in':
+      return n * 96
+    case 'mm':
+      return n * PX_PER_MM
+    case 'cm':
+      return n * PX_PER_MM * 10
+    case 'pt':
+      return n * (96 / 72)
+    case 'pc':
+      return n * 16
+    default:
+      return n // px or unitless
+  }
+}
+
+export const IDENT: Mat = [1, 0, 0, 1, 0, 0]
+
+/** m · n — point map is x' = a·x + c·y + e ; y' = b·x + d·y + f */
+export function matMul(m: Mat, n: Mat): Mat {
+  return [
+    m[0] * n[0] + m[2] * n[1],
+    m[1] * n[0] + m[3] * n[1],
+    m[0] * n[2] + m[2] * n[3],
+    m[1] * n[2] + m[3] * n[3],
+    m[0] * n[4] + m[2] * n[5] + m[4],
+    m[1] * n[4] + m[3] * n[5] + m[5]
+  ]
+}
+
+export function applyMat(m: Mat, x: number, y: number): Pt2 {
+  return { x: m[0] * x + m[2] * y + m[4], y: m[1] * x + m[3] * y + m[5] }
+}
+
+/** Parse an SVG `transform` attribute into one matrix. */
+export function parseTransform(str: string | null | undefined): Mat {
+  let m = IDENT
+  if (!str) return m
+  const re = /(matrix|translate|scale|rotate|skewX|skewY)\s*\(([^)]*)\)/g
+  let r: RegExpExecArray | null
+  while ((r = re.exec(str))) {
+    const fn = r[1]
+    const args = r[2]
+      .split(/[\s,]+/)
+      .map(parseFloat)
+      .filter((n) => !Number.isNaN(n))
+    let t: Mat = IDENT
+    if (fn === 'matrix' && args.length === 6) t = args as Mat
+    else if (fn === 'translate') t = [1, 0, 0, 1, args[0] || 0, args[1] || 0]
+    else if (fn === 'scale')
+      t = [args[0] || 1, 0, 0, args.length > 1 ? args[1] : args[0] || 1, 0, 0]
+    else if (fn === 'rotate') {
+      const rad = ((args[0] || 0) * Math.PI) / 180
+      const cos = Math.cos(rad)
+      const sin = Math.sin(rad)
+      const rot: Mat = [cos, sin, -sin, cos, 0, 0]
+      if (args.length >= 3) {
+        const cx = args[1]
+        const cy = args[2]
+        t = matMul(matMul([1, 0, 0, 1, cx, cy], rot), [1, 0, 0, 1, -cx, -cy])
+      } else t = rot
+    } else if (fn === 'skewX') t = [1, 0, Math.tan(((args[0] || 0) * Math.PI) / 180), 1, 0, 0]
+    else if (fn === 'skewY') t = [1, Math.tan(((args[0] || 0) * Math.PI) / 180), 0, 1, 0, 0]
+    m = matMul(m, t)
+  }
+  return m
+}
+
+/** Strip XML decl / DOCTYPE / comments and collapse inter-tag whitespace. */
+export function minifySvg(str: string): string {
+  return str
+    .replace(/<\?xml[\s\S]*?\?>/g, '')
+    .replace(/<!DOCTYPE[\s\S]*?>/gi, '')
+    .replace(/<!--[\s\S]*?-->/g, '')
+    .replace(/>\s+</g, '><')
+    .trim()
+}
diff --git a/src/renderer/src/circuit/parts/zip.ts b/src/renderer/src/circuit/parts/zip.ts
new file mode 100644
index 0000000..7a6c2b3
--- /dev/null
+++ b/src/renderer/src/circuit/parts/zip.ts
@@ -0,0 +1,68 @@
+/**
+ * circuit/parts/zip — minimal ZIP reader for `.fzpz` drop-import (M2).
+ *
+ * No dependency: entries are located via the central directory and inflated
+ * with the native `DecompressionStream('deflate-raw')` (Chromium, web, and
+ * Node ≥18 — so this stays testable under `node --test`). Only what Fritzing
+ * archives need: stored (method 0) and deflated (method 8) entries, no
+ * encryption, no ZIP64 (a .fzpz is a handful of SVGs).
+ */
+
+const EOCD_SIG = 0x06054b50
+const CEN_SIG = 0x02014b50
+const LOC_SIG = 0x04034b50
+
+export interface ZipEntry {
+  name: string
+  data: Uint8Array
+}
+
+async function inflateRaw(data: Uint8Array): Promise<Uint8Array> {
+  const ds = new DecompressionStream('deflate-raw')
+  const stream = new Blob([data as BlobPart]).stream().pipeThrough(ds)
+  return new Uint8Array(await new Response(stream).arrayBuffer())
+}
+
+/** Read every file entry of a ZIP archive. Throws on a malformed archive. */
+export async function unzip(bytes: Uint8Array): Promise<ZipEntry[]> {
+  const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)
+
+  // End-of-central-directory: scan backwards (comment can pad the tail).
+  let eocd = -1
+  for (let i = bytes.length - 22; i >= 0 && i >= bytes.length - 22 - 0xffff; i--) {
+    if (dv.getUint32(i, true) === EOCD_SIG) {
+      eocd = i
+      break
+    }
+  }
+  if (eocd < 0) throw new Error('not a zip archive (no end-of-central-directory)')
+  const count = dv.getUint16(eocd + 10, true)
+  let off = dv.getUint32(eocd + 16, true)
+
+  const decoder = new TextDecoder()
+  const out: ZipEntry[] = []
+  for (let i = 0; i < count; i++) {
+    if (dv.getUint32(off, true) !== CEN_SIG) throw new Error('bad central directory entry')
+    const method = dv.getUint16(off + 10, true)
+    const compSize = dv.getUint32(off + 20, true)
+    const nameLen = dv.getUint16(off + 28, true)
+    const extraLen = dv.getUint16(off + 30, true)
+    const commentLen = dv.getUint16(off + 32, true)
+    const localOff = dv.getUint32(off + 42, true)
+    const name = decoder.decode(bytes.subarray(off + 46, off + 46 + nameLen))
+    off += 46 + nameLen + extraLen + commentLen
+
+    if (name.endsWith('/')) continue // directory entry
+    if (dv.getUint32(localOff, true) !== LOC_SIG) throw new Error('bad local header')
+    // local header name/extra lengths can differ from the central ones
+    const lNameLen = dv.getUint16(localOff + 26, true)
+    const lExtraLen = dv.getUint16(localOff + 28, true)
+    const start = localOff + 30 + lNameLen + lExtraLen
+    const comp = bytes.subarray(start, start + compSize)
+
+    if (method === 0) out.push({ name, data: comp.slice() })
+    else if (method === 8) out.push({ name, data: await inflateRaw(comp) })
+    else throw new Error(`unsupported compression method ${method} for ${name}`)
+  }
+  return out
+}
diff --git a/src/renderer/src/circuit/views/CircuitView.tsx b/src/renderer/src/circuit/views/CircuitView.tsx
index f624225..8ea20fb 100644
--- a/src/renderer/src/circuit/views/CircuitView.tsx
+++ b/src/renderer/src/circuit/views/CircuitView.tsx
@@ -30,7 +30,9 @@ import {
 } from 'lucide-react'
 import React from 'react'
 import { ensureParts, getPart, loadPart, registerPart, type PartDef } from '../../lib/partsLibrary'
+import { toast } from 'sonner'
 import { initUserParts, saveUserPart } from '../../lib/userParts'
+import { importFzpz } from '../parts/fzpz'
 import { PartsEditor } from '../../components/PartsEditor'
 import * as cmd from '../core/commands'
 import { newId, type NetLabelKind, type Pt, type ViewId } from '../core/model'
@@ -211,6 +213,27 @@ export function CircuitViewV2({
     setSel({ parts: new Set([id]), wires: new Set() })
   }
 
+  // .fzpz dropped on the canvas: convert → persist → place at the cursor
+  const importFzpzFiles = async (files: File[], at: Pt): Promise<void> => {
+    for (const f of files) {
+      try {
+        const { def, warnings } = await importFzpz(new Uint8Array(await f.arrayBuffer()), f.name)
+        await saveUserPart(def)
+        bumpDefs()
+        await addPartAt(def.type, at)
+        toast.success(`Imported ${def.label}`, {
+          description: warnings.length
+            ? `${warnings.length} pin${warnings.length === 1 ? '' : 's'} could not be resolved`
+            : `${def.family} · now in the palette`
+        })
+      } catch (err) {
+        toast.error(`Couldn't import ${f.name}`, {
+          description: err instanceof Error ? err.message : String(err)
+        })
+      }
+    }
+  }
+
   const addNetLabel = (kind: NetLabelKind, name: string, at?: Pt): void => {
     const c = at ?? canvasRef.current?.centerWorld() ?? { x: 300, y: 200 }
     const id = newId('nl')
@@ -463,6 +486,7 @@ export function CircuitViewV2({
           handleRef={canvasRef}
           onDropPart={(type, at) => void addPartAt(type, at)}
           onDropNetLabel={(kind, name, at) => addNetLabel(kind, name, at)}
+          onImportFiles={(files, at) => void importFzpzFiles(files, at)}
           onRequestEdit={enterEdit}
         />
 
diff --git a/src/renderer/src/circuit/views/canvas/Canvas.tsx b/src/renderer/src/circuit/views/canvas/Canvas.tsx
index d7693b7..6c23db8 100644
--- a/src/renderer/src/circuit/views/canvas/Canvas.tsx
+++ b/src/renderer/src/circuit/views/canvas/Canvas.tsx
@@ -148,6 +148,7 @@ export function Canvas({
   handleRef,
   onDropPart,
   onDropNetLabel,
+  onImportFiles,
   onRequestEdit
 }: {
   store: CircuitStore
@@ -170,6 +171,8 @@ export function Canvas({
   handleRef: React.Ref<CanvasHandle>
   onDropPart: (type: string, at: Pt) => void
   onDropNetLabel: (kind: NetLabelKind, name: string, at: Pt) => void
+  /** dropped OS files (.fzpz part import) */
+  onImportFiles?: (files: File[], at: Pt) => void
   /** tray "attach to cursor" placement: id being placed + drop callback */
   /** double-clicking a component asks the shell to enter edit mode */
   onRequestEdit: () => void
@@ -819,6 +822,11 @@ export function Canvas({
 
   const onDrop = (e: React.DragEvent): void => {
     e.preventDefault()
+    const files = Array.from(e.dataTransfer.files ?? []).filter((f) => /\.fzpz$/i.test(f.name))
+    if (files.length && onImportFiles) {
+      onImportFiles(files, canvasPoint(e))
+      return
+    }
     const type = e.dataTransfer.getData('text/tinystudio-part')
     if (type) {
       onDropPart(type, canvasPoint(e))

From 3791423eba019732de6e9dc94b528fb5c027ec47 Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Sat, 11 Jul 2026 16:55:34 -0600
Subject: [PATCH 13/27] Circuit v2 M4 core: netlist gen, SimBackend +
 ngspice-WASM worker, Simulate panel, sim sources; progress log

---
 docs/circuit-editor-progress.md               |  38 ++
 electron.vite.config.ts                       |   2 +
 package-lock.json                             |  11 +-
 package.json                                  |   1 +
 .../src/circuit/__tests__/netlist.test.ts     | 154 +++++++
 .../src/circuit/__tests__/sim.test.ts         | 118 ++++++
 src/renderer/src/circuit/core/netlist.ts      | 376 ++++++++++++++++++
 src/renderer/src/circuit/parts/simParts.ts    | 101 +++++
 src/renderer/src/circuit/sim/backend.ts       |  49 +++
 src/renderer/src/circuit/sim/engine.ts        |  85 ++++
 src/renderer/src/circuit/sim/index.ts         |   9 +
 src/renderer/src/circuit/sim/simWorker.ts     |  78 ++++
 .../src/circuit/views/CircuitView.tsx         |  55 ++-
 .../src/circuit/views/canvas/Canvas.tsx       |  14 +
 .../src/circuit/views/sim/SimPanel.tsx        | 321 +++++++++++++++
 web.vite.config.mts                           |   2 +
 16 files changed, 1411 insertions(+), 3 deletions(-)
 create mode 100644 src/renderer/src/circuit/__tests__/netlist.test.ts
 create mode 100644 src/renderer/src/circuit/__tests__/sim.test.ts
 create mode 100644 src/renderer/src/circuit/core/netlist.ts
 create mode 100644 src/renderer/src/circuit/parts/simParts.ts
 create mode 100644 src/renderer/src/circuit/sim/backend.ts
 create mode 100644 src/renderer/src/circuit/sim/engine.ts
 create mode 100644 src/renderer/src/circuit/sim/index.ts
 create mode 100644 src/renderer/src/circuit/sim/simWorker.ts
 create mode 100644 src/renderer/src/circuit/views/sim/SimPanel.tsx

diff --git a/docs/circuit-editor-progress.md b/docs/circuit-editor-progress.md
index 1ede9b3..e5f882a 100644
--- a/docs/circuit-editor-progress.md
+++ b/docs/circuit-editor-progress.md
@@ -219,3 +219,41 @@ Eleven fixes across the circuit editor + app shell. `npm run typecheck` clean ·
 - Marquee/rubber-band still selects parts + wires only, not net labels (click / shift-click for labels).
 - Leg recolor is render-time and keyed by svg string; if a part with a different (non-`connectorNleg`) leg convention shows up, extend `blackenLegs`.
 - Tooling: `PartsEditor.tsx` hit the Cowork-mount truncation bug when written via the file tool (cut at line 399 mid-word) — rewritten Linux-side and verified. Everything else this round was written Linux-side. The stale `.git/index.lock` is still unremovable from the sandbox, so this round is **uncommitted** on `circuit-editor`.
+
+---
+
+## 2026-07-11 — M2 leftovers + M4 core: persistence, .fzpz import, simulation ✅
+
+Four chunks, committed separately. `npm run typecheck` clean · `npm run test:circuit` → **89/89** (sim tests run the real WASM engine on generated netlists).
+
+### Small gaps (from the 07-05 notes)
+
+- **Marquee selects net labels** (sch) alongside parts/wires; additive with Shift.
+- **Inspector breadboard rotate is rigid**: `rotateBoardAssemblyCmd` lifted into `partsAdapter` (shared by canvas gestures and the Inspector, `steps` param covers the 0/90/180/270 dropdown); Inspector detects `isBreadboard` + bb view and delegates.
+- **Net-label rotation**: `rotateNetLabelCmd` (90° steps about centre, pin re-snapped to grid, wires reroute) — `R` key with labels selected, plus a rotation dropdown + 90° button in the label Inspector.
+
+### M2: Part Editor persistence (B7) — `lib/userParts.ts`
+
+- Custom parts persist in **IndexedDB** (`tinystudio-user-parts`), one impl for Electron renderer + web; localStorage fallback. `initUserParts()` (idempotent) restores them into the live registry on CircuitView/DiagramEditor mount, before geometry; both PartsEditor save paths now `saveUserPart` (register + persist). `deleteUserPart` exported for a future pack-manager UI.
+
+### M2: `.fzpz` drop-import — `parts/zip.ts`, `parts/svgUnits.ts`, `parts/fzpz.ts`
+
+- **Zero-dep zip reader**: central-directory walk + native `DecompressionStream('deflate-raw')` (Chromium + Node ≥18 → unit-testable against real deflate streams from node:zlib).
+- **In-app fzp→PartDef conversion** mirroring `scripts/fritzing-import.mjs`: connector resolution by svgId/terminalId with full ancestor-transform accumulation (`svgUnits.ts` is the pure math, tested), viewBox→96 DPI scaling, line-end picking, name-uniquing, icon extraction. DOM parts use the browser DOMParser (renderer-only module).
+- **Drop a .fzpz on the canvas** → converts → `saveUserPart` (persists) → places at the cursor with collision avoidance → toast (with unresolved-pin count when partial). Canvas gained `onImportFiles`; multiple files per drop OK.
+
+### M4 core: netlist gen + SimBackend + Simulate panel
+
+- `core/netlist.ts` — pure SPICE generation from doc + NetModel (seating/buses included as the editor sees them). Node naming per spec §10.2 (GND label → `0`, named nets keep names, `n<k>` stable). Built-in emitter table (R/C/L/D/LED/pot→2R/NPN/PNP/switch/battery + `sim-*` sources) with name-matched pins (anode/cathode/+/-) and positional fallback; breadboards transparent; boards excluded with "drive its pins with sources" info; unknowns excluded with warning. `spiceNum` normalization (`4.7kΩ`→`4.7k`, `µ`→`u`, trailing `M`→`Meg`). Analyses: `.op`/`.tran [uic]`/`.dc`/`.ac`.
+- `parts/simParts.ts` — builtin **Source** family (`sim-vdc`, `sim-vsin`, `sim-idc`): generated circle symbols, same art both views, default attrs applied on placement (Inspector-editable). Registered at CircuitView mount like breadboards.
+- `sim/` — **`SimBackend`** interface (engine-agnostic per §10.6), `SpiceWorkerBackend`: module worker (Vite `?worker`, `worker.format='es'` set in both vite configs), lazy `eecircuit-engine` import (≈20 MB chunk, loaded on first Run), 10 s watchdog default, cancel = terminate+respawn. **eecircuit-engine installed as the first backend** — the tscircuit-build bake-off remains open behind the interface.
+- `views/sim/SimPanel.tsx` — bottom-docked panel: DC | Transient tabs (step/stop/uic), Run/Cancel, netlist preview toggle, generator warnings, error surface (ngspice messages), `.op` results table, transient traces in an inline SVG plot (uPlot lands with the full plotting pass). **DC annotations**: after an `.op` run the canvas shows node-voltage chips at one pin per net (both views); results auto-clear on any doc edit.
+- Tests: +18 (89 total) — netlist goldens (divider, LED chain model-once, exclusions, switches, spiceNum, analysis cards), zip round-trip/EOCD-comment, svgUnits math, **sim integration**: engine solves the generated divider `.op` within 1% and an RC transient (uic) charge curve within 5% at t=RC.
+
+### Deferred / notes for the next agent
+
+- M2 still open: pack manager + GitHub index install, bendable legs, default-pack regeneration, "all pins must seat" rule.
+- M4 still open: DC sweep + AC tabs in the panel (cards already generate), uPlot with cursors/zoom/log axes + CSV export, current probes (§10.3 probe parts — `sim.probes` is modeled but unused), error→part/net highlight mapping, auto-rerun toggle, breadboard hole-tooltip voltages, flag default ON + legacy editor removal.
+- M5 untouched (KiCad/Wokwi interop).
+- The sim source symbols seat on breadboards like any 2-pin part; netlist pin matching for them keys on `+`/`-` names.
+- Tooling: Cowork-mount truncation did NOT reproduce this session (new files written via the file tool verified clean); git index/HEAD locks were stale early on — **fixed by enabling file deletion for the folder**, commits work normally again.
diff --git a/electron.vite.config.ts b/electron.vite.config.ts
index 0f5dcf2..66e67af 100644
--- a/electron.vite.config.ts
+++ b/electron.vite.config.ts
@@ -16,6 +16,8 @@ export default defineConfig({
         '@renderer': resolve('src/renderer/src')
       }
     },
+    // module workers (sim engine lazy-imports ngspice-WASM inside a worker)
+    worker: { format: 'es' },
     plugins: [react(), tailwindcss()]
   }
 })
diff --git a/package-lock.json b/package-lock.json
index 9b4367f..5ec13dc 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "tinystudio",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "tinystudio",
-      "version": "0.1.1",
+      "version": "0.2.0",
       "hasInstallScript": true,
       "license": "GPL-3.0-or-later",
       "dependencies": {
@@ -21,6 +21,7 @@
         "@tailwindcss/vite": "^4.1.8",
         "blockly": "^12.1.0",
         "class-variance-authority": "^0.7.1",
+        "eecircuit-engine": "^1.7.0",
         "electron-updater": "^6.3.9",
         "express": "^4.18.2",
         "lucide-react": "^0.515.0",
@@ -7263,6 +7264,12 @@
       "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
       "license": "MIT"
     },
+    "node_modules/eecircuit-engine": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/eecircuit-engine/-/eecircuit-engine-1.7.0.tgz",
+      "integrity": "sha512-ZDpr/w/H81uCH3n2vjf0vohxOQqQ4NCsvaXkoYwcH+LCxIGKpBdvAIvGN5IdozW6AFJ8tojquKvDya3337yjSQ==",
+      "license": "MIT"
+    },
     "node_modules/ejs": {
       "version": "3.1.10",
       "resolved": "https://registry.npmjs.org/ejs/-/ejs-3.1.10.tgz",
diff --git a/package.json b/package.json
index acd5491..95a5607 100644
--- a/package.json
+++ b/package.json
@@ -46,6 +46,7 @@
     "@tailwindcss/vite": "^4.1.8",
     "blockly": "^12.1.0",
     "class-variance-authority": "^0.7.1",
+    "eecircuit-engine": "^1.7.0",
     "electron-updater": "^6.3.9",
     "express": "^4.18.2",
     "lucide-react": "^0.515.0",
diff --git a/src/renderer/src/circuit/__tests__/netlist.test.ts b/src/renderer/src/circuit/__tests__/netlist.test.ts
new file mode 100644
index 0000000..9f9e057
--- /dev/null
+++ b/src/renderer/src/circuit/__tests__/netlist.test.ts
@@ -0,0 +1,154 @@
+/** Golden tests for core/netlist — SPICE generation from the net model. */
+
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { emptyDoc, type CircuitDoc, type CircuitPart, type CircuitWire } from '../core/model'
+import { buildNets } from '../core/nets'
+import { analysisCard, generateNetlist, spiceNum } from '../core/netlist'
+
+let wid = 0
+const wire = (from: string, to: string): CircuitWire => ({
+  id: `w${++wid}`,
+  from,
+  to,
+  view: 'sch'
+})
+const part = (id: string, type: string, attrs?: CircuitPart['attrs']): CircuitPart => ({
+  id,
+  type,
+  attrs,
+  sch: { x: 0, y: 0 }
+})
+
+/** V1 5V across R1(10k) → R2(4.7kΩ) to ground — the RC-divider golden. */
+function divider(): CircuitDoc {
+  const doc = emptyDoc()
+  doc.parts = [
+    part('V1', 'sim-vdc', { voltage: '5' }),
+    part('R1', 'resistor', { resistance: '10k' }),
+    part('R2', 'resistor', { resistance: '4.7kΩ' })
+  ]
+  doc.netLabels = [{ id: 'nl1', name: 'GND', kind: 'ground', sch: { x: 0, y: 0 } }]
+  doc.wires = [
+    wire('V1:+', 'R1:Pin 0'),
+    wire('R1:Pin 1', 'R2:Pin 0'),
+    wire('R2:Pin 1', 'V1:-'),
+    wire('nl1:1', 'V1:-')
+  ]
+  return doc
+}
+
+test('voltage divider golden netlist (.op default, GND node = 0)', () => {
+  const doc = divider()
+  const res = generateNetlist(doc, buildNets(doc), { title: 'divider' })
+  const lines = res.netlist.trim().split('\n')
+  assert.equal(lines[0], '* divider')
+  assert.ok(lines.includes('.op'), 'implicit .op')
+  assert.equal(lines[lines.length - 1], '.end')
+  // one V, two R cards; GND net is node 0
+  const v = lines.find((l) => l.startsWith('VV1'))!
+  const r1 = lines.find((l) => l.startsWith('RR1'))!
+  const r2 = lines.find((l) => l.startsWith('RR2'))!
+  assert.match(v, /^VV1 (\S+) (\S+) DC 5$/)
+  assert.match(r2, /4\.7k$/)
+  const [, vp, vm] = v.match(/^VV1 (\S+) (\S+) DC 5$/)!
+  assert.equal(vm, '0', 'V- rides the GND net')
+  assert.ok(r1.includes(` ${vp} `) || r1.startsWith(`RR1 ${vp} `), 'R1 shares the V+ node')
+  assert.equal(res.warnings.length, 0)
+  assert.equal(res.excluded.length, 0)
+})
+
+test('named net labels become node names; analyses cards from sim config', () => {
+  const doc = divider()
+  doc.netLabels!.push({ id: 'nl2', name: 'OUT', kind: 'net', sch: { x: 0, y: 0 } })
+  doc.wires.push(wire('nl2:1', 'R1:Pin 1'))
+  doc.sim = { analyses: [{ id: 'a1', kind: 'tran', step: '1u', stop: '5m' }] }
+  const res = generateNetlist(doc, buildNets(doc))
+  assert.match(res.netlist, /RR1 \S+ OUT 10k/)
+  assert.ok(res.netlist.includes('.tran 1u 5m'))
+  assert.ok(!res.netlist.includes('.op'), 'explicit analyses replace the default')
+})
+
+test('LED maps anode/cathode by name, model card emitted once', () => {
+  const doc = emptyDoc()
+  doc.parts = [
+    part('V1', 'sim-vdc'),
+    part('LED1', 'led-generic-5mm'),
+    part('LED2', 'led-generic-5mm'),
+    part('R1', 'resistor', { resistance: '220' })
+  ]
+  doc.netLabels = [{ id: 'nl1', name: 'GND', kind: 'ground', sch: { x: 0, y: 0 } }]
+  doc.wires = [
+    wire('V1:+', 'R1:Pin 0'),
+    wire('R1:Pin 1', 'LED1:anode'),
+    wire('LED1:cathode', 'LED2:anode'),
+    wire('LED2:cathode', 'V1:-'),
+    wire('nl1:1', 'V1:-')
+  ]
+  const res = generateNetlist(doc, buildNets(doc), { familyOf: () => 'LED' })
+  const model = res.netlist.split('\n').filter((l) => l.startsWith('.model DLED'))
+  assert.equal(model.length, 1, 'one model card for two LEDs')
+  // anode before cathode in the D card
+  const d1 = res.netlist.split('\n').find((l) => l.startsWith('DLED1'))!
+  const anodeNet = res.netlist.split('\n').find((l) => l.startsWith('RR1'))!.split(' ')[2]
+  assert.equal(d1.split(' ')[1], anodeNet)
+})
+
+test('unknown parts are excluded with a warning; breadboards are transparent', () => {
+  const doc = divider()
+  doc.parts.push(part('U1', 'mystery-module'), part('BB1', 'breadboard-half'))
+  const res = generateNetlist(doc, buildNets(doc), {
+    familyOf: (t) => (t.startsWith('breadboard') ? 'breadboard' : undefined)
+  })
+  assert.deepEqual(res.excluded, ['U1'])
+  assert.ok(res.warnings.some((w) => w.includes('U1')))
+  assert.ok(!res.netlist.includes('BB1'), 'breadboard emits nothing')
+})
+
+test('boards are excluded with an info; open switches drop out, closed conduct', () => {
+  const doc = divider()
+  doc.parts.push(
+    part('U1', 'tinycore'),
+    part('SW1', 'pushbutton'),
+    part('SW2', 'pushbutton', { closed: 'true' })
+  )
+  doc.wires.push(wire('SW2:leg0', 'V1:+'), wire('SW2:leg1', 'R1:Pin 0'))
+  const res = generateNetlist(doc, buildNets(doc), {
+    familyOf: (t) => (t === 'tinycore' ? 'tinyStudio board' : undefined)
+  })
+  assert.ok(res.excluded.includes('U1'))
+  assert.ok(!res.netlist.includes('RSW1'), 'open switch is out')
+  assert.match(res.netlist, /RSW2 \S+ \S+ 1m/)
+})
+
+test('unconnected pins get fresh nc nodes + warnings', () => {
+  const doc = emptyDoc()
+  doc.parts = [part('R1', 'resistor')]
+  doc.wires = []
+  const res = generateNetlist(doc, buildNets(doc))
+  // both pins unconnected → nothing wired, but the card still emits with nc/0
+  assert.ok(res.netlist.split('\n').some((l) => l.startsWith('RR1')))
+})
+
+test('spiceNum normalization', () => {
+  assert.equal(spiceNum('4.7kΩ', '1k'), '4.7k')
+  assert.equal(spiceNum('10 µF', '1u'), '10u')
+  assert.equal(spiceNum('1M', '1'), '1Meg')
+  assert.equal(spiceNum('2m', '1'), '2m')
+  assert.equal(spiceNum(47, '1'), '47')
+  assert.equal(spiceNum(undefined, '5'), '5')
+  assert.equal(spiceNum('100 ohm', '1'), '100')
+})
+
+test('analysisCard forms', () => {
+  assert.equal(analysisCard({ id: 'a', kind: 'op' }), '.op')
+  assert.equal(analysisCard({ id: 'a', kind: 'tran', step: '1u', stop: '10m' }), '.tran 1u 10m')
+  assert.equal(
+    analysisCard({ id: 'a', kind: 'dc', src: 'VV1', from: 0, to: 5, step: 0.1 }),
+    '.dc VV1 0 5 0.1'
+  )
+  assert.equal(
+    analysisCard({ id: 'a', kind: 'ac', points: 20, fstart: '1', fstop: '100k' }),
+    '.ac dec 20 1 100k'
+  )
+})
diff --git a/src/renderer/src/circuit/__tests__/sim.test.ts b/src/renderer/src/circuit/__tests__/sim.test.ts
new file mode 100644
index 0000000..1f5dcb0
--- /dev/null
+++ b/src/renderer/src/circuit/__tests__/sim.test.ts
@@ -0,0 +1,118 @@
+/** Sim integration (spec §14): run ngspice-WASM (eecircuit-engine) on golden
+ * netlists produced by core/netlist and assert spot values within 1%.
+ * The engine is imported from node_modules at runtime (too big to bundle). */
+
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { emptyDoc, type CircuitPart, type CircuitWire } from '../core/model'
+import { buildNets } from '../core/nets'
+import { generateNetlist } from '../core/netlist'
+
+interface EngineSim {
+  start: () => Promise<void>
+  setNetList: (s: string) => void
+  runSim: () => Promise<{
+    numPoints: number
+    data: { name: string; values: number[] }[]
+  }>
+  getError: () => string[]
+}
+
+async function makeSim(): Promise<EngineSim> {
+  const href = pathToFileURL(
+    join(process.cwd(), 'node_modules', 'eecircuit-engine', 'dist', 'eecircuit-engine.mjs')
+  ).href
+  const mod = (await import(href)) as { Simulation: new () => EngineSim }
+  const sim = new mod.Simulation()
+  await sim.start()
+  return sim
+}
+
+let wid = 0
+const wire = (from: string, to: string): CircuitWire => ({
+  id: `w${++wid}`,
+  from,
+  to,
+  view: 'sch'
+})
+const part = (id: string, type: string, attrs?: CircuitPart['attrs']): CircuitPart => ({
+  id,
+  type,
+  attrs,
+  sch: { x: 0, y: 0 }
+})
+
+const vec = (
+  res: { data: { name: string; values: number[] }[] },
+  name: string
+): number[] | undefined => res.data.find((d) => d.name.toLowerCase() === name)?.values
+
+test('engine solves the generated divider .op within 1%', async () => {
+  const doc = emptyDoc()
+  doc.parts = [
+    part('V1', 'sim-vdc', { voltage: '5' }),
+    part('R1', 'resistor', { resistance: '10k' }),
+    part('R2', 'resistor', { resistance: '4.7k' })
+  ]
+  doc.netLabels = [
+    { id: 'nl1', name: 'GND', kind: 'ground', sch: { x: 0, y: 0 } },
+    { id: 'nl2', name: 'OUT', kind: 'net', sch: { x: 0, y: 0 } }
+  ]
+  doc.wires = [
+    wire('V1:+', 'R1:Pin 0'),
+    wire('R1:Pin 1', 'R2:Pin 0'),
+    wire('R2:Pin 1', 'V1:-'),
+    wire('nl1:1', 'V1:-'),
+    wire('nl2:1', 'R1:Pin 1')
+  ]
+  const { netlist, warnings } = generateNetlist(doc, buildNets(doc))
+  assert.equal(warnings.length, 0)
+
+  const sim = await makeSim()
+  sim.setNetList(netlist)
+  const res = await sim.runSim()
+  assert.equal(res.numPoints, 1)
+  const out = vec(res, 'v(out)')
+  assert.ok(out, `v(out) present (got: ${res.data.map((d) => d.name).join(', ')})`)
+  const expected = 5 * (4.7 / 14.7)
+  assert.ok(Math.abs(out![0] - expected) / expected < 0.01, `v(out)=${out![0]} ≈ ${expected}`)
+})
+
+test('engine runs a generated RC transient with sane charge curve', async () => {
+  const doc = emptyDoc()
+  doc.parts = [
+    part('V1', 'sim-vdc', { voltage: '5' }),
+    part('R1', 'resistor', { resistance: '1k' }),
+    part('C1', 'capacitor-ceramic-100mil', { capacitance: '1u' })
+  ]
+  doc.netLabels = [
+    { id: 'nl1', name: 'GND', kind: 'ground', sch: { x: 0, y: 0 } },
+    { id: 'nl2', name: 'OUT', kind: 'net', sch: { x: 0, y: 0 } }
+  ]
+  doc.wires = [
+    wire('V1:+', 'R1:Pin 0'),
+    wire('R1:Pin 1', 'C1:0'),
+    wire('C1:1', 'V1:-'),
+    wire('nl1:1', 'V1:-'),
+    wire('nl2:1', 'C1:0')
+  ]
+  doc.sim = { analyses: [{ id: 'a1', kind: 'tran', step: '10u', stop: '5m', uic: true }] }
+  const { netlist } = generateNetlist(doc, buildNets(doc))
+
+  const sim = await makeSim()
+  sim.setNetList(netlist)
+  const res = await sim.runSim()
+  assert.ok(res.numPoints > 50, 'transient produced a waveform')
+  const t = vec(res, 'time')!
+  const out = vec(res, 'v(out)')!
+  assert.ok(t && out && t.length === out.length)
+  // fully charged by 5·RC = 5 ms → within 1% of 5 V at the end
+  const final = out[out.length - 1]
+  assert.ok(Math.abs(final - 5) / 5 < 0.01, `final=${final}`)
+  // at t ≈ RC (1 ms) the cap sits near 5·(1-1/e) ≈ 3.161 V (±5% for step interp)
+  const i = t.findIndex((x) => x >= 1e-3)
+  const atRc = out[i]
+  assert.ok(Math.abs(atRc - 3.161) / 3.161 < 0.05, `v(RC)=${atRc}`)
+})
diff --git a/src/renderer/src/circuit/core/netlist.ts b/src/renderer/src/circuit/core/netlist.ts
new file mode 100644
index 0000000..917f6ec
--- /dev/null
+++ b/src/renderer/src/circuit/core/netlist.ts
@@ -0,0 +1,376 @@
+/**
+ * circuit/core/netlist — SPICE netlist generation (M4, spec §10.2).
+ *
+ * Pure: takes the document + a prebuilt NetModel (so breadboard seating and
+ * registry buses are included exactly as the editor sees them) and returns
+ * netlist text + node naming + warnings. No React, no DOM, no engine — the
+ * SimBackend consumes the text; tests golden-file it.
+ *
+ * Node naming: a net named GND (ground labels) is node `0`; other named nets
+ * keep their (sanitized) label name; everything else is `n<k>` in stable net
+ * order — diffable golden files.
+ *
+ * Part mapping: built-in table keyed on family/type keywords (resistor, led,
+ * battery, the sim-* sources…). Pins are matched by name (anode/cathode/+/-)
+ * with positional fallback, since the Fritzing catalogue is inconsistent
+ * ("Pin 0" vs "leg1" vs "0"). Parts without a mapping: breadboards are
+ * transparent (their buses already merged nets), boards/MCUs are excluded
+ * with an info (model their pins with sources — §10.2.5), other parts are
+ * excluded with a warning. The curated tinyparts overlay replaces this table
+ * eventually; keep the shape compatible.
+ */
+
+import type { Analysis, CircuitDoc, CircuitPart } from './model'
+import type { NetModel } from './nets'
+
+// ── SPICE value normalization ────────────────────────────────────────────────
+
+/** Normalize a human attr ("4.7kΩ", "10 µF", "1M") into a SPICE number.
+ * Note SPICE reads `m` as milli — a trailing capital M (common for megohm)
+ * becomes `Meg`; lowercase m stays milli. */
+export function spiceNum(v: string | number | boolean | undefined, fallback: string): string {
+  if (v === undefined || v === true || v === false) return fallback
+  let s = String(v).trim()
+  if (!s) return fallback
+  s = s
+    .replace(/[ΩΩ]|ohms?/gi, '')
+    .replace(/([0-9.]\s*[a-zµμ]*)[FH]$/i, '$1') // unit letters after value/prefix
+    .replace(/[µμ]/g, 'u')
+    .replace(/\s+/g, '')
+  s = s.replace(/^([0-9.eE+-]+)M$/, '$1Meg') // capital M = mega by human convention
+  return s || fallback
+}
+
+/** SPICE-safe node token from a net-label name. */
+function nodeToken(name: string): string {
+  return name.replace(/[^A-Za-z0-9_.]+/g, '_')
+}
+
+// ── part mapping ─────────────────────────────────────────────────────────────
+
+export interface SpiceCard {
+  /** element line(s), fully substituted */
+  lines: string[]
+  /** .model card emitted once per model name */
+  model?: { name: string; card: string }
+}
+
+export type MappingKind = 'element' | 'transparent' | 'board' | 'unknown'
+
+export interface NetlistOptions {
+  /** family for a part type (from the parts registry); improves matching */
+  familyOf?: (type: string) => string | undefined
+  title?: string
+}
+
+export interface NetlistResult {
+  netlist: string
+  /** node name per net index (annotation UI: net → voltage vector name) */
+  nodeOfNet: string[]
+  warnings: string[]
+  /** part ids not simulated (unknown/board) */
+  excluded: string[]
+}
+
+interface Ctx {
+  part: CircuitPart
+  /** ordered pin names actually referenced by nets or the registry — here we
+   * only know what the doc wired; order = wire discovery order. */
+  nodeOf: (pin: string) => string
+  pins: string[]
+  attr: (names: string[], fallback: string) => string
+  warn: (msg: string) => void
+}
+
+/** Find a pin matching any regex, else positional fallback (and warn). */
+function pinLike(ctx: Ctx, res: RegExp[], positional: number, what: string): string {
+  for (const re of res) {
+    const hit = ctx.pins.find((p) => re.test(p))
+    if (hit) return ctx.nodeOf(hit)
+  }
+  const p = ctx.pins[positional]
+  if (p === undefined) {
+    ctx.warn(`${ctx.part.id}: no pin for ${what} — grounded`)
+    return '0'
+  }
+  return ctx.nodeOf(p)
+}
+
+const two = (ctx: Ctx): [string, string] => {
+  const a = ctx.pins[0]
+  const b = ctx.pins[1]
+  return [a !== undefined ? ctx.nodeOf(a) : '0', b !== undefined ? ctx.nodeOf(b) : '0']
+}
+
+const PLUS = [/^\+$/, /anode/i, /^vcc$/i, /pos/i]
+const MINUS = [/^-$/, /cathode|kath/i, /^gnd$/i, /neg/i]
+
+type Emitter = (ctx: Ctx) => SpiceCard | null
+
+const LED_MODEL = { name: 'DLED', card: '.model DLED D(IS=1e-22 N=2.2 RS=2)' }
+const D_MODEL = { name: 'DGEN', card: '.model DGEN D(IS=1e-14 N=1.9 RS=0.1)' }
+const NPN_MODEL = { name: 'QNPN', card: '.model QNPN NPN(BF=150 VAF=100)' }
+const PNP_MODEL = { name: 'QPNP', card: '.model QPNP PNP(BF=150 VAF=100)' }
+
+const EMITTERS: { match: RegExp; kind?: MappingKind; emit?: Emitter }[] = [
+  { match: /breadboard/i, kind: 'transparent' },
+  { match: /tinystudio|microcontroller|\bboard\b|arduino|esp32/i, kind: 'board' },
+  {
+    match: /sim-vdc|voltage source|battery/i,
+    emit: (c) => ({
+      lines: [
+        `V${c.part.id} ${pinLike(c, PLUS, 0, '+')} ${pinLike(c, MINUS, 1, '-')} DC ${c.attr(
+          ['voltage', 'value'],
+          '5'
+        )}`
+      ]
+    })
+  },
+  {
+    match: /sim-vsin|sine|waveform/i,
+    emit: (c) => ({
+      lines: [
+        `V${c.part.id} ${pinLike(c, PLUS, 0, '+')} ${pinLike(c, MINUS, 1, '-')} SIN(${c.attr(
+          ['offset'],
+          '0'
+        )} ${c.attr(['amplitude', 'value'], '1')} ${c.attr(['frequency', 'freq'], '1k')})`
+      ]
+    })
+  },
+  {
+    match: /sim-idc|current source/i,
+    emit: (c) => ({
+      lines: [
+        `I${c.part.id} ${pinLike(c, PLUS, 0, '+')} ${pinLike(c, MINUS, 1, '-')} DC ${c.attr(
+          ['current', 'value'],
+          '1m'
+        )}`
+      ]
+    })
+  },
+  {
+    match: /resistor|photocell|ldr|thermistor/i,
+    emit: (c) => {
+      const [a, b] = two(c)
+      return { lines: [`R${c.part.id} ${a} ${b} ${c.attr(['resistance', 'value'], '1k')}`] }
+    }
+  },
+  {
+    match: /potentiometer|trimmer/i,
+    emit: (c) => {
+      const total = c.attr(['resistance', 'value'], '10k')
+      const posRaw = c.attr(['position'], '0.5')
+      const pos = Math.min(Math.max(parseFloat(posRaw) || 0.5, 0.001), 0.999)
+      const l1 = pinLike(c, [/leg1|^1$/i], 0, 'leg1')
+      const w = pinLike(c, [/wiper|^2$/i], 1, 'wiper')
+      const l2 = pinLike(c, [/leg2|^3$/i], 2, 'leg2')
+      return {
+        lines: [
+          `R${c.part.id}a ${l1} ${w} ${spiceScale(total, pos)}`,
+          `R${c.part.id}b ${w} ${l2} ${spiceScale(total, 1 - pos)}`
+        ]
+      }
+    }
+  },
+  {
+    match: /capacitor/i,
+    emit: (c) => {
+      const plus = c.pins.find((p) => PLUS.some((re) => re.test(p)))
+      const minus = c.pins.find((p) => MINUS.some((re) => re.test(p)))
+      const [a, b] =
+        plus && minus ? [c.nodeOf(plus), c.nodeOf(minus)] : two(c)
+      return { lines: [`C${c.part.id} ${a} ${b} ${c.attr(['capacitance', 'value'], '100n')}`] }
+    }
+  },
+  {
+    match: /inductor/i,
+    emit: (c) => {
+      const [a, b] = two(c)
+      return { lines: [`L${c.part.id} ${a} ${b} ${c.attr(['inductance', 'value'], '10u')}`] }
+    }
+  },
+  {
+    match: /led/i,
+    emit: (c) => ({
+      lines: [
+        `D${c.part.id} ${pinLike(c, [/anode/i, /^\+$/], 1, 'anode')} ${pinLike(
+          c,
+          [/cathode|kath/i, /^-$/],
+          0,
+          'cathode'
+        )} ${LED_MODEL.name}`
+      ],
+      model: LED_MODEL
+    })
+  },
+  {
+    match: /diode|zener/i,
+    emit: (c) => ({
+      lines: [
+        `D${c.part.id} ${pinLike(c, [/anode/i], 1, 'anode')} ${pinLike(
+          c,
+          [/cathode|kath/i],
+          0,
+          'cathode'
+        )} ${D_MODEL.name}`
+      ],
+      model: D_MODEL
+    })
+  },
+  {
+    match: /npn/i,
+    emit: (c) => ({
+      lines: [
+        `Q${c.part.id} ${pinLike(c, [/^c/i], 2, 'C')} ${pinLike(c, [/^b/i], 1, 'B')} ${pinLike(
+          c,
+          [/^e/i],
+          0,
+          'E'
+        )} ${NPN_MODEL.name}`
+      ],
+      model: NPN_MODEL
+    })
+  },
+  {
+    match: /pnp/i,
+    emit: (c) => ({
+      lines: [
+        `Q${c.part.id} ${pinLike(c, [/^c/i], 2, 'C')} ${pinLike(c, [/^b/i], 1, 'B')} ${pinLike(
+          c,
+          [/^e/i],
+          0,
+          'E'
+        )} ${PNP_MODEL.name}`
+      ],
+      model: PNP_MODEL
+    })
+  },
+  {
+    match: /switch|button/i,
+    emit: (c) => {
+      const closed = c.part.attrs?.closed === true || c.part.attrs?.closed === 'true'
+      if (!closed) return null // open switch = not in the circuit
+      const [a, b] = two(c)
+      return { lines: [`R${c.part.id} ${a} ${b} 1m`] }
+    }
+  }
+]
+
+/** total like "10k" scaled by a fraction → SPICE number (e.g. 10k*0.5 → 5000). */
+function spiceScale(total: string, frac: number): string {
+  const m = total.match(/^([0-9.eE+-]+)\s*(Meg|[kKmunpfgt])?$/)
+  if (!m) return total
+  const mult: Record<string, number> = {
+    Meg: 1e6, k: 1e3, K: 1e3, m: 1e-3, u: 1e-6, n: 1e-9, p: 1e-12, f: 1e-15, g: 1e9, t: 1e12
+  }
+  const base = parseFloat(m[1]) * (m[2] ? mult[m[2]] : 1)
+  const v = base * frac
+  return v >= 1 ? String(Math.round(v * 100) / 100) : v.toExponential(3)
+}
+
+// ── generator ────────────────────────────────────────────────────────────────
+
+export function generateNetlist(
+  doc: CircuitDoc,
+  net: NetModel,
+  opts: NetlistOptions = {}
+): NetlistResult {
+  const warnings: string[] = []
+  const excluded: string[] = []
+
+  // node names per net (spec §10.2.2)
+  let seq = 1
+  const nodeOfNet = net.nets.map((_members, i) => {
+    const name = net.netNames[i]
+    if (name && name.toUpperCase() === 'GND') return '0'
+    if (name) return nodeToken(name)
+    return `n${seq++}`
+  })
+  let ncSeq = 1
+
+  const lines: string[] = []
+  const models = new Map<string, string>()
+
+  for (const part of doc.parts) {
+    const family = opts.familyOf?.(part.type) ?? ''
+    const key = `${part.type} ${family}`
+    const entry = EMITTERS.find((e) => e.match.test(key))
+    if (!entry) {
+      excluded.push(part.id)
+      warnings.push(`${part.id} (${part.type}) has no simulation model — excluded`)
+      continue
+    }
+    if (entry.kind === 'transparent') continue
+    if (entry.kind === 'board') {
+      excluded.push(part.id)
+      warnings.push(`${part.id} (${part.type}) is a board — not simulated; drive its pins with sources`)
+      continue
+    }
+
+    // pins this part exposes to the net model (wired or seated)
+    const pins: string[] = []
+    for (const [ref] of net.pinToNet) {
+      const idx = ref.lastIndexOf(':')
+      if (ref.slice(0, idx) === part.id) pins.push(ref.slice(idx + 1))
+    }
+    const ctx: Ctx = {
+      part,
+      pins,
+      nodeOf: (pin) => {
+        const idx = net.pinToNet.get(`${part.id}:${pin}`)
+        if (idx === undefined) {
+          warnings.push(`${part.id}:${pin} is unconnected`)
+          return `nc${ncSeq++}`
+        }
+        return nodeOfNet[idx]
+      },
+      attr: (names, fallback) => {
+        for (const n of names) {
+          const v = part.attrs?.[n]
+          if (v !== undefined) return spiceNum(v, fallback)
+        }
+        return fallback
+      },
+      warn: (m) => warnings.push(m)
+    }
+    const card = entry.emit!(ctx)
+    if (!card) continue
+    lines.push(...card.lines)
+    if (card.model) models.set(card.model.name, card.model.card)
+  }
+
+  // analyses (spec §10.2.4) — default to .op
+  const analyses = (doc.sim?.analyses ?? []).filter((a) => a.enabled !== false)
+  const cards = analyses.length ? analyses.map(analysisCard).filter(Boolean) : ['.op']
+
+  const text = [
+    `* ${opts.title ?? 'tinyStudio circuit'}`,
+    ...lines,
+    ...[...models.values()].sort(),
+    ...(cards as string[]),
+    '.end',
+    ''
+  ].join('\n')
+
+  return { netlist: text, nodeOfNet, warnings, excluded }
+}
+
+export function analysisCard(a: Analysis): string | null {
+  const f = (k: string, d = ''): string => spiceNum(a[k] as string | number | undefined, d)
+  switch (a.kind) {
+    case 'op':
+      return '.op'
+    case 'tran':
+      // uic: skip the DC bias solve and start from zero initial conditions
+      return `.tran ${f('step', '10u')} ${f('stop', '10m')}${a.uic ? ' uic' : ''}`
+    case 'dc':
+      return a.src ? `.dc ${a.src} ${f('from', '0')} ${f('to', '5')} ${f('step', '0.1')}` : null
+    case 'ac':
+      return `.ac ${(a.variation as string) || 'dec'} ${f('points', '20')} ${f(
+        'fstart',
+        '1'
+      )} ${f('fstop', '1Meg')}`
+    default:
+      return null
+  }
+}
diff --git a/src/renderer/src/circuit/parts/simParts.ts b/src/renderer/src/circuit/parts/simParts.ts
new file mode 100644
index 0000000..2051d4b
--- /dev/null
+++ b/src/renderer/src/circuit/parts/simParts.ts
@@ -0,0 +1,101 @@
+/**
+ * circuit/parts/simParts — builtin simulation sources (M4, spec §10.3).
+ *
+ * Generated two-pin source symbols (DC voltage, sine, DC current) in the
+ * classic circle style. Both views get the same art so a source is placeable
+ * on the breadboard too (its pins seat in holes like any part). Pins land on
+ * the 9.6 grid; ink follows the theme via var(--text-strong) like symbols.ts.
+ *
+ * The netlist generator maps these by type (sim-vdc / sim-vsin / sim-idc);
+ * editable attrs (voltage, amplitude, frequency, current) ride Part attrs and
+ * are exposed in the Inspector like any other attr.
+ */
+
+import type { PartDef, PartView } from '../../lib/partsLibrary'
+import { GRID_BB } from '../core/model'
+
+const P = GRID_BB // 9.6
+const INK = 'var(--text-strong)'
+const STROKE = 2
+
+export interface SimSourceSpec {
+  type: string
+  label: string
+  /** default attrs applied on placement (editable in the Inspector) */
+  attrs: Record<string, string>
+  glyph: (cx: number, cy: number, r: number) => string
+}
+
+export const SIM_SOURCES: SimSourceSpec[] = [
+  {
+    type: 'sim-vdc',
+    label: 'DC voltage',
+    attrs: { voltage: '5' },
+    glyph: (cx, cy, r) =>
+      `<line x1="${cx - r * 0.35}" y1="${cy - r * 0.45}" x2="${cx + r * 0.35}" y2="${cy - r * 0.45}" stroke="${INK}" stroke-width="${STROKE}"/>` +
+      `<line x1="${cx}" y1="${cy - r * 0.45 - r * 0.35}" x2="${cx}" y2="${cy - r * 0.45 + r * 0.35}" stroke="${INK}" stroke-width="${STROKE}"/>` +
+      `<line x1="${cx - r * 0.35}" y1="${cy + r * 0.45}" x2="${cx + r * 0.35}" y2="${cy + r * 0.45}" stroke="${INK}" stroke-width="${STROKE}"/>`
+  },
+  {
+    type: 'sim-vsin',
+    label: 'Sine source',
+    attrs: { amplitude: '1', frequency: '1k' },
+    glyph: (cx, cy, r) =>
+      `<path d="M ${cx - r * 0.55} ${cy} q ${r * 0.28} ${-r * 0.8} ${r * 0.55} 0 q ${r * 0.28} ${r * 0.8} ${r * 0.55} 0" fill="none" stroke="${INK}" stroke-width="${STROKE}" stroke-linecap="round"/>`
+  },
+  {
+    type: 'sim-idc',
+    label: 'DC current',
+    attrs: { current: '10m' },
+    glyph: (cx, cy, r) =>
+      `<line x1="${cx}" y1="${cy + r * 0.55}" x2="${cx}" y2="${cy - r * 0.55}" stroke="${INK}" stroke-width="${STROKE}"/>` +
+      `<path d="M ${cx - r * 0.3} ${cy - r * 0.15} L ${cx} ${cy - r * 0.55} L ${cx + r * 0.3} ${cy - r * 0.15}" fill="none" stroke="${INK}" stroke-width="${STROKE}" stroke-linejoin="round"/>`
+  }
+]
+
+const cache = new Map<string, PartDef>()
+
+export function generateSimSource(spec: SimSourceSpec): PartDef {
+  const hit = cache.get(spec.type)
+  if (hit) return hit
+
+  const w = 4 * P
+  const h = 6 * P
+  const cx = 2 * P
+  const cy = 3 * P
+  const r = 1.5 * P
+
+  const svg =
+    `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${w} ${h}">` +
+    `<line x1="${cx}" y1="0" x2="${cx}" y2="${cy - r}" stroke="${INK}" stroke-width="${STROKE}"/>` +
+    `<line x1="${cx}" y1="${cy + r}" x2="${cx}" y2="${h}" stroke="${INK}" stroke-width="${STROKE}"/>` +
+    `<circle cx="${cx}" cy="${cy}" r="${r}" fill="none" stroke="${INK}" stroke-width="${STROKE}"/>` +
+    `<text x="${cx + r + 3}" y="${cy - r}" fill="${INK}" font-family="monospace" font-size="7">+</text>` +
+    spec.glyph(cx, cy, r) +
+    `</svg>`
+
+  const view: PartView = {
+    svg,
+    w,
+    h,
+    pins: { '+': [cx, 0], '-': [cx, h] }
+  }
+  const def: PartDef = {
+    type: spec.type,
+    label: spec.label,
+    family: 'Source',
+    builtin: true,
+    views: { breadboard: view, schematic: view }
+  }
+  cache.set(spec.type, def)
+  return def
+}
+
+export function isSimSource(type: string): boolean {
+  return SIM_SOURCES.some((s) => s.type === type)
+}
+
+/** Default attrs for a just-placed source (Inspector-editable). */
+export function simSourceDefaultAttrs(type: string): Record<string, string> | undefined {
+  return SIM_SOURCES.find((s) => s.type === type)?.attrs
+}
diff --git a/src/renderer/src/circuit/sim/backend.ts b/src/renderer/src/circuit/sim/backend.ts
new file mode 100644
index 0000000..8b87a0b
--- /dev/null
+++ b/src/renderer/src/circuit/sim/backend.ts
@@ -0,0 +1,49 @@
+/**
+ * circuit/sim/backend — the SimBackend abstraction (M4, spec §10.1/§10.6).
+ *
+ * Engine-agnostic on purpose: today's implementation is ngspice-WASM
+ * (eecircuit-engine) in a Web Worker; the M4 bake-off may swap in tscircuit's
+ * build, and the future tinyservice MCU co-sim backend implements the same
+ * interface. Nothing outside sim/ may assume "SPICE only".
+ */
+
+export interface SimVector {
+  name: string
+  type: 'voltage' | 'current' | 'time' | 'frequency' | 'notype'
+  values: number[]
+  /** present for complex (AC) results */
+  imag?: number[]
+}
+
+export interface SimRun {
+  header: string
+  numPoints: number
+  vectors: SimVector[]
+}
+
+export interface SimFailure {
+  message: string
+  details?: string[]
+}
+
+export class SimError extends Error {
+  details?: string[]
+  constructor(f: SimFailure) {
+    super(f.message)
+    this.details = f.details
+  }
+}
+
+export interface SimBackend {
+  /** Run a netlist; resolves with vectors or rejects with SimError. */
+  run(netlist: string, timeoutMs?: number): Promise<SimRun>
+  /** Abort the in-flight run (terminates + respawns the engine). */
+  cancel(): void
+  dispose(): void
+}
+
+/** Find `v(<node>)` in a result set (ngspice lowercases vector names). */
+export function voltageOf(run: SimRun, node: string): SimVector | undefined {
+  const key = `v(${node.toLowerCase()})`
+  return run.vectors.find((v) => v.name.toLowerCase() === key)
+}
diff --git a/src/renderer/src/circuit/sim/engine.ts b/src/renderer/src/circuit/sim/engine.ts
new file mode 100644
index 0000000..e091327
--- /dev/null
+++ b/src/renderer/src/circuit/sim/engine.ts
@@ -0,0 +1,85 @@
+/**
+ * circuit/sim/engine — the worker-hosted SPICE backend (M4, spec §10.1).
+ *
+ * Wraps simWorker.ts with a typed request/response protocol, a watchdog
+ * (default 10 s — WASM ngspice can spin on non-convergence), and cancellation
+ * by terminate+respawn (ngspice has no reentrant abort). The first run pays
+ * the engine download/compile; the instance is reused after that.
+ */
+
+import SimWorker from './simWorker?worker'
+import { SimError, type SimBackend, type SimFailure, type SimRun } from './backend'
+
+interface Pending {
+  resolve: (r: SimRun) => void
+  reject: (e: Error) => void
+  timer: ReturnType<typeof setTimeout>
+}
+
+export class SpiceWorkerBackend implements SimBackend {
+  private worker: Worker | null = null
+  private pending = new Map<number, Pending>()
+  private seq = 0
+
+  private spawn(): Worker {
+    if (this.worker) return this.worker
+    const w: Worker = new SimWorker()
+    w.onmessage = (
+      e: MessageEvent<{ id: number; ok: boolean; result?: SimRun; error?: SimFailure }>
+    ): void => {
+      const p = this.pending.get(e.data.id)
+      if (!p) return
+      this.pending.delete(e.data.id)
+      clearTimeout(p.timer)
+      if (e.data.ok && e.data.result) p.resolve(e.data.result)
+      else p.reject(new SimError(e.data.error ?? { message: 'simulation failed' }))
+    }
+    w.onerror = (e): void => {
+      this.failAll(new SimError({ message: e.message || 'simulation worker crashed' }))
+      this.worker = null
+      w.terminate()
+    }
+    this.worker = w
+    return w
+  }
+
+  run(netlist: string, timeoutMs = 10000): Promise<SimRun> {
+    const id = ++this.seq
+    const w = this.spawn()
+    return new Promise<SimRun>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id)
+        this.cancel() // engine may be stuck in WASM — replace it
+        reject(new SimError({ message: `simulation timed out after ${timeoutMs / 1000}s` }))
+      }, timeoutMs)
+      this.pending.set(id, { resolve, reject, timer })
+      w.postMessage({ id, netlist })
+    })
+  }
+
+  cancel(): void {
+    this.failAll(new SimError({ message: 'simulation cancelled' }))
+    this.worker?.terminate()
+    this.worker = null // respawned lazily on the next run
+  }
+
+  dispose(): void {
+    this.cancel()
+  }
+
+  private failAll(err: Error): void {
+    for (const [, p] of this.pending) {
+      clearTimeout(p.timer)
+      p.reject(err)
+    }
+    this.pending.clear()
+  }
+}
+
+let shared: SimBackend | null = null
+
+/** App-wide backend instance (the engine is heavy — share it across tabs). */
+export function getSimBackend(): SimBackend {
+  if (!shared) shared = new SpiceWorkerBackend()
+  return shared
+}
diff --git a/src/renderer/src/circuit/sim/index.ts b/src/renderer/src/circuit/sim/index.ts
new file mode 100644
index 0000000..af79fe4
--- /dev/null
+++ b/src/renderer/src/circuit/sim/index.ts
@@ -0,0 +1,9 @@
+export {
+  SimError,
+  voltageOf,
+  type SimBackend,
+  type SimFailure,
+  type SimRun,
+  type SimVector
+} from './backend'
+export { getSimBackend, SpiceWorkerBackend } from './engine'
diff --git a/src/renderer/src/circuit/sim/simWorker.ts b/src/renderer/src/circuit/sim/simWorker.ts
new file mode 100644
index 0000000..95391ef
--- /dev/null
+++ b/src/renderer/src/circuit/sim/simWorker.ts
@@ -0,0 +1,78 @@
+/**
+ * circuit/sim/simWorker — ngspice-WASM in a module worker (M4).
+ *
+ * The engine (eecircuit-engine ≈20 MB with embedded WASM) is imported lazily
+ * on the first message so opening the Circuit tab costs nothing; Vite splits
+ * it into its own chunk. One Simulation instance is reused across runs —
+ * cancellation is handled by the owner terminating this worker entirely.
+ *
+ * Protocol: { id, netlist } in → { id, ok: true, result } | { id, ok: false,
+ * error: { message, details } } out.
+ */
+
+import type { SimRun, SimVector } from './backend'
+
+interface EngineResult {
+  header: string
+  numVariables: number
+  variableNames: string[]
+  numPoints: number
+  dataType: 'real' | 'complex'
+  data: {
+    name: string
+    type: SimVector['type']
+    values: (number | { real: number; img: number })[]
+  }[]
+}
+
+interface EngineSim {
+  start: () => Promise<void>
+  setNetList: (s: string) => void
+  runSim: () => Promise<EngineResult>
+  getError: () => string[]
+}
+
+let sim: EngineSim | null = null
+
+function convert(res: EngineResult): SimRun {
+  const vectors: SimVector[] = res.data.map((d) => {
+    if (res.dataType === 'complex') {
+      const cx = d.values as { real: number; img: number }[]
+      return {
+        name: d.name,
+        type: d.type,
+        values: cx.map((v) => v.real),
+        imag: cx.map((v) => v.img)
+      }
+    }
+    return { name: d.name, type: d.type, values: d.values as number[] }
+  })
+  return { header: res.header, numPoints: res.numPoints, vectors }
+}
+
+self.onmessage = async (e: MessageEvent<{ id: number; netlist: string }>): Promise<void> => {
+  const { id, netlist } = e.data
+  try {
+    if (!sim) {
+      const mod = (await import('eecircuit-engine')) as {
+        Simulation: new () => EngineSim
+      }
+      sim = new mod.Simulation()
+      await sim.start()
+    }
+    sim.setNetList(netlist)
+    const result = await sim.runSim()
+    const errors = sim.getError()
+    if ((!result || result.numPoints === 0) && errors.length) {
+      self.postMessage({ id, ok: false, error: { message: errors[0], details: errors } })
+      return
+    }
+    self.postMessage({ id, ok: true, result: convert(result) })
+  } catch (err) {
+    self.postMessage({
+      id,
+      ok: false,
+      error: { message: err instanceof Error ? err.message : String(err) }
+    })
+  }
+}
diff --git a/src/renderer/src/circuit/views/CircuitView.tsx b/src/renderer/src/circuit/views/CircuitView.tsx
index 8ea20fb..1626672 100644
--- a/src/renderer/src/circuit/views/CircuitView.tsx
+++ b/src/renderer/src/circuit/views/CircuitView.tsx
@@ -20,6 +20,7 @@ import {
   Info,
   Maximize,
   Pencil,
+  Play,
   Redo2,
   ShieldCheck,
   TriangleAlert,
@@ -41,6 +42,7 @@ import { runErc, type ErcIssue, type ErcSeverity } from '../core/erc'
 import { nextRefdes, prefixForFamily } from '../core/refdes'
 import { CircuitStore } from '../core/store'
 import { BREADBOARDS, generateBreadboard, isBreadboard } from '../parts/breadboard'
+import { SIM_SOURCES, generateSimSource, simSourceDefaultAttrs } from '../parts/simParts'
 import { snapNetLabel } from '../parts/netLabels'
 import { Canvas, emptySel, type Cam, type CanvasHandle, type Selection } from './canvas/Canvas'
 import { exportPng, exportSvg } from './exportImage'
@@ -51,8 +53,10 @@ import {
   ercFloatingPins,
   findFreePlacement,
   implicitSeats,
+  pinWorldOf,
   ratsnest
 } from './partsAdapter'
+import { SimPanel, fmtSI, type SimState } from './sim/SimPanel'
 
 export function CircuitViewV2({
   content,
@@ -69,6 +73,7 @@ export function CircuitViewV2({
     // procedural breadboards live in the legacy registry until the M2+ pack
     // registry replaces it — register once, before first geometry pass
     for (const s of BREADBOARDS) if (!getPart(s.type)) registerPart(generateBreadboard(s).def)
+    for (const s of SIM_SOURCES) if (!getPart(s.type)) registerPart(generateSimSource(s))
     return CircuitStore.fromFile(content)
   })
   const revision = React.useSyncExternalStore(store.subscribe, store.getRevision)
@@ -82,6 +87,8 @@ export function CircuitViewV2({
   const [cam, setCam] = React.useState<Cam>({ scale: 1, tx: 40, ty: 40 })
   const [editorPart, setEditorPart] = React.useState<PartDef | null | undefined>(undefined)
   const [showErc, setShowErc] = React.useState(false)
+  const [showSim, setShowSim] = React.useState(false)
+  const [sim, setSim] = React.useState<SimState>({ run: null, netlist: null })
   const [defsTick, bumpDefs] = React.useReducer((n: number) => n + 1, 0)
   const canvasRef = React.useRef<CanvasHandle>(null)
 
@@ -138,6 +145,32 @@ export function CircuitViewV2({
       }),
     [doc, seats]
   )
+
+  // sim results go stale the moment the circuit changes — drop them
+  React.useEffect(() => {
+    setSim((s) => (s.run || s.netlist ? { run: null, netlist: null } : s))
+  }, [doc])
+
+  // DC (.op) node voltages → world-anchored chips at one pin per net
+  const simAnnotations = React.useMemo(() => {
+    if (!sim.run || sim.run.numPoints !== 1 || !sim.netlist) return []
+    const out: { x: number; y: number; text: string }[] = []
+    sim.netlist.nodeOfNet.forEach((node, i) => {
+      if (node === '0') return
+      const vec = sim.run!.vectors.find((v) => v.name.toLowerCase() === `v(${node.toLowerCase()})`)
+      if (!vec || vec.values.length !== 1) return
+      for (const ref of netModel.nets[i] ?? []) {
+        const ci = ref.lastIndexOf(':')
+        const part = doc.parts.find((p) => p.id === ref.slice(0, ci))
+        if (!part) continue
+        const pt = pinWorldOf(part, ref.slice(ci + 1), undefined, view)
+        if (!pt) continue
+        out.push({ x: pt.x, y: pt.y, text: fmtSI(vec.values[0], 'V') })
+        break
+      }
+    })
+    return out
+  }, [sim, netModel, doc, view])
   // nets satisfied elsewhere but unrouted here → dashed guidance (spec §8.2)
   const rats = React.useMemo(() => ratsnest(doc, view, netModel), [doc, view, netModel, defsTick])
   // ERC: net-model rules + view-side floating-pin findings (spec §9)
@@ -209,7 +242,8 @@ export function CircuitViewV2({
     const p = at ?? canvasRef.current?.centerWorld() ?? { x: 300, y: 200 }
     const id = nextRefdes(store.getDoc(), prefixForFamily(`${def.family ?? ''} ${def.type}`))
     const pl = findFreePlacement(store.getDoc(), type, view, p)
-    store.dispatch(cmd.addPart({ id, type, [view]: pl }))
+    const attrs = simSourceDefaultAttrs(type)
+    store.dispatch(cmd.addPart({ id, type, ...(attrs ? { attrs } : {}), [view]: pl }))
     setSel({ parts: new Set([id]), wires: new Set() })
   }
 
@@ -348,6 +382,13 @@ export function CircuitViewV2({
 
         {/* right toolbar: export / grid / code */}
         <div className="absolute top-3 right-3.5 z-10 flex gap-1.5">
+          <button
+            className={`${tool} w-8 justify-center px-0 ${showSim ? 'text-brand' : ''}`}
+            onClick={() => setShowSim((s) => !s)}
+            title="Simulate"
+          >
+            <Play size={15} />
+          </button>
           <button
             className={`${tool} w-8 justify-center px-0`}
             onClick={() => exportPng(doc, view)}
@@ -487,9 +528,21 @@ export function CircuitViewV2({
           onDropPart={(type, at) => void addPartAt(type, at)}
           onDropNetLabel={(kind, name, at) => addNetLabel(kind, name, at)}
           onImportFiles={(files, at) => void importFzpzFiles(files, at)}
+          annotations={simAnnotations}
           onRequestEdit={enterEdit}
         />
 
+        {showSim && (
+          <SimPanel
+            doc={doc}
+            netModel={netModel}
+            store={store}
+            familyOf={(t) => getPart(t)?.family}
+            onClose={() => setShowSim(false)}
+            onResult={setSim}
+          />
+        )}
+
         {/* watermark — matches the header wordmark: thin 'tiny', bold 'Studio' */}
         <div className="absolute bottom-8 right-6 z-0 pointer-events-none select-none text-[60px] leading-none tracking-[-0.02em] text-text-faint/25">
           <span className="font-light">tiny</span>
diff --git a/src/renderer/src/circuit/views/canvas/Canvas.tsx b/src/renderer/src/circuit/views/canvas/Canvas.tsx
index 6c23db8..6f0a141 100644
--- a/src/renderer/src/circuit/views/canvas/Canvas.tsx
+++ b/src/renderer/src/circuit/views/canvas/Canvas.tsx
@@ -149,6 +149,7 @@ export function Canvas({
   onDropPart,
   onDropNetLabel,
   onImportFiles,
+  annotations,
   onRequestEdit
 }: {
   store: CircuitStore
@@ -173,6 +174,8 @@ export function Canvas({
   onDropNetLabel: (kind: NetLabelKind, name: string, at: Pt) => void
   /** dropped OS files (.fzpz part import) */
   onImportFiles?: (files: File[], at: Pt) => void
+  /** world-anchored value chips (DC sim annotations) */
+  annotations?: { x: number; y: number; text: string }[]
   /** tray "attach to cursor" placement: id being placed + drop callback */
   /** double-clicking a component asks the shell to enter edit mode */
   onRequestEdit: () => void
@@ -1657,6 +1660,17 @@ export function Canvas({
             </div>
           )}
 
+          {/* sim annotations (node voltages after a DC run) */}
+          {annotations?.map((a, i) => (
+            <div
+              key={i}
+              className="pointer-events-none select-none px-1 py-0.5 rounded bg-surface-card/90 border border-brand/40 text-[9px] font-mono text-brand whitespace-nowrap"
+              style={{ position: 'absolute', left: a.x + 7, top: a.y - 21, zIndex: 4 }}
+            >
+              {a.text}
+            </div>
+          ))}
+
           {doc.parts.length === 0 && (
             <div
               className="absolute flex flex-col items-center gap-2 text-text-faint text-sm text-center"
diff --git a/src/renderer/src/circuit/views/sim/SimPanel.tsx b/src/renderer/src/circuit/views/sim/SimPanel.tsx
new file mode 100644
index 0000000..5bc2941
--- /dev/null
+++ b/src/renderer/src/circuit/views/sim/SimPanel.tsx
@@ -0,0 +1,321 @@
+/**
+ * circuit/views/sim/SimPanel — the M4 Simulate panel (spec §10.4, first cut).
+ *
+ * Docked at the bottom of the circuit area: analysis tabs (DC / Transient),
+ * parameters, Run/Cancel, results. DC (.op) lists node voltages and source
+ * currents — and the shell mirrors them onto the schematic as annotations;
+ * transient renders probe traces in a lightweight inline SVG plot (uPlot
+ * arrives with the full plotting pass — cursors/zoom/AC are M4 backlog).
+ *
+ * Analysis config persists in doc.sim via Commands (undoable, serialized).
+ */
+
+import { CircuitBoard, Loader2, Play, Square, X } from 'lucide-react'
+import React from 'react'
+import * as cmd from '../../core/commands'
+import type { Analysis, CircuitDoc } from '../../core/model'
+import type { NetModel } from '../../core/nets'
+import { generateNetlist, type NetlistResult } from '../../core/netlist'
+import type { CircuitStore } from '../../core/store'
+import { getSimBackend, SimError } from '../../sim'
+import type { SimRun } from '../../sim'
+
+const field =
+  'bg-bg-sunken border border-border-default rounded px-2 py-1 text-text-strong outline-none focus:border-brand w-20 text-xs'
+
+export interface SimState {
+  run: SimRun | null
+  netlist: NetlistResult | null
+}
+
+export function SimPanel({
+  doc,
+  netModel,
+  store,
+  familyOf,
+  onClose,
+  onResult
+}: {
+  doc: CircuitDoc
+  netModel: NetModel
+  store: CircuitStore
+  familyOf: (type: string) => string | undefined
+  onClose: () => void
+  /** surfaces the run to the shell (canvas DC annotations) */
+  onResult: (s: SimState) => void
+}): React.JSX.Element {
+  const analysis: Analysis = doc.sim?.analyses?.[0] ?? { id: 'a1', kind: 'op' }
+  const [running, setRunning] = React.useState(false)
+  const [result, setResult] = React.useState<SimRun | null>(null)
+  const [gen, setGen] = React.useState<NetlistResult | null>(null)
+  const [error, setError] = React.useState<{ message: string; details?: string[] } | null>(null)
+  const [showNetlist, setShowNetlist] = React.useState(false)
+
+  const setAnalysis = (patch: Partial<Analysis>): void => {
+    store.dispatch(cmd.setAnalyses([{ ...analysis, ...patch }]))
+  }
+
+  const run = async (): Promise<void> => {
+    setRunning(true)
+    setError(null)
+    const g = generateNetlist(doc, netModel, { familyOf, title: 'tinyStudio circuit' })
+    setGen(g)
+    try {
+      const r = await getSimBackend().run(g.netlist, 20000)
+      setResult(r)
+      onResult({ run: r, netlist: g })
+    } catch (err) {
+      setResult(null)
+      onResult({ run: null, netlist: g })
+      setError(
+        err instanceof SimError
+          ? { message: err.message, details: err.details }
+          : { message: err instanceof Error ? err.message : String(err) }
+      )
+    } finally {
+      setRunning(false)
+    }
+  }
+
+  const cancel = (): void => {
+    getSimBackend().cancel()
+    setRunning(false)
+  }
+
+  const isOp = result != null && result.numPoints === 1
+
+  return (
+    <div className="absolute bottom-0 left-0 right-0 z-20 border-t border-border-default bg-bg-raised flex flex-col max-h-[45%]">
+      {/* header row: analysis config + run */}
+      <div className="flex items-center gap-2 px-3 h-10 shrink-0 border-b border-border-default">
+        <CircuitBoard size={14} className="text-brand" />
+        <span className="text-xs font-semibold text-text-strong">Simulate</span>
+
+        <div className="flex rounded-md overflow-hidden tactile-bordered ml-3">
+          {(
+            [
+              ['op', 'DC'],
+              ['tran', 'Transient']
+            ] as [Analysis['kind'], string][]
+          ).map(([kind, label]) => (
+            <button
+              key={kind}
+              className={`h-7 px-2.5 text-[11px] font-medium ${
+                analysis.kind === kind
+                  ? 'bg-brand/15 text-brand'
+                  : 'bg-surface-card text-text-muted hover:text-text-body'
+              }`}
+              onClick={() => setAnalysis({ kind })}
+            >
+              {label}
+            </button>
+          ))}
+        </div>
+
+        {analysis.kind === 'tran' && (
+          <div className="flex items-center gap-1.5 text-[11px] text-text-muted">
+            <span>step</span>
+            <input
+              className={field}
+              defaultValue={String(analysis.step ?? '10u')}
+              key={`step:${analysis.id}`}
+              onBlur={(e) => setAnalysis({ step: e.target.value })}
+            />
+            <span>stop</span>
+            <input
+              className={field}
+              defaultValue={String(analysis.stop ?? '10m')}
+              key={`stop:${analysis.id}`}
+              onBlur={(e) => setAnalysis({ stop: e.target.value })}
+            />
+            <label className="flex items-center gap-1 cursor-pointer" title="Start from zero initial conditions instead of the DC operating point">
+              <input
+                type="checkbox"
+                checked={analysis.uic === true}
+                onChange={(e) => setAnalysis({ uic: e.target.checked || undefined })}
+              />
+              uic
+            </label>
+          </div>
+        )}
+
+        <div className="flex-1" />
+        <button
+          className="text-[11px] text-text-faint hover:text-text-body"
+          onClick={() => setShowNetlist((s) => !s)}
+        >
+          {showNetlist ? 'hide netlist' : 'netlist'}
+        </button>
+        {running ? (
+          <button
+            className="flex items-center gap-1.5 h-7 px-3 rounded-md bg-surface-card border border-border-default text-status-danger text-xs"
+            onClick={cancel}
+          >
+            <Square size={11} /> Cancel
+          </button>
+        ) : (
+          <button
+            className="flex items-center gap-1.5 h-7 px-3 rounded-md bg-brand text-white text-xs font-medium hover:bg-brand/90"
+            onClick={() => void run()}
+          >
+            <Play size={11} /> Run
+          </button>
+        )}
+        <button
+          className="w-7 h-7 flex items-center justify-center rounded text-text-faint hover:text-text-body"
+          onClick={onClose}
+          title="Close"
+        >
+          <X size={14} />
+        </button>
+      </div>
+
+      {/* body: results / errors / netlist */}
+      <div className="flex-1 min-h-0 overflow-auto p-3 text-xs flex flex-col gap-2">
+        {running && (
+          <div className="flex items-center gap-2 text-text-muted">
+            <Loader2 size={13} className="animate-spin" /> running… first run loads the engine
+            (~a few MB)
+          </div>
+        )}
+
+        {error && (
+          <div className="rounded-md border border-status-danger/40 bg-status-danger/5 p-2 text-status-danger">
+            <div className="font-medium">{error.message}</div>
+            {error.details && error.details.length > 1 && (
+              <pre className="mt-1 whitespace-pre-wrap text-[10px] opacity-80">
+                {error.details.slice(0, 8).join('\n')}
+              </pre>
+            )}
+          </div>
+        )}
+
+        {gen && (gen.warnings.length > 0 || gen.excluded.length > 0) && (
+          <div className="rounded-md border border-status-warning/40 bg-status-warning/5 p-2 text-status-warning">
+            {gen.warnings.slice(0, 6).map((w, i) => (
+              <div key={i}>{w}</div>
+            ))}
+          </div>
+        )}
+
+        {isOp && result && <OpTable run={result} />}
+        {result && result.numPoints > 1 && <WavePlot run={result} />}
+
+        {showNetlist && gen && (
+          <pre className="rounded-md border border-border-default bg-bg-sunken p-2 text-[10px] leading-relaxed text-text-body whitespace-pre-wrap">
+            {gen.netlist}
+          </pre>
+        )}
+
+        {!running && !result && !error && (
+          <div className="text-text-faint">
+            Run a DC operating point to annotate the schematic with node voltages, or a transient
+            to plot waveforms. Boards aren&apos;t simulated — drive their pins with sources from
+            the palette.
+          </div>
+        )}
+      </div>
+    </div>
+  )
+}
+
+// ── DC table ─────────────────────────────────────────────────────────────────
+
+export function fmtSI(v: number, unit: string): string {
+  const a = Math.abs(v)
+  if (a >= 1e6) return `${(v / 1e6).toFixed(2)} M${unit}`
+  if (a >= 1e3) return `${(v / 1e3).toFixed(2)} k${unit}`
+  if (a >= 1) return `${v.toFixed(3)} ${unit}`
+  if (a >= 1e-3) return `${(v * 1e3).toFixed(2)} m${unit}`
+  if (a >= 1e-6) return `${(v * 1e6).toFixed(2)} µ${unit}`
+  if (a === 0) return `0 ${unit}`
+  return `${(v * 1e9).toFixed(2)} n${unit}`
+}
+
+function OpTable({ run }: { run: SimRun }): React.JSX.Element {
+  const rows = run.vectors
+    .filter((v) => v.values.length === 1)
+    .map((v) => {
+      const isV = v.name.startsWith('v(')
+      const unit = isV ? 'V' : 'A'
+      return { name: v.name, value: fmtSI(v.values[0], unit) }
+    })
+  return (
+    <div className="grid grid-cols-[auto_auto] gap-x-6 gap-y-1 w-fit">
+      {rows.map((r) => (
+        <React.Fragment key={r.name}>
+          <span className="text-text-muted font-mono">{r.name}</span>
+          <span className="text-text-strong font-mono">{r.value}</span>
+        </React.Fragment>
+      ))}
+    </div>
+  )
+}
+
+// ── waveform plot (inline SVG — uPlot lands with the full plotting pass) ─────
+
+const TRACES = ['#4f9cf9', '#f36e6e', '#54c08a', '#e5b567', '#b78be5', '#5bc8c8']
+
+function WavePlot({ run }: { run: SimRun }): React.JSX.Element {
+  const x =
+    run.vectors.find((v) => v.type === 'time' || v.type === 'frequency') ?? run.vectors[0]
+  const traces = run.vectors
+    .filter((v) => v !== x && v.name.startsWith('v('))
+    .slice(0, TRACES.length)
+  if (!x || traces.length === 0) return <div className="text-text-faint">no voltage vectors</div>
+
+  const W = 640
+  const H = 180
+  const PAD = 28
+  const xmin = Math.min(...x.values)
+  const xmax = Math.max(...x.values)
+  let ymin = Infinity
+  let ymax = -Infinity
+  for (const tr of traces)
+    for (const v of tr.values) {
+      ymin = Math.min(ymin, v)
+      ymax = Math.max(ymax, v)
+    }
+  if (ymin === ymax) {
+    ymin -= 1
+    ymax += 1
+  }
+  const sx = (v: number): number => PAD + ((v - xmin) / (xmax - xmin || 1)) * (W - PAD * 2)
+  const sy = (v: number): number => H - PAD - ((v - ymin) / (ymax - ymin)) * (H - PAD * 2)
+
+  return (
+    <div className="flex flex-col gap-1">
+      <svg viewBox={`0 0 ${W} ${H}`} className="w-full max-w-[720px] rounded-md border border-border-default bg-bg-sunken">
+        {/* axes */}
+        <line x1={PAD} y1={H - PAD} x2={W - PAD} y2={H - PAD} stroke="var(--border-strong)" />
+        <line x1={PAD} y1={PAD} x2={PAD} y2={H - PAD} stroke="var(--border-strong)" />
+        <text x={PAD} y={PAD - 6} fontSize="9" fill="var(--text-muted)">
+          {fmtSI(ymax, 'V')}
+        </text>
+        <text x={PAD} y={H - PAD + 12} fontSize="9" fill="var(--text-muted)">
+          {fmtSI(ymin, 'V')}
+        </text>
+        <text x={W - PAD} y={H - PAD + 12} fontSize="9" fill="var(--text-muted)" textAnchor="end">
+          {fmtSI(xmax, x.type === 'frequency' ? 'Hz' : 's')}
+        </text>
+        {traces.map((tr, i) => (
+          <polyline
+            key={tr.name}
+            fill="none"
+            stroke={TRACES[i]}
+            strokeWidth="1.4"
+            points={tr.values.map((v, k) => `${sx(x.values[k])},${sy(v)}`).join(' ')}
+          />
+        ))}
+      </svg>
+      <div className="flex gap-3 flex-wrap">
+        {traces.map((tr, i) => (
+          <span key={tr.name} className="flex items-center gap-1 text-[10px] text-text-muted">
+            <span className="w-3 h-0.5 inline-block" style={{ background: TRACES[i] }} />
+            {tr.name}
+          </span>
+        ))}
+      </div>
+    </div>
+  )
+}
diff --git a/web.vite.config.mts b/web.vite.config.mts
index cf46aa3..b91aa80 100644
--- a/web.vite.config.mts
+++ b/web.vite.config.mts
@@ -10,6 +10,8 @@ export default defineConfig({
   // /assets/... correctly. A relative './' base would resolve assets against
   // the deep path and 404 once the Netlify SPA redirect serves index.html there.
   base: '/',
+  // module workers (sim engine lazy-imports ngspice-WASM inside a worker)
+  worker: { format: 'es' },
   build: {
     outDir: path.resolve(__dirname, 'dist-web'),
     emptyOutDir: true

From b641274d3067a864695f3c14eed437c6b8d6e8c2 Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Mon, 13 Jul 2026 08:54:12 -0600
Subject: [PATCH 14/27] Circuit v2 M4: sim value editing in Inspector
 (simAttrsFor), plot trace toggles, readable DC table

---
 docs/circuit-editor-progress.md               |  10 ++
 src/renderer/src/circuit/core/netlist.ts      |  37 ++++++-
 .../src/circuit/views/inspector/Inspector.tsx |  34 +++++-
 .../src/circuit/views/sim/SimPanel.tsx        | 104 ++++++++++++++----
 4 files changed, 164 insertions(+), 21 deletions(-)

diff --git a/docs/circuit-editor-progress.md b/docs/circuit-editor-progress.md
index e5f882a..cb06361 100644
--- a/docs/circuit-editor-progress.md
+++ b/docs/circuit-editor-progress.md
@@ -257,3 +257,13 @@ Four chunks, committed separately. `npm run typecheck` clean · `npm run test:ci
 - M5 untouched (KiCad/Wokwi interop).
 - The sim source symbols seat on breadboards like any 2-pin part; netlist pin matching for them keys on `+`/`-` names.
 - Tooling: Cowork-mount truncation did NOT reproduce this session (new files written via the file tool verified clean); git index/HEAD locks were stale early on — **fixed by enabling file deletion for the folder**, commits work normally again.
+
+---
+
+## 2026-07-13 — sim UX pass (Geoff's feedback: "can't set values, can't choose probes")
+
+- **Inspector "Simulation" section**: `netlist.simAttrsFor(type, family)` exposes each mapping's editable attrs (resistance/capacitance/inductance, voltage, amplitude+frequency+offset, current, pot position, switch closed) as labeled fields with the emitter's default as placeholder + unit hint. No more guessing magic attr names; the keys are excluded from the generic Properties rows. Attr edits are mergeKey'd (one undo step per field).
+- **Trace picking**: the transient plot's legend is now clickable — toggle traces on/off (state survives reruns; results still auto-clear on doc edits). Visible traces cap at 6 colors.
+- **Readable DC table**: each `v(node)` row shows the net's members ("R1:Pin 1 · LED1:anode"), `i(vxx)` rows say "current through …".
+- Real probe *parts* (§10.3, `sim.probes`) remain backlog — this pass makes everything probeable-by-default usable.
+- `npm run typecheck` clean · `npm run test:circuit` → 89/89.
diff --git a/src/renderer/src/circuit/core/netlist.ts b/src/renderer/src/circuit/core/netlist.ts
index 917f6ec..42c7da8 100644
--- a/src/renderer/src/circuit/core/netlist.ts
+++ b/src/renderer/src/circuit/core/netlist.ts
@@ -107,16 +107,31 @@ const MINUS = [/^-$/, /cathode|kath/i, /^gnd$/i, /neg/i]
 
 type Emitter = (ctx: Ctx) => SpiceCard | null
 
+/** An editable sim attr a part type understands (Inspector surfaces these). */
+export interface SimAttrSpec {
+  key: string
+  label: string
+  /** value used when the attr is unset (mirrors the emitter fallbacks) */
+  default: string
+  hint?: string
+}
+
 const LED_MODEL = { name: 'DLED', card: '.model DLED D(IS=1e-22 N=2.2 RS=2)' }
 const D_MODEL = { name: 'DGEN', card: '.model DGEN D(IS=1e-14 N=1.9 RS=0.1)' }
 const NPN_MODEL = { name: 'QNPN', card: '.model QNPN NPN(BF=150 VAF=100)' }
 const PNP_MODEL = { name: 'QPNP', card: '.model QPNP PNP(BF=150 VAF=100)' }
 
-const EMITTERS: { match: RegExp; kind?: MappingKind; emit?: Emitter }[] = [
+const EMITTERS: {
+  match: RegExp
+  kind?: MappingKind
+  emit?: Emitter
+  attrs?: SimAttrSpec[]
+}[] = [
   { match: /breadboard/i, kind: 'transparent' },
   { match: /tinystudio|microcontroller|\bboard\b|arduino|esp32/i, kind: 'board' },
   {
     match: /sim-vdc|voltage source|battery/i,
+    attrs: [{ key: 'voltage', label: 'Voltage', default: '5', hint: 'V' }],
     emit: (c) => ({
       lines: [
         `V${c.part.id} ${pinLike(c, PLUS, 0, '+')} ${pinLike(c, MINUS, 1, '-')} DC ${c.attr(
@@ -128,6 +143,11 @@ const EMITTERS: { match: RegExp; kind?: MappingKind; emit?: Emitter }[] = [
   },
   {
     match: /sim-vsin|sine|waveform/i,
+    attrs: [
+      { key: 'amplitude', label: 'Amplitude', default: '1', hint: 'V' },
+      { key: 'frequency', label: 'Frequency', default: '1k', hint: 'Hz' },
+      { key: 'offset', label: 'DC offset', default: '0', hint: 'V' }
+    ],
     emit: (c) => ({
       lines: [
         `V${c.part.id} ${pinLike(c, PLUS, 0, '+')} ${pinLike(c, MINUS, 1, '-')} SIN(${c.attr(
@@ -139,6 +159,7 @@ const EMITTERS: { match: RegExp; kind?: MappingKind; emit?: Emitter }[] = [
   },
   {
     match: /sim-idc|current source/i,
+    attrs: [{ key: 'current', label: 'Current', default: '1m', hint: 'A' }],
     emit: (c) => ({
       lines: [
         `I${c.part.id} ${pinLike(c, PLUS, 0, '+')} ${pinLike(c, MINUS, 1, '-')} DC ${c.attr(
@@ -150,6 +171,7 @@ const EMITTERS: { match: RegExp; kind?: MappingKind; emit?: Emitter }[] = [
   },
   {
     match: /resistor|photocell|ldr|thermistor/i,
+    attrs: [{ key: 'resistance', label: 'Resistance', default: '1k', hint: 'Ω' }],
     emit: (c) => {
       const [a, b] = two(c)
       return { lines: [`R${c.part.id} ${a} ${b} ${c.attr(['resistance', 'value'], '1k')}`] }
@@ -157,6 +179,10 @@ const EMITTERS: { match: RegExp; kind?: MappingKind; emit?: Emitter }[] = [
   },
   {
     match: /potentiometer|trimmer/i,
+    attrs: [
+      { key: 'resistance', label: 'Resistance', default: '10k', hint: 'Ω end-to-end' },
+      { key: 'position', label: 'Wiper position', default: '0.5', hint: '0–1' }
+    ],
     emit: (c) => {
       const total = c.attr(['resistance', 'value'], '10k')
       const posRaw = c.attr(['position'], '0.5')
@@ -174,6 +200,7 @@ const EMITTERS: { match: RegExp; kind?: MappingKind; emit?: Emitter }[] = [
   },
   {
     match: /capacitor/i,
+    attrs: [{ key: 'capacitance', label: 'Capacitance', default: '100n', hint: 'F' }],
     emit: (c) => {
       const plus = c.pins.find((p) => PLUS.some((re) => re.test(p)))
       const minus = c.pins.find((p) => MINUS.some((re) => re.test(p)))
@@ -184,6 +211,7 @@ const EMITTERS: { match: RegExp; kind?: MappingKind; emit?: Emitter }[] = [
   },
   {
     match: /inductor/i,
+    attrs: [{ key: 'inductance', label: 'Inductance', default: '10u', hint: 'H' }],
     emit: (c) => {
       const [a, b] = two(c)
       return { lines: [`L${c.part.id} ${a} ${b} ${c.attr(['inductance', 'value'], '10u')}`] }
@@ -247,6 +275,7 @@ const EMITTERS: { match: RegExp; kind?: MappingKind; emit?: Emitter }[] = [
   },
   {
     match: /switch|button/i,
+    attrs: [{ key: 'closed', label: 'Closed', default: 'false', hint: 'true/false' }],
     emit: (c) => {
       const closed = c.part.attrs?.closed === true || c.part.attrs?.closed === 'true'
       if (!closed) return null // open switch = not in the circuit
@@ -268,6 +297,12 @@ function spiceScale(total: string, frac: number): string {
   return v >= 1 ? String(Math.round(v * 100) / 100) : v.toExponential(3)
 }
 
+/** Sim attrs a part type supports (same matching rule as generation). */
+export function simAttrsFor(type: string, family = ''): SimAttrSpec[] {
+  const entry = EMITTERS.find((e) => e.match.test(`${type} ${family}`))
+  return entry?.attrs ?? []
+}
+
 // ── generator ────────────────────────────────────────────────────────────────
 
 export function generateNetlist(
diff --git a/src/renderer/src/circuit/views/inspector/Inspector.tsx b/src/renderer/src/circuit/views/inspector/Inspector.tsx
index ad3bd84..73103b6 100644
--- a/src/renderer/src/circuit/views/inspector/Inspector.tsx
+++ b/src/renderer/src/circuit/views/inspector/Inspector.tsx
@@ -20,6 +20,7 @@ import type {
   ViewId
 } from '../../core/model'
 import type { NetModel } from '../../core/nets'
+import { simAttrsFor } from '../../core/netlist'
 import { isValidRefdes } from '../../core/refdes'
 import type { CircuitStore } from '../../core/store'
 import { isBreadboard } from '../../parts/breadboard'
@@ -191,7 +192,11 @@ function PartInspector({
     [w.from, w.to].some((e) => typeof e === 'string' && e.split(':')[0] === part.id)
   ).length
 
-  const propRows = Object.entries(part.attrs || {}).filter(([k]) => k !== 'label')
+  const simAttrs = simAttrsFor(part.type, def?.family)
+  const simKeys = new Set(simAttrs.map((a) => a.key))
+  const propRows = Object.entries(part.attrs || {}).filter(
+    ([k]) => k !== 'label' && !simKeys.has(k)
+  )
 
   return (
     <>
@@ -283,6 +288,33 @@ function PartInspector({
         </>
       )}
 
+      {simAttrs.length > 0 && (
+        <div className="flex flex-col gap-1.5">
+          <span className={rowLabel}>Simulation</span>
+          {simAttrs.map((a) => (
+            <div key={a.key} className="flex items-center gap-1.5">
+              <span className="text-[11px] text-text-muted w-16 truncate" title={a.hint || a.label}>
+                {a.label}
+              </span>
+              <input
+                className={field}
+                value={String(part.attrs?.[a.key] ?? '')}
+                placeholder={a.default}
+                title={a.hint}
+                onChange={(e) =>
+                  store.dispatch(
+                    cmd.setPartAttr(part.id, a.key, e.target.value === '' ? undefined : e.target.value)
+                  )
+                }
+              />
+              {a.hint && (
+                <span className="text-[10px] text-text-faint w-8 shrink-0 truncate">{a.hint}</span>
+              )}
+            </div>
+          ))}
+        </div>
+      )}
+
       <div className="flex flex-col gap-1.5">
         <span className={rowLabel}>Properties</span>
         {propRows.length === 0 && (
diff --git a/src/renderer/src/circuit/views/sim/SimPanel.tsx b/src/renderer/src/circuit/views/sim/SimPanel.tsx
index 5bc2941..058a566 100644
--- a/src/renderer/src/circuit/views/sim/SimPanel.tsx
+++ b/src/renderer/src/circuit/views/sim/SimPanel.tsx
@@ -50,6 +50,7 @@ export function SimPanel({
   const [gen, setGen] = React.useState<NetlistResult | null>(null)
   const [error, setError] = React.useState<{ message: string; details?: string[] } | null>(null)
   const [showNetlist, setShowNetlist] = React.useState(false)
+  const [hidden, setHidden] = React.useState<Set<string>>(new Set())
 
   const setAnalysis = (patch: Partial<Analysis>): void => {
     store.dispatch(cmd.setAnalyses([{ ...analysis, ...patch }]))
@@ -84,6 +85,25 @@ export function SimPanel({
 
   const isOp = result != null && result.numPoints === 1
 
+  // "v(n1)" → the net's members ("R1:Pin 1 · LED1:anode"); "i(vv1)" → source
+  const describe = React.useCallback(
+    (vecName: string): string | undefined => {
+      if (!gen) return undefined
+      const m = /^v\((.+)\)$/i.exec(vecName)
+      if (m) {
+        const node = m[1]
+        const i = gen.nodeOfNet.findIndex((n) => n.toLowerCase() === node.toLowerCase())
+        if (i < 0) return undefined
+        const members = netModel.nets[i] ?? []
+        return members.slice(0, 4).join(' · ') + (members.length > 4 ? ' …' : '')
+      }
+      const im = /^i\((.+)\)$/i.exec(vecName)
+      if (im) return `current through ${im[1].toUpperCase()}`
+      return undefined
+    },
+    [gen, netModel]
+  )
+
   return (
     <div className="absolute bottom-0 left-0 right-0 z-20 border-t border-border-default bg-bg-raised flex flex-col max-h-[45%]">
       {/* header row: analysis config + run */}
@@ -198,8 +218,21 @@ export function SimPanel({
           </div>
         )}
 
-        {isOp && result && <OpTable run={result} />}
-        {result && result.numPoints > 1 && <WavePlot run={result} />}
+        {isOp && result && <OpTable run={result} describe={describe} />}
+        {result && result.numPoints > 1 && (
+          <WavePlot
+            run={result}
+            hidden={hidden}
+            onToggle={(name) =>
+              setHidden((h) => {
+                const next = new Set(h)
+                if (next.has(name)) next.delete(name)
+                else next.add(name)
+                return next
+              })
+            }
+          />
+        )}
 
         {showNetlist && gen && (
           <pre className="rounded-md border border-border-default bg-bg-sunken p-2 text-[10px] leading-relaxed text-text-body whitespace-pre-wrap">
@@ -232,20 +265,29 @@ export function fmtSI(v: number, unit: string): string {
   return `${(v * 1e9).toFixed(2)} n${unit}`
 }
 
-function OpTable({ run }: { run: SimRun }): React.JSX.Element {
+function OpTable({
+  run,
+  describe
+}: {
+  run: SimRun
+  describe: (vecName: string) => string | undefined
+}): React.JSX.Element {
   const rows = run.vectors
     .filter((v) => v.values.length === 1)
     .map((v) => {
       const isV = v.name.startsWith('v(')
       const unit = isV ? 'V' : 'A'
-      return { name: v.name, value: fmtSI(v.values[0], unit) }
+      return { name: v.name, value: fmtSI(v.values[0], unit), what: describe(v.name) }
     })
   return (
-    <div className="grid grid-cols-[auto_auto] gap-x-6 gap-y-1 w-fit">
+    <div className="grid grid-cols-[auto_auto_1fr] gap-x-6 gap-y-1 w-full max-w-[720px]">
       {rows.map((r) => (
         <React.Fragment key={r.name}>
           <span className="text-text-muted font-mono">{r.name}</span>
           <span className="text-text-strong font-mono">{r.value}</span>
+          <span className="text-text-faint truncate" title={r.what}>
+            {r.what ?? ''}
+          </span>
         </React.Fragment>
       ))}
     </div>
@@ -256,21 +298,28 @@ function OpTable({ run }: { run: SimRun }): React.JSX.Element {
 
 const TRACES = ['#4f9cf9', '#f36e6e', '#54c08a', '#e5b567', '#b78be5', '#5bc8c8']
 
-function WavePlot({ run }: { run: SimRun }): React.JSX.Element {
+function WavePlot({
+  run,
+  hidden,
+  onToggle
+}: {
+  run: SimRun
+  hidden: Set<string>
+  onToggle: (name: string) => void
+}): React.JSX.Element {
   const x =
     run.vectors.find((v) => v.type === 'time' || v.type === 'frequency') ?? run.vectors[0]
-  const traces = run.vectors
-    .filter((v) => v !== x && v.name.startsWith('v('))
-    .slice(0, TRACES.length)
-  if (!x || traces.length === 0) return <div className="text-text-faint">no voltage vectors</div>
+  const all = run.vectors.filter((v) => v !== x && v.name.startsWith('v('))
+  const traces = all.filter((v) => !hidden.has(v.name)).slice(0, TRACES.length)
+  if (!x || all.length === 0) return <div className="text-text-faint">no voltage vectors</div>
 
   const W = 640
   const H = 180
   const PAD = 28
   const xmin = Math.min(...x.values)
   const xmax = Math.max(...x.values)
-  let ymin = Infinity
-  let ymax = -Infinity
+  let ymin = traces.length ? Infinity : -1
+  let ymax = traces.length ? -Infinity : 1
   for (const tr of traces)
     for (const v of tr.values) {
       ymin = Math.min(ymin, v)
@@ -308,13 +357,30 @@ function WavePlot({ run }: { run: SimRun }): React.JSX.Element {
           />
         ))}
       </svg>
-      <div className="flex gap-3 flex-wrap">
-        {traces.map((tr, i) => (
-          <span key={tr.name} className="flex items-center gap-1 text-[10px] text-text-muted">
-            <span className="w-3 h-0.5 inline-block" style={{ background: TRACES[i] }} />
-            {tr.name}
-          </span>
-        ))}
+      <div className="flex gap-2 flex-wrap items-center">
+        {all.map((tr) => {
+          const idx = traces.indexOf(tr)
+          const off = idx < 0
+          return (
+            <button
+              key={tr.name}
+              className={`flex items-center gap-1 text-[10px] px-1.5 py-0.5 rounded border ${
+                off
+                  ? 'border-border-default text-text-faint line-through'
+                  : 'border-transparent text-text-muted'
+              }`}
+              title={off ? 'Show trace' : 'Hide trace'}
+              onClick={() => onToggle(tr.name)}
+            >
+              <span
+                className="w-3 h-0.5 inline-block"
+                style={{ background: off ? 'var(--border-strong)' : TRACES[idx] }}
+              />
+              {tr.name}
+            </button>
+          )
+        })}
+        <span className="text-[10px] text-text-faint ml-1">click to toggle</span>
       </div>
     </div>
   )

From f6d3f4e4bf257a3b869ce85ec351f5c8546832a1 Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Mon, 13 Jul 2026 09:15:57 -0600
Subject: [PATCH 15/27] Circuit v2 M4: Sweep+AC tabs with uPlot
 (cursors/zoom/log/dB+phase), CSV export; boards render under everything;
 resistor bands follow value

---
 docs/circuit-editor-progress.md               |  25 ++
 package-lock.json                             |   7 +
 package.json                                  |   1 +
 .../src/circuit/__tests__/netlist.test.ts     |  17 ++
 .../circuit/__tests__/resistorBands.test.ts   |  65 +++++
 src/renderer/src/circuit/core/netlist.ts      |  12 +-
 .../src/circuit/parts/resistorBands.ts        | 117 +++++++++
 .../src/circuit/views/canvas/Canvas.tsx       |   6 +-
 src/renderer/src/circuit/views/exportImage.ts |  34 +--
 .../src/circuit/views/partsAdapter.ts         |  12 +
 src/renderer/src/circuit/views/sim/Plot.tsx   | 212 ++++++++++++++++
 .../src/circuit/views/sim/SimPanel.tsx        | 240 +++++++++---------
 12 files changed, 613 insertions(+), 135 deletions(-)
 create mode 100644 src/renderer/src/circuit/__tests__/resistorBands.test.ts
 create mode 100644 src/renderer/src/circuit/parts/resistorBands.ts
 create mode 100644 src/renderer/src/circuit/views/sim/Plot.tsx

diff --git a/docs/circuit-editor-progress.md b/docs/circuit-editor-progress.md
index cb06361..16c91ce 100644
--- a/docs/circuit-editor-progress.md
+++ b/docs/circuit-editor-progress.md
@@ -267,3 +267,28 @@ Four chunks, committed separately. `npm run typecheck` clean · `npm run test:ci
 - **Readable DC table**: each `v(node)` row shows the net's members ("R1:Pin 1 · LED1:anode"), `i(vxx)` rows say "current through …".
 - Real probe *parts* (§10.3, `sim.probes`) remain backlog — this pass makes everything probeable-by-default usable.
 - `npm run typecheck` clean · `npm run test:circuit` → 89/89.
+
+---
+
+## 2026-07-13 (later) — M4 panel complete + visual fixes (Geoff's round 3)
+
+`npm run typecheck` clean · `npm run test:circuit` → **95/95** · web build verified (worker + engine chunks intact).
+
+### Sim panel: all four analyses (spec §10.4)
+
+- Tabs are now **DC | Sweep | Transient | AC**. Sweep: source select (element names as emitted — VV1/II1, seeded to the first source on tab switch), from/to/step. AC: dec/oct/lin, points, fstart/fstop.
+- **uPlot** (spec's decided plot lib, MIT, ~45 kB) replaces the inline SVG plot: live cursor readouts, drag-to-zoom (double-click resets), click-to-toggle legend. One `SimPlot` component handles the three sweep shapes — transient (x=time), DC sweep (x=`v(v-sweep)`), AC (log-frequency axis, magnitude in **dB** + dashed **phase** traces on a right-hand degree axis). Theme colors read from design tokens at mount.
+- **CSV export** button (full vectors; complex AC data exported as mag+deg columns).
+- **AC actually works**: the sine source card now carries `AC <amplitude>` (`SIN(…) AC 2`), so `.ac` sweeps have a stimulus. Generator hardening: an analysis list that resolves to zero cards falls back to `.op` (a `.dc` without a source can no longer emit a card-less netlist).
+
+### Visual fixes
+
+- **Breadboards render below everything**: canvas boards get `zIndex 1` (parts 2, wires 5); the image exporter paints a `boardsSvg` layer before wires and parts, so exports match the canvas.
+- **Resistor color bands follow the value** (`parts/resistorBands.ts`): the Fritzing art's `band_1_st`/`band_2_nd`/`band_rd_multiplier` ids are recolored to the 4-band IEC code computed from `attrs.resistance` (gold/silver multipliers for sub-10Ω; tolerance band untouched; unparseable values leave stock art). Wired through `partsAdapter.partArtFor` — used by both the canvas and the exporter, cached per (svg, value). Resistor sim default changed 1k → **220** to match the stock red-red-brown art.
+- Tests: +6 (95 total) — band parsing/coding/recolor, vsin AC card, dc-without-source fallback.
+
+### Notes
+
+- uPlot inlines into the main chunk (small); the engine stays its own lazy chunk.
+- Sandbox web build needed `NODE_OPTIONS=--max-old-space-size=4096` once (OOM at transform) — not a repo issue.
+- Remaining M4: probe parts (`sim.probes`), current probes, error→part highlight mapping, auto-rerun toggle, bb hole-tooltip voltages, flag default ON + legacy editor removal. Then M5 interop.
diff --git a/package-lock.json b/package-lock.json
index 5ec13dc..1a19e8a 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -40,6 +40,7 @@
         "tailwind-merge": "^3.3.1",
         "tailwindcss": "^4.1.8",
         "tw-animate-css": "^1.3.4",
+        "uplot": "^1.6.32",
         "uuid": "^14.0.0",
         "ws": "^8.14.2",
         "zod": "^4.0.5"
@@ -14548,6 +14549,12 @@
         "browserslist": ">= 4.21.0"
       }
     },
+    "node_modules/uplot": {
+      "version": "1.6.32",
+      "resolved": "https://registry.npmjs.org/uplot/-/uplot-1.6.32.tgz",
+      "integrity": "sha512-KIMVnG68zvu5XXUbC4LQEPnhwOxBuLyW1AHtpm6IKTXImkbLgkMy+jabjLgSLMasNuGGzQm/ep3tOkyTxpiQIw==",
+      "license": "MIT"
+    },
     "node_modules/uri-js": {
       "version": "4.4.1",
       "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
diff --git a/package.json b/package.json
index 95a5607..d97db4e 100644
--- a/package.json
+++ b/package.json
@@ -65,6 +65,7 @@
     "tailwind-merge": "^3.3.1",
     "tailwindcss": "^4.1.8",
     "tw-animate-css": "^1.3.4",
+    "uplot": "^1.6.32",
     "uuid": "^14.0.0",
     "ws": "^8.14.2",
     "zod": "^4.0.5"
diff --git a/src/renderer/src/circuit/__tests__/netlist.test.ts b/src/renderer/src/circuit/__tests__/netlist.test.ts
index 9f9e057..40e1b05 100644
--- a/src/renderer/src/circuit/__tests__/netlist.test.ts
+++ b/src/renderer/src/circuit/__tests__/netlist.test.ts
@@ -152,3 +152,20 @@ test('analysisCard forms', () => {
     '.ac dec 20 1 100k'
   )
 })
+
+test('sine source carries an AC magnitude; ac card sweeps log frequency', () => {
+  const doc = divider()
+  doc.parts.push(part('V2', 'sim-vsin', { amplitude: '2', frequency: '10k' }))
+  doc.wires.push(wire('V2:+', 'R1:Pin 0'), wire('V2:-', 'V1:-'))
+  doc.sim = { analyses: [{ id: 'a1', kind: 'ac', points: 10, fstart: '1', fstop: '100k' }] }
+  const res = generateNetlist(doc, buildNets(doc))
+  assert.match(res.netlist, /VV2 \S+ \S+ SIN\(0 2 10k\) AC 2/)
+  assert.ok(res.netlist.includes('.ac dec 10 1 100k'))
+})
+
+test('a dc analysis without a source falls back to .op instead of a card-less netlist', () => {
+  const doc = divider()
+  doc.sim = { analyses: [{ id: 'a1', kind: 'dc' }] }
+  const res = generateNetlist(doc, buildNets(doc))
+  assert.ok(res.netlist.includes('.op'))
+})
diff --git a/src/renderer/src/circuit/__tests__/resistorBands.test.ts b/src/renderer/src/circuit/__tests__/resistorBands.test.ts
new file mode 100644
index 0000000..a028ff6
--- /dev/null
+++ b/src/renderer/src/circuit/__tests__/resistorBands.test.ts
@@ -0,0 +1,65 @@
+/** Tests for parts/resistorBands — value parsing, 4-band color code, SVG recolor. */
+
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { bandColorsFor, decorateResistor, DIGIT_COLORS, parseOhms } from '../parts/resistorBands'
+
+test('parseOhms handles the usual spellings', () => {
+  assert.equal(parseOhms('220'), 220)
+  assert.equal(parseOhms('4.7k'), 4700)
+  assert.equal(parseOhms('4.7kΩ'), 4700)
+  assert.equal(parseOhms('1M'), 1e6)
+  assert.equal(parseOhms('1Meg'), 1e6)
+  assert.equal(parseOhms('10 ohm'), 10)
+  assert.equal(parseOhms(330), 330)
+  assert.equal(parseOhms('0'), null)
+  assert.equal(parseOhms('abc'), null)
+  assert.equal(parseOhms(undefined), null)
+})
+
+test('band colors follow the IEC code', () => {
+  // 220 Ω = red red brown
+  assert.deepEqual(bandColorsFor(220), {
+    d1: DIGIT_COLORS[2],
+    d2: DIGIT_COLORS[2],
+    mult: DIGIT_COLORS[1]
+  })
+  // 4.7 kΩ = yellow violet red
+  assert.deepEqual(bandColorsFor(4700), {
+    d1: DIGIT_COLORS[4],
+    d2: DIGIT_COLORS[7],
+    mult: DIGIT_COLORS[2]
+  })
+  // 1 MΩ = brown black green
+  assert.deepEqual(bandColorsFor(1e6), {
+    d1: DIGIT_COLORS[1],
+    d2: DIGIT_COLORS[0],
+    mult: DIGIT_COLORS[5]
+  })
+  // 4.7 Ω = yellow violet gold
+  const sub10 = bandColorsFor(4.7)!
+  assert.equal(sub10.d1, DIGIT_COLORS[4])
+  assert.equal(sub10.d2, DIGIT_COLORS[7])
+  assert.equal(sub10.mult, '#AD9F4E')
+})
+
+const ART =
+  '<svg><path id="band_1_st" fill="#C40808" d="M0 0"/>' +
+  '<rect id="band_2_nd" fill="#C40808"/>' +
+  '<rect id="band_rd_multiplier" fill="#8A3D06"/>' +
+  '<rect id="gold_band" fill="#AD9F4E"/></svg>'
+
+test('decorateResistor recolors exactly the three value bands', () => {
+  const out = decorateResistor(ART, '4.7k')
+  assert.ok(out.includes(`id="band_1_st" fill="${DIGIT_COLORS[4]}"`), 'digit 1 → yellow')
+  assert.ok(out.includes(`id="band_2_nd" fill="${DIGIT_COLORS[7]}"`), 'digit 2 → violet')
+  assert.ok(out.includes(`id="band_rd_multiplier" fill="${DIGIT_COLORS[2]}"`), 'mult → red')
+  assert.ok(out.includes('id="gold_band" fill="#AD9F4E"'), 'tolerance band untouched')
+})
+
+test('decorateResistor leaves art alone for bad values or non-resistor art', () => {
+  assert.equal(decorateResistor(ART, 'garbage'), ART)
+  assert.equal(decorateResistor(ART, undefined), ART)
+  const other = '<svg><rect fill="#123456"/></svg>'
+  assert.equal(decorateResistor(other, '220'), other)
+})
diff --git a/src/renderer/src/circuit/core/netlist.ts b/src/renderer/src/circuit/core/netlist.ts
index 42c7da8..477ad6a 100644
--- a/src/renderer/src/circuit/core/netlist.ts
+++ b/src/renderer/src/circuit/core/netlist.ts
@@ -153,7 +153,10 @@ const EMITTERS: {
         `V${c.part.id} ${pinLike(c, PLUS, 0, '+')} ${pinLike(c, MINUS, 1, '-')} SIN(${c.attr(
           ['offset'],
           '0'
-        )} ${c.attr(['amplitude', 'value'], '1')} ${c.attr(['frequency', 'freq'], '1k')})`
+        )} ${c.attr(['amplitude', 'value'], '1')} ${c.attr(['frequency', 'freq'], '1k')}) AC ${c.attr(
+          ['amplitude', 'value'],
+          '1'
+        )}`
       ]
     })
   },
@@ -171,10 +174,10 @@ const EMITTERS: {
   },
   {
     match: /resistor|photocell|ldr|thermistor/i,
-    attrs: [{ key: 'resistance', label: 'Resistance', default: '1k', hint: 'Ω' }],
+    attrs: [{ key: 'resistance', label: 'Resistance', default: '220', hint: 'Ω' }],
     emit: (c) => {
       const [a, b] = two(c)
-      return { lines: [`R${c.part.id} ${a} ${b} ${c.attr(['resistance', 'value'], '1k')}`] }
+      return { lines: [`R${c.part.id} ${a} ${b} ${c.attr(['resistance', 'value'], '220')}`] }
     }
   },
   {
@@ -376,7 +379,8 @@ export function generateNetlist(
 
   // analyses (spec §10.2.4) — default to .op
   const analyses = (doc.sim?.analyses ?? []).filter((a) => a.enabled !== false)
-  const cards = analyses.length ? analyses.map(analysisCard).filter(Boolean) : ['.op']
+  const resolved = analyses.map(analysisCard).filter(Boolean)
+  const cards = resolved.length ? resolved : ['.op'] // never emit a card-less netlist
 
   const text = [
     `* ${opts.title ?? 'tinyStudio circuit'}`,
diff --git a/src/renderer/src/circuit/parts/resistorBands.ts b/src/renderer/src/circuit/parts/resistorBands.ts
new file mode 100644
index 0000000..2cc5001
--- /dev/null
+++ b/src/renderer/src/circuit/parts/resistorBands.ts
@@ -0,0 +1,117 @@
+/**
+ * circuit/parts/resistorBands — resistor color-code decoration.
+ *
+ * The Fritzing resistor art carries clean band ids (`band_1_st`, `band_2_nd`,
+ * `band_rd_multiplier`; `gold_band` is tolerance and stays gold). When a part
+ * has a `resistance` attr we recolor those bands to the 4-band code, so the
+ * breadboard art always tells the truth about the value. Pure string work
+ * (regex on the id'd elements), cached per (svg, value).
+ */
+
+/** "4.7k", "220", "1M", "10 Ω" → ohms (number), or null if unparseable. */
+export function parseOhms(v: string | number | boolean | undefined): number | null {
+  if (v === undefined || typeof v === 'boolean') return null
+  if (typeof v === 'number') return Number.isFinite(v) && v > 0 ? v : null
+  const s = v
+    .trim()
+    .replace(/[ΩΩ]|ohms?/gi, '')
+    .replace(/\s+/g, '')
+  const m = /^([0-9]*\.?[0-9]+(?:[eE][+-]?[0-9]+)?)(Meg|meg|MEG|[GgkKMmunp])?$/.exec(s)
+  if (!m) return null
+  const base = parseFloat(m[1])
+  const suffix = m[2]
+  const mult = !suffix
+    ? 1
+    : /^meg$/i.test(suffix)
+      ? 1e6
+      : { G: 1e9, g: 1e9, k: 1e3, K: 1e3, M: 1e6, m: 1e-3, u: 1e-6, n: 1e-9, p: 1e-12 }[
+          suffix as 'G' | 'g' | 'k' | 'K' | 'M' | 'm' | 'u' | 'n' | 'p'
+        ]
+  const ohms = base * (mult ?? 1)
+  return Number.isFinite(ohms) && ohms > 0 ? ohms : null
+}
+
+/** IEC 60062 digit colors 0–9 (hexes tuned to the Fritzing art palette). */
+export const DIGIT_COLORS = [
+  '#000000', // 0 black
+  '#8A3D06', // 1 brown
+  '#C40808', // 2 red
+  '#E87800', // 3 orange
+  '#F5D100', // 4 yellow
+  '#189E30', // 5 green
+  '#2456D6', // 6 blue
+  '#7C2BC1', // 7 violet
+  '#8C8C8C', // 8 grey
+  '#F5F5F5' // 9 white
+] as const
+
+const GOLD = '#AD9F4E'
+const SILVER = '#BFBFBF'
+
+export interface BandColors {
+  d1: string
+  d2: string
+  mult: string
+}
+
+/** 4-band colors for a value (two significant digits + multiplier). */
+export function bandColorsFor(ohms: number): BandColors | null {
+  if (!Number.isFinite(ohms) || ohms <= 0) return null
+  let exp = Math.floor(Math.log10(ohms)) - 1
+  let sig = Math.round(ohms / Math.pow(10, exp))
+  if (sig >= 100) {
+    sig = Math.round(sig / 10)
+    exp += 1
+  }
+  if (sig < 10) {
+    // values < 10 Ω land here (e.g. 4.7 → sig 47, exp −1 — already handled);
+    // a degenerate rounding can still under-run, renormalize
+    sig *= 10
+    exp -= 1
+  }
+  const d1 = Math.floor(sig / 10)
+  const d2 = sig % 10
+  let mult: string
+  if (exp >= 0 && exp <= 9) mult = DIGIT_COLORS[exp]
+  else if (exp === -1) mult = GOLD
+  else if (exp === -2) mult = SILVER
+  else return null
+  return { d1: DIGIT_COLORS[d1], d2: DIGIT_COLORS[d2], mult }
+}
+
+const BAND_IDS: [keyof BandColors, string][] = [
+  ['d1', 'band_1_st'],
+  ['d2', 'band_2_nd'],
+  ['mult', 'band_rd_multiplier']
+]
+
+/** True when this art carries recolorable band elements. */
+export function hasResistorBands(svg: string): boolean {
+  return svg.includes('band_1_st')
+}
+
+const cache = new Map<string, string>()
+
+/** Recolor the value bands of resistor art for a given resistance attr.
+ * Unparseable/absent values return the art untouched. */
+export function decorateResistor(
+  svg: string,
+  resistance: string | number | boolean | undefined
+): string {
+  const ohms = parseOhms(resistance)
+  if (ohms === null || !hasResistorBands(svg)) return svg
+  const colors = bandColorsFor(ohms)
+  if (!colors) return svg
+  const key = `${colors.d1}|${colors.d2}|${colors.mult}|${svg.length}|${svg.slice(0, 64)}`
+  const hit = cache.get(key)
+  if (hit !== undefined) return hit
+  let out = svg
+  for (const [slot, id] of BAND_IDS) {
+    out = out.replace(
+      new RegExp(`(<[^>]*\\bid="${id}"[^>]*?\\bfill=")[^"]*(")`),
+      `$1${colors[slot]}$2`
+    )
+  }
+  cache.set(key, out)
+  return out
+}
diff --git a/src/renderer/src/circuit/views/canvas/Canvas.tsx b/src/renderer/src/circuit/views/canvas/Canvas.tsx
index 6f0a141..e1543e1 100644
--- a/src/renderer/src/circuit/views/canvas/Canvas.tsx
+++ b/src/renderer/src/circuit/views/canvas/Canvas.tsx
@@ -49,6 +49,7 @@ import {
   holeAt,
   makeEndResolver,
   pinAtWorld,
+  partArtFor,
   reroutesFor,
   rotateBoardAssemblyCmd,
   rotateNetLabelCmd,
@@ -1427,7 +1428,8 @@ export function Canvas({
                   top: pl.y,
                   width: vis.v.w,
                   height: vis.v.h,
-                  zIndex: 2,
+                  // boards sit under every other part (and under the z5 wire layer)
+                  zIndex: isBreadboard(part.type) ? 1 : 2,
                   transform:
                     pl.rotate || pl.flip
                       ? `${pl.rotate ? `rotate(${pl.rotate}deg)` : ''}${pl.flip ? ' scaleX(-1)' : ''}`
@@ -1482,7 +1484,7 @@ export function Canvas({
               >
                 <div
                   className="size-full [&>svg]:size-full [&>svg]:block pointer-events-none select-none"
-                  dangerouslySetInnerHTML={{ __html: vis.v.svg }}
+                  dangerouslySetInnerHTML={{ __html: partArtFor(part, vis, view) }}
                 />
                 {editable &&
                   Object.keys(vis.v.pins).length <= 60 &&
diff --git a/src/renderer/src/circuit/views/exportImage.ts b/src/renderer/src/circuit/views/exportImage.ts
index 5661e0b..3d83fb4 100644
--- a/src/renderer/src/circuit/views/exportImage.ts
+++ b/src/renderer/src/circuit/views/exportImage.ts
@@ -9,7 +9,7 @@ import { isBreadboard } from '../parts/breadboard'
 import { netLabelVisualOf } from '../parts/netLabels'
 import { escapeXml, namespaceSvgIds, prepareSvgForEmbed, svgNs } from '../parts/svg'
 import { isJunction, type CircuitDoc, type ViewId } from '../core/model'
-import { makeEndResolver, viewBounds, visualFor, wireGeometry } from './partsAdapter'
+import { makeEndResolver, partArtFor, viewBounds, visualFor, wireGeometry } from './partsAdapter'
 
 const WIRE_W = 2.8
 const WIRE_OUTLINE_W = WIRE_W + 1.8
@@ -103,20 +103,22 @@ export function composeSceneSvg(doc: CircuitDoc, bg: string, view: ViewId = 'bb'
     )
     .join('')
 
-  const partsSvg = doc.parts
-    .map((part) => {
-      const pl = part[view]
-      if (!pl) return ''
-      if (sch && isBreadboard(part.type)) return '' // breadboards are transparent in sch
-      const vis = visualFor(part.type, view)
-      if (!vis) return ''
-      const g = embed(vis.v.svg, part.id, pl.x, pl.y, vis.v.w, vis.v.h, pl.rotate, sch && pl.flip)
-      const off = pl.labelOffset || [0, 0]
-      const labelText = String(part.attrs?.label ?? part.id)
-      const label = `<text x="${pl.x + off[0]}" y="${pl.y + vis.v.h + 13 + off[1]}" fill="#969ba3" font-family="Plus Jakarta Sans, sans-serif" font-size="11">${escapeXml(labelText)}</text>`
-      return `${g}${label}`
-    })
-    .join('')
+  const partSvg = (part: (typeof doc.parts)[number]): string => {
+    const pl = part[view]
+    if (!pl) return ''
+    if (sch && isBreadboard(part.type)) return '' // breadboards are transparent in sch
+    const vis = visualFor(part.type, view)
+    if (!vis) return ''
+    const art = partArtFor(part, vis, view)
+    const g = embed(art, part.id, pl.x, pl.y, vis.v.w, vis.v.h, pl.rotate, sch && pl.flip)
+    const off = pl.labelOffset || [0, 0]
+    const labelText = String(part.attrs?.label ?? part.id)
+    const label = `<text x="${pl.x + off[0]}" y="${pl.y + vis.v.h + 13 + off[1]}" fill="#969ba3" font-family="Plus Jakarta Sans, sans-serif" font-size="11">${escapeXml(labelText)}</text>`
+    return `${g}${label}`
+  }
+  // boards paint first — under the wires and every other part
+  const boardsSvg = doc.parts.filter((p) => isBreadboard(p.type)).map(partSvg).join('')
+  const partsSvg = doc.parts.filter((p) => !isBreadboard(p.type)).map(partSvg).join('')
 
   const labelsSvg = sch
     ? (doc.netLabels ?? [])
@@ -128,7 +130,7 @@ export function composeSceneSvg(doc: CircuitDoc, bg: string, view: ViewId = 'bb'
     : ''
 
   const watermark = `<text x="${maxX - 14}" y="${maxY - 16}" text-anchor="end" fill="#79818c" fill-opacity="0.4" font-family="Plus Jakarta Sans, sans-serif" font-size="46" letter-spacing="-1"><tspan font-weight="300">tiny</tspan><tspan font-weight="800">Studio</tspan></text>`
-  return `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="${W}" height="${H}" viewBox="${minX} ${minY} ${W} ${H}"><rect x="${minX}" y="${minY}" width="${W}" height="${H}" fill="${bg}"/>${wires}${dots}${partsSvg}${labelsSvg}${watermark}</svg>`
+  return `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="${W}" height="${H}" viewBox="${minX} ${minY} ${W} ${H}"><rect x="${minX}" y="${minY}" width="${W}" height="${H}" fill="${bg}"/>${boardsSvg}${wires}${dots}${partsSvg}${labelsSvg}${watermark}</svg>`
 }
 
 /**
diff --git a/src/renderer/src/circuit/views/partsAdapter.ts b/src/renderer/src/circuit/views/partsAdapter.ts
index 0544b2b..72dbdaa 100644
--- a/src/renderer/src/circuit/views/partsAdapter.ts
+++ b/src/renderer/src/circuit/views/partsAdapter.ts
@@ -15,6 +15,7 @@
 import { getPart, viewFor, type PartDef, type PartView } from '../../lib/partsLibrary'
 import { schematicVisual } from '../parts/symbols'
 import { netLabelPinWorld, netLabelVisualOf, snapNetLabel } from '../parts/netLabels'
+import { decorateResistor, hasResistorBands } from '../parts/resistorBands'
 import { pinWorld, snapPlacementToPinGrid } from '../core/geometry'
 import {
   GRID_BB,
@@ -684,3 +685,14 @@ export function rotateNetLabelCmd(doc: CircuitDoc, labelId: string): Command | n
   const reroutes = reroutesFor(doc, frozen, new Map([[labelId, snapped]]), { x: 0, y: 0 }, 'sch')
   return moveNetLabel(labelId, snapped, reroutes)
 }
+
+/**
+ * Per-part art: the type-level visual, decorated with instance attrs.
+ * Today that's resistor color bands following `attrs.resistance` (bb art
+ * carries `band_*` ids); everything else renders the stock art.
+ */
+export function partArtFor(part: CircuitPart, vis: PartVisual, view: ViewId): string {
+  if (view === 'bb' && part.attrs?.resistance !== undefined && hasResistorBands(vis.v.svg))
+    return decorateResistor(vis.v.svg, part.attrs.resistance)
+  return vis.v.svg
+}
diff --git a/src/renderer/src/circuit/views/sim/Plot.tsx b/src/renderer/src/circuit/views/sim/Plot.tsx
new file mode 100644
index 0000000..eea8985
--- /dev/null
+++ b/src/renderer/src/circuit/views/sim/Plot.tsx
@@ -0,0 +1,212 @@
+/**
+ * circuit/views/sim/Plot — uPlot-backed waveform display (M4, spec §10.4).
+ *
+ * One component for the three sweep shapes:
+ *   - transient: x = time (linear)
+ *   - dc sweep:  x = the swept source voltage (`v(v-sweep)`)
+ *   - ac:        x = frequency (log), traces = magnitude in dB, plus dashed
+ *                phase traces on a right-hand degree axis
+ *
+ * uPlot gives cursors, drag-zoom (double-click resets), and a legend with
+ * click-to-toggle series for free. Theme colors are read from the design
+ * tokens at mount. CSV export lives here too (visible vectors, full data).
+ */
+
+import React from 'react'
+import uPlot from 'uplot'
+import 'uplot/dist/uPlot.min.css'
+import type { SimRun, SimVector } from '../../sim'
+
+export const TRACES = ['#4f9cf9', '#f36e6e', '#54c08a', '#e5b567', '#b78be5', '#5bc8c8', '#e08fd0', '#9aa76b']
+
+export type PlotMode = 'tran' | 'dc' | 'ac'
+
+function cssVar(name: string, fallback: string): string {
+  const v = getComputedStyle(document.documentElement).getPropertyValue(name).trim()
+  return v || fallback
+}
+
+const mag = (re: number, im: number): number => Math.sqrt(re * re + im * im)
+const db = (m: number): number => 20 * Math.log10(Math.max(m, 1e-20))
+const deg = (re: number, im: number): number => (Math.atan2(im, re) * 180) / Math.PI
+
+interface Prepared {
+  data: uPlot.AlignedData
+  series: uPlot.Series[]
+  xLabel: string
+  isLog: boolean
+  hasPhase: boolean
+}
+
+function prepare(run: SimRun, mode: PlotMode): Prepared | null {
+  const x =
+    mode === 'ac'
+      ? run.vectors.find((v) => v.type === 'frequency')
+      : mode === 'dc'
+        ? (run.vectors.find((v) => v.name.toLowerCase() === 'v(v-sweep)') ?? run.vectors[0])
+        : (run.vectors.find((v) => v.type === 'time') ?? run.vectors[0])
+  if (!x) return null
+  const ys = run.vectors
+    .filter((v) => v !== x && v.name.toLowerCase() !== 'v(v-sweep)' && v.name.startsWith('v('))
+    .slice(0, TRACES.length)
+  if (!ys.length) return null
+
+  const series: uPlot.Series[] = [{ label: mode === 'ac' ? 'Hz' : mode === 'dc' ? 'Vsweep' : 's' }]
+  const cols: number[][] = []
+
+  const isAc = mode === 'ac' && ys.some((v) => v.imag)
+  for (let i = 0; i < ys.length; i++) {
+    const v = ys[i]
+    if (isAc) {
+      cols.push(v.values.map((re, k) => db(mag(re, v.imag?.[k] ?? 0))))
+      series.push({
+        label: `${v.name} dB`,
+        stroke: TRACES[i],
+        width: 1.4,
+        scale: 'y',
+        value: (_u, val) => (val == null ? '' : `${val.toFixed(1)} dB`)
+      })
+    } else {
+      cols.push(v.values)
+      series.push({
+        label: v.name,
+        stroke: TRACES[i],
+        width: 1.4,
+        scale: 'y',
+        value: (_u, val) => (val == null ? '' : `${fmtEng(val)}V`)
+      })
+    }
+  }
+  if (isAc) {
+    for (let i = 0; i < ys.length; i++) {
+      const v = ys[i]
+      cols.push(v.values.map((re, k) => deg(re, v.imag?.[k] ?? 0)))
+      series.push({
+        label: `${v.name} °`,
+        stroke: TRACES[i],
+        width: 1,
+        dash: [4, 4],
+        scale: 'deg',
+        value: (_u, val) => (val == null ? '' : `${val.toFixed(1)}°`)
+      })
+    }
+  }
+  return {
+    data: [x.values, ...cols] as uPlot.AlignedData,
+    series,
+    xLabel: mode === 'ac' ? 'frequency (Hz)' : mode === 'dc' ? 'sweep (V)' : 'time (s)',
+    isLog: mode === 'ac',
+    hasPhase: isAc
+  }
+}
+
+export function fmtEng(v: number): string {
+  const a = Math.abs(v)
+  if (a >= 1e6) return `${(v / 1e6).toFixed(2)}M`
+  if (a >= 1e3) return `${(v / 1e3).toFixed(2)}k`
+  if (a >= 1) return v.toFixed(2)
+  if (a >= 1e-3) return `${(v * 1e3).toFixed(2)}m`
+  if (a >= 1e-6) return `${(v * 1e6).toFixed(2)}µ`
+  if (a === 0) return '0'
+  return `${(v * 1e9).toFixed(2)}n`
+}
+
+export function SimPlot({ run, mode }: { run: SimRun; mode: PlotMode }): React.JSX.Element {
+  const host = React.useRef<HTMLDivElement>(null)
+  const plot = React.useRef<uPlot | null>(null)
+  const prepared = React.useMemo(() => prepare(run, mode), [run, mode])
+
+  React.useEffect(() => {
+    const el = host.current
+    if (!el || !prepared) return
+    const axisInk = cssVar('--text-muted', '#9aa1ab')
+    const gridInk = cssVar('--border-default', '#2a2f37')
+
+    const make = (width: number): uPlot => {
+      const axes: uPlot.Axis[] = [
+        {
+          label: prepared.xLabel,
+          stroke: axisInk,
+          labelSize: 14,
+          grid: { stroke: gridInk, width: 0.5 },
+          ticks: { stroke: gridInk },
+          values: prepared.isLog
+            ? (_u, splits) => splits.map((s) => fmtEng(s))
+            : (_u, splits) => splits.map((s) => fmtEng(s))
+        },
+        {
+          scale: 'y',
+          stroke: axisInk,
+          grid: { stroke: gridInk, width: 0.5 },
+          ticks: { stroke: gridInk },
+          values: (_u, splits) => splits.map((s) => fmtEng(s))
+        }
+      ]
+      if (prepared.hasPhase)
+        axes.push({
+          scale: 'deg',
+          side: 1,
+          stroke: axisInk,
+          grid: { show: false },
+          ticks: { stroke: gridInk },
+          values: (_u, splits) => splits.map((s) => `${s}°`)
+        })
+      return new uPlot(
+        {
+          width,
+          height: 220,
+          series: prepared.series,
+          scales: {
+            x: prepared.isLog ? { distr: 3, log: 10 } : { time: false },
+            y: {},
+            ...(prepared.hasPhase ? { deg: {} } : {})
+          },
+          axes,
+          legend: { live: true },
+          cursor: { drag: { x: true, y: false } }
+        },
+        prepared.data,
+        el
+      )
+    }
+
+    plot.current = make(Math.max(el.clientWidth || 640, 320))
+    const ro = new ResizeObserver(() => {
+      const w = Math.max(el.clientWidth || 640, 320)
+      plot.current?.setSize({ width: w, height: 220 })
+    })
+    ro.observe(el)
+    return () => {
+      ro.disconnect()
+      plot.current?.destroy()
+      plot.current = null
+    }
+  }, [prepared])
+
+  if (!prepared) return <div className="text-text-faint">no voltage vectors to plot</div>
+  return (
+    <div className="flex flex-col gap-1 min-w-0">
+      <div ref={host} className="w-full min-w-0 [&_.u-legend]:text-[10px]" />
+      <span className="text-[10px] text-text-faint">
+        drag to zoom · double-click to reset · click legend entries to toggle traces
+      </span>
+    </div>
+  )
+}
+
+/** CSV of every vector in the run (x first), raw numbers. */
+export function runToCsv(run: SimRun): string {
+  const cols: { name: string; values: number[] }[] = []
+  for (const v of run.vectors as SimVector[]) {
+    if (v.imag) {
+      cols.push({ name: `${v.name} (mag)`, values: v.values.map((re, k) => mag(re, v.imag![k])) })
+      cols.push({ name: `${v.name} (deg)`, values: v.values.map((re, k) => deg(re, v.imag![k])) })
+    } else {
+      cols.push({ name: v.name, values: v.values })
+    }
+  }
+  const n = Math.max(...cols.map((c) => c.values.length))
+  const lines = [cols.map((c) => JSON.stringify(c.name)).join(',')]
+  for (let i = 0; i < n; i++) lines.push(cols.map((c) => c.values[i] ?? '').join(','))
+  return lines.join('\n') + '\n'
+}
diff --git a/src/renderer/src/circuit/views/sim/SimPanel.tsx b/src/renderer/src/circuit/views/sim/SimPanel.tsx
index 058a566..1f73b5c 100644
--- a/src/renderer/src/circuit/views/sim/SimPanel.tsx
+++ b/src/renderer/src/circuit/views/sim/SimPanel.tsx
@@ -1,16 +1,16 @@
 /**
  * circuit/views/sim/SimPanel — the M4 Simulate panel (spec §10.4, first cut).
  *
- * Docked at the bottom of the circuit area: analysis tabs (DC / Transient),
- * parameters, Run/Cancel, results. DC (.op) lists node voltages and source
- * currents — and the shell mirrors them onto the schematic as annotations;
- * transient renders probe traces in a lightweight inline SVG plot (uPlot
- * arrives with the full plotting pass — cursors/zoom/AC are M4 backlog).
+ * Docked at the bottom of the circuit area: analysis tabs (DC op / DC sweep /
+ * Transient / AC), parameters, Run/Cancel, results. DC (.op) lists node
+ * voltages and source currents — and the shell mirrors them onto the canvas
+ * as annotations; sweeps render in a uPlot chart (cursors, drag-zoom,
+ * legend-toggle) with CSV export.
  *
  * Analysis config persists in doc.sim via Commands (undoable, serialized).
  */
 
-import { CircuitBoard, Loader2, Play, Square, X } from 'lucide-react'
+import { CircuitBoard, Download, Loader2, Play, Square, X } from 'lucide-react'
 import React from 'react'
 import * as cmd from '../../core/commands'
 import type { Analysis, CircuitDoc } from '../../core/model'
@@ -19,6 +19,7 @@ import { generateNetlist, type NetlistResult } from '../../core/netlist'
 import type { CircuitStore } from '../../core/store'
 import { getSimBackend, SimError } from '../../sim'
 import type { SimRun } from '../../sim'
+import { runToCsv, SimPlot, type PlotMode } from './Plot'
 
 const field =
   'bg-bg-sunken border border-border-default rounded px-2 py-1 text-text-strong outline-none focus:border-brand w-20 text-xs'
@@ -50,12 +51,25 @@ export function SimPanel({
   const [gen, setGen] = React.useState<NetlistResult | null>(null)
   const [error, setError] = React.useState<{ message: string; details?: string[] } | null>(null)
   const [showNetlist, setShowNetlist] = React.useState(false)
-  const [hidden, setHidden] = React.useState<Set<string>>(new Set())
 
   const setAnalysis = (patch: Partial<Analysis>): void => {
     store.dispatch(cmd.setAnalyses([{ ...analysis, ...patch }]))
   }
 
+  // sweepable sources, named the way the netlist emits them (VV1, II1…)
+  const sources = React.useMemo(
+    () =>
+      doc.parts
+        .map((p) => {
+          const key = `${p.type} ${familyOf(p.type) ?? ''}`
+          if (/sim-vdc|voltage source|battery|sim-vsin|sine|waveform/i.test(key)) return `V${p.id}`
+          if (/sim-idc|current source/i.test(key)) return `I${p.id}`
+          return null
+        })
+        .filter((n): n is string => n !== null),
+    [doc.parts, familyOf]
+  )
+
   const run = async (): Promise<void> => {
     setRunning(true)
     setError(null)
@@ -115,7 +129,9 @@ export function SimPanel({
           {(
             [
               ['op', 'DC'],
-              ['tran', 'Transient']
+              ['dc', 'Sweep'],
+              ['tran', 'Transient'],
+              ['ac', 'AC']
             ] as [Analysis['kind'], string][]
           ).map(([kind, label]) => (
             <button
@@ -125,7 +141,13 @@ export function SimPanel({
                   ? 'bg-brand/15 text-brand'
                   : 'bg-surface-card text-text-muted hover:text-text-body'
               }`}
-              onClick={() => setAnalysis({ kind })}
+              onClick={() =>
+                setAnalysis(
+                  kind === 'dc'
+                    ? { kind, src: String(analysis.src ?? sources[0] ?? '') }
+                    : { kind }
+                )
+              }
             >
               {label}
             </button>
@@ -159,7 +181,102 @@ export function SimPanel({
           </div>
         )}
 
+        {analysis.kind === 'dc' && (
+          <div className="flex items-center gap-1.5 text-[11px] text-text-muted">
+            <span>source</span>
+            <select
+              className={`${field} w-24`}
+              value={String(analysis.src ?? sources[0] ?? '')}
+              onChange={(e) => setAnalysis({ src: e.target.value })}
+            >
+              {sources.length === 0 && <option value="">no sources</option>}
+              {sources.map((n) => (
+                <option key={n} value={n}>
+                  {n}
+                </option>
+              ))}
+            </select>
+            <span>from</span>
+            <input
+              className={field}
+              defaultValue={String(analysis.from ?? '0')}
+              key={`from:${analysis.id}`}
+              onBlur={(e) => setAnalysis({ from: e.target.value })}
+            />
+            <span>to</span>
+            <input
+              className={field}
+              defaultValue={String(analysis.to ?? '5')}
+              key={`to:${analysis.id}`}
+              onBlur={(e) => setAnalysis({ to: e.target.value })}
+            />
+            <span>step</span>
+            <input
+              className={field}
+              defaultValue={String(analysis.step ?? '0.1')}
+              key={`dcstep:${analysis.id}`}
+              onBlur={(e) => setAnalysis({ step: e.target.value })}
+            />
+          </div>
+        )}
+
+        {analysis.kind === 'ac' && (
+          <div className="flex items-center gap-1.5 text-[11px] text-text-muted">
+            <select
+              className={`${field} w-16`}
+              value={String(analysis.variation ?? 'dec')}
+              onChange={(e) => setAnalysis({ variation: e.target.value })}
+            >
+              {['dec', 'oct', 'lin'].map((v) => (
+                <option key={v} value={v}>
+                  {v}
+                </option>
+              ))}
+            </select>
+            <span>pts</span>
+            <input
+              className={`${field} w-12`}
+              defaultValue={String(analysis.points ?? '20')}
+              key={`pts:${analysis.id}`}
+              onBlur={(e) => setAnalysis({ points: e.target.value })}
+            />
+            <span>from</span>
+            <input
+              className={field}
+              defaultValue={String(analysis.fstart ?? '1')}
+              key={`fstart:${analysis.id}`}
+              onBlur={(e) => setAnalysis({ fstart: e.target.value })}
+            />
+            <span>to</span>
+            <input
+              className={field}
+              defaultValue={String(analysis.fstop ?? '1Meg')}
+              key={`fstop:${analysis.id}`}
+              onBlur={(e) => setAnalysis({ fstop: e.target.value })}
+            />
+            <span className="text-text-faint" title="AC needs a sine source — its amplitude sets the AC magnitude">
+              Hz
+            </span>
+          </div>
+        )}
+
         <div className="flex-1" />
+        {result && result.numPoints > 1 && (
+          <button
+            className="flex items-center gap-1 text-[11px] text-text-faint hover:text-text-body"
+            title="Download results as CSV"
+            onClick={() => {
+              const blob = new Blob([runToCsv(result)], { type: 'text/csv' })
+              const a = document.createElement('a')
+              a.href = URL.createObjectURL(blob)
+              a.download = 'simulation.csv'
+              a.click()
+              URL.revokeObjectURL(a.href)
+            }}
+          >
+            <Download size={11} /> CSV
+          </button>
+        )}
         <button
           className="text-[11px] text-text-faint hover:text-text-body"
           onClick={() => setShowNetlist((s) => !s)}
@@ -220,18 +337,7 @@ export function SimPanel({
 
         {isOp && result && <OpTable run={result} describe={describe} />}
         {result && result.numPoints > 1 && (
-          <WavePlot
-            run={result}
-            hidden={hidden}
-            onToggle={(name) =>
-              setHidden((h) => {
-                const next = new Set(h)
-                if (next.has(name)) next.delete(name)
-                else next.add(name)
-                return next
-              })
-            }
-          />
+          <SimPlot run={result} mode={(analysis.kind === 'op' ? 'tran' : analysis.kind) as PlotMode} />
         )}
 
         {showNetlist && gen && (
@@ -293,95 +399,3 @@ function OpTable({
     </div>
   )
 }
-
-// ── waveform plot (inline SVG — uPlot lands with the full plotting pass) ─────
-
-const TRACES = ['#4f9cf9', '#f36e6e', '#54c08a', '#e5b567', '#b78be5', '#5bc8c8']
-
-function WavePlot({
-  run,
-  hidden,
-  onToggle
-}: {
-  run: SimRun
-  hidden: Set<string>
-  onToggle: (name: string) => void
-}): React.JSX.Element {
-  const x =
-    run.vectors.find((v) => v.type === 'time' || v.type === 'frequency') ?? run.vectors[0]
-  const all = run.vectors.filter((v) => v !== x && v.name.startsWith('v('))
-  const traces = all.filter((v) => !hidden.has(v.name)).slice(0, TRACES.length)
-  if (!x || all.length === 0) return <div className="text-text-faint">no voltage vectors</div>
-
-  const W = 640
-  const H = 180
-  const PAD = 28
-  const xmin = Math.min(...x.values)
-  const xmax = Math.max(...x.values)
-  let ymin = traces.length ? Infinity : -1
-  let ymax = traces.length ? -Infinity : 1
-  for (const tr of traces)
-    for (const v of tr.values) {
-      ymin = Math.min(ymin, v)
-      ymax = Math.max(ymax, v)
-    }
-  if (ymin === ymax) {
-    ymin -= 1
-    ymax += 1
-  }
-  const sx = (v: number): number => PAD + ((v - xmin) / (xmax - xmin || 1)) * (W - PAD * 2)
-  const sy = (v: number): number => H - PAD - ((v - ymin) / (ymax - ymin)) * (H - PAD * 2)
-
-  return (
-    <div className="flex flex-col gap-1">
-      <svg viewBox={`0 0 ${W} ${H}`} className="w-full max-w-[720px] rounded-md border border-border-default bg-bg-sunken">
-        {/* axes */}
-        <line x1={PAD} y1={H - PAD} x2={W - PAD} y2={H - PAD} stroke="var(--border-strong)" />
-        <line x1={PAD} y1={PAD} x2={PAD} y2={H - PAD} stroke="var(--border-strong)" />
-        <text x={PAD} y={PAD - 6} fontSize="9" fill="var(--text-muted)">
-          {fmtSI(ymax, 'V')}
-        </text>
-        <text x={PAD} y={H - PAD + 12} fontSize="9" fill="var(--text-muted)">
-          {fmtSI(ymin, 'V')}
-        </text>
-        <text x={W - PAD} y={H - PAD + 12} fontSize="9" fill="var(--text-muted)" textAnchor="end">
-          {fmtSI(xmax, x.type === 'frequency' ? 'Hz' : 's')}
-        </text>
-        {traces.map((tr, i) => (
-          <polyline
-            key={tr.name}
-            fill="none"
-            stroke={TRACES[i]}
-            strokeWidth="1.4"
-            points={tr.values.map((v, k) => `${sx(x.values[k])},${sy(v)}`).join(' ')}
-          />
-        ))}
-      </svg>
-      <div className="flex gap-2 flex-wrap items-center">
-        {all.map((tr) => {
-          const idx = traces.indexOf(tr)
-          const off = idx < 0
-          return (
-            <button
-              key={tr.name}
-              className={`flex items-center gap-1 text-[10px] px-1.5 py-0.5 rounded border ${
-                off
-                  ? 'border-border-default text-text-faint line-through'
-                  : 'border-transparent text-text-muted'
-              }`}
-              title={off ? 'Show trace' : 'Hide trace'}
-              onClick={() => onToggle(tr.name)}
-            >
-              <span
-                className="w-3 h-0.5 inline-block"
-                style={{ background: off ? 'var(--border-strong)' : TRACES[idx] }}
-              />
-              {tr.name}
-            </button>
-          )
-        })}
-        <span className="text-[10px] text-text-faint ml-1">click to toggle</span>
-      </div>
-    </div>
-  )
-}

From e3246b076267ec90fb5d772de243d06ae9b4936a Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Mon, 13 Jul 2026 09:22:31 -0600
Subject: [PATCH 16/27] Bump version to 0.3.0; status-bar banner reads version
 from package.json

---
 package.json                              | 2 +-
 src/renderer/src/components/StatusBar.tsx | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/package.json b/package.json
index d97db4e..8de6b23 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "tinystudio",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "An open-source desktop + web IDE for building, wiring, simulating, and flashing tiny hardware projects — code, circuit, and visual views in one place.",
   "main": "./out/main/index.js",
   "author": "MR.INDUSTRIES",
diff --git a/src/renderer/src/components/StatusBar.tsx b/src/renderer/src/components/StatusBar.tsx
index a3e9b82..c6032e1 100644
--- a/src/renderer/src/components/StatusBar.tsx
+++ b/src/renderer/src/components/StatusBar.tsx
@@ -11,6 +11,7 @@ import {
   PlugZap
 } from 'lucide-react'
 import React from 'react'
+import { version as appVersion } from '../../../../package.json'
 import { useArduinoContext } from '../contexts/ArduinoContext'
 import { useSerial } from '../contexts/SerialContext'
 import {
@@ -218,7 +219,7 @@ export function StatusBar(): React.JSX.Element {
         <span className="text-white dark:text-[var(--text-faint)] mx-2">·</span>
         <span>Arduino (C++)</span>
         <span className="text-white dark:text-[var(--text-faint)] mx-2">·</span>
-        <span>tinyStudio 0.2.0</span>
+        <span>tinyStudio {appVersion}</span>
         <span className="ml-2.5">
           <Badge tone="yellow" variant="solid">
             alpha

From 5226072f5e59ebb54d25af8b4a92844bf4e3c1af Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Wed, 22 Jul 2026 13:55:56 -0600
Subject: [PATCH 17/27] Circuit v2 M4: flip to default editor, remove legacy
 DiagramEditor/CircuitEditor

Circuit View v2 is now the only editor mounted by EditorPanel's CircuitView -
no more tinystudio.circuitV2 flag or CircuitV1View branch. diagram.json
projects still auto-migrate to circuit.json on open (unchanged). Removes
src/renderer/src/components/DiagramEditor.tsx (2009 lines, legacy breadboard
editor) and the already-dead CircuitEditor.tsx static viewer (B21).

npm run typecheck (node+web) clean; test:circuit 95/95.
---
 src/renderer/src/circuit/index.ts             |   18 +-
 .../src/circuit/views/CircuitView.tsx         |    5 +-
 src/renderer/src/components/CircuitEditor.tsx |   60 -
 src/renderer/src/components/DiagramEditor.tsx | 2009 -----------------
 src/renderer/src/components/EditorPanel.tsx   |   54 +-
 5 files changed, 15 insertions(+), 2131 deletions(-)
 delete mode 100644 src/renderer/src/components/CircuitEditor.tsx
 delete mode 100644 src/renderer/src/components/DiagramEditor.tsx

diff --git a/src/renderer/src/circuit/index.ts b/src/renderer/src/circuit/index.ts
index 073dcc7..981f86d 100644
--- a/src/renderer/src/circuit/index.ts
+++ b/src/renderer/src/circuit/index.ts
@@ -1,12 +1,12 @@
 /**
- * circuit/ — public API of the Circuit View v2 module.
+ * circuit/ — public API of the Circuit View module.
  *
  * Everything outside this folder should import from here (or from
  * `circuit/views/CircuitView` for the React mount) — internals may reshuffle.
  *
- * Feature flag (M0–M3): localStorage `tinystudio.circuitV2` = '1' switches the
- * Circuit tab from the legacy DiagramEditor to the v2 module. Flip it from
- * DevTools:  localStorage.setItem('tinystudio.circuitV2', '1')
+ * As of M4 this is the only circuit editor (the legacy DiagramEditor and its
+ * `tinystudio.circuitV2` feature flag were removed once v2 reached parity +
+ * simulation).
  */
 
 export * from './core/model'
@@ -19,13 +19,3 @@ export * from './core/geometry'
 export * from './core/refdes'
 export * from './core/clipboard'
 export { namespaceSvgIds, svgNs, stripSvgSize, escapeXml } from './parts/svg'
-
-export const CIRCUIT_V2_FLAG = 'tinystudio.circuitV2'
-
-export function circuitV2Enabled(): boolean {
-  try {
-    return globalThis.localStorage?.getItem(CIRCUIT_V2_FLAG) === '1'
-  } catch {
-    return false
-  }
-}
diff --git a/src/renderer/src/circuit/views/CircuitView.tsx b/src/renderer/src/circuit/views/CircuitView.tsx
index 1626672..20e54f8 100644
--- a/src/renderer/src/circuit/views/CircuitView.tsx
+++ b/src/renderer/src/circuit/views/CircuitView.tsx
@@ -6,8 +6,9 @@
  * (store.serialize() → onChange → Redux buffer; disk save stays on Ctrl+S,
  * same as every other editor buffer).
  *
- * Mounted by EditorPanel behind the `tinystudio.circuitV2` flag, in the same
- * window slot the legacy DiagramEditor occupies — desktop and web builds.
+ * Mounted directly by EditorPanel's CircuitView in the Circuit tab — desktop
+ * and web builds. This has been the only circuit editor since M4 (the legacy
+ * DiagramEditor and its feature flag were removed).
  */
 
 import {
diff --git a/src/renderer/src/components/CircuitEditor.tsx b/src/renderer/src/components/CircuitEditor.tsx
deleted file mode 100644
index 5ab2200..0000000
--- a/src/renderer/src/components/CircuitEditor.tsx
+++ /dev/null
@@ -1,60 +0,0 @@
-import { useSelector } from 'react-redux'
-import { TransformComponent, TransformWrapper } from 'react-zoom-pan-pinch'
-import circuitDiagram from '../assets/circuitdiagram.png'
-import { RootState } from '../redux/store'
-
-interface CircuitEditorProps {
-  svgContent?: string
-}
-
-export function CircuitEditor({ svgContent }: CircuitEditorProps): React.JSX.Element {
-  const diagramSvgContent = useSelector((state: RootState) => state.file.diagramSvgContent)
-  const activeSvgContent = svgContent || diagramSvgContent
-
-  const diagramElement = activeSvgContent ? (
-    <div
-      className="size-1/2 z-30 flex items-center justify-center [&>svg]:w-auto [&>svg]:h-auto [&>svg]:max-w-full [&>svg]:max-h-full"
-      dangerouslySetInnerHTML={{ __html: activeSvgContent }}
-    />
-  ) : (
-    <img src={circuitDiagram} alt="Circuit diagram" className="size-fit object-contain" />
-  )
-
-  return (
-    <div className="size-full flex items-center justify-center bg-bg-sunken overflow-hidden">
-      <TransformWrapper
-        centerOnInit
-        centerZoomedOut
-        initialScale={1.8}
-        maxScale={5}
-        minScale={1.8}
-        wheel={{
-          smoothStep: 0.01,
-          touchPadDisabled: false
-        }}
-        pinch={{ step: 10 }}
-      >
-        <TransformComponent
-          wrapperStyle={{ width: '100%', height: '100%' }}
-          contentStyle={{
-            width: '100%',
-            height: '100%',
-            display: 'flex',
-            alignItems: 'center',
-            justifyContent: 'center'
-          }}
-        >
-          <div
-            className="absolute -inset-20"
-            style={{
-              backgroundImage: 'radial-gradient(var(--dot-color) 1.1px, transparent 1.1px)',
-              backgroundSize: '10px 10px',
-              backgroundColor: 'var(--bg-sunken)'
-            }}
-          ></div>
-          {diagramElement}
-        </TransformComponent>
-      </TransformWrapper>
-    </div>
-  )
-}
diff --git a/src/renderer/src/components/DiagramEditor.tsx b/src/renderer/src/components/DiagramEditor.tsx
deleted file mode 100644
index 190b2a8..0000000
--- a/src/renderer/src/components/DiagramEditor.tsx
+++ /dev/null
@@ -1,2009 +0,0 @@
-/**
- * DiagramEditor — renders a project's `diagram.json` as a live, editable circuit.
- *
- * The wiring system is ported from the tinySchematic prototype (a Fritzing-style
- * breadboard/schematic wiring engine): absolute bendpoints that hold their place
- * when parts move, orthogonal auto-routing with clean pin entry, junctions
- * (wire-to-wire taps), straight/diagonal mode (hold Shift), per-segment / bend /
- * endpoint handle editing, double-click to add or remove a bend, and a live
- * equipotential net model that glows everything sharing a node. Wires are drawn
- * exactly like tinySchematic: rounded glossy tubes (dark outline → color core →
- * animated selection dashes) with a yellow net glow.
- *
- * Around it: a Fritzing-style two-column components rail, a right-hand Inspector
- * that edits the selected part's name / location / rotation / properties (e.g. a
- * resistor's value) — or a selected wire's color — drag-to-place, draggable part
- * labels, zoom/fit, and Wokwi `diagram.json` serialization.
- *
- * Styling follows the tinyStudio design system: cold neutral surfaces, the four
- * PCB inks, a notebook dot-grid canvas, tactile controls, mono eyebrows,
- * sentence-case copy.
- */
-
-import {
-  ChevronDown,
-  ChevronRight,
-  CircuitBoard,
-  CodeXml,
-  Grid3x3,
-  ImageDown,
-  Maximize,
-  MousePointer2,
-  Pencil,
-  Plus,
-  RotateCw,
-  Trash2,
-  Eye,
-  Spline,
-  Zap,
-  ZoomIn,
-  ZoomOut
-} from 'lucide-react'
-import React from 'react'
-import {
-  ensureParts,
-  getPart,
-  loadPart,
-  partsByFamily,
-  viewFor,
-  type PartDef,
-  type PartMeta,
-  type ViewKind
-} from '../lib/partsLibrary'
-import {
-  bendsFromInstructions,
-  buildWirePoints,
-  calculateOrthogonalPath,
-  clampOntoSegment,
-  distanceToSegment,
-  dragSegment,
-  getWireAt,
-  getWirePoints,
-  instructionsFromPoints,
-  isStraightRoute,
-  simplifyWirePoints,
-  type Connection,
-  type PinRef,
-  type Pt
-} from '../lib/wireRouting'
-import { buildNets, meaningfulNetCount } from '../lib/circuitNets'
-import { initUserParts, saveUserPart } from '../lib/userParts'
-import { PartsEditor } from './PartsEditor'
-
-const CANVAS_W = 1100
-const CANVAS_H = 640
-const GRID = 9.6 // 100 mil (0.1in) at 96 DPI — the standard breadboard pitch
-
-// wire look (mirrors tinySchematic config.js)
-const WIRE_W = 2.8
-const WIRE_OUTLINE_W = WIRE_W + 1.8
-const WIRE_GLOW_W = WIRE_W + 5
-const WIRE_CORNER = 4
-const NET_GLOW = 'rgba(243, 203, 0, 0.30)' // brand-yellow equipotential glow
-
-interface Part {
-  id: string
-  type: string
-  left: number
-  top: number
-  rotate?: number // 0 | 90 | 180 | 270 (Wokwi-compatible)
-  attrs?: Record<string, unknown>
-}
-// Per-view overrides for the schematic layout. The top-level parts/connections
-// stay the Wokwi breadboard layout; the schematic view keeps its own positions
-// and wire routes here so the two diagrams can diverge. A part/wire with no
-// schematic entry falls back to its breadboard placement (until it's moved).
-interface SchematicLayout {
-  pos: Record<string, [number, number]> // partId -> [left, top]
-  routes: Record<string, string[]> // connKey -> h/v instructions
-}
-interface Diagram {
-  parts: Part[]
-  connections: Connection[]
-  author?: string
-  schematic: SchematicLayout
-}
-
-// The four PCB inks carry meaning (green = signal/connected, red = power/stop,
-// blue = primary, gold = warn) plus a neutral white and slate for contrast. We
-// persist concrete hex (not CSS vars) so the colors survive export.
-const WIRE_COLORS = ['#2fa46a', '#e5544b', '#42a5f5', '#f3cb00', '#ffffff', '#79818c']
-
-const uid = (): string => Math.random().toString(36).slice(2, 8)
-const snap = (v: number): number => Math.round(v / GRID) * GRID
-
-// read-compat: accept Wokwi left/top or the legacy x/y
-function readPart(p: Record<string, unknown>): Part {
-  return {
-    id: String(p.id),
-    type: String(p.type),
-    left: Number(p.left ?? p.x ?? 0),
-    top: Number(p.top ?? p.y ?? 0),
-    rotate: p.rotate ? Number(p.rotate) : undefined,
-    attrs: (p.attrs as Record<string, unknown>) || undefined
-  }
-}
-
-// rotate a local point (px,py) around a part's centre by `deg` (CSS-rotate space)
-function rotatePoint(px: number, py: number, w: number, h: number, deg: number): Pt {
-  const rad = (deg * Math.PI) / 180
-  const cos = Math.cos(rad)
-  const sin = Math.sin(rad)
-  const dx = px - w / 2
-  const dy = py - h / 2
-  return { x: w / 2 + dx * cos - dy * sin, y: h / 2 + dx * sin + dy * cos }
-}
-
-const eqRef = (a: PinRef, b: PinRef): boolean => {
-  if (typeof a === 'string' && typeof b === 'string') return a === b
-  if (typeof a === 'object' && typeof b === 'object')
-    return Math.abs(a.x - b.x) < 0.5 && Math.abs(a.y - b.y) < 0.5
-  return false
-}
-
-// Drag a bendpoint while keeping its neighbouring segments orthogonal (ported
-// from tinySchematic's vertex-drag logic).
-function vertexDrag(orig: Pt[], index: number, x: number, y: number): Pt[] {
-  const points = orig.map((p) => ({ x: p.x, y: p.y }))
-  points[index].x = x
-  points[index].y = y
-  if (index > 0) {
-    if (
-      Math.abs(points[index - 1].y - points[index].y) <
-      Math.abs(points[index - 1].x - points[index].x)
-    ) {
-      if (index - 1 > 0) points[index - 1].y = points[index].y
-      else points[index].y = points[index - 1].y
-    } else {
-      if (index - 1 > 0) points[index - 1].x = points[index].x
-      else points[index].x = points[index - 1].x
-    }
-  }
-  if (index < points.length - 1) {
-    if (
-      Math.abs(points[index + 1].y - points[index].y) <
-      Math.abs(points[index + 1].x - points[index].x)
-    ) {
-      if (index + 1 < points.length - 1) points[index + 1].y = points[index].y
-      else points[index].y = points[index + 1].y
-    } else {
-      if (index + 1 < points.length - 1) points[index + 1].x = points[index].x
-      else points[index].x = points[index + 1].x
-    }
-  }
-  return points
-}
-
-// Build an SVG path with rounded corners (a quadratic fillet at each bend),
-// matching tinySchematic's arcTo wire look.
-function roundedPath(points: Pt[], r = WIRE_CORNER): string {
-  if (points.length < 2) return ''
-  if (points.length === 2) return `M${points[0].x} ${points[0].y} L${points[1].x} ${points[1].y}`
-  let d = `M${points[0].x} ${points[0].y}`
-  for (let i = 1; i < points.length - 1; i++) {
-    const p = points[i - 1]
-    const c = points[i]
-    const n = points[i + 1]
-    const d1 = Math.hypot(c.x - p.x, c.y - p.y) || 1
-    const d2 = Math.hypot(n.x - c.x, n.y - c.y) || 1
-    const rr = Math.max(0, Math.min(r, d1 / 2, d2 / 2))
-    const a = { x: c.x - ((c.x - p.x) / d1) * rr, y: c.y - ((c.y - p.y) / d1) * rr }
-    const b = { x: c.x + ((n.x - c.x) / d2) * rr, y: c.y + ((n.y - c.y) / d2) * rr }
-    d += ` L${a.x} ${a.y} Q${c.x} ${c.y} ${b.x} ${b.y}`
-  }
-  const last = points[points.length - 1]
-  d += ` L${last.x} ${last.y}`
-  return d
-}
-
-// A darker shade of a wire's color for its "3D" outline (Fritzing tube look).
-function darken(hex: string, f = 0.55): string {
-  const m = /^#?([0-9a-fA-F]{6})$/.exec(hex.trim())
-  if (!m) return 'rgba(0,0,0,0.45)'
-  const n = parseInt(m[1], 16)
-  const r = Math.round(((n >> 16) & 255) * f)
-  const g = Math.round(((n >> 8) & 255) * f)
-  const b = Math.round((n & 255) * f)
-  return `rgb(${r}, ${g}, ${b})`
-}
-
-// Escape text for safe inclusion in exported SVG markup.
-function escapeXml(s: string): string {
-  return s.replace(
-    /[<>&'"]/g,
-    (c) => ({ '<': '&lt;', '>': '&gt;', '&': '&amp;', "'": '&apos;', '"': '&quot;' })[c] as string
-  )
-}
-
-// Display family/section names in sentence case (the catalogue stores some in
-// ALL CAPS, e.g. "CAPACITOR [BIDIRECTIONAL]") — the brand voice is no all-caps.
-function titleCase(s: string): string {
-  return s
-    .toLowerCase()
-    .replace(/\b([a-z])/g, (m) => m.toUpperCase())
-    .replace(/\bIc\b/, 'IC')
-}
-
-// A small SVG thumbnail for the palette / part tiles. Fritzing icon art is dark
-// line-work meant for a light background, so we put it on a light chip.
-function Thumb({ svg, size = 40 }: { svg?: string; size?: number }): React.JSX.Element {
-  if (!svg)
-    return (
-      <div
-        className="shrink-0 rounded-md grid place-items-center"
-        style={{ width: size, height: size, background: 'var(--warm-150)' }}
-      >
-        <CircuitBoard size={20} className="text-warm-500" style={{ color: '#79818c' }} />
-      </div>
-    )
-  return (
-    <div
-      className="shrink-0 rounded-md p-1 grid place-items-center [&>svg]:max-w-full [&>svg]:max-h-full [&>svg]:w-auto [&>svg]:h-auto"
-      style={{ width: size, height: size, background: 'var(--warm-150)' }}
-      dangerouslySetInnerHTML={{ __html: svg }}
-    />
-  )
-}
-
-type HandleKind = 'vertex' | 'edge' | 'endpoint'
-
-export function DiagramEditor({
-  content,
-  onChange,
-  onOpenCode,
-  onEditChange
-}: {
-  content: string
-  onChange: (next: string) => void
-  // Switch to the Code view with diagram.json selected (the `</>` button).
-  onOpenCode?: () => void
-  // Fires when the view/edit toggle flips (used to free space by closing the
-  // docs panel when you start editing).
-  onEditChange?: (editing: boolean) => void
-}): React.JSX.Element {
-  const diagram: Diagram = React.useMemo(() => {
-    try {
-      const d = JSON.parse(content || '{}')
-      const sch = d.schematic || {}
-      return {
-        parts: (d.parts || []).map(readPart),
-        connections: (d.connections || []) as Connection[],
-        author: d.author,
-        schematic: { pos: sch.pos || {}, routes: sch.routes || {} }
-      }
-    } catch {
-      return { parts: [], connections: [], schematic: { pos: {}, routes: {} } }
-    }
-  }, [content])
-
-  const [view] = React.useState<ViewKind>('breadboard')
-  const [editable, setEditable] = React.useState(false)
-  const [grid, setGrid] = React.useState(true)
-  const [editorPart, setEditorPart] = React.useState<PartDef | null | undefined>(undefined) // undefined = closed
-  const [selPart, setSelPart] = React.useState<string | null>(null)
-  const [selWire, setSelWire] = React.useState<number | null>(null)
-  const [wireColor, setWireColor] = React.useState(WIRE_COLORS[0])
-  const [armed, setArmed] = React.useState<{
-    from: PinRef
-    points: Pt[]
-    straight: boolean
-  } | null>(null)
-  const [hoverPin, setHoverPin] = React.useState<{ id: string; pin: string } | null>(null)
-  const [hoverWire, setHoverWire] = React.useState<number | null>(null)
-  const [mouse, setMouse] = React.useState<Pt>({ x: 0, y: 0 })
-  const [straight, setStraight] = React.useState(false)
-  const [collapsed, setCollapsed] = React.useState<Set<string>>(new Set())
-  const [editPts, setEditPts] = React.useState<Pt[] | null>(null) // selected-wire editing buffer
-  const [newAttr, setNewAttr] = React.useState('')
-  const [tick, force] = React.useReducer((n) => n + 1, 0)
-
-  const viewRef = React.useRef<HTMLDivElement>(null)
-  const innerRef = React.useRef<HTMLDivElement>(null)
-  const drag = React.useRef<{
-    id: string
-    offX: number
-    offY: number
-    affected: { i: number; bends: Pt[]; straight: boolean }[]
-  } | null>(null)
-  const labelDrag = React.useRef<{ id: string; ox: number; oy: number } | null>(null)
-  const pan = React.useRef<{ x: number; y: number } | null>(null)
-  const handleDrag = React.useRef<{ kind: HandleKind } | null>(null)
-  const [cam, setCam] = React.useState({ scale: 0.62, tx: 0, ty: 0 })
-  const scale = cam.scale
-  const didInit = React.useRef(false)
-
-  React.useEffect(() => {
-    void initUserParts().then((n) => {
-      const types = diagram.parts.map((p) => p.type).filter((t) => !getPart(t))
-      if (types.length) ensureParts(types).then(force)
-      else if (n) force()
-    })
-  }, [diagram.parts])
-
-  const write = (d: Partial<Diagram>): void => {
-    const sch = d.schematic || diagram.schematic
-    const hasSch = Object.keys(sch.pos).length > 0 || Object.keys(sch.routes).length > 0
-    const next = {
-      version: 1,
-      editor: 'tinystudio',
-      author: diagram.author,
-      parts: (d.parts || diagram.parts).map((p) => ({
-        type: p.type,
-        id: p.id,
-        left: p.left,
-        top: p.top,
-        ...(p.rotate ? { rotate: p.rotate } : {}),
-        ...(p.attrs && Object.keys(p.attrs).length ? { attrs: p.attrs } : {})
-      })),
-      connections: d.connections || diagram.connections,
-      ...(hasSch ? { schematic: sch } : {})
-    }
-    onChange(JSON.stringify(next, null, 2))
-  }
-
-  // ── per-view layout helpers ─────────────────────────────────────────────────
-
-  const refStr = (r: PinRef): string => (typeof r === 'string' ? r : `${r.x},${r.y}`)
-  const connKey = (c: Connection): string => `${refStr(c[0])}>${refStr(c[1])}`
-  // position of a part in the *current* view (schematic falls back to breadboard)
-  const partXY = (part: Part): [number, number] =>
-    view === 'schematic'
-      ? diagram.schematic.pos[part.id] || [part.left, part.top]
-      : [part.left, part.top]
-  // wire route in the current view (schematic starts clean, then diverges)
-  const routeFor = (c: Connection): string[] =>
-    view === 'schematic' ? (diagram.schematic.routes[connKey(c)] ?? []) : c[3] || []
-
-  // ── geometry ──────────────────────────────────────────────────────────────
-
-  const pinAbsAt = (part: Part, pin: string, left: number, top: number): Pt | null => {
-    const def = getPart(part.type)
-    if (!def) return null
-    const v = viewFor(def, view)
-    const p = v?.pins[pin]
-    if (!p) return null
-    const rp = part.rotate ? rotatePoint(p[0], p[1], v!.w, v!.h, part.rotate) : { x: p[0], y: p[1] }
-    return { x: left + rp.x, y: top + rp.y }
-  }
-  const pinAbs = (part: Part, pin: string): Pt | null => {
-    const [left, top] = partXY(part)
-    return pinAbsAt(part, pin, left, top)
-  }
-  // Resolve refs, optionally overriding some parts' positions (used mid-drag so
-  // bends stay fixed in space while a part moves).
-  const resolveWith =
-    (posMap: Record<string, [number, number]>) =>
-    (ref: PinRef): Pt | null => {
-      if (typeof ref === 'object') return ref
-      const [id, pin] = ref.split(':')
-      const part = diagram.parts.find((p) => p.id === id)
-      if (!part) return null
-      const [left, top] = posMap[id] ?? partXY(part)
-      return pinAbsAt(part, pin, left, top)
-    }
-  const resolve = resolveWith({})
-  const wirePts = (c: Connection): Pt[] => getWirePoints(c, resolve, routeFor(c))
-
-  const canvasPoint = (e: { clientX: number; clientY: number }): Pt => {
-    const r = innerRef.current!.getBoundingClientRect()
-    return { x: (e.clientX - r.left) / scale, y: (e.clientY - r.top) / scale }
-  }
-  const getPinAtWorld = (wx: number, wy: number): { id: string; pin: string; pos: Pt } | null => {
-    const tol = 8 / scale
-    for (const part of diagram.parts) {
-      const def = getPart(part.type)
-      const v = def && viewFor(def, view)
-      if (!v) continue
-      for (const pin of Object.keys(v.pins)) {
-        const pos = pinAbs(part, pin)
-        if (pos && Math.hypot(pos.x - wx, pos.y - wy) < tol) return { id: part.id, pin, pos }
-      }
-    }
-    return null
-  }
-
-  // ── equipotential net model (drives net glow + the routed count) ────────────
-
-  const netModel = React.useMemo(
-    () => buildNets(diagram.parts, diagram.connections, (c) => wirePts(c)),
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [diagram, view, tick]
-  )
-  // Highlight the net under the hovered pin, hovered wire, or selected wire — so
-  // you can see (and effectively "select") a whole net.
-  const highlightNet = React.useMemo(() => {
-    if (hoverPin) {
-      const i = netModel.pinToNet.get(`${hoverPin.id}:${hoverPin.pin}`)
-      if (i != null) return i
-    }
-    if (hoverWire != null) {
-      const i = netModel.connToNet[hoverWire]
-      if (i >= 0) return i
-    }
-    if (selWire != null) {
-      const i = netModel.connToNet[selWire]
-      if (i >= 0) return i
-    }
-    return -1
-  }, [hoverPin, hoverWire, selWire, netModel])
-
-  // ── camera ──────────────────────────────────────────────────────────────────
-
-  const fitView = (): void => {
-    const el = viewRef.current
-    if (!el) return
-    let minX = Infinity
-    let minY = Infinity
-    let maxX = -Infinity
-    let maxY = -Infinity
-    for (const part of diagram.parts) {
-      const def = getPart(part.type)
-      const v = def && viewFor(def, view)
-      if (!v) continue
-      const [l, t] = partXY(part)
-      minX = Math.min(minX, l)
-      minY = Math.min(minY, t)
-      maxX = Math.max(maxX, l + v.w)
-      maxY = Math.max(maxY, t + v.h)
-    }
-    for (const c of diagram.connections) {
-      for (const p of wirePts(c)) {
-        minX = Math.min(minX, p.x)
-        minY = Math.min(minY, p.y)
-        maxX = Math.max(maxX, p.x)
-        maxY = Math.max(maxY, p.y)
-      }
-    }
-    if (!isFinite(minX)) {
-      const f = Math.min(el.clientWidth / CANVAS_W, el.clientHeight / CANVAS_H, 1)
-      setCam({
-        scale: f,
-        tx: (el.clientWidth - CANVAS_W * f) / 2,
-        ty: (el.clientHeight - CANVAS_H * f) / 2
-      })
-      return
-    }
-    const pad = 40
-    minX -= pad
-    minY -= pad
-    maxX += pad
-    maxY += pad
-    const bw = maxX - minX
-    const bh = maxY - minY
-    const f = Math.max(0.25, Math.min(3, Math.min(el.clientWidth / bw, el.clientHeight / bh)))
-    setCam({
-      scale: f,
-      tx: (el.clientWidth - bw * f) / 2 - minX * f,
-      ty: (el.clientHeight - bh * f) / 2 - minY * f
-    })
-  }
-  React.useEffect(() => {
-    if (didInit.current) return
-    if (diagram.parts.length === 0 || diagram.parts.every((p) => getPart(p.type))) {
-      fitView()
-      didInit.current = true
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [content, tick])
-
-  const zoomAt = (factor: number, sx: number, sy: number): void => {
-    setCam((c) => {
-      const ns = Math.max(0.25, Math.min(3, c.scale * factor))
-      const k = ns / c.scale
-      return { scale: ns, tx: sx - (sx - c.tx) * k, ty: sy - (sy - c.ty) * k }
-    })
-  }
-  const zoomCenter = (factor: number): void => {
-    const el = viewRef.current
-    if (el) zoomAt(factor, el.clientWidth / 2, el.clientHeight / 2)
-  }
-  const onWheel = (e: React.WheelEvent): void => {
-    const rect = viewRef.current!.getBoundingClientRect()
-    zoomAt(e.deltaY < 0 ? 1.12 : 1 / 1.12, e.clientX - rect.left, e.clientY - rect.top)
-  }
-  const onViewPointerDown = (e: React.PointerEvent): void => {
-    if (e.button !== 1 && !(e.button === 0 && e.altKey)) return
-    e.preventDefault()
-    pan.current = { x: e.clientX, y: e.clientY }
-    window.addEventListener('pointermove', onPanMove)
-    window.addEventListener('pointerup', onPanUp)
-  }
-  const onPanMove = (e: PointerEvent): void => {
-    const p = pan.current
-    if (!p) return
-    setCam((c) => ({ ...c, tx: c.tx + (e.clientX - p.x), ty: c.ty + (e.clientY - p.y) }))
-    pan.current = { x: e.clientX, y: e.clientY }
-  }
-  const onPanUp = (): void => {
-    pan.current = null
-    window.removeEventListener('pointermove', onPanMove)
-    window.removeEventListener('pointerup', onPanUp)
-  }
-
-  // ── shared: re-sync a part's wires after a discrete move/rotate ──────────────
-
-  const touches = (ref: PinRef, id: string): boolean =>
-    typeof ref === 'string' && ref.split(':')[0] === id
-
-  const collectFrozen = (id: string): { i: number; bends: Pt[]; straight: boolean }[] => {
-    const f: { i: number; bends: Pt[]; straight: boolean }[] = []
-    diagram.connections.forEach((c, i) => {
-      if (!touches(c[0], id) && !touches(c[1], id)) return
-      const route = routeFor(c)
-      const s = resolve(c[0])
-      const t = resolve(c[1])
-      if (s && t)
-        f.push({ i, bends: bendsFromInstructions(route, s, t), straight: isStraightRoute(route) })
-    })
-    return f
-  }
-  // Apply a new parts array (and optional schematic-pos patch) for `id`, holding
-  // its wires' bends fixed in world space.
-  const commitParts = (
-    parts: Part[],
-    id: string,
-    schPosPatch?: Record<string, [number, number]>
-  ): void => {
-    const frozen = collectFrozen(id)
-    const schPos = schPosPatch
-      ? { ...diagram.schematic.pos, ...schPosPatch }
-      : diagram.schematic.pos
-    const resolveNew = (ref: PinRef): Pt | null => {
-      if (typeof ref === 'object') return ref
-      const [pid, pin] = ref.split(':')
-      const part = parts.find((p) => p.id === pid)
-      if (!part) return null
-      const [l, t] =
-        view === 'schematic' ? schPos[pid] || [part.left, part.top] : [part.left, part.top]
-      return pinAbsAt(part, pin, l, t)
-    }
-    if (view === 'schematic') {
-      const routes = { ...diagram.schematic.routes }
-      frozen.forEach((a) => {
-        const c = diagram.connections[a.i]
-        const s = resolveNew(c[0])
-        const t = resolveNew(c[1])
-        if (s && t)
-          routes[connKey(c)] = instructionsFromPoints(
-            buildWirePoints(s, a.bends, t, a.straight),
-            a.straight
-          )
-      })
-      write({ parts, schematic: { pos: schPos, routes } })
-    } else {
-      const conns = diagram.connections.slice()
-      frozen.forEach((a) => {
-        const c = diagram.connections[a.i]
-        const s = resolveNew(c[0])
-        const t = resolveNew(c[1])
-        if (s && t) {
-          const nc = conns[a.i].slice() as Connection
-          nc[3] = instructionsFromPoints(buildWirePoints(s, a.bends, t, a.straight), a.straight)
-          conns[a.i] = nc
-        }
-      })
-      write({ parts, connections: conns })
-    }
-  }
-
-  // ── part drag (absolute bendpoints: bends hold while the part moves) ─────────
-
-  const onPartDown = (e: React.PointerEvent, part: Part): void => {
-    if (!editable || (e.target as HTMLElement).closest('.pin-hit')) return
-    e.stopPropagation()
-    setSelPart(part.id)
-    selectWire(null)
-    const r = innerRef.current!.getBoundingClientRect()
-    const [left, top] = partXY(part)
-    drag.current = {
-      id: part.id,
-      offX: (e.clientX - r.left) / scale - left,
-      offY: (e.clientY - r.top) / scale - top,
-      affected: collectFrozen(part.id)
-    }
-    window.addEventListener('pointermove', onPartMove)
-    window.addEventListener('pointerup', onPartUp)
-  }
-  const onPartMove = (e: PointerEvent): void => {
-    const d = drag.current
-    if (!d) return
-    const r = innerRef.current!.getBoundingClientRect()
-    const nx = snap((e.clientX - r.left) / scale - d.offX)
-    const ny = snap((e.clientY - r.top) / scale - d.offY)
-    const resolveNext = resolveWith({ [d.id]: [nx, ny] })
-    const updates: { i: number; key: string; instr: string[] }[] = []
-    for (const a of d.affected) {
-      const c = diagram.connections[a.i]
-      const src = resolveNext(c[0])
-      const tgt = resolveNext(c[1])
-      if (!src || !tgt) continue
-      const pts = buildWirePoints(src, a.bends, tgt, a.straight)
-      updates.push({ i: a.i, key: connKey(c), instr: instructionsFromPoints(pts, a.straight) })
-    }
-    if (view === 'schematic') {
-      const routes = { ...diagram.schematic.routes }
-      updates.forEach((u) => (routes[u.key] = u.instr))
-      write({ schematic: { pos: { ...diagram.schematic.pos, [d.id]: [nx, ny] }, routes } })
-    } else {
-      const parts = diagram.parts.map((p) => (p.id === d.id ? { ...p, left: nx, top: ny } : p))
-      const conns = diagram.connections.slice()
-      updates.forEach((u) => {
-        const nc = conns[u.i].slice() as Connection
-        nc[3] = u.instr
-        conns[u.i] = nc
-      })
-      write({ parts, connections: conns })
-    }
-  }
-  const onPartUp = (): void => {
-    drag.current = null
-    window.removeEventListener('pointermove', onPartMove)
-    window.removeEventListener('pointerup', onPartUp)
-  }
-
-  // drag a part's title label to reposition it (offset stored on the part)
-  const onLabelDown = (e: React.PointerEvent, part: Part): void => {
-    if (!editable) return
-    e.stopPropagation()
-    setSelPart(part.id)
-    selectWire(null)
-    const start = canvasPoint(e)
-    const off = (part.attrs?.labelOffset as [number, number]) || [0, 0]
-    labelDrag.current = { id: part.id, ox: off[0] - start.x, oy: off[1] - start.y }
-    const move = (ev: PointerEvent): void => {
-      const ld = labelDrag.current
-      if (!ld) return
-      const cp = canvasPoint(ev)
-      const offset: [number, number] = [Math.round(ld.ox + cp.x), Math.round(ld.oy + cp.y)]
-      patchAttr(ld.id, 'labelOffset', offset)
-    }
-    const up = (): void => {
-      labelDrag.current = null
-      window.removeEventListener('pointermove', move)
-      window.removeEventListener('pointerup', up)
-    }
-    window.addEventListener('pointermove', move)
-    window.addEventListener('pointerup', up)
-  }
-
-  // ── wiring ──────────────────────────────────────────────────────────────────
-
-  const selectWire = (i: number | null): void => {
-    setSelWire(i)
-    setEditPts(i == null ? null : wirePts(diagram.connections[i]))
-  }
-
-  const commitNewWire = (from: PinRef, to: PinRef, instr: string[]): void => {
-    const conn: Connection =
-      view === 'schematic' ? [from, to, wireColor] : [from, to, wireColor, instr]
-    if (view === 'schematic') {
-      write({
-        connections: [...diagram.connections, conn],
-        schematic: {
-          ...diagram.schematic,
-          routes: { ...diagram.schematic.routes, [connKey(conn)]: instr }
-        }
-      })
-    } else {
-      write({ connections: [...diagram.connections, conn] })
-    }
-  }
-
-  const finalizeSegment = (target: Pt, clean: boolean): { pts: Pt[]; str: boolean } => {
-    const pts = [...armed!.points]
-    const last = pts[pts.length - 1]
-    const str = armed!.straight || straight
-    if (str) pts.push(target)
-    else pts.push(...calculateOrthogonalPath(last.x, last.y, target.x, target.y, clean).slice(1))
-    return { pts: simplifyWirePoints(pts), str }
-  }
-
-  const onPinClick = (e: React.MouseEvent, part: Part, pin: string): void => {
-    if (!editable) return
-    e.stopPropagation()
-    const ref = `${part.id}:${pin}`
-    const pos = pinAbs(part, pin)
-    if (!pos) return
-    if (!armed) {
-      setArmed({ from: ref, points: [pos], straight: false })
-      setSelPart(null)
-      selectWire(null)
-      return
-    }
-    if (eqRef(armed.from, ref)) {
-      setArmed(null)
-      return
-    }
-    const { pts, str } = finalizeSegment(pos, true)
-    const instr = instructionsFromPoints(pts, str)
-    const exists = diagram.connections.some(
-      (c) => (eqRef(c[0], armed.from) && c[1] === ref) || (c[0] === ref && eqRef(c[1], armed.from))
-    )
-    if (!exists) commitNewWire(armed.from, ref, instr)
-    setArmed(null)
-  }
-
-  // tap a junction onto an existing wire `i` at the click point
-  const tapJunction = (e: React.MouseEvent, i: number): void => {
-    const cp = canvasPoint(e)
-    const pts = wirePts(diagram.connections[i])
-    const hit = getWireAt(cp.x, cp.y, [diagram.connections[i]], () => pts, scale)
-    const seg = hit ? { p1: hit.p1, p2: hit.p2 } : { p1: pts[0], p2: pts[1] }
-    const jp = clampOntoSegment(seg.p1, seg.p2, snap(cp.x), snap(cp.y))
-    const { pts: fp, str } = finalizeSegment(jp, false)
-    commitNewWire(armed!.from, { x: jp.x, y: jp.y }, instructionsFromPoints(fp, str))
-    setArmed(null)
-  }
-
-  const onCanvasClick = (e: React.MouseEvent): void => {
-    if (armed) {
-      const cp = canvasPoint(e)
-      const hit = getWireAt(cp.x, cp.y, diagram.connections, (c) => wirePts(c), scale)
-      if (hit) {
-        tapJunction(e, hit.index)
-        return
-      }
-      const target = { x: snap(cp.x), y: snap(cp.y) }
-      const last = armed.points[armed.points.length - 1]
-      const seg = straight
-        ? [last, target]
-        : calculateOrthogonalPath(last.x, last.y, target.x, target.y, false)
-      setArmed({
-        ...armed,
-        points: [...armed.points, ...seg.slice(1)],
-        straight: armed.straight || straight
-      })
-      return
-    }
-    setSelPart(null)
-    selectWire(null)
-  }
-  const onCanvasMove = (e: React.PointerEvent): void => {
-    if (armed) setMouse(canvasPoint(e))
-  }
-
-  // ── wire editing — endpoint / bend / segment handles ─────────────────────────
-
-  const resolveEndpointTarget = (wx: number, wy: number, selfIdx: number): PinRef => {
-    const pin = getPinAtWorld(wx, wy)
-    if (pin) return `${pin.id}:${pin.pin}`
-    const hit = getWireAt(wx, wy, diagram.connections, (c) => wirePts(c), scale)
-    if (hit && hit.index !== selfIdx) return clampOntoSegment(hit.p1, hit.p2, snap(wx), snap(wy))
-    return { x: snap(wx), y: snap(wy) }
-  }
-
-  const writeWire = (i: number, opts: { instr: string[]; from?: PinRef; to?: PinRef }): void => {
-    const c = diagram.connections[i]
-    const oldKey = connKey(c)
-    const nc = c.slice() as Connection
-    if (opts.from !== undefined) nc[0] = opts.from
-    if (opts.to !== undefined) nc[1] = opts.to
-    const newKey = connKey(nc)
-    const conns = diagram.connections.slice()
-    if (view === 'schematic') {
-      const routes = { ...diagram.schematic.routes }
-      if (oldKey !== newKey) delete routes[oldKey]
-      routes[newKey] = opts.instr
-      conns[i] = nc
-      write({ connections: conns, schematic: { ...diagram.schematic, routes } })
-    } else {
-      nc[3] = opts.instr
-      conns[i] = nc
-      if (oldKey !== newKey && diagram.schematic.routes[oldKey]) {
-        const routes = { ...diagram.schematic.routes }
-        routes[newKey] = routes[oldKey]
-        delete routes[oldKey]
-        write({ connections: conns, schematic: { ...diagram.schematic, routes } })
-      } else {
-        write({ connections: conns })
-      }
-    }
-  }
-
-  // recolor an existing wire (conn[2] is the logical color, shared across views)
-  const recolorWire = (i: number, color: string): void => {
-    const conns = diagram.connections.slice()
-    const nc = conns[i].slice() as Connection
-    nc[2] = color
-    conns[i] = nc
-    write({ connections: conns })
-  }
-  // colour swatch: recolour the selected wire if one is selected; else set the
-  // colour future wires are drawn in.
-  const pickColor = (color: string): void => {
-    setWireColor(color)
-    if (selWire != null) recolorWire(selWire, color)
-  }
-
-  const startHandleDrag = (
-    e: React.PointerEvent,
-    kind: HandleKind,
-    idx: number,
-    end?: 0 | 1
-  ): void => {
-    if (!editable || selWire == null || !editPts) return
-    e.stopPropagation()
-    const wireIdx = selWire
-    const orig = editPts
-    const str = isStraightRoute(routeFor(diagram.connections[wireIdx]))
-    const axis: 'horizontal' | 'vertical' =
-      kind === 'edge' && Math.abs(orig[idx].y - orig[idx + 1].y) < 0.001 ? 'horizontal' : 'vertical'
-    const endIdx = end === 0 ? 0 : orig.length - 1
-    let live = orig
-    let lastWorld = { x: 0, y: 0 }
-    handleDrag.current = { kind }
-    const move = (ev: PointerEvent): void => {
-      const cp = canvasPoint(ev)
-      if (kind === 'vertex') {
-        live = vertexDrag(orig, idx, snap(cp.x), snap(cp.y))
-      } else if (kind === 'edge') {
-        live = dragSegment(orig, idx, axis, snap(cp.x), snap(cp.y))
-      } else {
-        lastWorld = { x: cp.x, y: cp.y }
-        const p = { x: snap(cp.x), y: snap(cp.y) }
-        live = orig.map((pt, k) => (k === endIdx ? p : pt))
-      }
-      setEditPts(live)
-    }
-    const up = (): void => {
-      window.removeEventListener('pointermove', move)
-      window.removeEventListener('pointerup', up)
-      handleDrag.current = null
-      let from: PinRef | undefined
-      let to: PinRef | undefined
-      if (kind === 'endpoint') {
-        const tgt = resolveEndpointTarget(lastWorld.x, lastWorld.y, wireIdx)
-        if (end === 0) from = tgt
-        else to = tgt
-        const rp = typeof tgt === 'object' ? tgt : resolve(tgt)
-        if (rp) live = live.map((pt, k) => (k === endIdx ? rp : pt))
-      }
-      writeWire(wireIdx, { instr: instructionsFromPoints(simplifyWirePoints(live), str), from, to })
-    }
-    window.addEventListener('pointermove', move)
-    window.addEventListener('pointerup', up)
-  }
-
-  const onWireDoubleClick = (e: React.MouseEvent, i: number): void => {
-    if (!editable) return
-    e.stopPropagation()
-    const c = diagram.connections[i]
-    const str = isStraightRoute(routeFor(c))
-    const cp = canvasPoint(e)
-    const pts = wirePts(c)
-    const handleR = 7 / scale
-    for (let k = 1; k < pts.length - 1; k++) {
-      if (Math.hypot(pts[k].x - cp.x, pts[k].y - cp.y) < handleR) {
-        const next = simplifyWirePoints(pts.filter((_, j) => j !== k))
-        writeWire(i, { instr: instructionsFromPoints(next, str) })
-        setEditPts(next)
-        return
-      }
-    }
-    const hit = getWireAt(cp.x, cp.y, [c], () => pts, scale)
-    if (hit) {
-      const next = pts.slice()
-      next.splice(hit.segmentIndex + 1, 0, { x: snap(cp.x), y: snap(cp.y) })
-      writeWire(i, { instr: instructionsFromPoints(next, str) })
-      selectWire(i)
-      setEditPts(next)
-    }
-  }
-
-  // wire <g> click: tap a junction while drawing, else select the wire
-  const onWireClick = (e: React.MouseEvent, i: number): void => {
-    e.stopPropagation()
-    if (armed) {
-      tapJunction(e, i)
-      return
-    }
-    if (!editable) {
-      selectWire(i) // view-mode: select to inspect / highlight its net
-      setSelPart(null)
-      return
-    }
-    selectWire(i)
-    setSelPart(null)
-  }
-
-  React.useEffect(() => {
-    if (selWire != null && !handleDrag.current) {
-      const c = diagram.connections[selWire]
-      if (c) setEditPts(wirePts(c))
-      else selectWire(null)
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [content, view])
-
-  // ── palette / add / delete / properties ─────────────────────────────────────
-
-  const addPart = async (type: string, at?: Pt): Promise<void> => {
-    const def = getPart(type) || (await loadPart(type))
-    if (!def) return
-    force()
-    const v = viewFor(def, view)
-    const w = v?.w || 80
-    const h = v?.h || 40
-    const left = at ? Math.round(at.x - w / 2) : Math.round(CANVAS_W / 2 - w / 2)
-    const top = at ? Math.round(at.y - h / 2) : Math.round(CANVAS_H / 2 - h / 2)
-    const pid = type + '_' + uid().slice(0, 3)
-    const parts = [...diagram.parts, { id: pid, type, left, top }]
-    write(
-      view === 'schematic'
-        ? {
-            parts,
-            schematic: {
-              ...diagram.schematic,
-              pos: { ...diagram.schematic.pos, [pid]: [left, top] }
-            }
-          }
-        : { parts }
-    )
-    setSelPart(pid)
-  }
-  const onDrop = (e: React.DragEvent): void => {
-    e.preventDefault()
-    const type = e.dataTransfer.getData('text/tinystudio-part')
-    if (type) addPart(type, canvasPoint(e))
-  }
-
-  const editExisting = async (type: string): Promise<void> => {
-    const def = getPart(type) || (await loadPart(type))
-    if (def) setEditorPart(def)
-  }
-
-  // patch a part's attrs (used by the Inspector + label drag)
-  const patchAttr = (id: string, key: string, value: unknown): void => {
-    write({
-      parts: diagram.parts.map((p) =>
-        p.id === id ? { ...p, attrs: { ...(p.attrs || {}), [key]: value } } : p
-      )
-    })
-  }
-  const removeAttr = (id: string, key: string): void => {
-    write({
-      parts: diagram.parts.map((p) => {
-        if (p.id !== id) return p
-        const attrs = { ...(p.attrs || {}) }
-        delete attrs[key]
-        return { ...p, attrs }
-      })
-    })
-  }
-  // move a part to an absolute location in the current view (Inspector inputs)
-  const movePartTo = (id: string, left: number, top: number): void => {
-    if (view === 'schematic') {
-      commitParts(diagram.parts, id, { [id]: [left, top] })
-    } else {
-      commitParts(
-        diagram.parts.map((p) => (p.id === id ? { ...p, left, top } : p)),
-        id
-      )
-    }
-  }
-  const setRotation = (id: string, deg: number): void => {
-    commitParts(
-      diagram.parts.map((p) => (p.id === id ? { ...p, rotate: ((deg % 360) + 360) % 360 } : p)),
-      id
-    )
-  }
-  const rotatePart = (id: string): void => {
-    const part = diagram.parts.find((p) => p.id === id)
-    if (part) setRotation(id, (part.rotate || 0) + 90)
-  }
-
-  const deletePart = (id: string): void => {
-    const keep = (c: Connection): boolean =>
-      (typeof c[0] !== 'string' || c[0].split(':')[0] !== id) &&
-      (typeof c[1] !== 'string' || c[1].split(':')[0] !== id)
-    const routes = { ...diagram.schematic.routes }
-    const pos = { ...diagram.schematic.pos }
-    delete pos[id]
-    diagram.connections.forEach((c) => {
-      if (!keep(c)) delete routes[connKey(c)]
-    })
-    write({
-      parts: diagram.parts.filter((p) => p.id !== id),
-      connections: diagram.connections.filter(keep),
-      schematic: { pos, routes }
-    })
-    setSelPart(null)
-  }
-  const deleteWire = (i: number): void => {
-    const gone = diagram.connections[i]
-    const routes = { ...diagram.schematic.routes }
-    if (gone) delete routes[connKey(gone)]
-    write({
-      connections: diagram.connections.filter((_, j) => j !== i),
-      schematic: { ...diagram.schematic, routes }
-    })
-    selectWire(null)
-  }
-
-  React.useEffect(() => {
-    const down = (e: KeyboardEvent): void => {
-      if (document.activeElement && /INPUT|TEXTAREA|SELECT/.test(document.activeElement.tagName))
-        return
-      if (e.key === 'Shift') setStraight(true)
-      if (editable && (e.key === ' ' || e.key === 'r' || e.key === 'R')) {
-        const id = drag.current?.id || selPart
-        if (id) {
-          e.preventDefault()
-          rotatePart(id)
-          return
-        }
-      }
-      if (e.key === 'Escape') {
-        setArmed(null)
-        setSelPart(null)
-        selectWire(null)
-      }
-      if (e.key === 'Delete' || e.key === 'Backspace') {
-        if (selWire != null) deleteWire(selWire)
-        else if (selPart) deletePart(selPart)
-      }
-    }
-    const up = (e: KeyboardEvent): void => {
-      if (e.key === 'Shift') setStraight(false)
-    }
-    window.addEventListener('keydown', down)
-    window.addEventListener('keyup', up)
-    return () => {
-      window.removeEventListener('keydown', down)
-      window.removeEventListener('keyup', up)
-    }
-  }, [selPart, selWire, diagram, editable, view, straight])
-
-  const previewPts = React.useMemo((): Pt[] | null => {
-    if (!armed) return null
-    const last = armed.points[armed.points.length - 1]
-    let target = { x: snap(mouse.x), y: snap(mouse.y) }
-    let clean = false
-    if (hoverPin) {
-      const part = diagram.parts.find((p) => p.id === hoverPin.id)
-      const pos = part && pinAbs(part, hoverPin.pin)
-      if (pos) {
-        target = pos
-        clean = true
-      }
-    }
-    if (straight) return [...armed.points, target]
-    return [
-      ...armed.points,
-      ...calculateOrthogonalPath(last.x, last.y, target.x, target.y, clean).slice(1)
-    ]
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [armed, mouse, hoverPin, diagram.parts, view, straight])
-
-  const isAI = (diagram.author || '').includes('Studio AI')
-  // tactile pixel-art toolbar buttons (design-system .tactile-bordered)
-  const tool =
-    'tactile-bordered h-8 px-2.5 flex items-center gap-1.5 rounded-md bg-surface-card text-text-muted text-xs hover:text-text-body active:translate-y-px'
-  const families = partsByFamily()
-  const isOpen = (fam: string): boolean => !collapsed.has(fam)
-  const toggleFam = (fam: string): void =>
-    setCollapsed((s) => {
-      const n = new Set(s)
-      if (n.has(fam)) n.delete(fam)
-      else n.add(fam)
-      return n
-    })
-  const netCount = meaningfulNetCount(netModel)
-  // Junction solder dots: a free-point endpoint takes the color of the wire it
-  // lands on (the one you attached it to), so the joint reads as part of it.
-  const junctions: { pt: Pt; color: string }[] = []
-  diagram.connections.forEach((c, ci) => {
-    ;[c[0], c[1]].forEach((r) => {
-      if (typeof r !== 'object') return
-      let color = view === 'schematic' ? 'var(--text-strong)' : (c[2] as string) || '#2fa46a'
-      if (view !== 'schematic') {
-        for (let oi = 0; oi < diagram.connections.length; oi++) {
-          if (oi === ci) continue
-          const pts = wirePts(diagram.connections[oi])
-          let on = false
-          for (let s = 0; s < pts.length - 1; s++) {
-            if (distanceToSegment(r, pts[s], pts[s + 1]) < 2) {
-              on = true
-              break
-            }
-          }
-          if (on) {
-            color = (diagram.connections[oi][2] as string) || color
-            break
-          }
-        }
-      }
-      junctions.push({ pt: r, color })
-    })
-  })
-
-  const labelOf = (part: Part): string => {
-    const def = getPart(part.type)
-    return (part.attrs?.label as string) || def?.label || part.type
-  }
-  const selectedPart = selPart ? diagram.parts.find((p) => p.id === selPart) : null
-
-  // Export the diagram (parts + wires + a tinyStudio watermark) to a PNG by
-  // composing a standalone SVG and rasterizing it through a canvas.
-  const exportImage = (): void => {
-    let minX = Infinity
-    let minY = Infinity
-    let maxX = -Infinity
-    let maxY = -Infinity
-    for (const part of diagram.parts) {
-      const def = getPart(part.type)
-      const v = def && viewFor(def, view)
-      if (!v) continue
-      const [l, t] = partXY(part)
-      minX = Math.min(minX, l)
-      minY = Math.min(minY, t)
-      maxX = Math.max(maxX, l + v.w + 60) // room for labels
-      maxY = Math.max(maxY, t + v.h + 18)
-    }
-    for (const c of diagram.connections) {
-      for (const p of wirePts(c)) {
-        minX = Math.min(minX, p.x)
-        minY = Math.min(minY, p.y)
-        maxX = Math.max(maxX, p.x)
-        maxY = Math.max(maxY, p.y)
-      }
-    }
-    if (!isFinite(minX)) return
-    const pad = 36
-    minX -= pad
-    minY -= pad
-    maxX += pad
-    maxY += pad + 16 // extra room for the watermark
-    const W = Math.round(maxX - minX)
-    const H = Math.round(maxY - minY)
-    const cs = getComputedStyle(document.documentElement)
-    const bg = (cs.getPropertyValue('--bg-sunken') || '#1e1f22').trim()
-
-    const wires = diagram.connections
-      .map((c) => {
-        const pts = wirePts(c)
-        if (pts.length < 2) return ''
-        const core = (c[2] as string) || '#2fa46a'
-        const d = roundedPath(pts)
-        return `<path d="${d}" fill="none" stroke="${darken(core)}" stroke-width="${WIRE_OUTLINE_W}" stroke-linejoin="round" stroke-linecap="round"/><path d="${d}" fill="none" stroke="${core}" stroke-width="${WIRE_W}" stroke-linejoin="round" stroke-linecap="round"/>`
-      })
-      .join('')
-    const dots = junctions
-      .map((j) => `<circle cx="${j.pt.x}" cy="${j.pt.y}" r="3" fill="${j.color}"/>`)
-      .join('')
-    const partsSvg = diagram.parts
-      .map((part) => {
-        const def = getPart(part.type)
-        const v = def && viewFor(def, view)
-        if (!v) return ''
-        const [l, t] = partXY(part)
-        // strip any width/height on the part's <svg> then size+place it
-        const inner = v.svg
-          .replace(/<svg([^>]*?)\swidth="[^"]*"/i, '<svg$1')
-          .replace(/<svg([^>]*?)\sheight="[^"]*"/i, '<svg$1')
-          .replace('<svg', `<svg x="${l}" y="${t}" width="${v.w}" height="${v.h}"`)
-        const rot = part.rotate ? ` transform="rotate(${part.rotate} ${l + v.w / 2} ${t + v.h / 2})"` : ''
-        const label = `<text x="${l}" y="${t + v.h + 13}" fill="#969ba3" font-family="Plus Jakarta Sans, sans-serif" font-size="11">${escapeXml(labelOf(part))}</text>`
-        return `<g${rot}>${inner}</g>${label}`
-      })
-      .join('')
-    const watermark = `<text x="${maxX - 10}" y="${maxY - 10}" text-anchor="end" fill="#79818c" fill-opacity="0.75" font-family="Plus Jakarta Sans, sans-serif" font-size="13" font-weight="600">tinyStudio</text>`
-
-    const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${W}" height="${H}" viewBox="${minX} ${minY} ${W} ${H}"><rect x="${minX}" y="${minY}" width="${W}" height="${H}" fill="${bg}"/>${wires}${dots}${partsSvg}${watermark}</svg>`
-
-    const blob = new Blob([svg], { type: 'image/svg+xml;charset=utf-8' })
-    const url = URL.createObjectURL(blob)
-    const img = new Image()
-    img.onload = () => {
-      const sf = 2
-      const canvas = document.createElement('canvas')
-      canvas.width = W * sf
-      canvas.height = H * sf
-      const ctx = canvas.getContext('2d')
-      if (!ctx) {
-        URL.revokeObjectURL(url)
-        return
-      }
-      ctx.scale(sf, sf)
-      ctx.drawImage(img, 0, 0)
-      URL.revokeObjectURL(url)
-      canvas.toBlob((png) => {
-        if (!png) return
-        const a = document.createElement('a')
-        const href = URL.createObjectURL(png)
-        a.href = href
-        a.download = 'circuit.png'
-        a.click()
-        setTimeout(() => URL.revokeObjectURL(href), 1000)
-      }, 'image/png')
-    }
-    img.onerror = () => URL.revokeObjectURL(url)
-    img.src = url
-  }
-
-  return (
-    <div className="size-full relative flex bg-bg overflow-hidden pb-7">
-      {/* components rail (edit mode only) */}
-      {editable && (
-        <div className="w-60 shrink-0 min-h-0 relative z-20 border-r border-border-default bg-bg-raised flex flex-col">
-          <div className="h-9 flex items-center justify-between px-3 border-b border-border-default shrink-0">
-            <span className="text-[13px] font-semibold text-text-body">Components</span>
-            <button
-              className="text-text-muted hover:text-brand"
-              title="New part…"
-              onClick={() => setEditorPart(null)}
-            >
-              <Plus size={15} />
-            </button>
-          </div>
-          {/* wire color — recolours the selected wire, else sets the next-wire colour */}
-          <div className="flex items-center gap-1.5 px-3 py-2 border-b border-border-default shrink-0">
-            <span className="text-[11px] text-text-muted mr-1">Wire</span>
-            {WIRE_COLORS.map((c) => (
-              <button
-                key={c}
-                onClick={() => pickColor(c)}
-                className="w-4 h-4 rounded-full border-2 transition-transform hover:scale-110"
-                style={{
-                  background: c,
-                  borderColor: wireColor === c ? 'var(--brand)' : 'rgba(255,255,255,0.18)'
-                }}
-                title={selWire != null ? 'Recolor selected wire' : 'Set wire color'}
-              />
-            ))}
-          </div>
-          <div className="flex-1 min-h-0 overflow-y-auto p-2 flex flex-col gap-2">
-            {families.map((group) => (
-              <div key={group.family}>
-                <button
-                  className="w-full flex items-center gap-1 px-1 py-1 text-[11px] font-medium text-text-muted hover:text-text-body"
-                  onClick={() => toggleFam(group.family)}
-                >
-                  {isOpen(group.family) ? <ChevronDown size={12} /> : <ChevronRight size={12} />}
-                  <span className="truncate">{titleCase(group.family)}</span>
-                  <span className="ml-auto text-text-faint/70">{group.parts.length}</span>
-                </button>
-                {isOpen(group.family) && (
-                  <div className="grid grid-cols-2 gap-1.5 pt-1 pb-1">
-                    {group.parts.map((c: PartMeta) => (
-                      <div
-                        key={c.type}
-                        draggable
-                        onDragStart={(e) => e.dataTransfer.setData('text/tinystudio-part', c.type)}
-                        onDoubleClick={() => addPart(c.type)}
-                        className="group relative flex flex-col items-center gap-1 p-2 rounded-lg border border-border-default bg-surface-card hover:bg-bg-sunken hover:-translate-y-px transition cursor-grab active:cursor-grabbing"
-                        title={`${c.label} · ${c.pins} pins — drag onto the canvas (or double-click)`}
-                      >
-                        <Thumb svg={c.icon} size={44} />
-                        <div className="text-[10px] text-text-body text-center leading-tight line-clamp-2 w-full">
-                          {c.label}
-                        </div>
-                        <button
-                          className="absolute top-1 right-1 opacity-0 group-hover:opacity-100 text-text-faint hover:text-brand"
-                          title="Edit this part"
-                          onClick={(e) => {
-                            e.stopPropagation()
-                            editExisting(c.type)
-                          }}
-                        >
-                          <Pencil size={11} />
-                        </button>
-                      </div>
-                    ))}
-                  </div>
-                )}
-              </div>
-            ))}
-          </div>
-        </div>
-      )}
-
-      {/* canvas + tools */}
-      <div className="flex-1 relative min-w-0 overflow-hidden">
-        <div className="absolute top-3 left-3 z-10 flex gap-1.5">
-          <button
-            className={`${tool} w-8 justify-center px-0 ${editable ? 'text-brand' : ''}`}
-            onClick={() => {
-              const next = !editable
-              setEditable(next)
-              setArmed(null)
-              setSelPart(null)
-              selectWire(null)
-              onEditChange?.(next)
-            }}
-            title={editable ? 'Editing — click for view-only' : 'View-only — click to edit'}
-          >
-            {editable ? <Eye size={15} /> : <Pencil size={15} />}
-          </button>
-        </div>
-
-        <div className="absolute top-3 right-3.5 z-10 flex gap-1.5">
-          <button
-            className={`${tool} w-8 justify-center px-0`}
-            onClick={exportImage}
-            title="Export circuit as image (PNG)"
-          >
-            <ImageDown size={15} />
-          </button>
-          <button
-            className={`${tool} w-8 justify-center px-0 ${grid ? 'text-brand' : ''}`}
-            onClick={() => setGrid((g) => !g)}
-            title="Toggle grid"
-          >
-            <Grid3x3 size={15} />
-          </button>
-          <button
-            className={`${tool} w-8 justify-center px-0`}
-            onClick={() => onOpenCode?.()}
-            title="Edit diagram.json as code"
-          >
-            <CodeXml size={15} />
-          </button>
-        </div>
-
-        <div className="absolute bottom-3 right-3.5 z-10 flex gap-1.5">
-          <button
-            className={`${tool} w-8 justify-center px-0`}
-            onClick={() => zoomCenter(1 / 1.15)}
-            title="Zoom out"
-          >
-            <ZoomOut size={15} />
-          </button>
-          <span className={`${tool} pointer-events-none min-w-[52px] justify-center`}>
-            {Math.round(scale * 100)}%
-          </span>
-          <button
-            className={`${tool} w-8 justify-center px-0`}
-            onClick={() => zoomCenter(1.15)}
-            title="Zoom in"
-          >
-            <ZoomIn size={15} />
-          </button>
-          <button
-            className={`${tool} w-8 justify-center px-0`}
-            onClick={fitView}
-            title="Fit to view"
-          >
-            <Maximize size={15} />
-          </button>
-        </div>
-
-        <div
-          ref={viewRef}
-          className="size-full overflow-hidden"
-          style={{
-            touchAction: 'none',
-            cursor: armed ? 'crosshair' : 'default',
-            backgroundColor: 'var(--bg-sunken)',
-            backgroundImage: grid
-              ? 'radial-gradient(var(--dot-color) 1.1px, transparent 1.1px)'
-              : 'none',
-            backgroundSize: `${GRID * scale}px ${GRID * scale}px`,
-            backgroundPosition: `${cam.tx}px ${cam.ty}px`
-          }}
-          onWheel={onWheel}
-          onPointerDown={onViewPointerDown}
-          onPointerMove={onCanvasMove}
-          onDragOver={(e) => {
-            e.preventDefault()
-            e.dataTransfer.dropEffect = 'copy'
-          }}
-          onDrop={onDrop}
-          onClick={onCanvasClick}
-        >
-          <div
-            ref={innerRef}
-            style={{
-              position: 'absolute',
-              left: 0,
-              top: 0,
-              width: CANVAS_W,
-              height: CANVAS_H,
-              transform: `translate(${cam.tx}px, ${cam.ty}px) scale(${scale})`,
-              transformOrigin: '0 0'
-            }}
-          >
-            <svg
-              width={CANVAS_W}
-              height={CANVAS_H}
-              style={{
-                position: 'absolute',
-                inset: 0,
-                overflow: 'visible',
-                zIndex: 5,
-                pointerEvents: 'none'
-              }}
-            >
-              {diagram.connections.map((c, i) => {
-                const pts = selWire === i && editPts ? editPts : wirePts(c)
-                if (pts.length < 2) return null
-                const sel = selWire === i
-                const onHotNet = highlightNet >= 0 && netModel.connToNet[i] === highlightNet
-                const core =
-                  view === 'schematic' ? 'var(--text-strong)' : (c[2] as string) || '#2fa46a'
-                const outline = view === 'schematic' ? 'rgba(0,0,0,0.45)' : darken(core)
-                const d = roundedPath(pts)
-                return (
-                  <g
-                    key={i}
-                    style={{ cursor: editable ? 'pointer' : 'default', pointerEvents: 'stroke' }}
-                    onPointerEnter={() => setHoverWire(i)}
-                    onPointerLeave={() => setHoverWire((h) => (h === i ? null : h))}
-                    onClick={(e) => onWireClick(e, i)}
-                    onDoubleClick={(e) => onWireDoubleClick(e, i)}
-                  >
-                    {/* equipotential net glow */}
-                    {onHotNet && (
-                      <path
-                        d={d}
-                        fill="none"
-                        stroke={NET_GLOW}
-                        strokeWidth={WIRE_GLOW_W}
-                        strokeLinejoin="round"
-                        strokeLinecap="round"
-                      />
-                    )}
-                    {/* darker outline → glossy tube */}
-                    <path
-                      d={d}
-                      fill="none"
-                      stroke={outline}
-                      strokeWidth={WIRE_OUTLINE_W}
-                      strokeLinejoin="round"
-                      strokeLinecap="round"
-                    />
-                    <path
-                      d={d}
-                      fill="none"
-                      stroke={core}
-                      strokeWidth={WIRE_W}
-                      strokeLinejoin="round"
-                      strokeLinecap="round"
-                    />
-                    {sel && (
-                      <path
-                        d={d}
-                        fill="none"
-                        stroke="rgba(255,255,255,0.85)"
-                        strokeWidth={1}
-                        strokeDasharray="4 4"
-                        strokeLinejoin="round"
-                      >
-                        <animate
-                          attributeName="stroke-dashoffset"
-                          from="0"
-                          to="-8"
-                          dur="0.5s"
-                          repeatCount="indefinite"
-                        />
-                      </path>
-                    )}
-                  </g>
-                )
-              })}
-
-              {/* junction solder dots where a wire taps another wire */}
-              {junctions.map((j, k) => (
-                <circle key={`j${k}`} cx={j.pt.x} cy={j.pt.y} r={3} fill={j.color} />
-              ))}
-
-              {previewPts && (
-                <path
-                  d={roundedPath(previewPts)}
-                  fill="none"
-                  stroke={view === 'schematic' ? 'var(--text-strong)' : wireColor}
-                  strokeWidth={WIRE_W}
-                  strokeLinejoin="round"
-                  strokeLinecap="round"
-                  opacity={0.6}
-                />
-              )}
-
-              {/* handles on the selected wire: bend (circle), segment (square),
-                  endpoint (ring) — Fritzing-style */}
-              {editable && selWire != null && editPts && (
-                <g style={{ pointerEvents: 'auto' }}>
-                  {editPts.slice(0, -1).map((p, i) => {
-                    const q = editPts[i + 1]
-                    const m = { x: (p.x + q.x) / 2, y: (p.y + q.y) / 2 }
-                    const horizontal = Math.abs(p.y - q.y) < 0.001
-                    return (
-                      <rect
-                        key={`s${i}`}
-                        x={m.x - 3.5}
-                        y={m.y - 3.5}
-                        width={7}
-                        height={7}
-                        rx={1.5}
-                        fill="var(--brand)"
-                        stroke="#fff"
-                        strokeWidth={1}
-                        style={{ cursor: horizontal ? 'ns-resize' : 'ew-resize' }}
-                        onPointerDown={(e) => startHandleDrag(e, 'edge', i)}
-                      />
-                    )
-                  })}
-                  {editPts.slice(1, -1).map((p, i) => (
-                    <circle
-                      key={`v${i}`}
-                      cx={p.x}
-                      cy={p.y}
-                      r={4}
-                      fill="var(--brand)"
-                      stroke="#fff"
-                      strokeWidth={1.2}
-                      style={{ cursor: 'move' }}
-                      onPointerDown={(e) => startHandleDrag(e, 'vertex', i + 1)}
-                    />
-                  ))}
-                  {[0, 1].map((end) => {
-                    const p = end === 0 ? editPts[0] : editPts[editPts.length - 1]
-                    return (
-                      <circle
-                        key={`e${end}`}
-                        cx={p.x}
-                        cy={p.y}
-                        r={4.5}
-                        fill="var(--surface-card)"
-                        stroke="var(--brand)"
-                        strokeWidth={2}
-                        style={{ cursor: 'grab' }}
-                        onPointerDown={(e) => startHandleDrag(e, 'endpoint', 0, end as 0 | 1)}
-                      />
-                    )
-                  })}
-                </g>
-              )}
-            </svg>
-
-            {diagram.parts.map((part) => {
-              const def = getPart(part.type)
-              const v = def && viewFor(def, view)
-              const [pLeft, pTop] = partXY(part)
-              if (!def || !v) {
-                return (
-                  <div
-                    key={part.id}
-                    style={{ position: 'absolute', left: pLeft, top: pTop, zIndex: 2 }}
-                    className="px-2 py-1 rounded bg-surface-card border border-border-default text-[10px] text-text-faint"
-                  >
-                    {part.type}…
-                  </div>
-                )
-              }
-              const labelOff = (part.attrs?.labelOffset as [number, number]) || [0, 0]
-              return (
-                <div
-                  key={part.id}
-                  style={{
-                    position: 'absolute',
-                    left: pLeft,
-                    top: pTop,
-                    width: v.w,
-                    height: v.h,
-                    zIndex: 2,
-                    transform: part.rotate ? `rotate(${part.rotate}deg)` : undefined,
-                    transformOrigin: 'center',
-                    outline: selPart === part.id ? '2px solid var(--brand)' : 'none',
-                    outlineOffset: 4,
-                    borderRadius: 6,
-                    cursor: editable ? 'move' : 'default'
-                  }}
-                  onPointerDown={(e) => onPartDown(e, part)}
-                  onClick={(e) => e.stopPropagation()}
-                  onContextMenu={(e) => {
-                    if (!editable) return
-                    e.preventDefault()
-                    rotatePart(part.id)
-                  }}
-                >
-                  <div
-                    className="size-full [&>svg]:size-full [&>svg]:block pointer-events-none select-none"
-                    dangerouslySetInnerHTML={{ __html: v.svg }}
-                  />
-                  {editable &&
-                    Object.keys(v.pins).map((pin) => {
-                      const [px, py] = v.pins[pin]
-                      const armedHere = armed && eqRef(armed.from, `${part.id}:${pin}`)
-                      const hovered = hoverPin?.id === part.id && hoverPin?.pin === pin
-                      const onHotNet =
-                        highlightNet >= 0 &&
-                        netModel.pinToNet.get(`${part.id}:${pin}`) === highlightNet
-                      const on = armedHere || hovered
-                      return (
-                        <div
-                          key={pin}
-                          className="pin-hit"
-                          title={pin}
-                          style={{
-                            position: 'absolute',
-                            left: px - 8,
-                            top: py - 8,
-                            width: 16,
-                            height: 16,
-                            zIndex: 3,
-                            cursor: 'crosshair'
-                          }}
-                          onPointerDown={(e) => e.stopPropagation()}
-                          onPointerEnter={() => setHoverPin({ id: part.id, pin })}
-                          onPointerLeave={() =>
-                            setHoverPin((h) => (h?.id === part.id && h?.pin === pin ? null : h))
-                          }
-                          onClick={(e) => onPinClick(e, part, pin)}
-                        >
-                          <svg width="16" height="16">
-                            {onHotNet && !on && (
-                              <circle
-                                cx="8"
-                                cy="8"
-                                r="5.5"
-                                fill="var(--yellow)"
-                                fillOpacity={0.4}
-                              />
-                            )}
-                            <circle
-                              cx="8"
-                              cy="8"
-                              r={on ? 3.4 : 2.6}
-                              fill={on ? 'var(--brand)' : 'var(--yellow)'}
-                              stroke={on ? 'var(--brand)' : 'var(--border-strong)'}
-                              strokeWidth="1"
-                            />
-                          </svg>
-                        </div>
-                      )
-                    })}
-                  {/* draggable title label */}
-                  <div
-                    className="absolute text-[11px] whitespace-nowrap select-none"
-                    style={{
-                      left: labelOff[0],
-                      top: v.h + 4 + labelOff[1],
-                      transform: part.rotate ? `rotate(${-part.rotate}deg)` : undefined,
-                      transformOrigin: 'left top',
-                      color: selPart === part.id ? 'var(--brand)' : 'var(--text-muted)',
-                      cursor: editable ? 'move' : 'default',
-                      pointerEvents: editable ? 'auto' : 'none'
-                    }}
-                    onPointerDown={(e) => onLabelDown(e, part)}
-                  >
-                    {labelOf(part)}
-                  </div>
-                </div>
-              )
-            })}
-
-            {diagram.parts.length === 0 && (
-              <div
-                className="absolute flex flex-col items-center gap-2 text-text-faint text-sm text-center"
-                style={{ left: CANVAS_W / 2 - 160, top: CANVAS_H / 2 - 40, width: 320 }}
-              >
-                <CircuitBoard size={42} />
-                <div>
-                  Drag parts from the components rail — or double-click one to drop it here.
-                </div>
-              </div>
-            )}
-          </div>
-        </div>
-
-        {/* tinyStudio watermark — sits above the bottom UI, bottom-right, and is
-            baked into the exported image */}
-        <div className="absolute bottom-12 right-4 z-0 pointer-events-none select-none text-[12px] font-semibold text-text-faint/70">
-          tinyStudio
-        </div>
-
-        {/* footer (kept clear of the zoom cluster on the right; wraps upward) */}
-        <div className="absolute bottom-3 left-3 right-[176px] z-10 flex flex-wrap gap-2 text-[11px]">
-          <span className="px-2.5 py-1 rounded-full bg-surface-card border border-border-default text-text-body">
-            Parts: {diagram.parts.length} · Connections: {diagram.connections.length} · Nets:{' '}
-            {netCount}
-          </span>
-          {isAI && (
-            <span className="px-2.5 py-1 rounded-full bg-surface-card border border-brand/40 text-brand flex items-center gap-1">
-              Auto-wired by Studio AI
-            </span>
-          )}
-          {!editable ? (
-            <span className="px-2.5 py-1 rounded-full bg-surface-card border border-border-default text-text-muted flex items-center gap-1">
-              <Eye size={12} /> View-only · hover a wire to light its net · click edit to change
-            </span>
-          ) : armed ? (
-            <span className="px-2.5 py-1 rounded-full bg-surface-card border border-brand/40 text-brand flex items-center gap-1">
-              <Zap size={12} /> Click a pin or wire to connect · click for a bend · hold Shift for
-              straight · Esc to cancel
-            </span>
-          ) : selWire != null ? (
-            <span className="px-2.5 py-1 rounded-full bg-surface-card border border-brand/40 text-brand flex items-center gap-1">
-              Drag a handle to reshape · double-click to add/remove a bend · pick a color · Del to
-              remove
-            </span>
-          ) : (
-            <span className="px-2.5 py-1 rounded-full bg-surface-card border border-border-default text-text-muted flex items-center gap-1">
-              <MousePointer2 size={12} /> Scroll to zoom · middle/Alt-drag to pan · click a pin to
-              wire
-            </span>
-          )}
-        </div>
-      </div>
-
-      {/* inspector (edit mode only) */}
-      {editable && (
-        <div className="w-64 shrink-0 min-h-0 relative z-20 border-l border-border-default bg-bg-raised flex flex-col">
-          <div className="h-9 flex items-center px-3 border-b border-border-default shrink-0">
-            <span className="text-[13px] font-semibold text-text-body">Inspector</span>
-          </div>
-          <div className="flex-1 min-h-0 overflow-y-auto p-3 flex flex-col gap-3 text-xs">
-            {selectedPart ? (
-              <Inspector
-                key={selectedPart.id}
-                part={selectedPart}
-                def={getPart(selectedPart.type)}
-                view={view}
-                xy={partXY(selectedPart)}
-                connCount={
-                  diagram.connections.filter(
-                    (c) => touches(c[0], selectedPart.id) || touches(c[1], selectedPart.id)
-                  ).length
-                }
-                onLabel={(val) => patchAttr(selectedPart.id, 'label', val)}
-                onMove={(l, t) => movePartTo(selectedPart.id, l, t)}
-                onRotate={(deg) => setRotation(selectedPart.id, deg)}
-                onSetAttr={(k, val) => patchAttr(selectedPart.id, k, val)}
-                onRemoveAttr={(k) => removeAttr(selectedPart.id, k)}
-                onDelete={() => deletePart(selectedPart.id)}
-                newAttr={newAttr}
-                setNewAttr={setNewAttr}
-              />
-            ) : selWire != null ? (
-              <WireInspector
-                color={(diagram.connections[selWire]?.[2] as string) || '#2fa46a'}
-                colors={WIRE_COLORS}
-                netPins={
-                  netModel.connToNet[selWire] >= 0
-                    ? netModel.nets[netModel.connToNet[selWire]].length
-                    : 0
-                }
-                onColor={(c) => recolorWire(selWire, c)}
-                onDelete={() => deleteWire(selWire)}
-              />
-            ) : (
-              <div className="text-text-faint text-[11px] leading-relaxed">
-                Select a component to edit its name, location, rotation, and properties — or a wire
-                to recolor it.
-              </div>
-            )}
-          </div>
-        </div>
-      )}
-
-      {editorPart !== undefined && (
-        <PartsEditor
-          initial={editorPart}
-          onClose={() => setEditorPart(undefined)}
-          onSave={(def: PartDef) => {
-            void saveUserPart(def)
-            force()
-            setEditorPart(undefined)
-          }}
-        />
-      )}
-    </div>
-  )
-}
-
-// ── Inspector subcomponents ───────────────────────────────────────────────────
-
-const field =
-  'bg-bg-sunken border border-border-default rounded px-2 py-1 text-text-strong outline-none focus:border-brand w-full'
-const rowLabel = 'text-[11px] text-text-muted'
-
-function Inspector({
-  part,
-  def,
-  view,
-  xy,
-  connCount,
-  onLabel,
-  onMove,
-  onRotate,
-  onSetAttr,
-  onRemoveAttr,
-  onDelete,
-  newAttr,
-  setNewAttr
-}: {
-  part: { id: string; type: string; rotate?: number; attrs?: Record<string, unknown> }
-  def?: PartDef
-  view: ViewKind
-  xy: [number, number]
-  connCount: number
-  onLabel: (v: string) => void
-  onMove: (l: number, t: number) => void
-  onRotate: (deg: number) => void
-  onSetAttr: (k: string, v: string) => void
-  onRemoveAttr: (k: string) => void
-  onDelete: () => void
-  newAttr: string
-  setNewAttr: (v: string) => void
-}): React.JSX.Element {
-  const label = (part.attrs?.label as string) ?? def?.label ?? part.type
-  // attrs to expose as editable properties (hide internal layout keys)
-  const propRows = Object.entries(part.attrs || {}).filter(
-    ([k]) => k !== 'label' && k !== 'labelOffset'
-  )
-  return (
-    <>
-      <div className="flex items-center gap-2">
-        <CircuitBoard size={16} className="text-brand shrink-0" />
-        <input
-          className={`${field} font-semibold`}
-          value={label}
-          onChange={(e) => onLabel(e.target.value)}
-        />
-      </div>
-      <div className="grid grid-cols-[auto_1fr] gap-x-2 gap-y-1 items-center text-text-muted">
-        <span className={rowLabel}>Type</span>
-        <span className="text-text-body truncate text-[11px]">{part.type}</span>
-        <span className={rowLabel}>Family</span>
-        <span className="text-text-body truncate">{def?.family ? titleCase(def.family) : '—'}</span>
-        <span className={rowLabel}>Wires</span>
-        <span className="text-text-body">{connCount}</span>
-      </div>
-
-      <div className="flex flex-col gap-1">
-        <span className={rowLabel}>Location ({view})</span>
-        <div className="flex gap-2">
-          <input
-            type="number"
-            className={`${field}`}
-            value={Math.round(xy[0])}
-            onChange={(e) => onMove(parseFloat(e.target.value) || 0, xy[1])}
-          />
-          <input
-            type="number"
-            className={`${field}`}
-            value={Math.round(xy[1])}
-            onChange={(e) => onMove(xy[0], parseFloat(e.target.value) || 0)}
-          />
-        </div>
-      </div>
-
-      <div className="flex items-center justify-between">
-        <span className={rowLabel}>Rotation</span>
-        <div className="flex items-center gap-1">
-          <select
-            className={`${field} w-auto`}
-            value={part.rotate || 0}
-            onChange={(e) => onRotate(parseInt(e.target.value, 10))}
-          >
-            {[0, 90, 180, 270].map((d) => (
-              <option key={d} value={d}>
-                {d}°
-              </option>
-            ))}
-          </select>
-          <button
-            className="tactile-bordered rounded-md p-1.5 bg-surface-card text-text-muted hover:text-brand"
-            title="Rotate 90°"
-            onClick={() => onRotate((part.rotate || 0) + 90)}
-          >
-            <RotateCw size={13} />
-          </button>
-        </div>
-      </div>
-
-      <div className="flex flex-col gap-1.5">
-        <span className={rowLabel}>Properties</span>
-        {propRows.length === 0 && (
-          <div className="text-[11px] text-text-faint">
-            No properties yet. Add one below — e.g. a resistor’s{' '}
-            <span className="text-text-body">value</span>.
-          </div>
-        )}
-        {propRows.map(([k, val]) => (
-          <div key={k} className="flex items-center gap-1.5">
-            <span className="text-[11px] text-text-muted w-16 truncate" title={k}>
-              {k}
-            </span>
-            <input
-              className={`${field}`}
-              value={String(val ?? '')}
-              onChange={(e) => onSetAttr(k, e.target.value)}
-            />
-            <button
-              className="text-text-faint hover:text-status-error shrink-0"
-              title="Remove property"
-              onClick={() => onRemoveAttr(k)}
-            >
-              <Trash2 size={13} />
-            </button>
-          </div>
-        ))}
-        <div className="flex items-center gap-1.5">
-          <input
-            className={`${field}`}
-            placeholder="new property…"
-            value={newAttr}
-            onChange={(e) => setNewAttr(e.target.value)}
-            onKeyDown={(e) => {
-              if (e.key === 'Enter' && newAttr.trim()) {
-                onSetAttr(newAttr.trim(), '')
-                setNewAttr('')
-              }
-            }}
-          />
-          <button
-            className="tactile-bordered rounded-md p-1.5 bg-surface-card text-text-muted hover:text-brand shrink-0"
-            title="Add property"
-            onClick={() => {
-              if (newAttr.trim()) {
-                onSetAttr(newAttr.trim(), '')
-                setNewAttr('')
-              }
-            }}
-          >
-            <Plus size={13} />
-          </button>
-        </div>
-      </div>
-
-      <button
-        className="mt-1 flex items-center justify-center gap-1.5 px-3 py-2 rounded-lg border border-border-default text-text-muted hover:text-status-error hover:border-status-error/40"
-        onClick={onDelete}
-      >
-        <Trash2 size={13} /> Delete component
-      </button>
-    </>
-  )
-}
-
-function WireInspector({
-  color,
-  colors,
-  netPins,
-  onColor,
-  onDelete
-}: {
-  color: string
-  colors: string[]
-  netPins: number
-  onColor: (c: string) => void
-  onDelete: () => void
-}): React.JSX.Element {
-  return (
-    <>
-      <div className="flex items-center gap-2">
-        <Spline size={16} className="text-brand shrink-0" />
-        <span className="text-text-strong font-semibold">Wire</span>
-      </div>
-      <div className="flex flex-col gap-1.5">
-        <span className={rowLabel}>Color</span>
-        <div className="flex items-center gap-2">
-          {colors.map((c) => (
-            <button
-              key={c}
-              onClick={() => onColor(c)}
-              className="w-5 h-5 rounded-full border-2 transition-transform hover:scale-110"
-              style={{
-                background: c,
-                borderColor:
-                  c.toLowerCase() === color.toLowerCase() ? 'var(--brand)' : 'rgba(255,255,255,0.18)'
-              }}
-            />
-          ))}
-        </div>
-      </div>
-      <div className="grid grid-cols-[auto_1fr] gap-x-2 gap-y-1 items-center">
-        <span className={rowLabel}>Net pins</span>
-        <span className="text-text-body">{netPins}</span>
-      </div>
-      <button
-        className="mt-1 flex items-center justify-center gap-1.5 px-3 py-2 rounded-lg border border-border-default text-text-muted hover:text-status-error hover:border-status-error/40"
-        onClick={onDelete}
-      >
-        <Trash2 size={13} /> Delete wire
-      </button>
-    </>
-  )
-}
diff --git a/src/renderer/src/components/EditorPanel.tsx b/src/renderer/src/components/EditorPanel.tsx
index 36016d1..06dca72 100644
--- a/src/renderer/src/components/EditorPanel.tsx
+++ b/src/renderer/src/components/EditorPanel.tsx
@@ -33,8 +33,7 @@ import * as monaco from 'monaco-editor'
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { notify as toast } from '@renderer/lib/notify'
 import { BlocklyEditor } from './BlocklyEditor'
-import { DiagramEditor } from './DiagramEditor'
-import { circuitV2Enabled, emptyDoc, parseCircuitFile, serializeDoc } from '../circuit'
+import { emptyDoc, parseCircuitFile, serializeDoc } from '../circuit'
 import { CircuitViewV2 } from '../circuit/views/CircuitView'
 import { MonacoEditor, MonacoEditorRef } from './MonacoEditor'
 import {
@@ -52,12 +51,6 @@ import { Input } from './ui/Input'
 import { VisualPreview } from './VisualPreview'
 
 loader.config({ monaco })
-
-const DEFAULT_DIAGRAM = JSON.stringify(
-  { version: 1, editor: 'tinystudio', parts: [], connections: [] },
-  null,
-  2
-)
 const DEFAULT_VISUAL = `// visual.js — Serial Plotter
 // Graphs the latest number printed over Serial (serialValue()) as a scrolling
 // line, auto-scaling to the data. Try Serial.println(analogRead(A0)) on the
@@ -361,50 +354,19 @@ function CodeView(): React.JSX.Element {
   )
 }
 
-// ── Circuit view: full-window interactive diagram.json / circuit.json ───────
-
-function CircuitView(): React.JSX.Element {
-  // Circuit View v2 (docs/circuit-view-tech-spec.md) — same window slot, both
-  // desktop and web builds. Enable: localStorage.setItem('tinystudio.circuitV2','1')
-  // The flag is stable for the app session, so branching to components with
-  // different hooks is safe here.
-  if (circuitV2Enabled()) return <CircuitV2View />
-  return <CircuitV1View />
-}
-
-function CircuitV1View(): React.JSX.Element {
-  const workspace = useAppSelector((s) => s.file.workspace)
-  const dispatch = useAppDispatch()
-  const file = useProjectFile('diagram.json', () => DEFAULT_DIAGRAM)
-
-  if (!workspace) return <EmptyHint icon="circuit" label="Open a project to design its circuit." />
-  if (!file) return <LoadingHint label="Loading circuit…" />
-
-  return (
-    <DiagramEditor
-      content={file.content}
-      onChange={(content) => dispatch(updateFileContent({ id: file.id, content }))}
-      onOpenCode={() => {
-        dispatch(revealFile(file.id))
-        dispatch(setEditorView('code'))
-      }}
-      onEditChange={(editing) => {
-        // entering edit mode frees horizontal space by closing the docs panel;
-        // returning to view mode reopens it.
-        dispatch(setPanelOpen({ panel: 'docs', isOpen: !editing }))
-      }}
-    />
-  )
-}
+// ── Circuit view: full-window interactive circuit.json editor (v2) ──────────
+//
+// Circuit View v2 (docs/circuit-view-tech-spec.md) is the only editor as of
+// M4 — the legacy DiagramEditor and its `diagram.json`-only path were removed
+// once v2 reached parity + simulation. Any project still holding a v1
+// `diagram.json` is migrated on open (see CircuitView below).
 
 /**
  * v2 adoption (spec §4, §13): the native file is `circuit.json`. On first
  * open of a project that only has a v1 `diagram.json`, migrate it on disk:
  * write `circuit.json` (converted) and `diagram.json.bak` (verbatim copy).
- * `diagram.json` itself is left in place until M4 removes the legacy editor —
- * flipping the flag off must keep working during the preview period.
  */
-function CircuitV2View(): React.JSX.Element {
+function CircuitView(): React.JSX.Element {
   const workspace = useAppSelector((s) => s.file.workspace)
   const [ready, setReady] = useState(false)
   const adopting = useRef(false)

From 1c099afb98023843933be3b91fb26aea8bcc174e Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Wed, 22 Jul 2026 13:59:14 -0600
Subject: [PATCH 18/27] Circuit v2 M4: auto-rerun toggle + breadboard hole
 voltage tooltip
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

SimPanel gets an auto-rerun checkbox: once on, doc edits re-run the active
analysis after a 400ms debounce (single in-flight run, guarded by a ref).
Breadboard hole tooltips now append the net's solved DC (.op) voltage
alongside the existing 'hole · net members' text, via a new
simVoltageForNet(netIdx) lookup threaded CircuitView -> Canvas.

npm run typecheck (node+web) clean; test:circuit 95/95.
---
 .../src/circuit/views/CircuitView.tsx         | 15 ++++++++
 .../src/circuit/views/canvas/Canvas.tsx       |  7 +++-
 .../src/circuit/views/sim/SimPanel.tsx        | 37 +++++++++++++++++++
 3 files changed, 58 insertions(+), 1 deletion(-)

diff --git a/src/renderer/src/circuit/views/CircuitView.tsx b/src/renderer/src/circuit/views/CircuitView.tsx
index 20e54f8..8fb7324 100644
--- a/src/renderer/src/circuit/views/CircuitView.tsx
+++ b/src/renderer/src/circuit/views/CircuitView.tsx
@@ -172,6 +172,20 @@ export function CircuitViewV2({
     })
     return out
   }, [sim, netModel, doc, view])
+  // per-net voltage lookup for the breadboard hole tooltip (M4 leftover) —
+  // same DC (.op) result as the canvas chips, keyed by net index instead of
+  // pre-picking one representative pin, so every hole in the net can show it.
+  const simVoltageForNet = React.useCallback(
+    (netIdx: number): string | undefined => {
+      if (!sim.run || sim.run.numPoints !== 1 || !sim.netlist) return undefined
+      const node = sim.netlist.nodeOfNet[netIdx]
+      if (!node || node === '0') return undefined
+      const vec = sim.run.vectors.find((v) => v.name.toLowerCase() === `v(${node.toLowerCase()})`)
+      if (!vec || vec.values.length !== 1) return undefined
+      return fmtSI(vec.values[0], 'V')
+    },
+    [sim]
+  )
   // nets satisfied elsewhere but unrouted here → dashed guidance (spec §8.2)
   const rats = React.useMemo(() => ratsnest(doc, view, netModel), [doc, view, netModel, defsTick])
   // ERC: net-model rules + view-side floating-pin findings (spec §9)
@@ -530,6 +544,7 @@ export function CircuitViewV2({
           onDropNetLabel={(kind, name, at) => addNetLabel(kind, name, at)}
           onImportFiles={(files, at) => void importFzpzFiles(files, at)}
           annotations={simAnnotations}
+          simVoltageForNet={simVoltageForNet}
           onRequestEdit={enterEdit}
         />
 
diff --git a/src/renderer/src/circuit/views/canvas/Canvas.tsx b/src/renderer/src/circuit/views/canvas/Canvas.tsx
index e1543e1..8da2f24 100644
--- a/src/renderer/src/circuit/views/canvas/Canvas.tsx
+++ b/src/renderer/src/circuit/views/canvas/Canvas.tsx
@@ -151,6 +151,7 @@ export function Canvas({
   onDropNetLabel,
   onImportFiles,
   annotations,
+  simVoltageForNet,
   onRequestEdit
 }: {
   store: CircuitStore
@@ -177,6 +178,8 @@ export function Canvas({
   onImportFiles?: (files: File[], at: Pt) => void
   /** world-anchored value chips (DC sim annotations) */
   annotations?: { x: number; y: number; text: string }[]
+  /** DC (.op) net voltage lookup, for the breadboard hole tooltip */
+  simVoltageForNet?: (netIdx: number) => string | undefined
   /** tray "attach to cursor" placement: id being placed + drop callback */
   /** double-clicking a component asks the shell to enter edit mode */
   onRequestEdit: () => void
@@ -1657,7 +1660,9 @@ export function Canvas({
               {hoverHole.pin}
               {(() => {
                 const idx = netModel.pinToNet.get(`${hoverHole.id}:${hoverHole.pin}`)
-                return idx != null ? ` · net: ${describeNet(netModel, idx)}` : ''
+                if (idx == null) return ''
+                const v = simVoltageForNet?.(idx)
+                return ` · net: ${describeNet(netModel, idx)}${v ? ` · ${v}` : ''}`
               })()}
             </div>
           )}
diff --git a/src/renderer/src/circuit/views/sim/SimPanel.tsx b/src/renderer/src/circuit/views/sim/SimPanel.tsx
index 1f73b5c..11ef2de 100644
--- a/src/renderer/src/circuit/views/sim/SimPanel.tsx
+++ b/src/renderer/src/circuit/views/sim/SimPanel.tsx
@@ -51,6 +51,7 @@ export function SimPanel({
   const [gen, setGen] = React.useState<NetlistResult | null>(null)
   const [error, setError] = React.useState<{ message: string; details?: string[] } | null>(null)
   const [showNetlist, setShowNetlist] = React.useState(false)
+  const [autoRerun, setAutoRerun] = React.useState(false)
 
   const setAnalysis = (patch: Partial<Analysis>): void => {
     store.dispatch(cmd.setAnalyses([{ ...analysis, ...patch }]))
@@ -70,7 +71,11 @@ export function SimPanel({
     [doc.parts, familyOf]
   )
 
+  const runningRef = React.useRef(false)
+
   const run = async (): Promise<void> => {
+    if (runningRef.current) return // one in-flight run at a time (esp. for auto-rerun)
+    runningRef.current = true
     setRunning(true)
     setError(null)
     const g = generateNetlist(doc, netModel, { familyOf, title: 'tinyStudio circuit' })
@@ -88,15 +93,31 @@ export function SimPanel({
           : { message: err instanceof Error ? err.message : String(err) }
       )
     } finally {
+      runningRef.current = false
       setRunning(false)
     }
   }
 
   const cancel = (): void => {
     getSimBackend().cancel()
+    runningRef.current = false
     setRunning(false)
   }
 
+  // auto-rerun (spec/M4 leftover): once enabled, every doc change re-runs the
+  // active analysis after a short debounce — same "Run" path, so results and
+  // canvas DC annotations refresh without a manual click. Skipped while a run
+  // is already in flight; the trailing edit still gets its own debounce timer.
+  const runRef = React.useRef(run)
+  runRef.current = run
+  const lastAutoDoc = React.useRef(doc)
+  React.useEffect(() => {
+    if (!autoRerun || doc === lastAutoDoc.current) return
+    lastAutoDoc.current = doc
+    const t = setTimeout(() => void runRef.current(), 400)
+    return () => clearTimeout(t)
+  }, [doc, autoRerun])
+
   const isOp = result != null && result.numPoints === 1
 
   // "v(n1)" → the net's members ("R1:Pin 1 · LED1:anode"); "i(vv1)" → source
@@ -261,6 +282,22 @@ export function SimPanel({
         )}
 
         <div className="flex-1" />
+        <label
+          className="flex items-center gap-1.5 text-[11px] text-text-muted cursor-pointer select-none"
+          title="Automatically re-run the active analysis after each edit"
+        >
+          <input
+            type="checkbox"
+            checked={autoRerun}
+            onChange={(e) => {
+              const on = e.target.checked
+              setAutoRerun(on)
+              lastAutoDoc.current = doc
+              if (on) void run()
+            }}
+          />
+          auto-rerun
+        </label>
         {result && result.numPoints > 1 && (
           <button
             className="flex items-center gap-1 text-[11px] text-text-faint hover:text-text-body"

From 83b5c7029350ba9efd5ff05d078ba4ff1487f957 Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Wed, 22 Jul 2026 14:03:55 -0600
Subject: [PATCH 19/27] Circuit v2 M4: error to part/net highlight mapping

generateNetlist now records elementOfPart (lowercased SPICE device names per
part id, e.g. R1 -> ['rr1']) alongside the existing nodeOfNet. New pure
mapSimIssue/mapSimIssues (core/netlist.ts) scan raw ngspice error/warning
lines for those device names and node names (word-boundary, case-insensitive,
ground '0' excluded) and return the implicated part ids + net indices.

SimPanel's error box now renders clickable part/net chips (+ a 'select all')
under any run failure; CircuitView wires them to canvas selection via a new
selectSimIssue, expanding net hits to their member parts.

+6 tests (elementOfPart, device-name match, node-name match incl. ground
skip, n1/n10 word-boundary, multi-line de-dup). npm run typecheck (node+web)
clean; test:circuit 100/100.
---
 .../src/circuit/__tests__/netlist.test.ts     | 47 ++++++++++++++-
 src/renderer/src/circuit/core/netlist.ts      | 57 ++++++++++++++++++-
 .../src/circuit/views/CircuitView.tsx         | 11 ++++
 .../src/circuit/views/sim/SimPanel.tsx        | 51 ++++++++++++++++-
 4 files changed, 161 insertions(+), 5 deletions(-)

diff --git a/src/renderer/src/circuit/__tests__/netlist.test.ts b/src/renderer/src/circuit/__tests__/netlist.test.ts
index 40e1b05..8da0a6b 100644
--- a/src/renderer/src/circuit/__tests__/netlist.test.ts
+++ b/src/renderer/src/circuit/__tests__/netlist.test.ts
@@ -4,7 +4,7 @@ import assert from 'node:assert/strict'
 import { test } from 'node:test'
 import { emptyDoc, type CircuitDoc, type CircuitPart, type CircuitWire } from '../core/model'
 import { buildNets } from '../core/nets'
-import { analysisCard, generateNetlist, spiceNum } from '../core/netlist'
+import { analysisCard, generateNetlist, mapSimIssue, mapSimIssues, spiceNum } from '../core/netlist'
 
 let wid = 0
 const wire = (from: string, to: string): CircuitWire => ({
@@ -169,3 +169,48 @@ test('a dc analysis without a source falls back to .op instead of a card-less ne
   const res = generateNetlist(doc, buildNets(doc))
   assert.ok(res.netlist.includes('.op'))
 })
+
+// ── mapSimIssue / mapSimIssues (M4: error → part/net highlight mapping) ─────
+
+test('elementOfPart records the lowercased device name(s) generateNetlist emitted', () => {
+  const doc = divider()
+  const res = generateNetlist(doc, buildNets(doc))
+  assert.deepEqual(res.elementOfPart.V1, ['vv1'])
+  assert.deepEqual(res.elementOfPart.R1, ['rr1'])
+  assert.equal(res.elementOfPart.R2?.[0], 'rr2')
+})
+
+test('mapSimIssue finds the part behind an ngspice device-name mention', () => {
+  const doc = divider()
+  const res = generateNetlist(doc, buildNets(doc))
+  const hit = mapSimIssue('Warning: singular matrix:  check node or device rr1', res)
+  assert.deepEqual(hit.parts, ['R1'])
+  assert.deepEqual(hit.nets, [])
+})
+
+test('mapSimIssue finds the net behind a node-name mention, skips ground', () => {
+  const doc = divider()
+  const res = generateNetlist(doc, buildNets(doc))
+  // R1/R2 share a node — find its synthetic name and confirm it round-trips
+  const midIdx = res.nodeOfNet.findIndex((n) => n !== '0' && n.startsWith('n'))
+  assert.ok(midIdx >= 0)
+  const hit = mapSimIssue(`doAnalyses: node ${res.nodeOfNet[midIdx]} is floating`, res)
+  assert.deepEqual(hit.nets, [midIdx])
+  const groundHit = mapSimIssue('node 0 shorted', res)
+  assert.deepEqual(groundHit.nets, [], 'ground is never matched')
+})
+
+test('mapSimIssue does not confuse n1 with n10 (word boundaries)', () => {
+  const doc = divider()
+  const res = generateNetlist(doc, buildNets(doc))
+  const hit = mapSimIssue('reference only to node n10 here', res)
+  const n1Idx = res.nodeOfNet.indexOf('n1')
+  if (n1Idx >= 0) assert.ok(!hit.nets.includes(n1Idx))
+})
+
+test('mapSimIssues de-dupes across multiple lines', () => {
+  const doc = divider()
+  const res = generateNetlist(doc, buildNets(doc))
+  const hit = mapSimIssues(['device rr1 bad', 'device rr1 bad again', 'device vv1 too'], res)
+  assert.deepEqual([...hit.parts].sort(), ['R1', 'V1'])
+})
diff --git a/src/renderer/src/circuit/core/netlist.ts b/src/renderer/src/circuit/core/netlist.ts
index 477ad6a..24838db 100644
--- a/src/renderer/src/circuit/core/netlist.ts
+++ b/src/renderer/src/circuit/core/netlist.ts
@@ -70,6 +70,9 @@ export interface NetlistResult {
   warnings: string[]
   /** part ids not simulated (unknown/board) */
   excluded: string[]
+  /** SPICE element/device names emitted per part id (e.g. R1 → ['rr1']),
+   *  lowercased to match ngspice's own casing — feeds mapSimIssue. */
+  elementOfPart: Record<string, string[]>
 }
 
 interface Ctx {
@@ -328,6 +331,7 @@ export function generateNetlist(
 
   const lines: string[] = []
   const models = new Map<string, string>()
+  const elementOfPart: Record<string, string[]> = {}
 
   for (const part of doc.parts) {
     const family = opts.familyOf?.(part.type) ?? ''
@@ -375,6 +379,10 @@ export function generateNetlist(
     if (!card) continue
     lines.push(...card.lines)
     if (card.model) models.set(card.model.name, card.model.card)
+    for (const line of card.lines) {
+      const dev = line.split(/\s+/, 1)[0]?.toLowerCase()
+      if (dev) (elementOfPart[part.id] ??= []).push(dev)
+    }
   }
 
   // analyses (spec §10.2.4) — default to .op
@@ -391,7 +399,7 @@ export function generateNetlist(
     ''
   ].join('\n')
 
-  return { netlist: text, nodeOfNet, warnings, excluded }
+  return { netlist: text, nodeOfNet, warnings, excluded, elementOfPart }
 }
 
 export function analysisCard(a: Analysis): string | null {
@@ -413,3 +421,50 @@ export function analysisCard(a: Analysis): string | null {
       return null
   }
 }
+
+// ── error → part/net mapping (M4 leftover) ──────────────────────────────────
+
+export interface SimIssueRef {
+  /** part ids whose emitted device name(s) appear in the message */
+  parts: string[]
+  /** net indices whose node name appears in the message */
+  nets: number[]
+}
+
+function escapeReg(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+/**
+ * Map one raw ngspice error/warning line back to the parts and nets it names,
+ * using the element/node names `generateNetlist` recorded for this run.
+ * Case-insensitive, word-boundary matching (ngspice lowercases everything it
+ * prints). Ground (`0`) is skipped — it appears in far too much numeric text
+ * to be a useful match.
+ */
+export function mapSimIssue(text: string, gen: NetlistResult): SimIssueRef {
+  const low = text.toLowerCase()
+  const parts: string[] = []
+  for (const [id, devices] of Object.entries(gen.elementOfPart)) {
+    if (devices.some((d) => new RegExp(`\\b${escapeReg(d)}\\b`).test(low))) parts.push(id)
+  }
+  const nets: number[] = []
+  gen.nodeOfNet.forEach((node, i) => {
+    if (!node || node === '0') return
+    if (new RegExp(`\\b${escapeReg(node.toLowerCase())}\\b`).test(low)) nets.push(i)
+  })
+  return { parts, nets }
+}
+
+/** Same as `mapSimIssue`, folded over every line of a failure's details
+ * (or just the top-level message), de-duplicated. */
+export function mapSimIssues(lines: string[], gen: NetlistResult): SimIssueRef {
+  const parts = new Set<string>()
+  const nets = new Set<number>()
+  for (const line of lines) {
+    const r = mapSimIssue(line, gen)
+    r.parts.forEach((p) => parts.add(p))
+    r.nets.forEach((n) => nets.add(n))
+  }
+  return { parts: [...parts], nets: [...nets] }
+}
diff --git a/src/renderer/src/circuit/views/CircuitView.tsx b/src/renderer/src/circuit/views/CircuitView.tsx
index 8fb7324..65503ce 100644
--- a/src/renderer/src/circuit/views/CircuitView.tsx
+++ b/src/renderer/src/circuit/views/CircuitView.tsx
@@ -39,6 +39,7 @@ import { PartsEditor } from '../../components/PartsEditor'
 import * as cmd from '../core/commands'
 import { newId, type NetLabelKind, type Pt, type ViewId } from '../core/model'
 import { buildNets } from '../core/nets'
+import type { SimIssueRef } from '../core/netlist'
 import { runErc, type ErcIssue, type ErcSeverity } from '../core/erc'
 import { nextRefdes, prefixForFamily } from '../core/refdes'
 import { CircuitStore } from '../core/store'
@@ -205,6 +206,15 @@ export function CircuitViewV2({
     else if (i.ref?.label)
       setSel({ parts: new Set(), wires: new Set(), labels: new Set([i.ref.label]) })
   }
+  // sim error chip click (mapSimIssues): select the implicated part(s), plus
+  // every part touching an implicated net (a net has no its own selection).
+  const selectSimIssue = (refs: SimIssueRef): void => {
+    const partIds = new Set(refs.parts)
+    for (const i of refs.nets) {
+      for (const ref of netModel.nets[i] ?? []) partIds.add(ref.slice(0, ref.lastIndexOf(':')))
+    }
+    setSel({ parts: partIds, wires: new Set(), labels: new Set() })
+  }
   // parts with no placement in the current view live in the tray.
   // Breadboards are excluded from the schematic entirely (spec §10.2: they
   // are transparent — their row/rail buses still merge nets globally).
@@ -556,6 +566,7 @@ export function CircuitViewV2({
             familyOf={(t) => getPart(t)?.family}
             onClose={() => setShowSim(false)}
             onResult={setSim}
+            onSelectIssue={selectSimIssue}
           />
         )}
 
diff --git a/src/renderer/src/circuit/views/sim/SimPanel.tsx b/src/renderer/src/circuit/views/sim/SimPanel.tsx
index 11ef2de..ca460dc 100644
--- a/src/renderer/src/circuit/views/sim/SimPanel.tsx
+++ b/src/renderer/src/circuit/views/sim/SimPanel.tsx
@@ -14,8 +14,8 @@ import { CircuitBoard, Download, Loader2, Play, Square, X } from 'lucide-react'
 import React from 'react'
 import * as cmd from '../../core/commands'
 import type { Analysis, CircuitDoc } from '../../core/model'
-import type { NetModel } from '../../core/nets'
-import { generateNetlist, type NetlistResult } from '../../core/netlist'
+import { describeNet, type NetModel } from '../../core/nets'
+import { generateNetlist, mapSimIssues, type NetlistResult, type SimIssueRef } from '../../core/netlist'
 import type { CircuitStore } from '../../core/store'
 import { getSimBackend, SimError } from '../../sim'
 import type { SimRun } from '../../sim'
@@ -35,7 +35,8 @@ export function SimPanel({
   store,
   familyOf,
   onClose,
-  onResult
+  onResult,
+  onSelectIssue
 }: {
   doc: CircuitDoc
   netModel: NetModel
@@ -44,6 +45,8 @@ export function SimPanel({
   onClose: () => void
   /** surfaces the run to the shell (canvas DC annotations) */
   onResult: (s: SimState) => void
+  /** clicking a part/net chip on an error asks the shell to select it */
+  onSelectIssue?: (refs: SimIssueRef) => void
 }): React.JSX.Element {
   const analysis: Analysis = doc.sim?.analyses?.[0] ?? { id: 'a1', kind: 'op' }
   const [running, setRunning] = React.useState(false)
@@ -120,6 +123,16 @@ export function SimPanel({
 
   const isOp = result != null && result.numPoints === 1
 
+  // error → part/net highlight mapping (M4 leftover): scan the engine's raw
+  // message lines for the device/node names this run's netlist used, so the
+  // offending elements can be selected on the canvas straight from the error.
+  const issueRefs: SimIssueRef | null = React.useMemo(() => {
+    if (!error || !gen) return null
+    const lines = error.details?.length ? error.details : [error.message]
+    const r = mapSimIssues(lines, gen)
+    return r.parts.length || r.nets.length ? r : null
+  }, [error, gen])
+
   // "v(n1)" → the net's members ("R1:Pin 1 · LED1:anode"); "i(vv1)" → source
   const describe = React.useCallback(
     (vecName: string): string | undefined => {
@@ -361,6 +374,38 @@ export function SimPanel({
                 {error.details.slice(0, 8).join('\n')}
               </pre>
             )}
+            {issueRefs && (
+              <div className="mt-1.5 flex flex-wrap items-center gap-1">
+                <span className="text-[10px] opacity-70">select:</span>
+                {issueRefs.parts.map((id) => (
+                  <button
+                    key={id}
+                    className="px-1.5 py-0.5 rounded bg-status-danger/10 hover:bg-status-danger/20 text-[10px] font-mono text-status-danger"
+                    onClick={() => onSelectIssue?.({ parts: [id], nets: [] })}
+                  >
+                    {id}
+                  </button>
+                ))}
+                {issueRefs.nets.map((i) => (
+                  <button
+                    key={`n${i}`}
+                    className="px-1.5 py-0.5 rounded bg-status-danger/10 hover:bg-status-danger/20 text-[10px] text-status-danger"
+                    onClick={() => onSelectIssue?.({ parts: [], nets: [i] })}
+                    title={describeNet(netModel, i)}
+                  >
+                    net {i}
+                  </button>
+                ))}
+                {(issueRefs.parts.length > 1 || issueRefs.nets.length > 0) && (
+                  <button
+                    className="px-1.5 py-0.5 rounded bg-status-danger/15 hover:bg-status-danger/25 text-[10px] font-medium text-status-danger"
+                    onClick={() => onSelectIssue?.(issueRefs)}
+                  >
+                    select all
+                  </button>
+                )}
+              </div>
+            )}
           </div>
         )}
 

From 715824abef6985b00c575465d353f185e681faf1 Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Wed, 22 Jul 2026 14:16:58 -0600
Subject: [PATCH 20/27] Circuit v2 M4: probe parts (voltage, differential
 voltage, current)

Closes the last M2/M4-leftover item on sim.probes (spec Sec10.3): three
placeable builtin probes, CircuitLab-flag style, seatable on breadboards
like any part:
  - sim-probe-v      1 pin  - voltage probe (ngspice already reports every
                               node, so this needs no SPICE element)
  - sim-probe-vdiff  2 pins - differential voltage; core/probes.ts computes
                               a synthetic vdiff(<id>) = v(+) - v(-) vector
                               (real and imaginary, for AC) after each run
  - sim-probe-i      2 pins - current probe, wired in series; emits a real
                               0V series voltage source (V<id> DC 0) so
                               ngspice reports i(v<id>) without disturbing
                               the circuit

core/netlist.ts: EMITTERS regexes for the three types (anchored with \b, not
$, since the match key has a trailing ' <family>'); elementOfPart already
built into the last commit's error-mapping change. core/probes.ts adds
probesIn/diffProbeVector(s)/probeLabelFor, all pure and tested. SimPanel/Plot
now merge diff-probe vectors into results and prefer a probe's attrs.label
over the raw v(node)/i(vXX)/vdiff(id) name in the DC table and plot legend.
refdes.ts gets an explicit probe->'P' prefix entry (matches the prior
fallback, now documented).

+9 unit tests (probes.test.ts) +1 real-engine integration test (sim.test.ts:
verifies i(vamm1) against the analytic divider current). npm run typecheck
(node+web) clean; test:circuit 107/107.
---
 .../src/circuit/__tests__/probes.test.ts      | 153 ++++++++++++++++++
 .../src/circuit/__tests__/sim.test.ts         |  30 ++++
 src/renderer/src/circuit/core/netlist.ts      |  14 ++
 src/renderer/src/circuit/core/probes.ts       | 122 ++++++++++++++
 src/renderer/src/circuit/core/refdes.ts       |   3 +-
 src/renderer/src/circuit/parts/simProbes.ts   | 112 +++++++++++++
 .../src/circuit/views/CircuitView.tsx         |   4 +-
 src/renderer/src/circuit/views/sim/Plot.tsx   |  34 +++-
 .../src/circuit/views/sim/SimPanel.tsx        |  37 ++++-
 9 files changed, 494 insertions(+), 15 deletions(-)
 create mode 100644 src/renderer/src/circuit/__tests__/probes.test.ts
 create mode 100644 src/renderer/src/circuit/core/probes.ts
 create mode 100644 src/renderer/src/circuit/parts/simProbes.ts

diff --git a/src/renderer/src/circuit/__tests__/probes.test.ts b/src/renderer/src/circuit/__tests__/probes.test.ts
new file mode 100644
index 0000000..6ecb848
--- /dev/null
+++ b/src/renderer/src/circuit/__tests__/probes.test.ts
@@ -0,0 +1,153 @@
+/** core/probes — sim probe recognition + diff-probe subtraction + labeling. */
+
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { emptyDoc, type CircuitDoc, type CircuitPart, type CircuitWire } from '../core/model'
+import { buildNets } from '../core/nets'
+import { generateNetlist } from '../core/netlist'
+import { diffProbeVector, diffProbeVectors, probeLabelFor, probesIn } from '../core/probes'
+import type { SimRun } from '../sim/backend'
+
+let wid = 0
+const wire = (from: string, to: string): CircuitWire => ({
+  id: `w${++wid}`,
+  from,
+  to,
+  view: 'sch'
+})
+const part = (id: string, type: string, attrs?: CircuitPart['attrs']): CircuitPart => ({
+  id,
+  type,
+  attrs,
+  sch: { x: 0, y: 0 }
+})
+
+/** V1 5V across R1(10k) -> R2(4.7k) to ground, with all three probe kinds
+ * wired in: AMM1 in series before R1, VP1 on the OUT node, VD1 across R2. */
+function circuitWithProbes(): CircuitDoc {
+  const doc = emptyDoc()
+  doc.parts = [
+    part('V1', 'sim-vdc', { voltage: '5' }),
+    part('AMM1', 'sim-probe-i'),
+    part('R1', 'resistor', { resistance: '10k' }),
+    part('R2', 'resistor', { resistance: '4.7k' }),
+    part('VP1', 'sim-probe-v', { label: 'Vout' }),
+    part('VD1', 'sim-probe-vdiff', { label: 'Vr2' })
+  ]
+  doc.netLabels = [{ id: 'nl1', name: 'GND', kind: 'ground', sch: { x: 0, y: 0 } }]
+  doc.wires = [
+    wire('V1:+', 'AMM1:in'),
+    wire('AMM1:out', 'R1:Pin 0'),
+    wire('R1:Pin 1', 'R2:Pin 0'),
+    wire('R2:Pin 1', 'V1:-'),
+    wire('nl1:1', 'V1:-'),
+    wire('VP1:+', 'R1:Pin 1'),
+    wire('VD1:+', 'R2:Pin 0'),
+    wire('VD1:-', 'R2:Pin 1')
+  ]
+  return doc
+}
+
+test('probesIn recognizes all three probe kinds and ignores everything else', () => {
+  const doc = circuitWithProbes()
+  const probes = probesIn(doc)
+  assert.deepEqual(
+    probes.map((p) => [p.part.id, p.kind]).sort(),
+    [
+      ['AMM1', 'current'],
+      ['VD1', 'diff'],
+      ['VP1', 'voltage']
+    ].sort()
+  )
+})
+
+test('probesIn labels fall back to the part id when attrs.label is unset', () => {
+  const doc = emptyDoc()
+  doc.parts = [part('P1', 'sim-probe-v')]
+  assert.equal(probesIn(doc)[0].label, 'P1')
+})
+
+test('diffProbeVector subtracts the two node voltages; undefined when a pin is unwired', () => {
+  const doc = circuitWithProbes()
+  const net = buildNets(doc)
+  const gen = generateNetlist(doc, net)
+  const run: SimRun = {
+    header: '',
+    numPoints: 1,
+    vectors: gen.nodeOfNet.map((node, i) =>
+      node === '0'
+        ? { name: 'v(0)', type: 'voltage' as const, values: [0] }
+        : { name: `v(${node})`, type: 'voltage' as const, values: [(i + 1) * 1.5] }
+    )
+  }
+  const vd1 = doc.parts.find((p) => p.id === 'VD1')!
+  const vec = diffProbeVector(vd1, net, gen, run)
+  assert.ok(vec)
+  assert.equal(vec!.name, 'vdiff(VD1)')
+
+  const orphan = part('LONER', 'sim-probe-vdiff')
+  const undef = diffProbeVector(orphan, net, gen, run)
+  assert.equal(undef, undefined)
+})
+
+test('diffProbeVector subtracts real and imaginary parts when the run is complex (AC)', () => {
+  const doc = emptyDoc()
+  doc.parts = [
+    part('R1', 'resistor', { resistance: '1k' }),
+    part('R2', 'resistor', { resistance: '1k' }),
+    part('VD1', 'sim-probe-vdiff')
+  ]
+  // two disjoint nets, no GND — so neither resolves to node '0'
+  doc.wires = [wire('VD1:+', 'R1:Pin 1'), wire('VD1:-', 'R2:Pin 1')]
+  const net = buildNets(doc)
+  const gen = generateNetlist(doc, net)
+  const plusNode = gen.nodeOfNet[net.pinToNet.get('VD1:+')!]
+  const minusNode = gen.nodeOfNet[net.pinToNet.get('VD1:-')!]
+  assert.notEqual(plusNode, '0')
+  assert.notEqual(minusNode, '0')
+  assert.notEqual(plusNode, minusNode)
+  const run: SimRun = {
+    header: '',
+    numPoints: 2,
+    vectors: [
+      { name: `v(${plusNode})`, type: 'voltage', values: [5, 6], imag: [1, 1.5] },
+      { name: `v(${minusNode})`, type: 'voltage', values: [0.5, 0.5], imag: [0.25, 0.25] }
+    ]
+  }
+  const vd1 = doc.parts.find((p) => p.id === 'VD1')!
+  const vec = diffProbeVector(vd1, net, gen, run)
+  assert.ok(vec)
+  assert.deepEqual(vec!.values, [4.5, 5.5])
+  assert.deepEqual(vec!.imag, [0.75, 1.25])
+})
+
+test('diffProbeVectors only returns diff-kind probes', () => {
+  const doc = circuitWithProbes()
+  const net = buildNets(doc)
+  const gen = generateNetlist(doc, net)
+  const run: SimRun = {
+    header: '',
+    numPoints: 1,
+    vectors: gen.nodeOfNet.map((node, i) => ({
+      name: node === '0' ? 'v(0)' : `v(${node})`,
+      type: 'voltage' as const,
+      values: [i]
+    }))
+  }
+  const vecs = diffProbeVectors(doc, net, gen, run)
+  assert.deepEqual(
+    vecs.map((v) => v.name),
+    ['vdiff(VD1)']
+  )
+})
+
+test('probeLabelFor maps vdiff/current/voltage vector names back to a probe label', () => {
+  const doc = circuitWithProbes()
+  const net = buildNets(doc)
+  const gen = generateNetlist(doc, net)
+  assert.equal(probeLabelFor('vdiff(VD1)', doc, net, gen), 'Vr2')
+  assert.equal(probeLabelFor('i(vamm1)', doc, net, gen), 'AMM1') // no label set -> id
+  const outNode = gen.nodeOfNet[net.pinToNet.get('VP1:+')!]
+  assert.equal(probeLabelFor(`v(${outNode})`, doc, net, gen), 'Vout')
+  assert.equal(probeLabelFor('v(some-unrelated-node)', doc, net, gen), undefined)
+})
diff --git a/src/renderer/src/circuit/__tests__/sim.test.ts b/src/renderer/src/circuit/__tests__/sim.test.ts
index 1f5dcb0..ac03d77 100644
--- a/src/renderer/src/circuit/__tests__/sim.test.ts
+++ b/src/renderer/src/circuit/__tests__/sim.test.ts
@@ -116,3 +116,33 @@ test('engine runs a generated RC transient with sane charge curve', async () =>
   const atRc = out[i]
   assert.ok(Math.abs(atRc - 3.161) / 3.161 < 0.05, `v(RC)=${atRc}`)
 })
+
+test('current probe (M4 leftover): engine reports the divider branch current', async () => {
+  const doc = emptyDoc()
+  doc.parts = [
+    part('V1', 'sim-vdc', { voltage: '5' }),
+    part('AMM1', 'sim-probe-i'),
+    part('R1', 'resistor', { resistance: '10k' }),
+    part('R2', 'resistor', { resistance: '4.7k' })
+  ]
+  doc.netLabels = [{ id: 'nl1', name: 'GND', kind: 'ground', sch: { x: 0, y: 0 } }]
+  doc.wires = [
+    wire('V1:+', 'AMM1:in'),
+    wire('AMM1:out', 'R1:Pin 0'),
+    wire('R1:Pin 1', 'R2:Pin 0'),
+    wire('R2:Pin 1', 'V1:-'),
+    wire('nl1:1', 'V1:-')
+  ]
+  const { netlist, warnings } = generateNetlist(doc, buildNets(doc))
+  assert.equal(warnings.length, 0)
+  assert.match(netlist, /VAMM1 \S+ \S+ DC 0/)
+
+  const sim = await makeSim()
+  sim.setNetList(netlist)
+  const res = await sim.runSim()
+  const i = vec(res, 'i(vamm1)')
+  assert.ok(i, `i(vamm1) present (got: ${res.data.map((d) => d.name).join(', ')})`)
+  // 5V across 14.7k, current flows V+ -> AMM1 -> R1 -> R2 -> V- (into V- => negative by SPICE convention)
+  const expected = 5 / 14700
+  assert.ok(Math.abs(Math.abs(i![0]) - expected) / expected < 0.01, `i(vamm1)=${i![0]} ≈ ±${expected}`)
+})
diff --git a/src/renderer/src/circuit/core/netlist.ts b/src/renderer/src/circuit/core/netlist.ts
index 24838db..1fa5ca9 100644
--- a/src/renderer/src/circuit/core/netlist.ts
+++ b/src/renderer/src/circuit/core/netlist.ts
@@ -279,6 +279,20 @@ const EMITTERS: {
       model: PNP_MODEL
     })
   },
+  {
+    // current probe (spec §10.3): a 0V series source, so ngspice reports
+    // i(v<id>) through it without disturbing the circuit — an ideal ammeter.
+    match: /^sim-probe-i\b/i,
+    emit: (c) => {
+      const [a, b] = two(c)
+      return { lines: [`V${c.part.id} ${a} ${b} DC 0`] }
+    }
+  },
+  // voltage / diff. voltage probes need no element — every node's voltage is
+  // already reported by ngspice; core/probes.ts reads it back by node name
+  // (and computes the diff-probe subtraction). Just don't warn about them.
+  { match: /^sim-probe-vdiff\b/i, kind: 'transparent' },
+  { match: /^sim-probe-v\b/i, kind: 'transparent' },
   {
     match: /switch|button/i,
     attrs: [{ key: 'closed', label: 'Closed', default: 'false', hint: 'true/false' }],
diff --git a/src/renderer/src/circuit/core/probes.ts b/src/renderer/src/circuit/core/probes.ts
new file mode 100644
index 0000000..bb9c9f8
--- /dev/null
+++ b/src/renderer/src/circuit/core/probes.ts
@@ -0,0 +1,122 @@
+/**
+ * circuit/core/probes — placeable sim probes, the pure/testable half (M4
+ * leftover, spec §10.3). Part art + registration live in parts/simProbes.ts
+ * (renderer-facing); the emitted SPICE for the current probe lives in
+ * core/netlist.ts. This module only needs to:
+ *   - recognize probe part types (probesIn), and
+ *   - compute a differential-voltage probe's subtraction vector from a
+ *     completed run (diffProbeVector/diffProbeVectors) — voltage/diff probes
+ *     emit no SPICE element, so there's nothing else to derive.
+ *
+ * Zero React, zero Node — same rule as the rest of core/.
+ */
+
+import type { CircuitDoc, CircuitPart } from './model'
+import type { NetModel } from './nets'
+import type { NetlistResult } from './netlist'
+import type { SimRun, SimVector } from '../sim/backend'
+
+export type ProbeKind = 'voltage' | 'diff' | 'current'
+
+export const PROBE_TYPES: Record<string, ProbeKind> = {
+  'sim-probe-v': 'voltage',
+  'sim-probe-vdiff': 'diff',
+  'sim-probe-i': 'current'
+}
+
+export function isProbeType(type: string): boolean {
+  return type in PROBE_TYPES
+}
+
+export interface ProbeInfo {
+  part: CircuitPart
+  kind: ProbeKind
+  /** attrs.label if the user set one, else the part id (refdes) */
+  label: string
+}
+
+/** Every placed probe part in the doc, in part order. */
+export function probesIn(doc: CircuitDoc): ProbeInfo[] {
+  const out: ProbeInfo[] = []
+  for (const p of doc.parts) {
+    const kind = PROBE_TYPES[p.type]
+    if (!kind) continue
+    out.push({ part: p, kind, label: String(p.attrs?.label ?? p.id) })
+  }
+  return out
+}
+
+function vectorOfNode(run: SimRun, node: string): SimVector | undefined {
+  if (node === '0') return { name: 'v(0)', type: 'voltage', values: new Array(run.numPoints).fill(0) }
+  const key = `v(${node.toLowerCase()})`
+  return run.vectors.find((v) => v.name.toLowerCase() === key)
+}
+
+/**
+ * A diff probe's `+`/`-` pins land on two nets; ngspice already reports each
+ * node's voltage, so the probe's own value is just their subtraction. Returns
+ * undefined if either pin isn't wired into a net, or the run has no matching
+ * vector for one side (e.g. that node was excluded/unreachable).
+ */
+export function diffProbeVector(
+  probe: CircuitPart,
+  net: NetModel,
+  gen: NetlistResult,
+  run: SimRun
+): SimVector | undefined {
+  const plusIdx = net.pinToNet.get(`${probe.id}:+`)
+  const minusIdx = net.pinToNet.get(`${probe.id}:-`)
+  if (plusIdx == null || minusIdx == null) return undefined
+  const a = vectorOfNode(run, gen.nodeOfNet[plusIdx])
+  const b = vectorOfNode(run, gen.nodeOfNet[minusIdx])
+  if (!a || !b || a.values.length !== b.values.length) return undefined
+  const values = a.values.map((v, i) => v - b.values[i])
+  const vec: SimVector = { name: `vdiff(${probe.id})`, type: 'voltage', values }
+  if (a.imag && b.imag) vec.imag = a.imag.map((v, i) => v - b.imag![i])
+  return vec
+}
+
+/** All synthetic diff-probe vectors for the current doc + completed run. */
+export function diffProbeVectors(
+  doc: CircuitDoc,
+  net: NetModel,
+  gen: NetlistResult,
+  run: SimRun
+): SimVector[] {
+  const out: SimVector[] = []
+  for (const p of probesIn(doc)) {
+    if (p.kind !== 'diff') continue
+    const v = diffProbeVector(p.part, net, gen, run)
+    if (v) out.push(v)
+  }
+  return out
+}
+
+/**
+ * Friendly label for a vector name, preferring a probe's attrs.label over
+ * the raw SPICE name: `v(n3)` → "Probe1" when a voltage probe sits on that
+ * node; `i(v<id>)` → the current probe's label; `vdiff(<id>)` → its label.
+ */
+export function probeLabelFor(vecName: string, doc: CircuitDoc, net: NetModel, gen: NetlistResult): string | undefined {
+  const diffM = /^vdiff\((.+)\)$/i.exec(vecName)
+  if (diffM) {
+    const p = doc.parts.find((p) => p.id.toLowerCase() === diffM[1].toLowerCase())
+    return p ? String(p.attrs?.label ?? p.id) : undefined
+  }
+  const iM = /^i\(v(.+)\)$/i.exec(vecName)
+  if (iM) {
+    const p = doc.parts.find((p) => p.type === 'sim-probe-i' && p.id.toLowerCase() === iM[1].toLowerCase())
+    return p ? String(p.attrs?.label ?? p.id) : undefined
+  }
+  const vM = /^v\((.+)\)$/i.exec(vecName)
+  if (vM) {
+    const node = vM[1].toLowerCase()
+    const netIdx = gen.nodeOfNet.findIndex((n) => n.toLowerCase() === node)
+    if (netIdx < 0) return undefined
+    for (const p of probesIn(doc)) {
+      if (p.kind !== 'voltage') continue
+      if (net.pinToNet.get(`${p.part.id}:+`) === netIdx) return p.label
+    }
+  }
+  return undefined
+}
diff --git a/src/renderer/src/circuit/core/refdes.ts b/src/renderer/src/circuit/core/refdes.ts
index 7b44468..a92da19 100644
--- a/src/renderer/src/circuit/core/refdes.ts
+++ b/src/renderer/src/circuit/core/refdes.ts
@@ -24,7 +24,8 @@ const FAMILY_PREFIX: Record<string, string> = {
   battery: 'BT',
   source: 'V',
   breadboard: 'BB',
-  label: 'NL'
+  label: 'NL',
+  probe: 'P'
 }
 
 export function prefixForFamily(family?: string, explicit?: string): string {
diff --git a/src/renderer/src/circuit/parts/simProbes.ts b/src/renderer/src/circuit/parts/simProbes.ts
new file mode 100644
index 0000000..e8fbe2a
--- /dev/null
+++ b/src/renderer/src/circuit/parts/simProbes.ts
@@ -0,0 +1,112 @@
+/**
+ * circuit/parts/simProbes — builtin sim probes (M4 leftover, spec §10.3).
+ *
+ * Three placeable 1/2-pin builtins, CircuitLab-flag style, same art both
+ * views (seatable on a breadboard like any part):
+ *   - sim-probe-v      voltage probe   (1 pin: `+`)
+ *   - sim-probe-vdiff  diff. voltage   (2 pins: `+`, `-`)
+ *   - sim-probe-i      current probe   (2 pins: `in`, `out` — wired in
+ *                      series with the branch to measure)
+ *
+ * Voltage/diff probes need no SPICE element (ngspice already reports every
+ * node's voltage under `.op`/`.tran`/`.ac`) — core/netlist.ts marks them
+ * `transparent`. The current probe DOES need a real element: it emits a 0V
+ * series voltage source so ngspice reports `i(v<id>)` through it (an ideal
+ * ammeter). Diff-probe subtraction and probe labeling live in core/probes.ts.
+ */
+
+import type { PartDef, PartView } from '../../lib/partsLibrary'
+import { GRID_BB } from '../core/model'
+
+const P = GRID_BB // 9.6
+const INK = 'var(--text-strong)'
+const FLAG = '#f0b429' // CircuitLab-style amber flag
+
+export type ProbeKind = 'voltage' | 'diff' | 'current'
+
+export interface ProbeSpec {
+  type: string
+  label: string
+  kind: ProbeKind
+}
+
+export const SIM_PROBES: ProbeSpec[] = [
+  { type: 'sim-probe-v', label: 'Voltage Probe', kind: 'voltage' },
+  { type: 'sim-probe-vdiff', label: 'Diff. Voltage Probe', kind: 'diff' },
+  { type: 'sim-probe-i', label: 'Current Probe', kind: 'current' }
+]
+
+const cache = new Map<string, PartDef>()
+
+/** Small triangular pennant + stem from y=0 to y=stemLen, CircuitLab-style. */
+function flag(cx: number, stemLen: number): string {
+  const pennantH = Math.min(1.1 * P, stemLen * 0.6)
+  return (
+    `<line x1="${cx}" y1="0" x2="${cx}" y2="${stemLen}" stroke="${INK}" stroke-width="2"/>` +
+    `<path d="M ${cx} 0 L ${cx + 1.6 * P} ${pennantH / 2} L ${cx} ${pennantH} Z" fill="${FLAG}" stroke="${INK}" stroke-width="1"/>`
+  )
+}
+
+export function generateSimProbe(spec: ProbeSpec): PartDef {
+  const hit = cache.get(spec.type)
+  if (hit) return hit
+
+  let view: PartView
+  if (spec.kind === 'current') {
+    // inline ammeter: two pins on a horizontal line through a circled "A"
+    const w = 4 * P
+    const h = 2 * P
+    const cy = P
+    const r = 0.85 * P
+    const svg =
+      `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${w} ${h}">` +
+      `<line x1="0" y1="${cy}" x2="${w / 2 - r}" y2="${cy}" stroke="${INK}" stroke-width="2"/>` +
+      `<line x1="${w / 2 + r}" y1="${cy}" x2="${w}" y2="${cy}" stroke="${INK}" stroke-width="2"/>` +
+      `<circle cx="${w / 2}" cy="${cy}" r="${r}" fill="none" stroke="${FLAG}" stroke-width="2"/>` +
+      `<text x="${w / 2}" y="${cy + 3}" fill="${INK}" font-family="monospace" font-size="9" text-anchor="middle">A</text>` +
+      `</svg>`
+    view = { svg, w, h, pins: { in: [0, cy], out: [w, cy] } }
+  } else if (spec.kind === 'diff') {
+    const stem = 2.4 * P
+    const w = 3.6 * P
+    const h = stem + 0.8 * P
+    const svg =
+      `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${w} ${h}">` +
+      `<g transform="translate(${0.3 * P},0)">${flag(0, stem)}</g>` +
+      `<g transform="translate(${2 * P},0)">${flag(0, stem)}</g>` +
+      `<text x="${w / 2}" y="${h - 1}" fill="${INK}" font-family="monospace" font-size="6" text-anchor="middle">+ −</text>` +
+      `</svg>`
+    view = { svg, w, h, pins: { '+': [0.3 * P, stem], '-': [2 * P, stem] } }
+  } else {
+    const stem = 2.4 * P
+    const w = 2.4 * P
+    const h = stem
+    const svg =
+      `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${w} ${h}">` + flag(0.4 * P, stem) + `</svg>`
+    view = { svg, w, h, pins: { '+': [0.4 * P, stem] } }
+  }
+
+  const def: PartDef = {
+    type: spec.type,
+    label: spec.label,
+    family: 'Probe',
+    builtin: true,
+    views: { breadboard: view, schematic: view }
+  }
+  cache.set(spec.type, def)
+  return def
+}
+
+export function isSimProbe(type: string): boolean {
+  return SIM_PROBES.some((s) => s.type === type)
+}
+
+export function probeKindOf(type: string): ProbeKind | undefined {
+  return SIM_PROBES.find((s) => s.type === type)?.kind
+}
+
+/** Default attrs for a just-placed probe (Inspector-editable `label`). */
+export function simProbeDefaultAttrs(type: string): Record<string, string> | undefined {
+  const spec = SIM_PROBES.find((s) => s.type === type)
+  return spec ? { label: spec.label } : undefined
+}
diff --git a/src/renderer/src/circuit/views/CircuitView.tsx b/src/renderer/src/circuit/views/CircuitView.tsx
index 65503ce..12a8828 100644
--- a/src/renderer/src/circuit/views/CircuitView.tsx
+++ b/src/renderer/src/circuit/views/CircuitView.tsx
@@ -45,6 +45,7 @@ import { nextRefdes, prefixForFamily } from '../core/refdes'
 import { CircuitStore } from '../core/store'
 import { BREADBOARDS, generateBreadboard, isBreadboard } from '../parts/breadboard'
 import { SIM_SOURCES, generateSimSource, simSourceDefaultAttrs } from '../parts/simParts'
+import { SIM_PROBES, generateSimProbe, simProbeDefaultAttrs } from '../parts/simProbes'
 import { snapNetLabel } from '../parts/netLabels'
 import { Canvas, emptySel, type Cam, type CanvasHandle, type Selection } from './canvas/Canvas'
 import { exportPng, exportSvg } from './exportImage'
@@ -76,6 +77,7 @@ export function CircuitViewV2({
     // registry replaces it — register once, before first geometry pass
     for (const s of BREADBOARDS) if (!getPart(s.type)) registerPart(generateBreadboard(s).def)
     for (const s of SIM_SOURCES) if (!getPart(s.type)) registerPart(generateSimSource(s))
+    for (const s of SIM_PROBES) if (!getPart(s.type)) registerPart(generateSimProbe(s))
     return CircuitStore.fromFile(content)
   })
   const revision = React.useSyncExternalStore(store.subscribe, store.getRevision)
@@ -267,7 +269,7 @@ export function CircuitViewV2({
     const p = at ?? canvasRef.current?.centerWorld() ?? { x: 300, y: 200 }
     const id = nextRefdes(store.getDoc(), prefixForFamily(`${def.family ?? ''} ${def.type}`))
     const pl = findFreePlacement(store.getDoc(), type, view, p)
-    const attrs = simSourceDefaultAttrs(type)
+    const attrs = simSourceDefaultAttrs(type) ?? simProbeDefaultAttrs(type)
     store.dispatch(cmd.addPart({ id, type, ...(attrs ? { attrs } : {}), [view]: pl }))
     setSel({ parts: new Set([id]), wires: new Set() })
   }
diff --git a/src/renderer/src/circuit/views/sim/Plot.tsx b/src/renderer/src/circuit/views/sim/Plot.tsx
index eea8985..b713646 100644
--- a/src/renderer/src/circuit/views/sim/Plot.tsx
+++ b/src/renderer/src/circuit/views/sim/Plot.tsx
@@ -38,7 +38,11 @@ interface Prepared {
   hasPhase: boolean
 }
 
-function prepare(run: SimRun, mode: PlotMode): Prepared | null {
+function prepare(
+  run: SimRun,
+  mode: PlotMode,
+  labelFor?: (name: string) => string | undefined
+): Prepared | null {
   const x =
     mode === 'ac'
       ? run.vectors.find((v) => v.type === 'frequency')
@@ -47,7 +51,12 @@ function prepare(run: SimRun, mode: PlotMode): Prepared | null {
         : (run.vectors.find((v) => v.type === 'time') ?? run.vectors[0])
   if (!x) return null
   const ys = run.vectors
-    .filter((v) => v !== x && v.name.toLowerCase() !== 'v(v-sweep)' && v.name.startsWith('v('))
+    .filter(
+      (v) =>
+        v !== x &&
+        v.name.toLowerCase() !== 'v(v-sweep)' &&
+        (v.name.startsWith('v(') || v.name.startsWith('vdiff('))
+    )
     .slice(0, TRACES.length)
   if (!ys.length) return null
 
@@ -57,10 +66,11 @@ function prepare(run: SimRun, mode: PlotMode): Prepared | null {
   const isAc = mode === 'ac' && ys.some((v) => v.imag)
   for (let i = 0; i < ys.length; i++) {
     const v = ys[i]
+    const name = labelFor?.(v.name) ?? v.name
     if (isAc) {
       cols.push(v.values.map((re, k) => db(mag(re, v.imag?.[k] ?? 0))))
       series.push({
-        label: `${v.name} dB`,
+        label: `${name} dB`,
         stroke: TRACES[i],
         width: 1.4,
         scale: 'y',
@@ -69,7 +79,7 @@ function prepare(run: SimRun, mode: PlotMode): Prepared | null {
     } else {
       cols.push(v.values)
       series.push({
-        label: v.name,
+        label: name,
         stroke: TRACES[i],
         width: 1.4,
         scale: 'y',
@@ -80,9 +90,10 @@ function prepare(run: SimRun, mode: PlotMode): Prepared | null {
   if (isAc) {
     for (let i = 0; i < ys.length; i++) {
       const v = ys[i]
+      const name = labelFor?.(v.name) ?? v.name
       cols.push(v.values.map((re, k) => deg(re, v.imag?.[k] ?? 0)))
       series.push({
-        label: `${v.name} °`,
+        label: `${name} °`,
         stroke: TRACES[i],
         width: 1,
         dash: [4, 4],
@@ -111,10 +122,19 @@ export function fmtEng(v: number): string {
   return `${(v * 1e9).toFixed(2)}n`
 }
 
-export function SimPlot({ run, mode }: { run: SimRun; mode: PlotMode }): React.JSX.Element {
+export function SimPlot({
+  run,
+  mode,
+  labelFor
+}: {
+  run: SimRun
+  mode: PlotMode
+  /** override a vector's displayed legend name (e.g. a probe's label) */
+  labelFor?: (name: string) => string | undefined
+}): React.JSX.Element {
   const host = React.useRef<HTMLDivElement>(null)
   const plot = React.useRef<uPlot | null>(null)
-  const prepared = React.useMemo(() => prepare(run, mode), [run, mode])
+  const prepared = React.useMemo(() => prepare(run, mode, labelFor), [run, mode, labelFor])
 
   React.useEffect(() => {
     const el = host.current
diff --git a/src/renderer/src/circuit/views/sim/SimPanel.tsx b/src/renderer/src/circuit/views/sim/SimPanel.tsx
index ca460dc..b8d7794 100644
--- a/src/renderer/src/circuit/views/sim/SimPanel.tsx
+++ b/src/renderer/src/circuit/views/sim/SimPanel.tsx
@@ -16,6 +16,7 @@ import * as cmd from '../../core/commands'
 import type { Analysis, CircuitDoc } from '../../core/model'
 import { describeNet, type NetModel } from '../../core/nets'
 import { generateNetlist, mapSimIssues, type NetlistResult, type SimIssueRef } from '../../core/netlist'
+import { diffProbeVectors, probeLabelFor } from '../../core/probes'
 import type { CircuitStore } from '../../core/store'
 import { getSimBackend, SimError } from '../../sim'
 import type { SimRun } from '../../sim'
@@ -84,7 +85,11 @@ export function SimPanel({
     const g = generateNetlist(doc, netModel, { familyOf, title: 'tinyStudio circuit' })
     setGen(g)
     try {
-      const r = await getSimBackend().run(g.netlist, 20000)
+      const raw = await getSimBackend().run(g.netlist, 20000)
+      // fold in synthetic diff-probe vectors (voltage/current probes need no
+      // extra work — ngspice already reports every node and probe source)
+      const diffs = diffProbeVectors(doc, netModel, g, raw)
+      const r: SimRun = diffs.length ? { ...raw, vectors: [...raw.vectors, ...diffs] } : raw
       setResult(r)
       onResult({ run: r, netlist: g })
     } catch (err) {
@@ -123,6 +128,15 @@ export function SimPanel({
 
   const isOp = result != null && result.numPoints === 1
 
+  // probe labels (M4 leftover): a placed sim-probe-v/-vdiff/-i part's
+  // attrs.label, if any, stands in for the raw v(node)/vdiff(id)/i(v<id>)
+  // vector name in the table and plot legend.
+  const labelFor = React.useCallback(
+    (vecName: string): string | undefined =>
+      gen ? probeLabelFor(vecName, doc, netModel, gen) : undefined,
+    [gen, doc, netModel]
+  )
+
   // error → part/net highlight mapping (M4 leftover): scan the engine's raw
   // message lines for the device/node names this run's netlist used, so the
   // offending elements can be selected on the canvas straight from the error.
@@ -417,9 +431,13 @@ export function SimPanel({
           </div>
         )}
 
-        {isOp && result && <OpTable run={result} describe={describe} />}
+        {isOp && result && <OpTable run={result} describe={describe} labelFor={labelFor} />}
         {result && result.numPoints > 1 && (
-          <SimPlot run={result} mode={(analysis.kind === 'op' ? 'tran' : analysis.kind) as PlotMode} />
+          <SimPlot
+            run={result}
+            mode={(analysis.kind === 'op' ? 'tran' : analysis.kind) as PlotMode}
+            labelFor={labelFor}
+          />
         )}
 
         {showNetlist && gen && (
@@ -455,17 +473,24 @@ export function fmtSI(v: number, unit: string): string {
 
 function OpTable({
   run,
-  describe
+  describe,
+  labelFor
 }: {
   run: SimRun
   describe: (vecName: string) => string | undefined
+  labelFor?: (vecName: string) => string | undefined
 }): React.JSX.Element {
   const rows = run.vectors
     .filter((v) => v.values.length === 1)
     .map((v) => {
-      const isV = v.name.startsWith('v(')
+      const isV = v.name.startsWith('v(') || v.name.startsWith('vdiff(')
       const unit = isV ? 'V' : 'A'
-      return { name: v.name, value: fmtSI(v.values[0], unit), what: describe(v.name) }
+      const label = labelFor?.(v.name)
+      return {
+        name: label ? `${label} (${v.name})` : v.name,
+        value: fmtSI(v.values[0], unit),
+        what: describe(v.name)
+      }
     })
   return (
     <div className="grid grid-cols-[auto_auto_1fr] gap-x-6 gap-y-1 w-full max-w-[720px]">

From e70ce3a738304545b582f0503d5071134bcc68a5 Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Wed, 22 Jul 2026 14:20:03 -0600
Subject: [PATCH 21/27] Circuit v2 M2: rigid 'all pins must seat' rule for
 breadboard drop-to-connect
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

implicitSeats() previously seated each of a part's pins independently against
the nearest hole within SEAT_RADIUS, so a part with one leg near a hole and
another off-grid would report a single spurious connection while the rest of
its pins silently dangled unconnected. Now a part seats as a rigid body —
ALL of its pins must land within SEAT_RADIUS at the part's current placement
for ANY of them to seat; otherwise none do (matches Fritzing: a component
either fully plugs in or just rests on top). Pairs naturally with the
existing snap-by-first-pin grid snap, so well-formed grid-pitched parts still
seat on the first touch.

Single computation point (CircuitView.tsx memo), consumed by net building,
hole seat marks, sticky-board drag, and rigid board rotation — all get the
fix for free. npm run typecheck (node+web) clean; test:circuit 107/107
(implicitSeats depends on the legacy partsLibrary registry like the rest of
partsAdapter.ts, so it isn't unit-tested in isolation, consistent with the
rest of that module).
---
 .../src/circuit/views/partsAdapter.ts         | 28 +++++++++++++------
 1 file changed, 20 insertions(+), 8 deletions(-)

diff --git a/src/renderer/src/circuit/views/partsAdapter.ts b/src/renderer/src/circuit/views/partsAdapter.ts
index 72dbdaa..5a240e3 100644
--- a/src/renderer/src/circuit/views/partsAdapter.ts
+++ b/src/renderer/src/circuit/views/partsAdapter.ts
@@ -342,9 +342,14 @@ export interface Seat {
 }
 
 /**
- * Derive implicit pin-in-hole connections: every placed non-breadboard pin
- * within SEAT_RADIUS of a breadboard hole. Grid-snapped placement makes the
- * common case an exact coordinate match.
+ * Derive implicit pin-in-hole connections: a part seats as a rigid body —
+ * ALL of its pins must land within SEAT_RADIUS of a breadboard hole at the
+ * part's current placement/rotation, or NONE of them seat (Fritzing rule:
+ * a component either fully plugs in or it's just resting on top). This
+ * avoids a part with one pin near a hole and another dangling off-grid
+ * reporting a single spurious connection while silently leaving the rest
+ * of its pins unconnected. Grid-snapped placement makes the common case an
+ * exact coordinate match.
  */
 export function implicitSeats(doc: CircuitDoc): Seat[] {
   const hash = new SpatialHash<string>()
@@ -366,13 +371,20 @@ export function implicitSeats(doc: CircuitDoc): Seat[] {
   for (const part of doc.parts) {
     if (!part.bb || isBreadboard(part.type)) continue
     const vis = bbVisual(part.type)
-    if (!vis) continue
-    for (const pin of Object.keys(vis.v.pins)) {
+    const pins = vis ? Object.keys(vis.v.pins) : []
+    if (!pins.length) continue
+    const candidates: Seat[] = []
+    let allSeated = true
+    for (const pin of pins) {
       const p = pinWorldOf(part, pin)
-      if (!p) continue
-      const hit = hash.nearest(p, SEAT_RADIUS)
-      if (hit) seats.push({ pin: `${part.id}:${pin}`, hole: hit.v, pos: hit.p })
+      const hit = p ? hash.nearest(p, SEAT_RADIUS) : null
+      if (!hit) {
+        allSeated = false
+        break
+      }
+      candidates.push({ pin: `${part.id}:${pin}`, hole: hit.v, pos: hit.p })
     }
+    if (allSeated) seats.push(...candidates)
   }
   return seats
 }

From dc3dd87bff31c90c69dbe776e006dcb528941ce2 Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Wed, 22 Jul 2026 14:29:35 -0600
Subject: [PATCH 22/27] Circuit v2 M2: bendable rubber-band legs (legId)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Closes the last M2-scope gap noted since M1 ('leg pins resolve to the drawn
leg end; real rubber-band legs are a Phase 2 renderer feature').

Import (both importers, mirrored):
  - scripts/fritzing-import.mjs and circuit/parts/fzpz.ts now read each
    connector's legId and tag the resolved pin name into a new
    PartView.legs: string[] (lib/partsLibrary.ts). Geometry itself needed no
    change — core/geometry.pinWorld and partsAdapter.pinWorldOf were already
    leg-offset aware (Placement.legs existed in the model since M0/M1 but
    nothing ever produced or consumed it).

Canvas (bb view only, per the model's 'legs bb only' contract):
  - A pin tagged as a leg can be dragged independent of the part body
    (beginLegDrag in views/canvas/Canvas.tsx): live-dispatches merged
    placePart commands per move (same pattern as the existing label-offset
    drag), so wires re-anchor to the tip in real time via the normal
    doc -> resolve()/wireGeometry() recompute — no separate drag-override
    path needed. A real (>=3px) drag suppresses the trailing click so it
    doesn't also arm/complete a wire from that pin; a plain click still
    works normally. Double-click a bent leg to reset it to rest.
  - Visual: a simple ink line from the rest pin to the dragged tip, overlaid
    on the existing static Fritzing leg art (which stays at rest position) —
    real per-instance SVG leg-path warping is future work, noted in code.
  - implicitSeats() (M2's rigid seat rule, previous commit) already reads
    pin world position through the leg-aware pinWorldOf, so a stretched leg
    can now actually reach an adjacent hole and seat, matching Fritzing.

Not covered: Inspector UI for leg offsets (canvas drag + reset covers the
interaction), and this specific gesture code has no automated test (Canvas.tsx
render/gesture code isn't unit-tested anywhere in this suite; verified by
typecheck + code review only — the importer half touches DOM-only code paths
the existing fzpz.test.ts also intentionally leaves untested).

npm run typecheck (node+web) clean; test:circuit 107/107 (unaffected).
---
 scripts/fritzing-import.mjs                   |  14 ++-
 src/renderer/src/circuit/parts/fzpz.ts        |  12 +-
 .../src/circuit/views/canvas/Canvas.tsx       | 117 +++++++++++++++++-
 src/renderer/src/lib/partsLibrary.ts          |   3 +
 4 files changed, 138 insertions(+), 8 deletions(-)

diff --git a/scripts/fritzing-import.mjs b/scripts/fritzing-import.mjs
index 7d10b6e..ada66fe 100644
--- a/scripts/fritzing-import.mjs
+++ b/scripts/fritzing-import.mjs
@@ -386,6 +386,7 @@ function extractView(fzp, view, srcRoot) {
 
   // resolve each connector's pin point
   const pins = {}
+  const legPins = []
   const unresolved = []
   const usedNames = new Set()
   for (const c of fzp.connectors) {
@@ -430,6 +431,10 @@ function extractView(fzp, view, srcRoot) {
     while (usedNames.has(n)) n = `${name}.${i++}`
     usedNames.add(n)
     pins[n] = [round(canvas.x), round(canvas.y)]
+    // bendable rubber-band leg (LED/resistor class parts, breadboard view
+    // only — cv.legId is only ever set there): tag the pin so the editor
+    // knows it can be dragged independent of the part body (Placement.legs).
+    if (cv.legId) legPins.push(n)
   }
 
   // normalize the SVG for inline rendering: strip width/height, keep viewBox
@@ -444,6 +449,7 @@ function extractView(fzp, view, srcRoot) {
     w: round(wPx != null ? wPx : vbw * sx),
     h: round(hPx != null ? hPx : vbh * sy),
     pins,
+    legs: legPins.length ? legPins : undefined,
     unresolved
   }
 }
@@ -586,7 +592,13 @@ function main() {
       if (!VIEW_DIR[view]) continue
       const res = extractView(fzp, view, srcRoot)
       if (res.skip) continue
-      def.views[view] = { svg: minifySvg(res.svg), w: res.w, h: res.h, pins: res.pins }
+      def.views[view] = {
+        svg: minifySvg(res.svg),
+        w: res.w,
+        h: res.h,
+        pins: res.pins,
+        ...(res.legs ? { legs: res.legs } : {})
+      }
       anyView = true
       if (res.unresolved && res.unresolved.length) anyUnresolved = true
     }
diff --git a/src/renderer/src/circuit/parts/fzpz.ts b/src/renderer/src/circuit/parts/fzpz.ts
index a9ab7df..ec87f74 100644
--- a/src/renderer/src/circuit/parts/fzpz.ts
+++ b/src/renderer/src/circuit/parts/fzpz.ts
@@ -27,7 +27,7 @@ export interface FzpzResult {
 interface FzpConnector {
   id: string
   name: string
-  views: Partial<Record<string, { svgId?: string; terminalId?: string }>>
+  views: Partial<Record<string, { svgId?: string; terminalId?: string; legId?: string }>>
 }
 
 interface Fzp {
@@ -188,7 +188,8 @@ function parseFzp(xml: string): Fzp {
         if (!p) continue
         views[vname] = {
           svgId: p.getAttribute('svgId') ?? undefined,
-          terminalId: p.getAttribute('terminalId') ?? undefined
+          terminalId: p.getAttribute('terminalId') ?? undefined,
+          legId: p.getAttribute('legId') ?? undefined
         }
       }
       connectors.push({ id, name: c.getAttribute('name') || id, views })
@@ -224,6 +225,7 @@ function extractView(
 
   const tag = VIEW_TAG[view]
   const pins: Record<string, [number, number]> = {}
+  const legPins: string[] = []
   const unresolved: string[] = []
   const usedNames = new Set<string>()
   for (const c of fzp.connectors) {
@@ -267,6 +269,9 @@ function extractView(
     while (usedNames.has(n)) n = `${name}.${i++}`
     usedNames.add(n)
     pins[n] = [round((pt.x - vbx) * sx), round((pt.y - vby) * sy)]
+    // bendable rubber-band leg (LED/resistor class parts) — see scripts/
+    // fritzing-import.mjs for the matching bulk-importer half of this.
+    if (cv.legId) legPins.push(n)
   }
   if (!Object.keys(pins).length) return null
 
@@ -281,7 +286,8 @@ function extractView(
       svg: svgStr,
       w: round(wPx != null ? wPx : vbw * sx),
       h: round(hPx != null ? hPx : vbh * sy),
-      pins
+      pins,
+      ...(legPins.length ? { legs: legPins } : {})
     },
     unresolved: unresolved.map((id) => `${view}: ${id}`)
   }
diff --git a/src/renderer/src/circuit/views/canvas/Canvas.tsx b/src/renderer/src/circuit/views/canvas/Canvas.tsx
index 8da2f24..3eda10d 100644
--- a/src/renderer/src/circuit/views/canvas/Canvas.tsx
+++ b/src/renderer/src/circuit/views/canvas/Canvas.tsx
@@ -486,6 +486,58 @@ export function Canvas({
     window.addEventListener('pointerup', up)
   }
 
+  // drag a bendable leg tip (LED/resistor class parts, breadboard view only —
+  // M2 leftover, spec §6.2/§7.4). `base` is the pin's leg offset at grab time
+  // ([0,0] if it was resting). Live-dispatches like onLabelDown (merged
+  // commands per move) so wires re-anchor to the tip in real time without a
+  // separate dragOverrides path — nothing else needs to know this isn't a
+  // normal edit. A real (>=3px) drag suppresses the trailing click so it
+  // doesn't also arm/complete a wire from this pin.
+  const beginLegDrag = (
+    e: React.PointerEvent,
+    partId: string,
+    pin: string,
+    base: [number, number]
+  ): void => {
+    const startClient = { x: e.clientX, y: e.clientY }
+    let moved = false
+    const move = (ev: PointerEvent): void => {
+      const dxs = (ev.clientX - startClient.x) / scale
+      const dys = (ev.clientY - startClient.y) / scale
+      if (!moved && Math.hypot(dxs, dys) < 3) return
+      moved = true
+      const cur = doc.parts.find((p) => p.id === partId)?.[view]
+      if (!cur) return
+      // legOffset is added to the local pin coord BEFORE rotate/flip
+      // (core/geometry pinWorld) — invert that so dragging the tip on
+      // screen moves it the direction the user is actually dragging.
+      const rad = (-(cur.rotate ?? 0) * Math.PI) / 180
+      let ldx = dxs * Math.cos(rad) - dys * Math.sin(rad)
+      let ldy = dxs * Math.sin(rad) + dys * Math.cos(rad)
+      if (cur.flip) ldx = -ldx
+      const next: [number, number] = [
+        Math.round((base[0] + ldx) * 100) / 100,
+        Math.round((base[1] + ldy) * 100) / 100
+      ]
+      store.dispatch(
+        cmd.placePart(
+          partId,
+          view,
+          { ...cur, legs: { ...(cur.legs ?? {}), [pin]: next } },
+          [],
+          true
+        )
+      )
+    }
+    const up = (): void => {
+      window.removeEventListener('pointermove', move)
+      window.removeEventListener('pointerup', up)
+      if (moved) suppressClick.current = true
+    }
+    window.addEventListener('pointermove', move)
+    window.addEventListener('pointerup', up)
+  }
+
   // drag / select a schematic net label (moves its sch placement + reroutes wires)
   const onNetLabelDown = (e: React.PointerEvent, id: string): void => {
     if ((e.target as HTMLElement).closest('.pin-hit')) return
@@ -1492,7 +1544,11 @@ export function Canvas({
                 {editable &&
                   Object.keys(vis.v.pins).length <= 60 &&
                   Object.keys(vis.v.pins).map((pin) => {
-                    const [px, py] = vis.v.pins[pin]
+                    const [restX, restY] = vis.v.pins[pin]
+                    const isLeg = view === 'bb' && (vis.v.legs?.includes(pin) ?? false)
+                    const legOff = isLeg ? pl.legs?.[pin] : undefined
+                    const px = restX + (legOff?.[0] ?? 0)
+                    const py = restY + (legOff?.[1] ?? 0)
                     const armedHere = armed?.from === `${part.id}:${pin}`
                     const hovered = hoverPin?.id === part.id && hoverPin?.pin === pin
                     const netIdx = netModel.pinToNet.get(`${part.id}:${pin}`)
@@ -1507,7 +1563,7 @@ export function Canvas({
                       <div
                         key={pin}
                         className="pin-hit"
-                        title={pin}
+                        title={isLeg ? `${pin} (drag to bend the leg)` : pin}
                         style={{
                           position: 'absolute',
                           left: px - 8,
@@ -1517,12 +1573,37 @@ export function Canvas({
                           zIndex: 3,
                           cursor: 'crosshair'
                         }}
-                        onPointerDown={(e) => e.stopPropagation()}
+                        onPointerDown={(e) => {
+                          e.stopPropagation()
+                          if (editable && isLeg && !armed)
+                            beginLegDrag(e, part.id, pin, legOff ?? [0, 0])
+                        }}
+                        onDoubleClick={(e) => {
+                          if (!editable || !isLeg || !legOff) return
+                          e.stopPropagation()
+                          const cur = doc.parts.find((p) => p.id === part.id)?.[view]
+                          if (!cur?.legs?.[pin]) return
+                          const legs = { ...cur.legs }
+                          delete legs[pin]
+                          store.dispatch(
+                            cmd.placePart(part.id, view, {
+                              ...cur,
+                              legs: Object.keys(legs).length ? legs : undefined
+                            })
+                          )
+                        }}
                         onPointerEnter={() => setHoverPin({ id: part.id, pin })}
                         onPointerLeave={() =>
                           setHoverPin((h) => (h?.id === part.id && h?.pin === pin ? null : h))
                         }
-                        onClick={(e) => onPinClick(e, part.id, pin)}
+                        onClick={(e) => {
+                          if (suppressClick.current) {
+                            suppressClick.current = false
+                            e.stopPropagation()
+                            return
+                          }
+                          onPinClick(e, part.id, pin)
+                        }}
                       >
                         <svg width="16" height="16">
                           {onHotNet && !on && (
@@ -1542,6 +1623,34 @@ export function Canvas({
                       </div>
                     )
                   })}
+                {view === 'bb' && vis.v.legs && vis.v.legs.length > 0 && (
+                  // bent-leg indicator: a simple ink line from the rest pin to
+                  // the dragged tip, overlaid on the (static) Fritzing art —
+                  // real per-instance leg-path warping is future work.
+                  <svg
+                    className="absolute inset-0 pointer-events-none overflow-visible"
+                    width={vis.v.w}
+                    height={vis.v.h}
+                  >
+                    {vis.v.legs.map((pin) => {
+                      const off = pl.legs?.[pin]
+                      if (!off || (off[0] === 0 && off[1] === 0)) return null
+                      const [rx, ry] = vis.v.pins[pin]
+                      return (
+                        <line
+                          key={pin}
+                          x1={rx}
+                          y1={ry}
+                          x2={rx + off[0]}
+                          y2={ry + off[1]}
+                          stroke="var(--text-strong)"
+                          strokeWidth={2}
+                          strokeLinecap="round"
+                        />
+                      )
+                    })}
+                  </svg>
+                )}
                 <div
                   className="absolute text-[11px] whitespace-nowrap select-none"
                   style={{
diff --git a/src/renderer/src/lib/partsLibrary.ts b/src/renderer/src/lib/partsLibrary.ts
index 5b35f7c..2a26c64 100644
--- a/src/renderer/src/lib/partsLibrary.ts
+++ b/src/renderer/src/lib/partsLibrary.ts
@@ -24,6 +24,9 @@ export interface PartView {
   w: number
   h: number
   pins: Record<string, [number, number]>
+  /** pin names with a bendable rubber-band leg in this view (Fritzing
+   * legId — LED/resistor class parts). Breadboard view only in practice. */
+  legs?: string[]
 }
 
 export interface PartDef {

From be71da3cb765aba1b73cc40fed0d201f21d786d7 Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Wed, 22 Jul 2026 14:39:30 -0600
Subject: [PATCH 23/27] Circuit v2 M2: parts-pack manager UI + GitHub index
 installer
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Closes the last M2-scope item: GitHub-distributed parts packs (spec §5.4,
Arduino Boards-Manager pattern), targeting the app's actual current pipeline
(legacy PartDef v1 + lib/userParts.ts persistence) rather than the unbuilt v2
registry the spec assumes.

- circuit/parts/packs.ts: fetchIndex/fetchManifest (shape-validated, relative
  URLs resolved against their own manifest/index), installPack (per-part
  fetch + saveUserPart, continues past individual failures, marks the pack
  installed only if >=1 part landed), index-URL list + installed-version
  settings in localStorage. DEFAULT_INDEX_URL points at the tinyparts repo
  the M2 decision log already named.
- circuit/views/packs/PackManager.tsx: modal (Components rail -> new package
  icon) — add/remove index URLs, per-pack Install/Update with progress and
  toast summaries.
- scripts/make-pack-index.mjs: wraps a scripts/fritzing-import.mjs output
  directory into pack.json + index.json — re-shapes the existing bulk
  importer's manifest, no new conversion logic.
- docs/tinyparts-pack-setup.md: full guide for Geoff to create/host the
  tinyparts repo by hand (layout, exact JSON schemas, the generator command,
  local testing, ATTRIBUTION requirement per the M0 licensing decision, and
  an explicit 'not done' list — no hash verification, no launch-time update
  check, no zip hosting).

Verified two ways: 7 unit tests (packs.test.ts — index/manifest validation,
relative-URL resolution, partial-failure install, settings) against mocked
fetch/localStorage, AND a real end-to-end smoke test (not part of the
suite): ran make-pack-index.mjs against the app's actual bundled 29-part
catalogue, served the output over a plain local HTTP server, and installed
it through the real packs.ts client — 29/29 installed, 0 failures.

npm run typecheck (node+web) clean; test:circuit 114/114.
---
 docs/tinyparts-pack-setup.md                  | 133 ++++++++++
 scripts/make-pack-index.mjs                   |  98 +++++++
 .../src/circuit/__tests__/packs.test.ts       | 163 ++++++++++++
 src/renderer/src/circuit/parts/packs.ts       | 191 ++++++++++++++
 .../src/circuit/views/CircuitView.tsx         |   7 +
 .../src/circuit/views/packs/PackManager.tsx   | 247 ++++++++++++++++++
 .../src/circuit/views/palette/Palette.tsx     |  13 +-
 7 files changed, 850 insertions(+), 2 deletions(-)
 create mode 100644 docs/tinyparts-pack-setup.md
 create mode 100644 scripts/make-pack-index.mjs
 create mode 100644 src/renderer/src/circuit/__tests__/packs.test.ts
 create mode 100644 src/renderer/src/circuit/parts/packs.ts
 create mode 100644 src/renderer/src/circuit/views/packs/PackManager.tsx

diff --git a/docs/tinyparts-pack-setup.md b/docs/tinyparts-pack-setup.md
new file mode 100644
index 0000000..92a9349
--- /dev/null
+++ b/docs/tinyparts-pack-setup.md
@@ -0,0 +1,133 @@
+# Setting up the `tinyparts` parts-pack repo
+
+**Audience:** Geoff, setting up GitHub distribution for circuit parts (M2 leftover, spec §5.4). The app-side pack manager (Parts Packs button in the Circuit view's Components rail) and installer logic already ship — this doc is the other half: how to host something for it to install.
+
+**Status:** the client (`circuit/parts/packs.ts` + `circuit/views/packs/PackManager.tsx`) is done, tested, and verified end-to-end against a real local server serving real `fritzing-import.mjs` output (29/29 parts installed with zero failures). What's below is entirely repo/hosting setup on your end — no app code needed.
+
+## Why this exists
+
+The app already has ~29 Fritzing-derived parts bundled in (`src/renderer/src/assets/parts/`) plus whatever a user imports via `.fzpz` drag-and-drop or authors in the Parts Editor (both persist locally via IndexedDB — that part's been working since M2). What's been missing is a way to *distribute* a curated, larger catalogue without bloating the app download — exactly Arduino's "Boards Manager" pattern: a small index.json the app polls, pointing at packs it can fetch on demand.
+
+## 1. Create the repo
+
+```
+Mister-Industries/tinyparts   (per the M2 decision log — this is the name/org the app defaults to)
+```
+
+Public repo, any license note you want at the top level (the parts themselves need their own attribution — see §4).
+
+## 2. Layout
+
+```
+tinyparts/
+  index.json                       # top-level: lists every pack
+  packs/
+    tinystudio-core/
+      pack.json                    # this pack's manifest
+      ATTRIBUTION.md                # required if it includes Fritzing CC-BY-SA art
+      parts/
+        resistor.json
+        led-generic-5mm.json
+        ...
+    some-other-pack/
+      pack.json
+      parts/...
+```
+
+Nothing here needs a build step or CI to work — the app fetches `index.json` and each `pack.json` directly as **raw GitHub URLs**:
+
+```
+https://raw.githubusercontent.com/Mister-Industries/tinyparts/main/index.json
+```
+
+That URL is already the app's built-in default (`DEFAULT_INDEX_URL` in `circuit/parts/packs.ts`) — once it's live at that path, every install of the app picks it up automatically the next time someone opens the Parts Packs panel. No app update needed to add/update packs later.
+
+## 3. File formats (exactly what the app expects)
+
+**`index.json`** (repo root):
+
+```json
+{
+  "schema": 1,
+  "packs": [
+    {
+      "id": "tinystudio-core",
+      "name": "tinyStudio Core Parts",
+      "version": "1.0.0",
+      "description": "Curated Fritzing-derived parts for breadboard + schematic.",
+      "url": "packs/tinystudio-core/pack.json"
+    }
+  ]
+}
+```
+
+`url` may be relative (resolved against `index.json`'s own URL) or absolute — relative is simplest and is what the generator script below produces.
+
+**`packs/<id>/pack.json`**:
+
+```json
+{
+  "schema": 1,
+  "id": "tinystudio-core",
+  "name": "tinyStudio Core Parts",
+  "version": "1.0.0",
+  "description": "Curated Fritzing-derived parts for breadboard + schematic.",
+  "parts": [
+    { "type": "resistor", "file": "parts/resistor.json" },
+    { "type": "led-generic-5mm", "file": "parts/led-generic-5mm.json" }
+  ]
+}
+```
+
+Each `file` is a **plain `PartDef`** — literally the same JSON shape `scripts/fritzing-import.mjs` and the in-app `.fzpz` importer already produce (`{ type, label, family, icon?, views: { breadboard?, schematic? } }`). If you can drop a `.fzpz` on the canvas and see it appear, that same converted JSON is installable as a pack part with zero changes.
+
+Bumping `version` in both `index.json` and the pack's own `pack.json` is what makes the app's Parts Packs panel show "Update" instead of "Install" — there's no other versioning magic, just a string compare.
+
+## 4. Generating a pack from a `fritzing-parts` checkout
+
+You already have the tool for the hard part (SVG/transform resolution) — `scripts/fritzing-import.mjs` in this repo. A new small script, `scripts/make-pack-index.mjs`, wraps its output into the pack format above:
+
+```bash
+# 1. Convert Fritzing parts the usual way (see docs/circuit-architecture-and-roadmap.md Part IV)
+node scripts/fritzing-import.mjs \
+  --src /path/to/fritzing-parts \
+  --out /tmp/converted-parts \
+  --all --views breadboard,schematic
+
+# 2. Wrap that output into a pack, writing straight into your tinyparts checkout
+node scripts/make-pack-index.mjs \
+  --parts /tmp/converted-parts \
+  --out   /path/to/tinyparts \
+  --id    tinystudio-core \
+  --name  "tinyStudio Core Parts" \
+  --version 1.0.0 \
+  --description "Curated Fritzing-derived parts for breadboard + schematic"
+
+# 3. Review, commit, push
+cd /path/to/tinyparts
+git add -A && git commit -m "tinystudio-core 1.0.0" && git push
+```
+
+`make-pack-index.mjs` is additive and idempotent — re-running it with a bumped `--version` overwrites that pack's `pack.json` + copies the (re-converted) part files, and updates just that pack's entry in the top-level `index.json` (other packs already listed there are left alone). Running it with a new `--id` adds a second pack alongside the first.
+
+This was smoke-tested end-to-end against the app's real bundled catalogue (`src/renderer/src/assets/parts/`, 29 parts) — served over a plain local HTTP server and installed through the actual `packs.ts` client with 0 failures — so the format round-trip is verified; the only unverified step is the real `raw.githubusercontent.com` fetch once it's actually published (can't reach the public internet from here to confirm, but it's the same `fetch()` path, just a different origin).
+
+## 5. Trying it in the app before/without publishing
+
+Point the Parts Packs panel (Components rail → the package icon) at anything reachable, including `http://localhost:<port>/index.json` if you serve the folder locally (`npx http-server ./tinyparts`) — handy for checking a pack before pushing. The default index URL is pre-filled, but you can add/remove index URLs freely; they persist in `localStorage` (`tinystudio.packs.indexUrls`).
+
+## 6. Licensing (per the M0 decision log)
+
+> Fritzing CC-BY-SA art OK with per-pack ATTRIBUTION; behaviors (not code) ported from GPLv3 fritzing-app; tinyStudio is GPL-3.0 so either is compatible.
+
+Concretely: any pack containing Fritzing-derived SVGs needs an `ATTRIBUTION.md` alongside its `pack.json` crediting the Fritzing project (and any part-specific authors the source `.fzp` names) under CC-BY-SA. Packs you author entirely yourself don't need this.
+
+## 7. Optional: CI validation
+
+Not required to ship the first pack, but worth adding once there's more than one contributor: a GitHub Action that runs `node -e "JSON.parse(require('fs').readFileSync('index.json'))"` (and the same over every `pack.json`) on push, so a malformed JSON commit fails CI instead of silently breaking every user's install. `scripts/test-circuit.mjs` in this repo is a reasonable model for "zero-dependency Node script as the CI gate" if you want the same style.
+
+## What's NOT done (be aware)
+
+- **No signature/hash verification** on install (spec §5.4 mentions `sha256`) — the client trusts whatever the index/pack JSON says. Fine for a single maintained repo; revisit if this ever accepts third-party pack submissions.
+- **No update-check-on-launch** — installing/updating is manual (open Parts Packs, click Install/Update). The panel does show "vX installed" vs. the index's version so staleness is visible, just not proactively surfaced elsewhere in the UI.
+- **No zip-based hosting** — packs are raw JSON files fetched individually (one request per part on install). Fine at tens of parts; if a pack grows into the thousands, revisit (bundle as a zip + the existing `parts/zip.ts` unzip-in-renderer code, already used for `.fzpz`, could be reused).
diff --git a/scripts/make-pack-index.mjs b/scripts/make-pack-index.mjs
new file mode 100644
index 0000000..1352d5d
--- /dev/null
+++ b/scripts/make-pack-index.mjs
@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+/**
+ * make-pack-index.mjs — wrap a scripts/fritzing-import.mjs output directory
+ * into a tinyStudio parts pack (pack.json + parts/*.json) plus a repo-level
+ * index.json, ready to publish as the raw contents of a GitHub repo. See
+ * docs/tinyparts-pack-setup.md for the full walkthrough.
+ *
+ * fritzing-import.mjs already writes flat per-part JSON + its own index.json
+ * manifest ({ parts: [{ type, file, ... }] }) — this script just re-shapes
+ * that manifest into circuit/parts/packs.ts's pack.json format and copies
+ * the part files alongside it, merging into (or creating) the repo's
+ * top-level index.json so multiple packs can coexist.
+ *
+ * Usage:
+ *   node scripts/make-pack-index.mjs \
+ *     --parts src/renderer/src/assets/parts \   # fritzing-import.mjs output (has index.json)
+ *     --out   ../tinyparts \                    # the tinyparts repo checkout
+ *     --id    tinystudio-core \
+ *     --name  "tinyStudio Core Parts" \
+ *     --version 1.0.0 \
+ *     --description "Curated Fritzing-derived parts for breadboard + schematic"
+ */
+import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+function parseArgs(argv) {
+  const a = {}
+  for (let i = 0; i < argv.length; i++) {
+    const t = argv[i]
+    const next = () => argv[++i]
+    if (t === '--parts') a.parts = next()
+    else if (t === '--out') a.out = next()
+    else if (t === '--id') a.id = next()
+    else if (t === '--name') a.name = next()
+    else if (t === '--version') a.version = next()
+    else if (t === '--description') a.description = next()
+    else if (t === '--help' || t === '-h') a.help = true
+  }
+  return a
+}
+
+const args = parseArgs(process.argv.slice(2))
+if (args.help || !args.parts || !args.out || !args.id || !args.name || !args.version) {
+  console.log(`Usage: node scripts/make-pack-index.mjs --parts <dir> --out <dir> --id <id> --name "<name>" --version <semver> [--description "..."]
+
+  --parts   output directory of a prior fritzing-import.mjs run (must contain index.json)
+  --out     the tinyparts repo checkout to write/update (index.json + packs/<id>/)
+  --id      pack id, e.g. tinystudio-core
+  --name    display name, e.g. "tinyStudio Core Parts"
+  --version semver, e.g. 1.0.0
+`)
+  process.exit(args.help ? 0 : 1)
+}
+
+const manifestPath = join(args.parts, 'index.json')
+if (!existsSync(manifestPath)) {
+  console.error(`No index.json in ${args.parts} — run scripts/fritzing-import.mjs first.`)
+  process.exit(1)
+}
+const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'))
+
+const packDir = join(args.out, 'packs', args.id)
+mkdirSync(join(packDir, 'parts'), { recursive: true })
+
+const parts = []
+for (const p of manifest.parts) {
+  cpSync(join(args.parts, p.file), join(packDir, 'parts', p.file))
+  parts.push({ type: p.type, file: `parts/${p.file}` })
+}
+
+const pack = {
+  schema: 1,
+  id: args.id,
+  name: args.name,
+  version: args.version,
+  ...(args.description ? { description: args.description } : {}),
+  parts
+}
+writeFileSync(join(packDir, 'pack.json'), JSON.stringify(pack, null, 2))
+
+const indexPath = join(args.out, 'index.json')
+const index = existsSync(indexPath)
+  ? JSON.parse(readFileSync(indexPath, 'utf8'))
+  : { schema: 1, packs: [] }
+const entry = {
+  id: args.id,
+  name: args.name,
+  version: args.version,
+  ...(args.description ? { description: args.description } : {}),
+  url: `packs/${args.id}/pack.json`
+}
+const i = index.packs.findIndex((p) => p.id === args.id)
+if (i >= 0) index.packs[i] = entry
+else index.packs.push(entry)
+writeFileSync(indexPath, JSON.stringify(index, null, 2))
+
+console.log(`Wrote ${packDir}/pack.json (${parts.length} parts)`)
+console.log(`Updated ${indexPath} (${index.packs.length} pack${index.packs.length === 1 ? '' : 's'} listed)`)
diff --git a/src/renderer/src/circuit/__tests__/packs.test.ts b/src/renderer/src/circuit/__tests__/packs.test.ts
new file mode 100644
index 0000000..c4133bd
--- /dev/null
+++ b/src/renderer/src/circuit/__tests__/packs.test.ts
@@ -0,0 +1,163 @@
+/** Tests for parts/packs — index/manifest fetch+validate, install, settings.
+ * Network (fetch) and localStorage are stubbed; registerPart/getPart are the
+ * real in-memory registry (no DOM needed), so installPack is exercised
+ * end-to-end against it. */
+
+import assert from 'node:assert/strict'
+import { beforeEach, test } from 'node:test'
+import { getPart } from '../../lib/partsLibrary'
+import {
+  DEFAULT_INDEX_URL,
+  fetchIndex,
+  fetchManifest,
+  getIndexUrls,
+  getInstalledPacks,
+  installPack,
+  setIndexUrls,
+  type PackManifest
+} from '../parts/packs'
+
+// ── in-memory localStorage stub (Node has no browser globals) ──────────────
+
+class MemoryStorage {
+  private map = new Map<string, string>()
+  getItem(k: string): string | null {
+    return this.map.has(k) ? this.map.get(k)! : null
+  }
+  setItem(k: string, v: string): void {
+    this.map.set(k, v)
+  }
+  removeItem(k: string): void {
+    this.map.delete(k)
+  }
+  clear(): void {
+    this.map.clear()
+  }
+}
+;(globalThis as unknown as { localStorage: MemoryStorage }).localStorage = new MemoryStorage()
+
+beforeEach(() => {
+  ;(globalThis as unknown as { localStorage: MemoryStorage }).localStorage.clear()
+})
+
+// ── fetch stub ───────────────────────────────────────────────────────────────
+
+function stubFetch(routes: Record<string, unknown | (() => unknown) | { status: number }>): void {
+  ;(globalThis as unknown as { fetch: typeof fetch }).fetch = (async (
+    url: string
+  ): Promise<Response> => {
+    const hit = routes[url]
+    if (hit === undefined) return { ok: false, status: 404, json: async () => ({}) } as Response
+    if (typeof hit === 'object' && hit !== null && 'status' in hit && !('json' in hit)) {
+      return { ok: false, status: (hit as { status: number }).status, json: async () => ({}) } as Response
+    }
+    const body = typeof hit === 'function' ? (hit as () => unknown)() : hit
+    return { ok: true, status: 200, json: async () => body } as Response
+  }) as typeof fetch
+}
+
+// ── fetchIndex / fetchManifest ───────────────────────────────────────────────
+
+test('fetchIndex resolves each pack.url relative to the index url', async () => {
+  stubFetch({
+    'https://example.com/sub/index.json': {
+      schema: 1,
+      packs: [{ id: 'core', name: 'Core', version: '1.0.0', url: 'pack.json' }]
+    }
+  })
+  const idx = await fetchIndex('https://example.com/sub/index.json')
+  assert.equal(idx.packs.length, 1)
+  assert.equal(idx.packs[0].url, 'https://example.com/sub/pack.json')
+})
+
+test('fetchIndex rejects a response that is not { packs: [...] }', async () => {
+  stubFetch({ 'https://example.com/bad.json': { oops: true } })
+  await assert.rejects(() => fetchIndex('https://example.com/bad.json'), /not a valid pack index/)
+})
+
+test('fetchIndex surfaces a readable error on HTTP failure (unpublished repo)', async () => {
+  stubFetch({ [DEFAULT_INDEX_URL]: { status: 404 } })
+  await assert.rejects(() => fetchIndex(DEFAULT_INDEX_URL), /HTTP 404/)
+})
+
+test('fetchManifest validates { id, parts: [...] } shape', async () => {
+  stubFetch({
+    'https://example.com/pack.json': {
+      schema: 1,
+      id: 'core',
+      name: 'Core',
+      version: '1.0.0',
+      parts: [{ type: 'resistor', file: 'parts/resistor.json' }]
+    },
+    'https://example.com/bad.json': { name: 'no id or parts' }
+  })
+  const man = await fetchManifest('https://example.com/pack.json')
+  assert.equal(man.id, 'core')
+  await assert.rejects(() => fetchManifest('https://example.com/bad.json'), /not a valid pack manifest/)
+})
+
+// ── installPack ──────────────────────────────────────────────────────────────
+
+const RESISTOR_DEF = {
+  type: 'pack-test-resistor',
+  label: 'Resistor',
+  family: 'Passive',
+  views: { breadboard: { svg: '<svg/>', w: 10, h: 10, pins: { '1': [0, 5], '2': [10, 5] } } }
+}
+
+test('installPack registers every valid part via saveUserPart, continues past one bad part', async () => {
+  const manifest: PackManifest = {
+    schema: 1,
+    id: 'core',
+    name: 'Core',
+    version: '2.0.0',
+    parts: [
+      { type: 'pack-test-resistor', file: 'parts/resistor.json' },
+      { type: 'pack-test-missing', file: 'parts/missing.json' }, // 404
+      { type: 'pack-test-malformed', file: 'parts/malformed.json' } // not a PartDef
+    ]
+  }
+  stubFetch({
+    'https://example.com/parts/resistor.json': RESISTOR_DEF,
+    'https://example.com/parts/malformed.json': { not: 'a part' }
+    // parts/missing.json intentionally absent -> 404
+  })
+  const progress: [number, number][] = []
+  const res = await installPack(manifest, 'https://example.com/pack.json', (done, total) =>
+    progress.push([done, total])
+  )
+  assert.deepEqual(res.installed, ['pack-test-resistor'])
+  assert.equal(res.failed.length, 2)
+  assert.ok(res.failed.some((f) => f.type === 'pack-test-missing' && /HTTP 404/.test(f.error)))
+  assert.ok(res.failed.some((f) => f.type === 'pack-test-malformed'))
+  assert.equal(progress.length, 3)
+  assert.deepEqual(progress[2], [3, 3])
+
+  // the successfully-installed part is live in the registry
+  assert.ok(getPart('pack-test-resistor'))
+
+  // a pack with at least one success is marked installed at its version
+  assert.equal(getInstalledPacks().core, '2.0.0')
+})
+
+test('installPack does not mark a pack installed when every part fails', async () => {
+  const manifest: PackManifest = {
+    schema: 1,
+    id: 'all-bad',
+    name: 'All Bad',
+    version: '9.9.9',
+    parts: [{ type: 'x', file: 'x.json' }]
+  }
+  stubFetch({}) // everything 404s
+  const res = await installPack(manifest, 'https://example.com/pack.json')
+  assert.equal(res.installed.length, 0)
+  assert.equal(getInstalledPacks()['all-bad'], undefined)
+})
+
+// ── settings (index URL list) ───────────────────────────────────────────────
+
+test('getIndexUrls defaults to the tinyparts index; setIndexUrls persists a custom list', () => {
+  assert.deepEqual(getIndexUrls(), [DEFAULT_INDEX_URL])
+  setIndexUrls(['https://example.com/a.json', 'https://example.com/b.json'])
+  assert.deepEqual(getIndexUrls(), ['https://example.com/a.json', 'https://example.com/b.json'])
+})
diff --git a/src/renderer/src/circuit/parts/packs.ts b/src/renderer/src/circuit/parts/packs.ts
new file mode 100644
index 0000000..e3a1479
--- /dev/null
+++ b/src/renderer/src/circuit/parts/packs.ts
@@ -0,0 +1,191 @@
+/**
+ * circuit/parts/packs — GitHub-distributed parts packs (M2 leftover, spec
+ * §5.3/§5.4, "Boards-Manager pattern").
+ *
+ * This targets the app's ACTUAL current parts pipeline — the legacy
+ * `lib/partsLibrary` PartDef (v1) persisted via `lib/userParts.ts` (B7) —
+ * not the aspirational v2 `registry.ts`/pack.json-with-zips design in the
+ * spec, which needs the still-unbuilt M2 parts registry migration first. A
+ * pack here is just a manifest of hosted PartDef v1 JSON files (exactly
+ * what `scripts/fritzing-import.mjs` / the in-app `.fzpz` importer already
+ * emit); installing one calls the same `saveUserPart` every other part
+ * source uses. See docs/tinyparts-pack-setup.md for how to host one.
+ *
+ * Formats:
+ *   index.json  { schema: 1, packs: [{ id, name, version, description?, url }] }
+ *   pack.json   { schema: 1, id, name, version, parts: [{ type, file }] }
+ *   parts/*.json  a plain PartDef (registerPart-compatible)
+ *
+ * `file`/`url` may be relative — resolved against the manifest/index's own
+ * URL, so a pack can ship as a self-contained folder of relative paths.
+ */
+
+import type { PartDef } from '../../lib/partsLibrary'
+import { saveUserPart } from '../../lib/userParts'
+
+export interface PackIndexEntry {
+  id: string
+  name: string
+  version: string
+  description?: string
+  url: string
+}
+
+export interface PackIndex {
+  schema: number
+  packs: PackIndexEntry[]
+}
+
+export interface PackPartRef {
+  type: string
+  file: string
+}
+
+export interface PackManifest {
+  schema: number
+  id: string
+  name: string
+  version: string
+  description?: string
+  parts: PackPartRef[]
+}
+
+/** Seeded per the M2 decision log ("new tinyparts repo under
+ * Mister-Industries"); harmless to fetch — a 404 just surfaces as an error
+ * row in the UI until the repo/index is published. */
+export const DEFAULT_INDEX_URL =
+  'https://raw.githubusercontent.com/Mister-Industries/tinyparts/main/index.json'
+
+const LS_INDEX_URLS = 'tinystudio.packs.indexUrls'
+const LS_INSTALLED = 'tinystudio.packs.installed'
+
+function resolveUrl(file: string, base: string): string {
+  try {
+    return new URL(file, base).toString()
+  } catch {
+    return file
+  }
+}
+
+async function fetchJson(url: string): Promise<unknown> {
+  let res: Response
+  try {
+    res = await fetch(url, { cache: 'no-store' })
+  } catch (e) {
+    throw new Error(`network error fetching ${url}: ${e instanceof Error ? e.message : String(e)}`)
+  }
+  if (!res.ok) throw new Error(`${url} → HTTP ${res.status}`)
+  try {
+    return await res.json()
+  } catch {
+    throw new Error(`${url} did not return valid JSON`)
+  }
+}
+
+export async function fetchIndex(url: string): Promise<PackIndex> {
+  const json = await fetchJson(url)
+  if (!json || typeof json !== 'object' || !Array.isArray((json as PackIndex).packs))
+    throw new Error(`${url} is not a valid pack index (expected { packs: [...] })`)
+  const idx = json as PackIndex
+  // resolve each pack's manifest url relative to the index itself
+  return { ...idx, packs: idx.packs.map((p) => ({ ...p, url: resolveUrl(p.url, url) })) }
+}
+
+export async function fetchManifest(url: string): Promise<PackManifest> {
+  const json = await fetchJson(url)
+  if (
+    !json ||
+    typeof json !== 'object' ||
+    typeof (json as PackManifest).id !== 'string' ||
+    !Array.isArray((json as PackManifest).parts)
+  )
+    throw new Error(`${url} is not a valid pack manifest (expected { id, parts: [...] })`)
+  return json as PackManifest
+}
+
+function isPartDef(v: unknown): v is PartDef {
+  return (
+    !!v &&
+    typeof v === 'object' &&
+    typeof (v as PartDef).type === 'string' &&
+    typeof (v as PartDef).label === 'string' &&
+    !!(v as PartDef).views &&
+    typeof (v as PartDef).views === 'object'
+  )
+}
+
+export interface InstallResult {
+  installed: string[]
+  failed: { type: string; error: string }[]
+}
+
+/** Install every part in a manifest via the existing saveUserPart path
+ * (registers + persists to IndexedDB, same as the Parts Editor / .fzpz
+ * import). Continues past individual part failures. */
+export async function installPack(
+  manifest: PackManifest,
+  manifestUrl: string,
+  onProgress?: (done: number, total: number) => void
+): Promise<InstallResult> {
+  const installed: string[] = []
+  const failed: { type: string; error: string }[] = []
+  let done = 0
+  for (const ref of manifest.parts) {
+    try {
+      const url = resolveUrl(ref.file, manifestUrl)
+      const json = await fetchJson(url)
+      if (!isPartDef(json)) throw new Error(`${url} is not a valid part definition`)
+      await saveUserPart(json)
+      installed.push(ref.type)
+    } catch (e) {
+      failed.push({ type: ref.type, error: e instanceof Error ? e.message : String(e) })
+    } finally {
+      done++
+      onProgress?.(done, manifest.parts.length)
+    }
+  }
+  if (installed.length) markInstalled(manifest.id, manifest.version)
+  return { installed, failed }
+}
+
+// ── settings (index URL list + installed-version tracking) ─────────────────
+
+export function getIndexUrls(): string[] {
+  try {
+    const raw = localStorage.getItem(LS_INDEX_URLS)
+    if (!raw) return [DEFAULT_INDEX_URL]
+    const parsed = JSON.parse(raw)
+    return Array.isArray(parsed) && parsed.every((u) => typeof u === 'string')
+      ? parsed
+      : [DEFAULT_INDEX_URL]
+  } catch {
+    return [DEFAULT_INDEX_URL]
+  }
+}
+
+export function setIndexUrls(urls: string[]): void {
+  try {
+    localStorage.setItem(LS_INDEX_URLS, JSON.stringify(urls))
+  } catch {
+    /* quota / privacy mode — session-only */
+  }
+}
+
+export function getInstalledPacks(): Record<string, string> {
+  try {
+    const raw = localStorage.getItem(LS_INSTALLED)
+    return raw ? (JSON.parse(raw) as Record<string, string>) : {}
+  } catch {
+    return {}
+  }
+}
+
+function markInstalled(id: string, version: string): void {
+  const map = getInstalledPacks()
+  map[id] = version
+  try {
+    localStorage.setItem(LS_INSTALLED, JSON.stringify(map))
+  } catch {
+    /* quota / privacy mode */
+  }
+}
diff --git a/src/renderer/src/circuit/views/CircuitView.tsx b/src/renderer/src/circuit/views/CircuitView.tsx
index 12a8828..26b2fb9 100644
--- a/src/renderer/src/circuit/views/CircuitView.tsx
+++ b/src/renderer/src/circuit/views/CircuitView.tsx
@@ -46,6 +46,7 @@ import { CircuitStore } from '../core/store'
 import { BREADBOARDS, generateBreadboard, isBreadboard } from '../parts/breadboard'
 import { SIM_SOURCES, generateSimSource, simSourceDefaultAttrs } from '../parts/simParts'
 import { SIM_PROBES, generateSimProbe, simProbeDefaultAttrs } from '../parts/simProbes'
+import { PackManager } from './packs/PackManager'
 import { snapNetLabel } from '../parts/netLabels'
 import { Canvas, emptySel, type Cam, type CanvasHandle, type Selection } from './canvas/Canvas'
 import { exportPng, exportSvg } from './exportImage'
@@ -90,6 +91,7 @@ export function CircuitViewV2({
   const [wireColor, setWireColor] = React.useState(WIRE_COLORS[0])
   const [cam, setCam] = React.useState<Cam>({ scale: 1, tx: 40, ty: 40 })
   const [editorPart, setEditorPart] = React.useState<PartDef | null | undefined>(undefined)
+  const [showPacks, setShowPacks] = React.useState(false)
   const [showErc, setShowErc] = React.useState(false)
   const [showSim, setShowSim] = React.useState(false)
   const [sim, setSim] = React.useState<SimState>({ run: null, netlist: null })
@@ -328,6 +330,7 @@ export function CircuitViewV2({
           onAddNetLabel={(kind, name) => addNetLabel(kind as NetLabelKind, name)}
           onEditPart={(type) => void editExisting(type)}
           onNewPart={() => setEditorPart(null)}
+          onOpenPacks={() => setShowPacks(true)}
         />
       )}
 
@@ -601,6 +604,10 @@ export function CircuitViewV2({
           }}
         />
       )}
+
+      {showPacks && (
+        <PackManager onClose={() => setShowPacks(false)} onInstalled={() => bumpDefs()} />
+      )}
     </div>
   )
 }
diff --git a/src/renderer/src/circuit/views/packs/PackManager.tsx b/src/renderer/src/circuit/views/packs/PackManager.tsx
new file mode 100644
index 0000000..ca2700b
--- /dev/null
+++ b/src/renderer/src/circuit/views/packs/PackManager.tsx
@@ -0,0 +1,247 @@
+/**
+ * circuit/views/packs/PackManager — GitHub parts-pack installer UI (M2
+ * leftover, spec §5.4 "Boards-Manager pattern"). See parts/packs.ts for the
+ * fetch/validate/install logic and docs/tinyparts-pack-setup.md for how to
+ * host an index + packs.
+ *
+ * Settings → Parts Libraries in spirit, but scoped into the Circuit view
+ * since that's the only place parts matter today: a list of index URLs
+ * (add/remove, persisted), each expanding to its packs with an
+ * Install/Update button and per-part progress + failure summary.
+ */
+
+import { Download, Loader2, Package, Plus, RefreshCw, TriangleAlert, X } from 'lucide-react'
+import React from 'react'
+import { toast } from 'sonner'
+import {
+  fetchIndex,
+  fetchManifest,
+  getIndexUrls,
+  getInstalledPacks,
+  installPack,
+  setIndexUrls,
+  type PackIndexEntry
+} from '../../parts/packs'
+
+interface IndexState {
+  loading: boolean
+  error?: string
+  packs: PackIndexEntry[]
+}
+
+export function PackManager({
+  onClose,
+  onInstalled
+}: {
+  onClose: () => void
+  /** a part landed in the registry — caller should re-resolve/refresh */
+  onInstalled: () => void
+}): React.JSX.Element {
+  const [urls, setUrls] = React.useState<string[]>(() => getIndexUrls())
+  const [newUrl, setNewUrl] = React.useState('')
+  const [entries, setEntries] = React.useState<Record<string, IndexState>>({})
+  const [installing, setInstalling] = React.useState<string | null>(null)
+  const [progress, setProgress] = React.useState<{ done: number; total: number } | null>(null)
+  const [installed, setInstalled] = React.useState(() => getInstalledPacks())
+
+  const refreshIndex = React.useCallback((url: string) => {
+    setEntries((e) => ({ ...e, [url]: { loading: true, packs: e[url]?.packs ?? [] } }))
+    fetchIndex(url)
+      .then((idx) => setEntries((e) => ({ ...e, [url]: { loading: false, packs: idx.packs } })))
+      .catch((err) =>
+        setEntries((e) => ({
+          ...e,
+          [url]: { loading: false, error: err instanceof Error ? err.message : String(err), packs: [] }
+        }))
+      )
+  }, [])
+
+  React.useEffect(() => {
+    for (const url of urls) refreshIndex(url)
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [])
+
+  const addUrl = (): void => {
+    const u = newUrl.trim()
+    if (!u || urls.includes(u)) return
+    const next = [...urls, u]
+    setUrls(next)
+    setIndexUrls(next)
+    setNewUrl('')
+    refreshIndex(u)
+  }
+
+  const removeUrl = (u: string): void => {
+    const next = urls.filter((x) => x !== u)
+    setUrls(next)
+    setIndexUrls(next)
+    setEntries((e) => {
+      const n = { ...e }
+      delete n[u]
+      return n
+    })
+  }
+
+  const install = async (pack: PackIndexEntry): Promise<void> => {
+    setInstalling(pack.id)
+    setProgress(null)
+    try {
+      const manifest = await fetchManifest(pack.url)
+      const res = await installPack(manifest, pack.url, (done, total) => setProgress({ done, total }))
+      setInstalled(getInstalledPacks())
+      if (res.installed.length) onInstalled()
+      if (res.failed.length) {
+        toast.error(`${pack.name}: ${res.installed.length} installed, ${res.failed.length} failed`, {
+          description: res.failed
+            .slice(0, 4)
+            .map((f) => `${f.type}: ${f.error}`)
+            .join('\n')
+        })
+      } else {
+        toast.success(`${pack.name} v${manifest.version} installed`, {
+          description: `${res.installed.length} part${res.installed.length === 1 ? '' : 's'}`
+        })
+      }
+    } catch (err) {
+      toast.error(`Couldn't install ${pack.name}`, {
+        description: err instanceof Error ? err.message : String(err)
+      })
+    } finally {
+      setInstalling(null)
+      setProgress(null)
+    }
+  }
+
+  const field =
+    'flex-1 bg-bg-sunken border border-border-default rounded px-2 py-1.5 text-xs text-text-strong outline-none focus:border-brand'
+
+  return (
+    <div
+      className="fixed inset-0 z-50 flex items-center justify-center"
+      style={{ background: 'var(--scrim)', backdropFilter: 'blur(3px)' }}
+      onClick={onClose}
+    >
+      <div
+        className="w-[640px] max-w-[94vw] h-[560px] max-h-[90vh] bg-surface-overlay border border-border-default rounded-xl flex flex-col overflow-hidden"
+        style={{ boxShadow: 'var(--shadow-soft-lg)' }}
+        onClick={(e) => e.stopPropagation()}
+      >
+        <div className="flex items-center gap-2 px-4 py-3 border-b border-border-default">
+          <Package size={16} className="text-brand" />
+          <span className="text-text-strong font-semibold">Parts Packs</span>
+          <span className="text-[11px] text-text-muted">
+            install additional components from a GitHub-hosted index
+          </span>
+          <div className="flex-1" />
+          <button className="text-text-muted hover:text-text-strong" onClick={onClose}>
+            <X size={18} />
+          </button>
+        </div>
+
+        <div className="flex items-center gap-2 px-4 py-2.5 border-b border-border-default shrink-0">
+          <input
+            className={field}
+            placeholder="https://raw.githubusercontent.com/<org>/<repo>/main/index.json"
+            value={newUrl}
+            onChange={(e) => setNewUrl(e.target.value)}
+            onKeyDown={(e) => e.key === 'Enter' && addUrl()}
+          />
+          <button
+            className="h-7 px-2.5 rounded-md bg-brand text-white text-xs font-medium hover:bg-brand/90 flex items-center gap-1"
+            onClick={addUrl}
+          >
+            <Plus size={13} /> Add index
+          </button>
+        </div>
+
+        <div className="flex-1 min-h-0 overflow-y-auto p-3 flex flex-col gap-3">
+          {urls.length === 0 && (
+            <div className="text-text-faint text-xs px-1">
+              No index URLs configured. Add one above to browse installable parts packs.
+            </div>
+          )}
+          {urls.map((url) => {
+            const state = entries[url]
+            return (
+              <div key={url} className="rounded-lg border border-border-default overflow-hidden">
+                <div className="flex items-center gap-2 px-3 py-1.5 bg-bg-sunken">
+                  <span className="text-[11px] text-text-muted font-mono truncate flex-1" title={url}>
+                    {url}
+                  </span>
+                  <button
+                    className="text-text-faint hover:text-text-body"
+                    title="Refresh"
+                    onClick={() => refreshIndex(url)}
+                  >
+                    <RefreshCw size={12} className={state?.loading ? 'animate-spin' : ''} />
+                  </button>
+                  <button
+                    className="text-text-faint hover:text-status-danger"
+                    title="Remove this index"
+                    onClick={() => removeUrl(url)}
+                  >
+                    <X size={13} />
+                  </button>
+                </div>
+                <div className="p-2 flex flex-col gap-1.5">
+                  {!state && <div className="text-text-faint text-xs px-1">loading…</div>}
+                  {state?.error && (
+                    <div className="flex items-start gap-1.5 text-status-danger text-xs px-1 py-1">
+                      <TriangleAlert size={13} className="mt-0.5 shrink-0" />
+                      <span>{state.error}</span>
+                    </div>
+                  )}
+                  {state && !state.error && !state.loading && state.packs.length === 0 && (
+                    <div className="text-text-faint text-xs px-1">no packs listed</div>
+                  )}
+                  {state?.packs.map((pack) => {
+                    const curVersion = installed[pack.id]
+                    const isInstalling = installing === pack.id
+                    const upToDate = curVersion === pack.version
+                    return (
+                      <div
+                        key={pack.id}
+                        className="flex items-center gap-2 px-2 py-1.5 rounded-md bg-surface-card border border-border-default"
+                      >
+                        <div className="min-w-0 flex-1">
+                          <div className="text-xs font-medium text-text-strong truncate">
+                            {pack.name} <span className="text-text-faint font-normal">v{pack.version}</span>
+                          </div>
+                          {pack.description && (
+                            <div className="text-[11px] text-text-muted truncate">{pack.description}</div>
+                          )}
+                        </div>
+                        {curVersion && (
+                          <span className="text-[10px] text-text-faint">
+                            {upToDate ? 'installed' : `v${curVersion} installed`}
+                          </span>
+                        )}
+                        <button
+                          className="h-6 px-2 rounded bg-brand text-white text-[11px] font-medium hover:bg-brand/90 disabled:opacity-50 flex items-center gap-1"
+                          disabled={isInstalling}
+                          onClick={() => void install(pack)}
+                        >
+                          {isInstalling ? (
+                            <>
+                              <Loader2 size={11} className="animate-spin" />
+                              {progress ? `${progress.done}/${progress.total}` : '…'}
+                            </>
+                          ) : (
+                            <>
+                              <Download size={11} />
+                              {curVersion ? (upToDate ? 'Reinstall' : 'Update') : 'Install'}
+                            </>
+                          )}
+                        </button>
+                      </div>
+                    )
+                  })}
+                </div>
+              </div>
+            )
+          })}
+        </div>
+      </div>
+    </div>
+  )
+}
diff --git a/src/renderer/src/circuit/views/palette/Palette.tsx b/src/renderer/src/circuit/views/palette/Palette.tsx
index 1a5f329..6f022fc 100644
--- a/src/renderer/src/circuit/views/palette/Palette.tsx
+++ b/src/renderer/src/circuit/views/palette/Palette.tsx
@@ -4,7 +4,7 @@
  * M2); drag a tile onto the canvas or double-click to drop it at centre.
  */
 
-import { ChevronDown, ChevronRight, CircuitBoard, Pencil, Plus } from 'lucide-react'
+import { ChevronDown, ChevronRight, CircuitBoard, Package, Pencil, Plus } from 'lucide-react'
 import React from 'react'
 import { getPart, partsByFamily, type PartMeta } from '../../../lib/partsLibrary'
 import type { ViewId } from '../../core/model'
@@ -54,7 +54,8 @@ export function Palette({
   onAdd,
   onAddNetLabel,
   onEditPart,
-  onNewPart
+  onNewPart,
+  onOpenPacks
 }: {
   view: ViewId
   wireColor: string
@@ -63,6 +64,7 @@ export function Palette({
   onAddNetLabel: (kind: string, name: string) => void
   onEditPart: (type: string) => void
   onNewPart: () => void
+  onOpenPacks: () => void
 }): React.JSX.Element {
   const [collapsed, setCollapsed] = React.useState<Set<string>>(new Set())
   const families = partsByFamily()
@@ -79,6 +81,13 @@ export function Palette({
     <div className="w-60 shrink-0 min-h-0 relative z-20 border-r border-border-default bg-bg-raised flex flex-col">
       <div className="h-9 flex items-center justify-between px-3 border-b border-border-default shrink-0">
         <span className="text-[13px] font-semibold text-text-body">Components</span>
+        <button
+          className="text-text-muted hover:text-brand"
+          title="Parts packs — install more components"
+          onClick={onOpenPacks}
+        >
+          <Package size={15} />
+        </button>
         <button className="text-text-muted hover:text-brand" title="New part…" onClick={onNewPart}>
           <Plus size={15} />
         </button>

From dc432355aac7e4922dab27aae380a6079502153b Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Wed, 22 Jul 2026 14:41:28 -0600
Subject: [PATCH 24/27] docs: log M4 + M2 leftovers session (2026-07-22)

Both milestones now fully closed per the tech spec's Section 15 table. Only
M5 (KiCad/Wokwi interop) remains untouched. Full rundown of all seven
commits, verification method (sandbox esbuild-linux workaround for
test:circuit), and known gaps for the next agent.
---
 docs/circuit-editor-progress.md | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/docs/circuit-editor-progress.md b/docs/circuit-editor-progress.md
index 16c91ce..5dafe6c 100644
--- a/docs/circuit-editor-progress.md
+++ b/docs/circuit-editor-progress.md
@@ -292,3 +292,36 @@ Four chunks, committed separately. `npm run typecheck` clean · `npm run test:ci
 - uPlot inlines into the main chunk (small); the engine stays its own lazy chunk.
 - Sandbox web build needed `NODE_OPTIONS=--max-old-space-size=4096` once (OOM at transform) — not a repo issue.
 - Remaining M4: probe parts (`sim.probes`), current probes, error→part highlight mapping, auto-rerun toggle, bb hole-tooltip voltages, flag default ON + legacy editor removal. Then M5 interop.
+
+---
+
+## 2026-07-22 — M4 + M2 leftovers closed out ✅ (both milestones now fully scoped-complete)
+
+Seven commits, each independently typechecked + tested. `npm run typecheck` (node+web) clean · `npm run test:circuit` → **114/114** throughout (started the session at 95).
+
+### M4 (closes every item on the 07-13 "remaining" list)
+
+- **Flag default ON + legacy editor removed** (`5226072`). `EditorPanel`'s `CircuitView` now mounts `CircuitViewV2` unconditionally — no more `tinystudio.circuitV2` flag, no `CircuitV1View` branch. Deleted `components/DiagramEditor.tsx` (2009 lines) and the already-dead `CircuitEditor.tsx` static viewer (B21). `diagram.json` → `circuit.json` migration-on-open is unchanged. **This is a real behavior change for anyone who had the flag off** — done deliberately, at Geoff's request, ahead of the rest of this session so the remaining work lands on the real path.
+- **Auto-rerun + hole voltage tooltips** (`1c099af`). `SimPanel` gets an "auto-rerun" checkbox: once on, doc edits re-run the active analysis after a 400 ms debounce (single in-flight run). Breadboard hole tooltips now append the net's solved DC voltage next to the existing "hole · net members" text, via a new `simVoltageForNet(netIdx)` threaded `CircuitView → Canvas`.
+- **Error → part/net highlight mapping** (`83b5c70`). `generateNetlist` now records `elementOfPart` (lowercased SPICE device names per part id). New pure `mapSimIssue`/`mapSimIssues` (`core/netlist.ts`) scan raw ngspice error/warning lines for those device names and node names (word-boundary, case-insensitive, ground `0` excluded) and return implicated parts/nets. `SimPanel`'s error box renders clickable chips (+ "select all"); `CircuitView.selectSimIssue` expands net hits to member parts and selects on canvas. +6 tests.
+- **Probe parts** (`715824a`) — voltage, differential voltage, current. Three placeable builtins (`parts/simProbes.ts`, CircuitLab-flag glyphs, family `Probe`). Voltage/diff probes need no SPICE element (ngspice already reports every node); the current probe emits a real `V<id> DC 0` series source so `i(v<id>)` reports the branch current without disturbing the circuit. `core/probes.ts` (pure, tested): `probesIn`, `diffProbeVector(s)` (computes `vdiff(<id>) = v(+) − v(−)`, real + imaginary for AC), `probeLabelFor` (a probe's `attrs.label` stands in for the raw vector name in `SimPanel`'s table and `Plot`'s legend — `Plot.tsx` gained an optional `labelFor` prop). +9 unit tests, +1 real-engine integration test (verifies `i(vamm1)` against the analytic divider current).
+
+### M2 (closes every item on the 07-11 "still open" list)
+
+- **Rigid "all pins must seat" rule** (`e70ce3a`). `partsAdapter.implicitSeats()` previously seated each pin independently against its nearest hole — a part with one leg near a hole and another off-grid reported a spurious single connection while the rest silently dangled. Now a part seats as a rigid body: **all** its pins must land within `SEAT_RADIUS` at the current placement, or none do (Fritzing's rule). Not unit-tested in isolation — `implicitSeats` depends on the legacy `partsLibrary` registry like the rest of `partsAdapter.ts`, consistent with that module's existing (lack of) coverage.
+- **Bendable rubber-band legs** (`dc3dd87`). Both importers (`scripts/fritzing-import.mjs`, `circuit/parts/fzpz.ts`) now read each connector's `legId` and tag the resolved pin into a new `PartView.legs: string[]`. Geometry needed no change — `pinWorld`/`pinWorldOf` were already leg-offset aware (`Placement.legs` existed since M0/M1 but nothing produced or consumed it). Canvas (bb view only): a leg-tagged pin drags independent of the part body (`beginLegDrag`, live-dispatched merged `placePart` commands, same pattern as the existing label-offset drag — no separate drag-override path needed since wires re-anchor through the normal `doc → resolve()` recompute); a real drag suppresses the trailing click; double-click resets a bent leg. Visual is a simple ink line from rest to tip overlaid on the existing static Fritzing leg art (real per-instance SVG leg-path warping is still future work — noted in code). `implicitSeats`'s rigid rule (above) now lets a stretched leg actually reach and seat in an adjacent hole. **Not automated-tested**: this is gesture code in `Canvas.tsx`, which has no test coverage anywhere in the suite (same caveat as every other canvas interaction in this repo) — verified by typecheck + code review only, not click-tested in a real browser (no display in this environment).
+- **Parts-pack manager + GitHub index installer** (`be71da3`). Targets the app's *actual* pipeline (legacy `PartDef` v1 + `lib/userParts.ts`/IndexedDB persistence), not the unbuilt v2 `registry.ts` the spec's §5.3/§5.4 assumes. `circuit/parts/packs.ts`: `fetchIndex`/`fetchManifest` (validated, relative URLs resolved against their own manifest), `installPack` (per-part fetch + `saveUserPart`, continues past individual failures). `circuit/views/packs/PackManager.tsx`: modal off a new Components-rail icon — add/remove index URLs, per-pack Install/Update with progress + toast summaries. `scripts/make-pack-index.mjs`: wraps a `fritzing-import.mjs` output directory into `pack.json`/`index.json` — re-shapes the existing manifest, no new conversion logic. `docs/tinyparts-pack-setup.md`: full guide for Geoff to create the `tinyparts` repo by hand (he offered to do this manually rather than granting repo access this session) — layout, exact schemas, the generator command, local testing, ATTRIBUTION requirement (M0 licensing decision), explicit gaps (no hash verification, no launch-time update check, no zip hosting). +7 unit tests against mocked fetch/localStorage, **plus a real end-to-end smoke test outside the suite**: ran `make-pack-index.mjs` against the app's actual 29-part bundled catalogue, served it over a plain local HTTP server, installed it through the real `packs.ts` client — 29/29, 0 failures.
+
+### Both milestones: what's left
+
+- **M2**: nothing outstanding against the spec's M2 line item. The only thing not delivered is publishing the `tinyparts` repo itself — that's Geoff's action per `docs/tinyparts-pack-setup.md`.
+- **M4**: nothing outstanding against the spec's M4 line item.
+- **M5 (interop)** is untouched — KiCad netlist/`.kicad_sch` export, Wokwi import/export + lint CI, `.fzz` import. This is genuinely the only milestone left per the spec's Section 15 table.
+
+### Session notes for the next agent
+
+- **Sandbox tooling fixed**: `.git/index.lock` could not be removed all session start (`allow_cowork_file_delete` on the folder resolves it in one call, same as the 07-11 session's fix — apparently doesn't stick across sessions, ask again if `git` operations silently fail with `Operation not permitted`).
+- **This sandbox's `node_modules` is Windows-native** (esbuild etc.), so `npm run test:circuit` fails here directly (`esbuild ... needs the "@esbuild/linux-x64" package`). Workaround used all session: a scratch `npm install esbuild --no-save --prefix /tmp/esbuild-linux`, then a copy of `scripts/test-circuit.mjs` importing esbuild from that absolute path instead of the repo's `node_modules` (repo `node_modules` never touched). **Must `cd` into the repo root before running it** — `sim.test.ts` resolves `eecircuit-engine` via `process.cwd()`, not `import.meta.url`. This isn't a repo change, just a note for whoever hits this again.
+- **`uplot` was declared in `package.json`/`package-lock.json` but missing from `node_modules`** at session start (stale install, unrelated to this session's changes) — Geoff needs to run `npm install` on his machine; not done here since this sandbox's platform-native deps would corrupt the Windows install.
+- `package.json`/`package-lock.json` carry a small pre-existing uncommitted diff (a `postinstall` fix, and a `0.2.0`→`0.3.0` lockfile version mismatch) that predates this session — left alone, not part of any commit above.
+- Bendable legs and the rigid seat rule are both real behavior changes to breadboard placement that would benefit from a manual click-through (drop a resistor near-but-not-quite on holes; drag an LED leg) before calling M2 done-done — flagged, not blocking, since the logic itself is straightforward and typechecked.

From 0fba603a57e916c881b127db2af32f4ba7c6e674 Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Wed, 22 Jul 2026 15:08:44 -0600
Subject: [PATCH 25/27] UI theming pass: light default, green chrome, tab
 colors + auto-switch

- Default theme to light mode (main.tsx)
- Top/bottom bar recolored blue -> green via new --bar-accent token,
  kept independent of --brand so buttons/selection/focus rings are
  untouched (base.css, Header.tsx, StatusBar.tsx)
- Docs panel tabs are now controlled via editorSlice.docsTab; opening a
  folder or example (activateWorkspace in fileCommands.ts) switches off
  Examples onto Docs automatically
- Per-tab accent colors: Examples yellow, Docs unchanged blue, Studio AI
  grape (#9c6c9c) (DocsPanel.tsx)
- Examples tab: removed redundant "Examples" header, added generous
  spacing/padding around cards (ExamplesContent.tsx)
- AI panel toolbar: dropped "Studio AI" label, shows just the model name
---
 src/renderer/src/assets/base.css              |  10 ++
 src/renderer/src/commands/fileCommands.ts     |   4 +
 src/renderer/src/components/AIAssistant.tsx   |   3 +-
 src/renderer/src/components/DocsPanel.tsx     | 133 ++++++++++--------
 .../src/components/ExamplesContent.tsx        |   6 +-
 src/renderer/src/components/Header.tsx        |  12 +-
 src/renderer/src/components/StatusBar.tsx     |   7 +-
 src/renderer/src/main.tsx                     |   2 +-
 src/renderer/src/redux/editorSlice.ts         |  19 ++-
 9 files changed, 119 insertions(+), 77 deletions(-)

diff --git a/src/renderer/src/assets/base.css b/src/renderer/src/assets/base.css
index d946b23..a9b4200 100644
--- a/src/renderer/src/assets/base.css
+++ b/src/renderer/src/assets/base.css
@@ -102,6 +102,12 @@
   --brand-on: var(--blue-on);
   --brand-contrast: #ffffff;
 
+  /* top/bottom bar accent — deliberately independent of --brand so the
+     window chrome can be recolored without touching buttons/selection/focus */
+  --bar-accent: var(--green);
+  --bar-accent-deep: var(--green-deep);
+  --bar-accent-contrast: #ffffff;
+
   /* status (board state, compile, etc.) */
   --status-ok: var(--green);
   --status-error: var(--red);
@@ -316,6 +322,10 @@
   --yellow-deep: #cdae1f;
   --yellow-on: #f4e29a;
 
+  --bar-accent: var(--green);
+  --bar-accent-deep: var(--green-deep);
+  --bar-accent-contrast: #06243b;
+
   /* surfaces — Discord-ish cold grey ladder */
   --bg: #2b2d31;
   --bg-sunken: #1e1f22;
diff --git a/src/renderer/src/commands/fileCommands.ts b/src/renderer/src/commands/fileCommands.ts
index b7d97f4..aa4cb74 100644
--- a/src/renderer/src/commands/fileCommands.ts
+++ b/src/renderer/src/commands/fileCommands.ts
@@ -2,6 +2,7 @@ import { Dispatch } from '@reduxjs/toolkit'
 import { fileSystem, FileSystemItem } from '@renderer/lib/fileSystem'
 import { fetchRepoFolder, loadAccount } from '@renderer/lib/github'
 import { VIRTUAL_PREFIX, virtualFileSystem } from '@renderer/lib/virtualFileSystem'
+import { setDocsTab } from '@renderer/redux/editorSlice'
 import {
   BaseFileItem,
   closeFile,
@@ -168,6 +169,9 @@ async function activateWorkspace(workspace: Workspace, dispatch: Dispatch): Prom
   // old workspace's tabs/tree/README/diagram.
   dispatch(closeWorkspace())
   dispatch(openWorkspace(workspace))
+  // Opening a project (folder or example) means there's now something to read —
+  // switch the docs panel off the Examples tab and onto Docs.
+  dispatch(setDocsTab('readme'))
 
   const readme = fileItems.find((file) => file.name === 'README.md')
   if (readme) {
diff --git a/src/renderer/src/components/AIAssistant.tsx b/src/renderer/src/components/AIAssistant.tsx
index 463f314..f77cb4a 100644
--- a/src/renderer/src/components/AIAssistant.tsx
+++ b/src/renderer/src/components/AIAssistant.tsx
@@ -194,8 +194,7 @@ export function AIAssistant(): React.JSX.Element {
       {/* Slim toolbar */}
       <div className="flex items-center gap-1 px-3 py-1.5 border-b border-navy-600 text-xs text-fg-3">
         <Sparkles size={13} className="text-pink" />
-        <span className="font-medium text-fg-2">Studio AI</span>
-        <span className="text-fg-4">· Claude Opus 4.8</span>
+        <span className="font-medium text-fg-2">Claude Opus 4.8</span>
         <div className="flex-1" />
         <Button
           variant="ghost"
diff --git a/src/renderer/src/components/DocsPanel.tsx b/src/renderer/src/components/DocsPanel.tsx
index 63705e5..3e3612e 100644
--- a/src/renderer/src/components/DocsPanel.tsx
+++ b/src/renderer/src/components/DocsPanel.tsx
@@ -1,57 +1,76 @@
-import { selectOpenFiles, setPanelOpen, useAppDispatch, useAppSelector } from '@renderer/redux'
-import { BookOpen, Sparkles, X, Zap } from 'lucide-react'
-import { AIAssistant } from './AIAssistant'
-import { ExamplesContent } from './ExamplesContent'
-import { ReadmeContent } from './ReferenceContent'
-import { Tabs, TabsContent, TabsList, TabsTrigger } from './ui/Tabs'
-
-export function DocsPanel(): React.JSX.Element {
-  const dispatch = useAppDispatch()
-  // On a fresh start with nothing open, land on Examples so there's somewhere to
-  // go; once a project is open, default to Docs. (Uncontrolled — only the initial
-  // tab; the user can switch freely after.)
-  const initialTab = useAppSelector(selectOpenFiles).length === 0 ? 'examples' : 'readme'
-
-  const handleCloseDocsPanel = (): void => {
-    dispatch(setPanelOpen({ panel: 'docs', isOpen: false }))
-  }
-
-  return (
-    <div className="size-full flex flex-col bg-[var(--bg-raised)] border-l border-[var(--border-default)]">
-      <Tabs defaultValue={initialTab} className="size-full flex flex-col gap-0">
-        <div className="flex items-stretch h-[36px] gap-1 pl-3 pr-1 border-b-[1.5px] border-[var(--border-default)]">
-          <TabsList className="flex-1 border-0 gap-1">
-            <TabsTrigger value="readme" className="flex-1 justify-center">
-              <BookOpen size={15} />
-              Docs
-            </TabsTrigger>
-            <TabsTrigger value="examples" className="flex-1 justify-center">
-              <Zap size={15} />
-              Examples
-            </TabsTrigger>
-            <TabsTrigger value="ai" className="flex-1 justify-center">
-              <Sparkles size={15} />
-              Studio AI
-            </TabsTrigger>
-          </TabsList>
-          <button
-            className="shrink-0 self-center flex items-center justify-center size-6 rounded-[var(--radius-xs)] text-[var(--text-faint)] hover:bg-[var(--bg-sunken)] hover:text-[var(--text-strong)]"
-            title="Close"
-            onClick={handleCloseDocsPanel}
-          >
-            <X size={15} />
-          </button>
-        </div>
-        <TabsContent value="readme" className="flex-1 min-h-0 min-w-0 overflow-hidden">
-          <ReadmeContent />
-        </TabsContent>
-        <TabsContent value="examples" className="flex-1 min-h-0 min-w-0 overflow-hidden">
-          <ExamplesContent />
-        </TabsContent>
-        <TabsContent value="ai" className="flex-1 min-h-0 min-w-0 overflow-hidden">
-          <AIAssistant />
-        </TabsContent>
-      </Tabs>
-    </div>
-  )
-}
\ No newline at end of file
+import {
+  selectDocsTab,
+  setDocsTab,
+  setPanelOpen,
+  useAppDispatch,
+  useAppSelector
+} from '@renderer/redux'
+import type { DocsTab } from '@renderer/redux/editorSlice'
+import { BookOpen, Sparkles, X, Zap } from 'lucide-react'
+import { AIAssistant } from './AIAssistant'
+import { ExamplesContent } from './ExamplesContent'
+import { ReadmeContent } from './ReferenceContent'
+import { Tabs, TabsContent, TabsList, TabsTrigger } from './ui/Tabs'
+
+// Per-tab accent color, overriding the shared TabsTrigger's brand-blue
+// underline/active-state. Docs is left alone (brand blue is already the
+// intended scheme); Examples gets yellow; Studio AI gets a light grape purple.
+const examplesAccent =
+  'after:bg-[var(--yellow)] hover:text-[var(--yellow-deep)] data-[state=active]:text-[var(--yellow-deep)] focus-visible:text-[var(--yellow-deep)]'
+const aiAccent =
+  'after:bg-[#9c6c9c] hover:text-[#9c6c9c] data-[state=active]:text-[#9c6c9c] focus-visible:text-[#9c6c9c]'
+
+export function DocsPanel(): React.JSX.Element {
+  const dispatch = useAppDispatch()
+  // Controlled: starts on 'examples' (see editorSlice initialState) and
+  // activateWorkspace() flips it to 'readme' whenever a folder or example
+  // is opened. The user can still switch freely afterward.
+  const activeTab = useAppSelector(selectDocsTab)
+
+  const handleCloseDocsPanel = (): void => {
+    dispatch(setPanelOpen({ panel: 'docs', isOpen: false }))
+  }
+
+  return (
+    <div className="size-full flex flex-col bg-[var(--bg-raised)] border-l border-[var(--border-default)]">
+      <Tabs
+        value={activeTab}
+        onValueChange={(v) => dispatch(setDocsTab(v as DocsTab))}
+        className="size-full flex flex-col gap-0"
+      >
+        <div className="flex items-stretch h-[36px] gap-1 pl-3 pr-1 border-b-[1.5px] border-[var(--border-default)]">
+          <TabsList className="flex-1 border-0 gap-1">
+            <TabsTrigger value="readme" className="flex-1 justify-center">
+              <BookOpen size={15} />
+              Docs
+            </TabsTrigger>
+            <TabsTrigger value="examples" className={`flex-1 justify-center ${examplesAccent}`}>
+              <Zap size={15} />
+              Examples
+            </TabsTrigger>
+            <TabsTrigger value="ai" className={`flex-1 justify-center ${aiAccent}`}>
+              <Sparkles size={15} />
+              Studio AI
+            </TabsTrigger>
+          </TabsList>
+          <button
+            className="shrink-0 self-center flex items-center justify-center size-6 rounded-[var(--radius-xs)] text-[var(--text-faint)] hover:bg-[var(--bg-sunken)] hover:text-[var(--text-strong)]"
+            title="Close"
+            onClick={handleCloseDocsPanel}
+          >
+            <X size={15} />
+          </button>
+        </div>
+        <TabsContent value="readme" className="flex-1 min-h-0 min-w-0 overflow-hidden">
+          <ReadmeContent />
+        </TabsContent>
+        <TabsContent value="examples" className="flex-1 min-h-0 min-w-0 overflow-hidden">
+          <ExamplesContent />
+        </TabsContent>
+        <TabsContent value="ai" className="flex-1 min-h-0 min-w-0 overflow-hidden">
+          <AIAssistant />
+        </TabsContent>
+      </Tabs>
+    </div>
+  )
+}
diff --git a/src/renderer/src/components/ExamplesContent.tsx b/src/renderer/src/components/ExamplesContent.tsx
index 75af2bc..231c0c1 100644
--- a/src/renderer/src/components/ExamplesContent.tsx
+++ b/src/renderer/src/components/ExamplesContent.tsx
@@ -49,12 +49,8 @@ export function ExamplesContent(): React.JSX.Element {
 
   return (
     <div className="size-full flex flex-col">
-      <div className="flex items-center gap-2 px-4 py-4 text-primary text-sm font-semibold border-b border-border mb-4 shrink-0">
-        <Zap size={16} />
-        Examples
-      </div>
       <ScrollArea className="flex-1 min-h-0">
-        <div className="flex flex-col gap-4 px-1">
+        <div className="flex flex-col gap-6 p-5">
           {status === 'loading' && (
             <div className="flex items-center gap-2 px-3 text-sm text-muted-foreground">
               <Loader2 size={16} className="animate-spin" />
diff --git a/src/renderer/src/components/Header.tsx b/src/renderer/src/components/Header.tsx
index 21f85ba..4eda33d 100644
--- a/src/renderer/src/components/Header.tsx
+++ b/src/renderer/src/components/Header.tsx
@@ -11,9 +11,11 @@ import { GitHubAccountButton } from './GitHubAccountButton'
  * Top bar (38px). Brand wordmark + breadcrumb on the left; theme toggle, GitHub
  * account, and (on Electron) window controls on the right.
  *
- * Theme-aware per the design system: in LIGHT mode the bar is the blue brand
- * color with a white wordmark; in DARK mode it's the raised grey surface with
- * the wordmark's "Studio" in brand blue. Inset controls flip with it.
+ * Theme-aware per the design system: in LIGHT mode the bar is the green bar
+ * accent color with a white wordmark; in DARK mode it's the raised grey
+ * surface with the wordmark's "Studio" in that same accent green. Inset
+ * controls flip with it. Uses --bar-accent (not --brand), so buttons and
+ * selection elsewhere stay on the blue brand color.
  */
 export function Header(): React.JSX.Element {
   const [isMaximized, setIsMaximized] = useState(false)
@@ -49,11 +51,11 @@ export function Header(): React.JSX.Element {
 
   return (
     <div
-      className="h-[38px] w-full shrink-0 flex items-center justify-between bg-[var(--brand)] shadow-[inset_0_-1px_0_0_rgba(0,0,0,0.18)] dark:bg-[var(--bg-raised)] dark:border-b dark:border-[var(--border-default)] dark:shadow-none"
+      className="h-[38px] w-full shrink-0 flex items-center justify-between bg-[var(--bar-accent)] shadow-[inset_0_-1px_0_0_rgba(0,0,0,0.18)] dark:bg-[var(--bg-raised)] dark:border-b dark:border-[var(--border-default)] dark:shadow-none"
       style={isElectron() ? ({ WebkitAppRegion: 'drag' } as React.CSSProperties) : {}}
     >
       <div className="flex items-center gap-2 pl-3 min-w-0">
-        <h1 className="text-[15px] font-extrabold tracking-[-0.02em] select-none text-white dark:text-[var(--brand)]">
+        <h1 className="text-[15px] font-extrabold tracking-[-0.02em] select-none text-white dark:text-[var(--bar-accent)]">
           <span className="font-medium text-white/70 dark:text-[var(--text-muted)]">tiny</span>Studio
         </h1>
         {workspace && (
diff --git a/src/renderer/src/components/StatusBar.tsx b/src/renderer/src/components/StatusBar.tsx
index c6032e1..66a49f5 100644
--- a/src/renderer/src/components/StatusBar.tsx
+++ b/src/renderer/src/components/StatusBar.tsx
@@ -164,12 +164,13 @@ export function StatusBar(): React.JSX.Element {
   const busy = isUploading || isCompiling
   const busyLabel = isUploading ? 'Uploading…' : isCompiling ? 'Compiling…' : 'Ready'
 
-  // Links must read on the blue bar (light) and the grey bar (dark).
+  // Links must read on the green bar (light) and the grey bar (dark). Uses
+  // --bar-accent (not --brand) so this stays independent of button/selection color.
   const link =
-    'underline underline-offset-2 text-white/90 hover:text-white dark:text-[var(--brand)] dark:no-underline dark:hover:underline'
+    'underline underline-offset-2 text-white/90 hover:text-white dark:text-[var(--bar-accent)] dark:no-underline dark:hover:underline'
 
   return (
-    <footer className="ts-statusbar flex items-center justify-between shrink-0 h-[27px] px-3 text-[11.5px] font-sans bg-[var(--brand)] text-white/[0.88] shadow-[inset_0_1px_0_0_rgba(0,0,0,0.14)] dark:bg-[var(--bg-raised)] dark:text-[var(--text-muted)] dark:border-t dark:border-[var(--border-default)] dark:shadow-none">
+    <footer className="ts-statusbar flex items-center justify-between shrink-0 h-[27px] px-3 text-[11.5px] font-sans bg-[var(--bar-accent)] text-white/[0.88] shadow-[inset_0_1px_0_0_rgba(0,0,0,0.14)] dark:bg-[var(--bg-raised)] dark:text-[var(--text-muted)] dark:border-t dark:border-[var(--border-default)] dark:shadow-none">
       <div className="flex items-center">
         <StatusPill status={busy ? 'warn' : 'idle'} pulse={busy} bare>
           {busyLabel}
diff --git a/src/renderer/src/main.tsx b/src/renderer/src/main.tsx
index 1401605..6afa10a 100644
--- a/src/renderer/src/main.tsx
+++ b/src/renderer/src/main.tsx
@@ -11,7 +11,7 @@ import { store } from './redux'
 
 createRoot(document.getElementById('root')!).render(
   <StrictMode>
-    <ThemeProvider defaultTheme="dark" storageKey="vite-ui-theme">
+    <ThemeProvider defaultTheme="light" storageKey="vite-ui-theme">
       <Provider store={store}>
         <ErrorBoundary>
           <App />
diff --git a/src/renderer/src/redux/editorSlice.ts b/src/renderer/src/redux/editorSlice.ts
index 33dbaef..a8374a6 100644
--- a/src/renderer/src/redux/editorSlice.ts
+++ b/src/renderer/src/redux/editorSlice.ts
@@ -3,6 +3,9 @@ import { createAppSlice } from './createAppSlice'
 
 export type EditorView = 'code' | 'circuit' | 'visual'
 
+// Which tab is active in the docs/examples/AI side panel.
+export type DocsTab = 'readme' | 'examples' | 'ai'
+
 export type EditorSliceState = {
   status: 'idle' | 'loading' | 'failed'
   isFileExplorerOpen: boolean
@@ -13,6 +16,9 @@ export type EditorSliceState = {
   // diagram.json interactively; 'visual' runs a p5 sketch (.js). The toolbar
   // segment sets this and auto-focuses the matching file.
   editorView: EditorView
+  // Starts on 'examples' when nothing is open yet; activateWorkspace() flips
+  // this to 'readme' whenever a folder or example is opened.
+  docsTab: DocsTab
 }
 
 const initialState: EditorSliceState = {
@@ -21,7 +27,8 @@ const initialState: EditorSliceState = {
   isSerialMonitorOpen: true,
   isDocsPanelOpen: true,
   editorMode: 'code',
-  editorView: 'code'
+  editorView: 'code',
+  docsTab: 'examples'
 }
 
 // If you are not using async thunks you can use the standalone `createSlice`.
@@ -51,6 +58,9 @@ export const editorSlice = createAppSlice({
     }),
     setEditorView: create.reducer((state, payload: PayloadAction<EditorView>) => {
       state.editorView = payload.payload
+    }),
+    setDocsTab: create.reducer((state, payload: PayloadAction<DocsTab>) => {
+      state.docsTab = payload.payload
     })
   }),
   selectors: {
@@ -66,12 +76,13 @@ export const editorSlice = createAppSlice({
         isDocsPanelOpen
       })
     ),
-    selectEditorView: (state) => state.editorView
+    selectEditorView: (state) => state.editorView,
+    selectDocsTab: (state) => state.docsTab
   }
 })
 
 // Action creators are generated for each case reducer function.
-export const { setPanelOpen, setEditorMode, setEditorView } = editorSlice.actions
+export const { setPanelOpen, setEditorMode, setEditorView, setDocsTab } = editorSlice.actions
 
 // Selectors returned by `slice.selectors` take the root state as their first argument.
-export const { selectPanelState, selectEditorView } = editorSlice.selectors
+export const { selectPanelState, selectEditorView, selectDocsTab } = editorSlice.selectors

From 1edff9160d1c2ff827b5edd0136bed112d2daef4 Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Wed, 22 Jul 2026 15:13:38 -0600
Subject: [PATCH 26/27] postinstall: run install-electron before
 electron-builder install-app-deps

Fixes electron binary not being fetched on postinstall.
---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 8de6b23..27fe377 100644
--- a/package.json
+++ b/package.json
@@ -27,7 +27,7 @@
     "dev": "electron-vite dev",
     "dev:web": "vite --config web.vite.config.mts",
     "build": "npm run typecheck && electron-vite build",
-    "postinstall": "electron-builder install-app-deps",
+    "postinstall": "install-electron && electron-builder install-app-deps",
     "build:unpack": "npm run build && electron-builder --dir",
     "build:win": "npm run build && electron-builder --win",
     "build:mac": "electron-vite build && electron-builder --mac",

From 2cc5a658db1a79c691d2039217fcbd09738c6e4c Mon Sep 17 00:00:00 2001
From: Geoff McIntyre <macgeoffrey123@gmail.com>
Date: Wed, 22 Jul 2026 15:39:43 -0600
Subject: [PATCH 27/27] Updated version to 0.3 and changed colors on right
 panels

---
 package-lock.json                             |  4 ++--
 src/renderer/src/assets/base.css              | 24 +++++++++++++++----
 src/renderer/src/components/AIAssistant.tsx   |  8 +++----
 src/renderer/src/components/DocsPanel.tsx     | 14 ++++-------
 .../src/components/ExamplesContent.tsx        |  2 +-
 src/renderer/src/components/ui/Button.tsx     |  2 ++
 tsconfig.web.tsbuildinfo                      |  2 +-
 7 files changed, 35 insertions(+), 21 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 1a19e8a..5cfd075 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "tinystudio",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "tinystudio",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "hasInstallScript": true,
       "license": "GPL-3.0-or-later",
       "dependencies": {
diff --git a/src/renderer/src/assets/base.css b/src/renderer/src/assets/base.css
index a9b4200..9620b94 100644
--- a/src/renderer/src/assets/base.css
+++ b/src/renderer/src/assets/base.css
@@ -58,6 +58,16 @@
   --yellow: #f3cb00;
   --yellow-deep: #c6a500;
   --yellow-on: #6b5800;
+  /* text on the solid --yellow swatch specifically (button fills, badges) —
+     always dark since the gold stays bright in both themes, unlike --yellow-on
+     which is tuned for the soft tinted surface and flips in dark mode */
+  --yellow-contrast: #3d2f00;
+
+  /* PURPLE — Studio AI accent (chat bubbles, send button) */
+  --purple-soft: #efe3fb;
+  --purple: #9d5fd6;
+  --purple-deep: #7c3fb0;
+  --purple-on: #5a2a82;
 
   /* ── COLD NEUTRAL RAMP — white → slate ───────────────────────────────────── */
   --warm-50: #fbfcfd;
@@ -104,8 +114,8 @@
 
   /* top/bottom bar accent — deliberately independent of --brand so the
      window chrome can be recolored without touching buttons/selection/focus */
-  --bar-accent: var(--green);
-  --bar-accent-deep: var(--green-deep);
+  --bar-accent: var(--blue);
+  --bar-accent-deep: var(--blue-deep);
   --bar-accent-contrast: #ffffff;
 
   /* status (board state, compile, etc.) */
@@ -321,9 +331,15 @@
   --yellow: #f5d426;
   --yellow-deep: #cdae1f;
   --yellow-on: #f4e29a;
+  --yellow-contrast: #3d2f00;
+
+  --purple-soft: #2f2140;
+  --purple: #b47ee8;
+  --purple-deep: #9757c9;
+  --purple-on: #ecd6fb;
 
-  --bar-accent: var(--green);
-  --bar-accent-deep: var(--green-deep);
+  --bar-accent: var(--blue);
+  --bar-accent-deep: var(--blue-deep);
   --bar-accent-contrast: #06243b;
 
   /* surfaces — Discord-ish cold grey ladder */
diff --git a/src/renderer/src/components/AIAssistant.tsx b/src/renderer/src/components/AIAssistant.tsx
index f77cb4a..05e5414 100644
--- a/src/renderer/src/components/AIAssistant.tsx
+++ b/src/renderer/src/components/AIAssistant.tsx
@@ -256,7 +256,7 @@ export function AIAssistant(): React.JSX.Element {
           </button>
         ) : (
           <button
-            className="px-3 rounded-lg bg-cyan text-[var(--fg-on-cyan)] disabled:opacity-50"
+            className="px-3 rounded-lg bg-[var(--purple)] text-white disabled:opacity-50"
             onClick={send}
             disabled={!input.trim()}
           >
@@ -333,8 +333,8 @@ function TimelineRow({ item }: { item: TimelineItem }): React.JSX.Element {
 function AiBubble({ text }: { text: string }): React.JSX.Element {
   return (
     <div
-      className="self-start rounded-xl bg-navy-600 text-fg-1 py-2 px-4 mr-8 max-w-[90%] text-sm leading-relaxed"
-      style={{ border: '1px solid var(--pink-line)' }}
+      className="self-start rounded-xl bg-[var(--purple-soft)] text-[var(--purple-on)] py-2 px-4 mr-8 max-w-[90%] text-sm leading-relaxed"
+      style={{ border: '1px solid var(--purple)' }}
     >
       <Markdown>{text}</Markdown>
     </div>
@@ -343,7 +343,7 @@ function AiBubble({ text }: { text: string }): React.JSX.Element {
 
 function UserBubble({ text }: { text: string }): React.JSX.Element {
   return (
-    <div className="self-end rounded-xl border border-navy-400 bg-navy-700 text-fg-2 py-2 px-4 ml-8 w-fit text-sm whitespace-pre-wrap">
+    <div className="self-end rounded-xl border border-[var(--purple-deep)] bg-[var(--purple)] text-white py-2 px-4 ml-8 w-fit text-sm whitespace-pre-wrap">
       {text}
     </div>
   )
diff --git a/src/renderer/src/components/DocsPanel.tsx b/src/renderer/src/components/DocsPanel.tsx
index 3e3612e..1d33bb0 100644
--- a/src/renderer/src/components/DocsPanel.tsx
+++ b/src/renderer/src/components/DocsPanel.tsx
@@ -12,13 +12,9 @@ import { ExamplesContent } from './ExamplesContent'
 import { ReadmeContent } from './ReferenceContent'
 import { Tabs, TabsContent, TabsList, TabsTrigger } from './ui/Tabs'
 
-// Per-tab accent color, overriding the shared TabsTrigger's brand-blue
-// underline/active-state. Docs is left alone (brand blue is already the
-// intended scheme); Examples gets yellow; Studio AI gets a light grape purple.
-const examplesAccent =
-  'after:bg-[var(--yellow)] hover:text-[var(--yellow-deep)] data-[state=active]:text-[var(--yellow-deep)] focus-visible:text-[var(--yellow-deep)]'
-const aiAccent =
-  'after:bg-[#9c6c9c] hover:text-[#9c6c9c] data-[state=active]:text-[#9c6c9c] focus-visible:text-[#9c6c9c]'
+// All three tabs share the shared TabsTrigger's brand-blue underline/active
+// state — the accent colors below live in the tab content instead (Examples'
+// buttons are yellow, Studio AI's bubbles and send button are purple).
 
 export function DocsPanel(): React.JSX.Element {
   const dispatch = useAppDispatch()
@@ -44,11 +40,11 @@ export function DocsPanel(): React.JSX.Element {
               <BookOpen size={15} />
               Docs
             </TabsTrigger>
-            <TabsTrigger value="examples" className={`flex-1 justify-center ${examplesAccent}`}>
+            <TabsTrigger value="examples" className="flex-1 justify-center">
               <Zap size={15} />
               Examples
             </TabsTrigger>
-            <TabsTrigger value="ai" className={`flex-1 justify-center ${aiAccent}`}>
+            <TabsTrigger value="ai" className="flex-1 justify-center">
               <Sparkles size={15} />
               Studio AI
             </TabsTrigger>
diff --git a/src/renderer/src/components/ExamplesContent.tsx b/src/renderer/src/components/ExamplesContent.tsx
index 231c0c1..d689f6d 100644
--- a/src/renderer/src/components/ExamplesContent.tsx
+++ b/src/renderer/src/components/ExamplesContent.tsx
@@ -81,7 +81,7 @@ export function ExamplesContent(): React.JSX.Element {
                   {example.board && (
                     <p className="mb-3 text-xs text-muted-foreground">Board: {example.board}</p>
                   )}
-                  <Button onClick={() => open(example)} disabled={opening}>
+                  <Button variant="warning" onClick={() => open(example)} disabled={opening}>
                     {opening ? <Loader2 className="animate-spin" /> : <Zap />}
                     {opening ? 'Opening…' : 'Open example'}
                   </Button>
diff --git a/src/renderer/src/components/ui/Button.tsx b/src/renderer/src/components/ui/Button.tsx
index 25a3f65..3f6ad6c 100644
--- a/src/renderer/src/components/ui/Button.tsx
+++ b/src/renderer/src/components/ui/Button.tsx
@@ -19,6 +19,8 @@ const buttonVariants = cva(
         default: 'tactile bg-primary text-white [--_edge:var(--brand-deep)]',
         destructive: 'tactile bg-[var(--red)] text-white [--_edge:var(--red-deep)]',
         success: 'tactile bg-[var(--green)] text-white [--_edge:var(--green-deep)]',
+        warning:
+          'tactile bg-[var(--yellow)] text-[var(--yellow-contrast)] [--_edge:var(--yellow-deep)]',
         // bordered tactile — neutral actions
         secondary: 'tactile-bordered bg-card text-[var(--text-strong)]',
         outline: 'tactile-bordered bg-background text-[var(--text-strong)]',
diff --git a/tsconfig.web.tsbuildinfo b/tsconfig.web.tsbuildinfo
index 9a7fc0b..92a5b65 100644
--- a/tsconfig.web.tsbuildinfo
+++ b/tsconfig.web.tsbuildinfo
@@ -1 +1 @@
-{"fileNames":["./node_modules/typescript/lib/lib.es5.d.ts","./node_modules/typescript/lib/lib.es2015.d.ts","./node_modules/typescript/lib/lib.es2016.d.ts","./node_modules/typescript/lib/lib.es2017.d.ts","./node_modules/typescript/lib/lib.es2018.d.ts","./node_modules/typescript/lib/lib.es2019.d.ts","./node_modules/typescript/lib/lib.es2020.d.ts","./node_modules/typescript/lib/lib.es2021.d.ts","./node_modules/typescript/lib/lib.es2022.d.ts","./node_modules/typescript/lib/lib.es2023.d.ts","./node_modules/typescript/lib/lib.es2024.d.ts","./node_modules/typescript/lib/lib.esnext.d.ts","./node_modules/typescript/lib/lib.dom.d.ts","./node_modules/typescript/lib/lib.dom.iterable.d.ts","./node_modules/typescript/lib/lib.es2015.core.d.ts","./node_modules/typescript/lib/lib.es2015.collection.d.ts","./node_modules/typescript/lib/lib.es2015.generator.d.ts","./node_modules/typescript/lib/lib.es2015.iterable.d.ts","./node_modules/typescript/lib/lib.es2015.promise.d.ts","./node_modules/typescript/lib/lib.es2015.proxy.d.ts","./node_modules/typescript/lib/lib.es2015.reflect.d.ts","./node_modules/typescript/lib/lib.es2015.symbol.d.ts","./node_modules/typescript/lib/lib.es2015.symbol.wellknown.d.ts","./node_modules/typescript/lib/lib.es2016.array.include.d.ts","./node_modules/typescript/lib/lib.es2016.intl.d.ts","./node_modules/typescript/lib/lib.es2017.arraybuffer.d.ts","./node_modules/typescript/lib/lib.es2017.date.d.ts","./node_modules/typescript/lib/lib.es2017.object.d.ts","./node_modules/typescript/lib/lib.es2017.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2017.string.d.ts","./node_modules/typescript/lib/lib.es2017.intl.d.ts","./node_modules/typescript/lib/lib.es2017.typedarrays.d.ts","./node_modules/typescript/lib/lib.es2018.asyncgenerator.d.ts","./node_modules/typescript/lib/lib.es2018.asynciterable.d.ts","./node_modules/typescript/lib/lib.es2018.intl.d.ts","./node_modules/typescript/lib/lib.es2018.promise.d.ts","./node_modules/typescript/lib/lib.es2018.regexp.d.ts","./node_modules/typescript/lib/lib.es2019.array.d.ts","./node_modules/typescript/lib/lib.es2019.object.d.ts","./node_modules/typescript/lib/lib.es2019.string.d.ts","./node_modules/typescript/lib/lib.es2019.symbol.d.ts","./node_modules/typescript/lib/lib.es2019.intl.d.ts","./node_modules/typescript/lib/lib.es2020.bigint.d.ts","./node_modules/typescript/lib/lib.es2020.date.d.ts","./node_modules/typescript/lib/lib.es2020.promise.d.ts","./node_modules/typescript/lib/lib.es2020.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2020.string.d.ts","./node_modules/typescript/lib/lib.es2020.symbol.wellknown.d.ts","./node_modules/typescript/lib/lib.es2020.intl.d.ts","./node_modules/typescript/lib/lib.es2020.number.d.ts","./node_modules/typescript/lib/lib.es2021.promise.d.ts","./node_modules/typescript/lib/lib.es2021.string.d.ts","./node_modules/typescript/lib/lib.es2021.weakref.d.ts","./node_modules/typescript/lib/lib.es2021.intl.d.ts","./node_modules/typescript/lib/lib.es2022.array.d.ts","./node_modules/typescript/lib/lib.es2022.error.d.ts","./node_modules/typescript/lib/lib.es2022.intl.d.ts","./node_modules/typescript/lib/lib.es2022.object.d.ts","./node_modules/typescript/lib/lib.es2022.string.d.ts","./node_modules/typescript/lib/lib.es2022.regexp.d.ts","./node_modules/typescript/lib/lib.es2023.array.d.ts","./node_modules/typescript/lib/lib.es2023.collection.d.ts","./node_modules/typescript/lib/lib.es2023.intl.d.ts","./node_modules/typescript/lib/lib.es2024.arraybuffer.d.ts","./node_modules/typescript/lib/lib.es2024.collection.d.ts","./node_modules/typescript/lib/lib.es2024.object.d.ts","./node_modules/typescript/lib/lib.es2024.promise.d.ts","./node_modules/typescript/lib/lib.es2024.regexp.d.ts","./node_modules/typescript/lib/lib.es2024.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2024.string.d.ts","./node_modules/typescript/lib/lib.esnext.array.d.ts","./node_modules/typescript/lib/lib.esnext.collection.d.ts","./node_modules/typescript/lib/lib.esnext.intl.d.ts","./node_modules/typescript/lib/lib.esnext.disposable.d.ts","./node_modules/typescript/lib/lib.esnext.promise.d.ts","./node_modules/typescript/lib/lib.esnext.decorators.d.ts","./node_modules/typescript/lib/lib.esnext.iterator.d.ts","./node_modules/typescript/lib/lib.esnext.float16.d.ts","./node_modules/typescript/lib/lib.decorators.d.ts","./node_modules/typescript/lib/lib.decorators.legacy.d.ts","./node_modules/vite/types/hmrpayload.d.ts","./node_modules/vite/types/customevent.d.ts","./node_modules/vite/types/hot.d.ts","./node_modules/vite/types/importglob.d.ts","./node_modules/vite/types/importmeta.d.ts","./node_modules/vite/client.d.ts","./src/renderer/src/env.d.ts","./node_modules/@types/react/global.d.ts","./node_modules/csstype/index.d.ts","./node_modules/@types/react/index.d.ts","./node_modules/@types/react/jsx-runtime.d.ts","./node_modules/redux/dist/redux.d.ts","./node_modules/immer/dist/immer.d.ts","./node_modules/reselect/dist/reselect.d.ts","./node_modules/redux-thunk/dist/redux-thunk.d.ts","./node_modules/@reduxjs/toolkit/dist/uncheckedindexed.ts","./node_modules/@reduxjs/toolkit/dist/index.d.ts","./src/renderer/src/lib/webfilesystem.ts","./src/renderer/src/lib/filesystem.ts","./src/renderer/src/redux/createappslice.ts","./src/renderer/src/redux/fileslice.ts","./src/renderer/src/redux/editorslice.ts","./src/renderer/src/redux/store.ts","./src/renderer/src/commands/command.ts","./src/renderer/src/commands/filecommands.ts","./node_modules/react-redux/dist/react-redux.d.ts","./src/renderer/src/redux/hooks.ts","./src/renderer/src/redux/index.ts","./node_modules/lucide-react/dist/lucide-react.d.ts","./node_modules/clsx/clsx.d.ts","./node_modules/tailwind-merge/dist/types.d.ts","./src/renderer/src/lib/utils.tsx","../tinyservice/packages/shared/dist/types.d.ts","../tinyservice/packages/shared/dist/constants.d.ts","../tinyservice/packages/shared/dist/factory.d.ts","../tinyservice/packages/shared/dist/validator.d.ts","../tinyservice/packages/shared/dist/client.d.ts","../tinyservice/packages/shared/dist/hooks/usetinyservice.d.ts","../tinyservice/packages/shared/dist/index.d.ts","./src/renderer/src/services/arduino/types.ts","./src/renderer/src/services/arduino/electronarduinoservice.ts","./src/renderer/src/services/arduino/webarduinoservice.ts","./src/renderer/src/services/arduino/index.ts","./src/renderer/src/services/arduino/arduinoservicefactory.ts","./node_modules/sonner/dist/index.d.ts","./src/renderer/src/hooks/usearduinoagent.ts","./src/renderer/src/hooks/usearduino.ts","./src/renderer/src/contexts/arduinocontext.tsx","./node_modules/@radix-ui/react-context/dist/index.d.ts","./node_modules/@radix-ui/react-primitive/dist/index.d.ts","./node_modules/@radix-ui/react-scroll-area/dist/index.d.ts","./src/renderer/src/components/ui/scrollarea.tsx","./src/renderer/src/components/aiassistant.tsx","./node_modules/@types/unist/index.d.ts","./node_modules/@types/hast/index.d.ts","./node_modules/vfile-message/lib/index.d.ts","./node_modules/vfile-message/index.d.ts","./node_modules/vfile/lib/index.d.ts","./node_modules/vfile/index.d.ts","./node_modules/unified/lib/callable-instance.d.ts","./node_modules/trough/lib/index.d.ts","./node_modules/trough/index.d.ts","./node_modules/unified/lib/index.d.ts","./node_modules/unified/index.d.ts","./node_modules/@types/mdast/index.d.ts","./node_modules/mdast-util-to-hast/lib/state.d.ts","./node_modules/mdast-util-to-hast/lib/footer.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/blockquote.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/break.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/code.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/delete.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/emphasis.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/heading.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/html.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/image-reference.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/image.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/inline-code.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/link-reference.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/link.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/list-item.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/list.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/paragraph.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/root.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/strong.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/table.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/table-cell.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/table-row.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/text.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/thematic-break.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/index.d.ts","./node_modules/mdast-util-to-hast/lib/index.d.ts","./node_modules/mdast-util-to-hast/index.d.ts","./node_modules/remark-rehype/lib/index.d.ts","./node_modules/remark-rehype/index.d.ts","./node_modules/react-markdown/lib/index.d.ts","./node_modules/react-markdown/index.d.ts","./src/renderer/src/components/referencecontent.tsx","./node_modules/@radix-ui/react-slot/dist/index.d.ts","./node_modules/class-variance-authority/dist/types.d.ts","./node_modules/class-variance-authority/dist/index.d.ts","./src/renderer/src/components/ui/button.tsx","./node_modules/@radix-ui/react-roving-focus/dist/index.d.ts","./node_modules/@radix-ui/react-tabs/dist/index.d.ts","./src/renderer/src/components/ui/tabs.tsx","./src/renderer/src/components/docspanel.tsx","./node_modules/monaco-editor/esm/vs/editor/editor.api.d.ts","./node_modules/@monaco-editor/loader/lib/types.d.ts","./node_modules/@monaco-editor/react/dist/index.d.ts","./src/renderer/src/lib/github.ts","./src/renderer/src/lib/visualexport.ts","./node_modules/blockly/blocks.d.ts","./node_modules/blockly/core/interfaces/i_focusable_tree.d.ts","./node_modules/blockly/core/interfaces/i_focusable_node.d.ts","./node_modules/blockly/core/interfaces/i_selectable.d.ts","./node_modules/blockly/core/interfaces/i_copyable.d.ts","./node_modules/blockly/core/utils/coordinate.d.ts","./node_modules/blockly/core/events/events_abstract.d.ts","./node_modules/blockly/core/events/events_ui_base.d.ts","./node_modules/blockly/core/events/type.d.ts","./node_modules/blockly/core/events/events_theme_change.d.ts","./node_modules/blockly/core/events/events_viewport.d.ts","./node_modules/blockly/core/browser_events.d.ts","./node_modules/blockly/core/utils/size.d.ts","./node_modules/blockly/core/comments/workspace_comment.d.ts","./node_modules/blockly/core/interfaces/i_component.d.ts","./node_modules/blockly/core/interfaces/i_autohideable.d.ts","./node_modules/blockly/core/utils/rect.d.ts","./node_modules/blockly/core/interfaces/i_draggable.d.ts","./node_modules/blockly/core/interfaces/i_drag_target.d.ts","./node_modules/blockly/core/interfaces/i_delete_area.d.ts","./node_modules/blockly/core/interfaces/i_bounded_element.d.ts","./node_modules/blockly/core/flyout_item.d.ts","./node_modules/blockly/core/utils/svg.d.ts","./node_modules/blockly/core/interfaces/i_serializer.d.ts","./node_modules/blockly/core/serialization/blocks.d.ts","./node_modules/blockly/core/interfaces/i_toolbox_item.d.ts","./node_modules/blockly/core/interfaces/i_selectable_toolbox_item.d.ts","./node_modules/blockly/core/interfaces/i_collapsible_toolbox_item.d.ts","./node_modules/blockly/core/interfaces/i_registrable.d.ts","./node_modules/blockly/core/interfaces/i_toolbox.d.ts","./node_modules/blockly/core/toolbox/toolbox_item.d.ts","./node_modules/blockly/core/toolbox/category.d.ts","./node_modules/blockly/core/toolbox/separator.d.ts","./node_modules/blockly/core/utils/toolbox.d.ts","./node_modules/blockly/core/interfaces/i_flyout.d.ts","./node_modules/blockly/core/utils/metrics.d.ts","./node_modules/blockly/core/interfaces/i_metrics_manager.d.ts","./node_modules/blockly/core/metrics_manager.d.ts","./node_modules/blockly/core/interfaces/i_positionable.d.ts","./node_modules/blockly/core/component_manager.d.ts","./node_modules/blockly/core/interfaces/i_rendered_element.d.ts","./node_modules/blockly/core/flyout_button.d.ts","./node_modules/blockly/core/events/events_click.d.ts","./node_modules/blockly/core/comments/comment_view.d.ts","./node_modules/blockly/core/comments.d.ts","./node_modules/blockly/core/interfaces/i_contextmenu.d.ts","./node_modules/blockly/core/interfaces/i_bubble.d.ts","./node_modules/blockly/core/interfaces/i_dragger.d.ts","./node_modules/blockly/core/interfaces/i_has_bubble.d.ts","./node_modules/blockly/core/interfaces/i_serializable.d.ts","./node_modules/blockly/core/extensions.d.ts","./node_modules/blockly/core/utils/aria.d.ts","./node_modules/blockly/core/utils/array.d.ts","./node_modules/blockly/core/utils/colour.d.ts","./node_modules/blockly/core/utils/deprecation.d.ts","./node_modules/blockly/core/utils/dom.d.ts","./node_modules/blockly/core/utils/idgenerator.d.ts","./node_modules/blockly/core/utils/keycodes.d.ts","./node_modules/blockly/core/utils/math.d.ts","./node_modules/blockly/core/utils/object.d.ts","./node_modules/blockly/core/utils/parsing.d.ts","./node_modules/blockly/core/utils/string.d.ts","./node_modules/blockly/core/utils/style.d.ts","./node_modules/blockly/core/utils/svg_math.d.ts","./node_modules/blockly/core/utils/svg_paths.d.ts","./node_modules/blockly/core/utils/useragent.d.ts","./node_modules/blockly/core/utils/xml.d.ts","./node_modules/blockly/core/utils.d.ts","./node_modules/blockly/core/tooltip.d.ts","./node_modules/blockly/core/icons/icon.d.ts","./node_modules/blockly/core/icons/comment_icon.d.ts","./node_modules/blockly/core/interfaces/i_comment_icon.d.ts","./node_modules/blockly/core/icons/mutator_icon.d.ts","./node_modules/blockly/core/icons/warning_icon.d.ts","./node_modules/blockly/core/icons/icon_types.d.ts","./node_modules/blockly/core/interfaces/i_icon.d.ts","./node_modules/blockly/core/workspace_dragger.d.ts","./node_modules/blockly/core/gesture.d.ts","./node_modules/blockly/core/theme.d.ts","./node_modules/blockly/core/blockly_options.d.ts","./node_modules/blockly/core/options.d.ts","./node_modules/blockly/core/grid.d.ts","./node_modules/blockly/core/keyboard_nav/marker.d.ts","./node_modules/blockly/core/keyboard_nav/line_cursor.d.ts","./node_modules/blockly/core/layer_manager.d.ts","./node_modules/blockly/core/marker_manager.d.ts","./node_modules/blockly/core/interfaces/i_navigation_policy.d.ts","./node_modules/blockly/core/navigator.d.ts","./node_modules/blockly/core/rendered_connection.d.ts","./node_modules/blockly/core/renderers/common/constants.d.ts","./node_modules/blockly/core/renderers/measurables/base.d.ts","./node_modules/blockly/core/renderers/measurables/connection.d.ts","./node_modules/blockly/core/renderers/measurables/field.d.ts","./node_modules/blockly/core/renderers/measurables/icon.d.ts","./node_modules/blockly/core/renderers/measurables/input_connection.d.ts","./node_modules/blockly/core/renderers/measurables/inline_input.d.ts","./node_modules/blockly/core/renderers/measurables/in_row_spacer.d.ts","./node_modules/blockly/core/renderers/measurables/row.d.ts","./node_modules/blockly/core/renderers/measurables/next_connection.d.ts","./node_modules/blockly/core/renderers/measurables/bottom_row.d.ts","./node_modules/blockly/core/renderers/measurables/input_row.d.ts","./node_modules/blockly/core/renderers/measurables/output_connection.d.ts","./node_modules/blockly/core/renderers/measurables/spacer_row.d.ts","./node_modules/blockly/core/renderers/measurables/previous_connection.d.ts","./node_modules/blockly/core/renderers/measurables/top_row.d.ts","./node_modules/blockly/core/renderers/common/info.d.ts","./node_modules/blockly/core/renderers/common/drawer.d.ts","./node_modules/blockly/core/renderers/common/i_path_object.d.ts","./node_modules/blockly/core/renderers/common/renderer.d.ts","./node_modules/blockly/core/scrollbar.d.ts","./node_modules/blockly/core/scrollbar_pair.d.ts","./node_modules/blockly/core/theme_manager.d.ts","./node_modules/blockly/core/drag_target.d.ts","./node_modules/blockly/core/delete_area.d.ts","./node_modules/blockly/core/events/events_trashcan_open.d.ts","./node_modules/blockly/core/trashcan.d.ts","./node_modules/blockly/core/workspace_audio.d.ts","./node_modules/blockly/core/zoom_controls.d.ts","./node_modules/blockly/core/workspace_svg.d.ts","./node_modules/blockly/core/interfaces/i_paster.d.ts","./node_modules/blockly/core/serialization/workspace_comments.d.ts","./node_modules/blockly/core/clipboard/workspace_comment_paster.d.ts","./node_modules/blockly/core/interfaces/i_deletable.d.ts","./node_modules/blockly/core/comments/rendered_workspace_comment.d.ts","./node_modules/blockly/core/contextmenu_registry.d.ts","./node_modules/blockly/core/shortcut_registry.d.ts","./node_modules/blockly/core/interfaces/i_keyboard_accessible.d.ts","./node_modules/blockly/core/field.d.ts","./node_modules/blockly/core/field_label.d.ts","./node_modules/blockly/core/connection_type.d.ts","./node_modules/blockly/core/inputs/align.d.ts","./node_modules/blockly/core/inputs/input_types.d.ts","./node_modules/blockly/core/inputs/input.d.ts","./node_modules/blockly/core/interfaces/i_connection_checker.d.ts","./node_modules/blockly/core/connection.d.ts","./node_modules/blockly/core/connection_checker.d.ts","./node_modules/blockly/core/connection_db.d.ts","./node_modules/blockly/core/interfaces/i_parameter_model.d.ts","./node_modules/blockly/core/serialization/procedures.d.ts","./node_modules/blockly/core/interfaces/i_procedure_model.d.ts","./node_modules/blockly/core/interfaces/i_procedure_map.d.ts","./node_modules/blockly/core/interfaces/i_variable_model.d.ts","./node_modules/blockly/core/interfaces/i_variable_map.d.ts","./node_modules/blockly/core/workspace.d.ts","./node_modules/blockly/core/events/events_selected.d.ts","./node_modules/blockly/core/clipboard/block_paster.d.ts","./node_modules/blockly/core/block_svg.d.ts","./node_modules/blockly/core/events/events_block_base.d.ts","./node_modules/blockly/core/events/events_block_change.d.ts","./node_modules/blockly/core/events/events_block_delete.d.ts","./node_modules/blockly/core/block.d.ts","./node_modules/blockly/core/events/events_block_create.d.ts","./node_modules/blockly/core/events/workspace_events.d.ts","./node_modules/blockly/core/events/events_var_base.d.ts","./node_modules/blockly/core/events/events_var_create.d.ts","./node_modules/blockly/core/block_animations.d.ts","./node_modules/blockly/core/interfaces/i_flyout_inflater.d.ts","./node_modules/blockly/core/block_flyout_inflater.d.ts","./node_modules/blockly/core/blocks.d.ts","./node_modules/blockly/core/bubbles/bubble.d.ts","./node_modules/blockly/core/bubbles/mini_workspace_bubble.d.ts","./node_modules/blockly/core/bubbles/text_bubble.d.ts","./node_modules/blockly/core/bubbles/textinput_bubble.d.ts","./node_modules/blockly/core/bubbles.d.ts","./node_modules/blockly/core/bump_objects.d.ts","./node_modules/blockly/core/button_flyout_inflater.d.ts","./node_modules/blockly/core/clipboard/registry.d.ts","./node_modules/blockly/core/clipboard.d.ts","./node_modules/blockly/core/common.d.ts","./node_modules/blockly/core/config.d.ts","./node_modules/blockly/core/constants.d.ts","./node_modules/blockly/core/contextmenu.d.ts","./node_modules/blockly/core/contextmenu_items.d.ts","./node_modules/blockly/core/css.d.ts","./node_modules/blockly/core/toast.d.ts","./node_modules/blockly/core/dialog.d.ts","./node_modules/blockly/core/dragging/block_drag_strategy.d.ts","./node_modules/blockly/core/dragging/bubble_drag_strategy.d.ts","./node_modules/blockly/core/dragging/comment_drag_strategy.d.ts","./node_modules/blockly/core/dragging/dragger.d.ts","./node_modules/blockly/core/dragging.d.ts","./node_modules/blockly/core/dropdowndiv.d.ts","./node_modules/blockly/core/events/events_block_drag.d.ts","./node_modules/blockly/core/events/events_block_field_intermediate_change.d.ts","./node_modules/blockly/core/events/events_block_move.d.ts","./node_modules/blockly/core/events/events_bubble_open.d.ts","./node_modules/blockly/core/events/events_comment_create.d.ts","./node_modules/blockly/core/events/events_comment_delete.d.ts","./node_modules/blockly/core/events/events_comment_base.d.ts","./node_modules/blockly/core/events/events_comment_change.d.ts","./node_modules/blockly/core/events/events_comment_collapse.d.ts","./node_modules/blockly/core/events/events_comment_drag.d.ts","./node_modules/blockly/core/events/events_comment_move.d.ts","./node_modules/blockly/core/events/events_comment_resize.d.ts","./node_modules/blockly/core/events/events_toolbox_item_select.d.ts","./node_modules/blockly/core/events/events_var_delete.d.ts","./node_modules/blockly/core/events/events_var_rename.d.ts","./node_modules/blockly/core/events/events_var_type_change.d.ts","./node_modules/blockly/core/events/utils.d.ts","./node_modules/blockly/core/events/events.d.ts","./node_modules/blockly/core/field_checkbox.d.ts","./node_modules/blockly/core/menu_separator.d.ts","./node_modules/blockly/core/menuitem.d.ts","./node_modules/blockly/core/menu.d.ts","./node_modules/blockly/core/field_dropdown.d.ts","./node_modules/blockly/core/field_image.d.ts","./node_modules/blockly/core/field_label_serializable.d.ts","./node_modules/blockly/core/field_input.d.ts","./node_modules/blockly/core/field_number.d.ts","./node_modules/blockly/core/field_registry.d.ts","./node_modules/blockly/core/field_textinput.d.ts","./node_modules/blockly/core/field_variable.d.ts","./node_modules/blockly/core/flyout_base.d.ts","./node_modules/blockly/core/flyout_horizontal.d.ts","./node_modules/blockly/core/flyout_metrics_manager.d.ts","./node_modules/blockly/core/flyout_separator.d.ts","./node_modules/blockly/core/flyout_vertical.d.ts","./node_modules/blockly/core/focus_manager.d.ts","./node_modules/blockly/core/names.d.ts","./node_modules/blockly/core/generator.d.ts","./node_modules/blockly/core/icons/exceptions.d.ts","./node_modules/blockly/core/icons/registry.d.ts","./node_modules/blockly/core/icons.d.ts","./node_modules/blockly/core/inject.d.ts","./node_modules/blockly/core/inputs/dummy_input.d.ts","./node_modules/blockly/core/inputs/end_row_input.d.ts","./node_modules/blockly/core/inputs/statement_input.d.ts","./node_modules/blockly/core/inputs/value_input.d.ts","./node_modules/blockly/core/inputs.d.ts","./node_modules/blockly/core/label_flyout_inflater.d.ts","./node_modules/blockly/core/separator_flyout_inflater.d.ts","./node_modules/blockly/core/utils/focusable_tree_traverser.d.ts","./node_modules/blockly/core/interfaces/i_connection_previewer.d.ts","./node_modules/blockly/core/insertion_marker_previewer.d.ts","./node_modules/blockly/core/interfaces/i_movable.d.ts","./node_modules/blockly/core/interfaces/i_observable.d.ts","./node_modules/blockly/core/interfaces/i_styleable.d.ts","./node_modules/blockly/core/interfaces/i_variable_backed_parameter_model.d.ts","./node_modules/blockly/core/keyboard_navigation_controller.d.ts","./node_modules/blockly/core/layers.d.ts","./node_modules/blockly/core/msg.d.ts","./node_modules/blockly/core/positionable_helpers.d.ts","./node_modules/blockly/core/interfaces/i_legacy_procedure_blocks.d.ts","./node_modules/blockly/core/interfaces/i_procedure_block.d.ts","./node_modules/blockly/core/observable_procedure_map.d.ts","./node_modules/blockly/core/procedures.d.ts","./node_modules/blockly/core/registry.d.ts","./node_modules/blockly/core/render_management.d.ts","./node_modules/blockly/core/renderers/measurables/external_value_input.d.ts","./node_modules/blockly/core/renderers/measurables/hat.d.ts","./node_modules/blockly/core/renderers/measurables/jagged_edge.d.ts","./node_modules/blockly/core/renderers/measurables/round_corner.d.ts","./node_modules/blockly/core/renderers/measurables/square_corner.d.ts","./node_modules/blockly/core/renderers/measurables/statement_input.d.ts","./node_modules/blockly/core/renderers/measurables/types.d.ts","./node_modules/blockly/core/renderers/common/path_object.d.ts","./node_modules/blockly/core/renderers/common/block_rendering.d.ts","./node_modules/blockly/core/renderers/geras/constants.d.ts","./node_modules/blockly/core/renderers/geras/highlight_constants.d.ts","./node_modules/blockly/core/renderers/geras/path_object.d.ts","./node_modules/blockly/core/renderers/geras/renderer.d.ts","./node_modules/blockly/core/renderers/geras/info.d.ts","./node_modules/blockly/core/renderers/geras/measurables/inline_input.d.ts","./node_modules/blockly/core/renderers/geras/highlighter.d.ts","./node_modules/blockly/core/renderers/geras/drawer.d.ts","./node_modules/blockly/core/renderers/geras/measurables/statement_input.d.ts","./node_modules/blockly/core/renderers/geras/geras.d.ts","./node_modules/blockly/core/renderers/thrasos/renderer.d.ts","./node_modules/blockly/core/renderers/thrasos/info.d.ts","./node_modules/blockly/core/renderers/thrasos/thrasos.d.ts","./node_modules/blockly/core/renderers/zelos/constants.d.ts","./node_modules/blockly/core/renderers/zelos/measurables/bottom_row.d.ts","./node_modules/blockly/core/renderers/zelos/measurables/row_elements.d.ts","./node_modules/blockly/core/renderers/zelos/measurables/top_row.d.ts","./node_modules/blockly/core/renderers/zelos/path_object.d.ts","./node_modules/blockly/core/renderers/zelos/renderer.d.ts","./node_modules/blockly/core/renderers/zelos/info.d.ts","./node_modules/blockly/core/renderers/zelos/drawer.d.ts","./node_modules/blockly/core/renderers/zelos/measurables/inputs.d.ts","./node_modules/blockly/core/renderers/zelos/zelos.d.ts","./node_modules/blockly/core/serialization/exceptions.d.ts","./node_modules/blockly/core/serialization/priorities.d.ts","./node_modules/blockly/core/serialization/registry.d.ts","./node_modules/blockly/core/serialization/variables.d.ts","./node_modules/blockly/core/serialization/workspaces.d.ts","./node_modules/blockly/core/serialization.d.ts","./node_modules/blockly/core/shortcut_items.d.ts","./node_modules/blockly/core/theme/classic.d.ts","./node_modules/blockly/core/theme/zelos.d.ts","./node_modules/blockly/core/theme/themes.d.ts","./node_modules/blockly/core/toolbox/collapsible_category.d.ts","./node_modules/blockly/core/toolbox/toolbox.d.ts","./node_modules/blockly/core/touch.d.ts","./node_modules/blockly/core/variable_map.d.ts","./node_modules/blockly/core/variable_model.d.ts","./node_modules/blockly/core/variables.d.ts","./node_modules/blockly/core/variables_dynamic.d.ts","./node_modules/blockly/core/widgetdiv.d.ts","./node_modules/blockly/core/xml.d.ts","./node_modules/blockly/core/flyout_navigator.d.ts","./node_modules/blockly/core/keyboard_nav/block_navigation_policy.d.ts","./node_modules/blockly/core/keyboard_nav/connection_navigation_policy.d.ts","./node_modules/blockly/core/keyboard_nav/field_navigation_policy.d.ts","./node_modules/blockly/core/keyboard_nav/flyout_button_navigation_policy.d.ts","./node_modules/blockly/core/keyboard_nav/flyout_navigation_policy.d.ts","./node_modules/blockly/core/keyboard_nav/flyout_separator_navigation_policy.d.ts","./node_modules/blockly/core/keyboard_nav/workspace_navigation_policy.d.ts","./node_modules/blockly/core/blockly.d.ts","./node_modules/blockly/index.d.ts","./src/renderer/src/lib/themeprovider.tsx","./src/renderer/src/lib/arduinoblocks.ts","./src/renderer/src/components/blocklyeditor.tsx","./src/renderer/src/assets/parts/index.json","./src/renderer/src/lib/partslibrary.ts","./src/renderer/src/lib/wirerouting.ts","./src/renderer/src/components/partseditor.tsx","./src/renderer/src/components/diagrameditor.tsx","./src/renderer/src/components/monacoeditor.tsx","./src/renderer/src/components/ui/filetab.tsx","./src/renderer/src/components/visualpreview.tsx","./src/renderer/src/components/editorpanel.tsx","./node_modules/@radix-ui/react-dismissable-layer/dist/index.d.ts","./node_modules/@radix-ui/react-arrow/dist/index.d.ts","./node_modules/@radix-ui/rect/dist/index.d.ts","./node_modules/@radix-ui/react-popper/dist/index.d.ts","./node_modules/@radix-ui/react-portal/dist/index.d.ts","./node_modules/@radix-ui/react-tooltip/dist/index.d.ts","./src/renderer/src/components/ui/tooltip.tsx","./node_modules/react-hook-form/dist/constants.d.ts","./node_modules/react-hook-form/dist/utils/createsubject.d.ts","./node_modules/react-hook-form/dist/types/events.d.ts","./node_modules/react-hook-form/dist/types/path/common.d.ts","./node_modules/react-hook-form/dist/types/path/eager.d.ts","./node_modules/react-hook-form/dist/types/path/index.d.ts","./node_modules/react-hook-form/dist/types/fieldarray.d.ts","./node_modules/react-hook-form/dist/types/resolvers.d.ts","./node_modules/react-hook-form/dist/types/form.d.ts","./node_modules/react-hook-form/dist/types/utils.d.ts","./node_modules/react-hook-form/dist/types/fields.d.ts","./node_modules/react-hook-form/dist/types/errors.d.ts","./node_modules/react-hook-form/dist/types/validator.d.ts","./node_modules/react-hook-form/dist/types/controller.d.ts","./node_modules/react-hook-form/dist/types/index.d.ts","./node_modules/react-hook-form/dist/controller.d.ts","./node_modules/react-hook-form/dist/form.d.ts","./node_modules/react-hook-form/dist/logic/appenderrors.d.ts","./node_modules/react-hook-form/dist/logic/createformcontrol.d.ts","./node_modules/react-hook-form/dist/logic/index.d.ts","./node_modules/react-hook-form/dist/usecontroller.d.ts","./node_modules/react-hook-form/dist/usefieldarray.d.ts","./node_modules/react-hook-form/dist/useform.d.ts","./node_modules/react-hook-form/dist/useformcontext.d.ts","./node_modules/react-hook-form/dist/useformstate.d.ts","./node_modules/react-hook-form/dist/usewatch.d.ts","./node_modules/react-hook-form/dist/utils/get.d.ts","./node_modules/react-hook-form/dist/utils/set.d.ts","./node_modules/react-hook-form/dist/utils/index.d.ts","./node_modules/react-hook-form/dist/index.d.ts","./node_modules/zod/v3/helpers/typealiases.d.cts","./node_modules/zod/v3/helpers/util.d.cts","./node_modules/zod/v3/zoderror.d.cts","./node_modules/zod/v3/locales/en.d.cts","./node_modules/zod/v3/errors.d.cts","./node_modules/zod/v3/helpers/parseutil.d.cts","./node_modules/zod/v3/helpers/enumutil.d.cts","./node_modules/zod/v3/helpers/errorutil.d.cts","./node_modules/zod/v3/helpers/partialutil.d.cts","./node_modules/zod/v3/standard-schema.d.cts","./node_modules/zod/v3/types.d.cts","./node_modules/zod/v3/external.d.cts","./node_modules/zod/v3/index.d.cts","./node_modules/zod/v4/core/standard-schema.d.cts","./node_modules/zod/v4/core/util.d.cts","./node_modules/zod/v4/core/versions.d.cts","./node_modules/zod/v4/core/schemas.d.cts","./node_modules/zod/v4/core/checks.d.cts","./node_modules/zod/v4/core/errors.d.cts","./node_modules/zod/v4/core/core.d.cts","./node_modules/zod/v4/core/parse.d.cts","./node_modules/zod/v4/core/regexes.d.cts","./node_modules/zod/v4/locales/ar.d.cts","./node_modules/zod/v4/locales/az.d.cts","./node_modules/zod/v4/locales/be.d.cts","./node_modules/zod/v4/locales/ca.d.cts","./node_modules/zod/v4/locales/cs.d.cts","./node_modules/zod/v4/locales/de.d.cts","./node_modules/zod/v4/locales/en.d.cts","./node_modules/zod/v4/locales/eo.d.cts","./node_modules/zod/v4/locales/es.d.cts","./node_modules/zod/v4/locales/fa.d.cts","./node_modules/zod/v4/locales/fi.d.cts","./node_modules/zod/v4/locales/fr.d.cts","./node_modules/zod/v4/locales/fr-ca.d.cts","./node_modules/zod/v4/locales/he.d.cts","./node_modules/zod/v4/locales/hu.d.cts","./node_modules/zod/v4/locales/id.d.cts","./node_modules/zod/v4/locales/it.d.cts","./node_modules/zod/v4/locales/ja.d.cts","./node_modules/zod/v4/locales/kh.d.cts","./node_modules/zod/v4/locales/ko.d.cts","./node_modules/zod/v4/locales/mk.d.cts","./node_modules/zod/v4/locales/ms.d.cts","./node_modules/zod/v4/locales/nl.d.cts","./node_modules/zod/v4/locales/no.d.cts","./node_modules/zod/v4/locales/ota.d.cts","./node_modules/zod/v4/locales/ps.d.cts","./node_modules/zod/v4/locales/pl.d.cts","./node_modules/zod/v4/locales/pt.d.cts","./node_modules/zod/v4/locales/ru.d.cts","./node_modules/zod/v4/locales/sl.d.cts","./node_modules/zod/v4/locales/sv.d.cts","./node_modules/zod/v4/locales/ta.d.cts","./node_modules/zod/v4/locales/th.d.cts","./node_modules/zod/v4/locales/tr.d.cts","./node_modules/zod/v4/locales/ua.d.cts","./node_modules/zod/v4/locales/ur.d.cts","./node_modules/zod/v4/locales/vi.d.cts","./node_modules/zod/v4/locales/zh-cn.d.cts","./node_modules/zod/v4/locales/zh-tw.d.cts","./node_modules/zod/v4/locales/index.d.cts","./node_modules/zod/v4/core/registries.d.cts","./node_modules/zod/v4/core/doc.d.cts","./node_modules/zod/v4/core/function.d.cts","./node_modules/zod/v4/core/api.d.cts","./node_modules/zod/v4/core/json-schema.d.cts","./node_modules/zod/v4/core/to-json-schema.d.cts","./node_modules/zod/v4/core/index.d.cts","./node_modules/@hookform/resolvers/zod/dist/zod.d.ts","./node_modules/@hookform/resolvers/zod/dist/index.d.ts","./node_modules/@radix-ui/react-focus-scope/dist/index.d.ts","./node_modules/@radix-ui/react-dialog/dist/index.d.ts","./src/renderer/src/components/ui/dialog.tsx","./node_modules/@radix-ui/react-label/dist/index.d.ts","./src/renderer/src/components/ui/label.tsx","./src/renderer/src/components/ui/form.tsx","./src/renderer/src/components/ui/input.tsx","./node_modules/zod/v4/classic/errors.d.cts","./node_modules/zod/v4/classic/parse.d.cts","./node_modules/zod/v4/classic/schemas.d.cts","./node_modules/zod/v4/classic/checks.d.cts","./node_modules/zod/v4/classic/compat.d.cts","./node_modules/zod/v4/classic/iso.d.cts","./node_modules/zod/v4/classic/coerce.d.cts","./node_modules/zod/v4/classic/external.d.cts","./node_modules/zod/index.d.cts","./src/renderer/src/components/fileexplorer/schemas.ts","./src/renderer/src/components/fileexplorer/utils.ts","./src/renderer/src/components/fileexplorer/createprojectdialog.tsx","./node_modules/@radix-ui/react-alert-dialog/dist/index.d.ts","./src/renderer/src/components/ui/alertdialog.tsx","./node_modules/@radix-ui/react-menu/dist/index.d.ts","./node_modules/@radix-ui/react-dropdown-menu/dist/index.d.ts","./src/renderer/src/components/ui/dropdownmenu.tsx","./src/renderer/src/components/fileexplorer/filetreeitem.tsx","./src/renderer/src/components/fileexplorer/fileexplorercontent.tsx","./src/renderer/src/hooks/usegithubaccount.ts","./src/renderer/src/components/fileexplorer/sourcecontrol.tsx","./src/renderer/src/components/fileexplorer/fileexplorer.tsx","./src/renderer/src/components/fileexplorer/index.ts","./src/renderer/src/components/githubaccountbutton.tsx","./src/renderer/src/components/header.tsx","./src/renderer/src/lib/serialbus.ts","./src/renderer/src/contexts/serialcontext.tsx","./node_modules/@radix-ui/react-select/dist/index.d.ts","./src/renderer/src/components/ui/select.tsx","./src/renderer/src/components/serialmonitor.tsx","./src/renderer/src/components/statusbar.tsx","./src/renderer/src/components/arduino/arduinobuttons.tsx","./src/renderer/src/components/arduino/boardcontrols.tsx","./src/renderer/src/components/arduino/librarymanager.tsx","./src/renderer/src/components/viewsegment.tsx","./src/renderer/src/components/toolbar.tsx","./node_modules/react-resizable-panels/dist/declarations/src/panel.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/types.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/panelgroup.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/panelresizehandleregistry.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/panelresizehandle.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/constants.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/hooks/usepanelgroupcontext.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/assert.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/csp.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/cursor.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/dom/getpanelelement.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/dom/getpanelelementsforgroup.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/dom/getpanelgroupelement.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/dom/getresizehandleelement.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/dom/getresizehandleelementindex.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/dom/getresizehandleelementsforgroup.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/dom/getresizehandlepanelids.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/rects/types.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/rects/getintersectingrectangle.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/rects/intersects.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/index.d.ts","./node_modules/react-resizable-panels/dist/react-resizable-panels.d.ts","./src/renderer/src/components/ui/resizable.tsx","./src/renderer/src/app.tsx","./node_modules/@types/react-dom/client.d.ts","./src/renderer/src/main.tsx","./src/renderer/src/commands/index.ts","./node_modules/react-zoom-pan-pinch/dist/index.d.ts","./src/renderer/src/components/circuiteditor.tsx","./src/renderer/src/components/ui/card.tsx","./src/renderer/src/components/examplescontent.tsx","./node_modules/@radix-ui/react-avatar/dist/index.d.ts","./src/renderer/src/components/ui/avatar.tsx","./src/renderer/src/components/usermenu.tsx","./src/renderer/src/components/arduino/boardselect.tsx","./src/renderer/src/components/arduino/index.ts","./node_modules/@radix-ui/react-collapsible/dist/index.d.ts","./node_modules/@radix-ui/react-accordion/dist/index.d.ts","./src/renderer/src/components/ui/accordion.tsx","./node_modules/@radix-ui/react-separator/dist/index.d.ts","./src/renderer/src/components/ui/separator.tsx","./node_modules/@radix-ui/react-switch/dist/index.d.ts","./src/renderer/src/components/ui/switch.tsx","./src/renderer/src/components/ui/themetoggle.tsx","./src/renderer/src/lib/arduinofileutils.ts","./node_modules/@types/node/compatibility/disposable.d.ts","./node_modules/@types/node/compatibility/indexable.d.ts","./node_modules/@types/node/compatibility/iterators.d.ts","./node_modules/@types/node/compatibility/index.d.ts","./node_modules/@types/node/globals.typedarray.d.ts","./node_modules/@types/node/buffer.buffer.d.ts","./node_modules/buffer/index.d.ts","./node_modules/undici-types/header.d.ts","./node_modules/undici-types/readable.d.ts","./node_modules/undici-types/file.d.ts","./node_modules/undici-types/fetch.d.ts","./node_modules/undici-types/formdata.d.ts","./node_modules/undici-types/connector.d.ts","./node_modules/undici-types/client.d.ts","./node_modules/undici-types/errors.d.ts","./node_modules/undici-types/dispatcher.d.ts","./node_modules/undici-types/global-dispatcher.d.ts","./node_modules/undici-types/global-origin.d.ts","./node_modules/undici-types/pool-stats.d.ts","./node_modules/undici-types/pool.d.ts","./node_modules/undici-types/handlers.d.ts","./node_modules/undici-types/balanced-pool.d.ts","./node_modules/undici-types/agent.d.ts","./node_modules/undici-types/mock-interceptor.d.ts","./node_modules/undici-types/mock-agent.d.ts","./node_modules/undici-types/mock-client.d.ts","./node_modules/undici-types/mock-pool.d.ts","./node_modules/undici-types/mock-errors.d.ts","./node_modules/undici-types/proxy-agent.d.ts","./node_modules/undici-types/env-http-proxy-agent.d.ts","./node_modules/undici-types/retry-handler.d.ts","./node_modules/undici-types/retry-agent.d.ts","./node_modules/undici-types/api.d.ts","./node_modules/undici-types/interceptors.d.ts","./node_modules/undici-types/util.d.ts","./node_modules/undici-types/cookies.d.ts","./node_modules/undici-types/patch.d.ts","./node_modules/undici-types/websocket.d.ts","./node_modules/undici-types/eventsource.d.ts","./node_modules/undici-types/filereader.d.ts","./node_modules/undici-types/diagnostics-channel.d.ts","./node_modules/undici-types/content-type.d.ts","./node_modules/undici-types/cache.d.ts","./node_modules/undici-types/index.d.ts","./node_modules/@types/node/globals.d.ts","./node_modules/@types/node/assert.d.ts","./node_modules/@types/node/assert/strict.d.ts","./node_modules/@types/node/async_hooks.d.ts","./node_modules/@types/node/buffer.d.ts","./node_modules/@types/node/child_process.d.ts","./node_modules/@types/node/cluster.d.ts","./node_modules/@types/node/console.d.ts","./node_modules/@types/node/constants.d.ts","./node_modules/@types/node/crypto.d.ts","./node_modules/@types/node/dgram.d.ts","./node_modules/@types/node/diagnostics_channel.d.ts","./node_modules/@types/node/dns.d.ts","./node_modules/@types/node/dns/promises.d.ts","./node_modules/@types/node/domain.d.ts","./node_modules/@types/node/dom-events.d.ts","./node_modules/@types/node/events.d.ts","./node_modules/@types/node/fs.d.ts","./node_modules/@types/node/fs/promises.d.ts","./node_modules/@types/node/http.d.ts","./node_modules/@types/node/http2.d.ts","./node_modules/@types/node/https.d.ts","./node_modules/@types/node/inspector.d.ts","./node_modules/@types/node/module.d.ts","./node_modules/@types/node/net.d.ts","./node_modules/@types/node/os.d.ts","./node_modules/@types/node/path.d.ts","./node_modules/@types/node/perf_hooks.d.ts","./node_modules/@types/node/process.d.ts","./node_modules/@types/node/punycode.d.ts","./node_modules/@types/node/querystring.d.ts","./node_modules/@types/node/readline.d.ts","./node_modules/@types/node/readline/promises.d.ts","./node_modules/@types/node/repl.d.ts","./node_modules/@types/node/sea.d.ts","./node_modules/@types/node/sqlite.d.ts","./node_modules/@types/node/stream.d.ts","./node_modules/@types/node/stream/promises.d.ts","./node_modules/@types/node/stream/consumers.d.ts","./node_modules/@types/node/stream/web.d.ts","./node_modules/@types/node/string_decoder.d.ts","./node_modules/@types/node/test.d.ts","./node_modules/@types/node/timers.d.ts","./node_modules/@types/node/timers/promises.d.ts","./node_modules/@types/node/tls.d.ts","./node_modules/@types/node/trace_events.d.ts","./node_modules/@types/node/tty.d.ts","./node_modules/@types/node/url.d.ts","./node_modules/@types/node/util.d.ts","./node_modules/@types/node/v8.d.ts","./node_modules/@types/node/vm.d.ts","./node_modules/@types/node/wasi.d.ts","./node_modules/@types/node/worker_threads.d.ts","./node_modules/@types/node/zlib.d.ts","./node_modules/@types/node/index.d.ts","./node_modules/electron/electron.d.ts","./node_modules/@electron-toolkit/preload/dist/index.d.ts","./src/preload/index.d.ts","./node_modules/@babel/types/lib/index.d.ts","./node_modules/@types/babel__generator/index.d.ts","./node_modules/@babel/parser/typings/babel-parser.d.ts","./node_modules/@types/babel__template/index.d.ts","./node_modules/@types/babel__traverse/index.d.ts","./node_modules/@types/babel__core/index.d.ts","./node_modules/keyv/src/index.d.ts","./node_modules/@types/http-cache-semantics/index.d.ts","./node_modules/@types/responselike/index.d.ts","./node_modules/@types/cacheable-request/index.d.ts","./node_modules/@types/ms/index.d.ts","./node_modules/@types/debug/index.d.ts","./node_modules/@types/estree/index.d.ts","./node_modules/@types/estree-jsx/index.d.ts","./node_modules/@types/fs-extra/index.d.ts","./node_modules/@types/json-schema/index.d.ts","./node_modules/@types/keyv/index.d.ts","./node_modules/@types/react-dom/index.d.ts","./node_modules/@types/use-sync-external-store/index.d.ts","./node_modules/@types/yauzl/index.d.ts"],"fileIdsList":[[113,714,757],[714,757],[113,117,714,757],[113,114,115,116,117,118,714,757],[714,757,811],[714,757,808],[619,714,757],[549,562,618,714,757],[187,714,757],[90,187,188,714,757],[90,129,130,700,714,757],[90,129,622,714,757],[90,130,714,757],[90,129,130,714,757],[90,714,757],[90,129,130,513,517,621,714,757],[90,129,130,642,714,757],[90,129,130,183,513,516,517,621,714,757],[90,129,130,514,515,714,757],[90,129,130,513,516,517,621,714,757],[90,129,130,183,714,757],[90,129,130,513,516,517,714,757],[92,93,94,95,96,714,757],[91,714,757],[714,757,811,812,813,814,815],[714,757,811,813],[714,757,769,772,800,807,817,818,819],[714,757,821],[714,757,823,824],[714,757,770,807],[134,714,757],[714,757,769,807],[714,754,757],[714,756,757],[757],[714,757,762,792],[714,757,758,763,769,770,777,789,800],[714,757,758,759,769,777],[709,710,711,714,757],[714,757,760,801],[714,757,761,762,770,778],[714,757,762,789,797],[714,757,763,765,769,777],[714,756,757,764],[714,757,765,766],[714,757,767,769],[714,756,757,769],[714,757,769,770,771,789,800],[714,757,769,770,771,784,789,792],[714,752,757],[714,752,757,765,769,772,777,789,800],[714,757,769,770,772,773,777,789,797,800],[714,757,772,774,789,797,800],[712,713,714,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806],[714,757,769,775],[714,757,776,800],[714,757,765,769,777,789],[714,757,778],[714,757,779],[714,756,757,780],[714,754,755,756,757,758,759,760,761,762,763,764,765,766,767,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806],[714,757,782],[714,757,783],[714,757,769,784,785],[714,757,784,786,801,803],[714,757,769,789,790,792],[714,757,791,792],[714,757,789,790],[714,757,792],[714,757,793],[714,754,757,789],[714,757,769,795,796],[714,757,795,796],[714,757,762,777,789,797],[714,757,798],[714,757,777,799],[714,757,772,783,800],[714,757,762,801],[714,757,789,802],[714,757,776,803],[714,757,804],[714,757,769,771,780,789,792,800,803,805],[714,757,789,806],[88,89,714,757],[714,757,772,789,807],[714,757,769,789,807],[197,198,204,260,264,266,267,319,321,324,326,333,335,340,341,343,714,757],[338,714,757],[203,213,225,226,310,338,348,714,757],[193,194,196,197,208,209,212,225,237,264,266,267,270,280,299,310,314,316,321,324,326,335,336,337,342,714,757],[193,194,195,196,199,203,206,207,209,210,211,212,213,217,218,219,220,221,222,223,224,226,228,229,230,231,232,233,236,237,238,239,240,241,242,259,260,267,268,269,270,271,272,273,274,275,276,277,278,279,280,301,302,303,304,305,307,308,309,310,311,314,316,317,318,319,320,321,324,325,326,327,328,333,334,335,338,342,343,344,346,347,348,349,350,355,356,357,359,360,361,362,363,364,365,366,367,372,373,391,392,394,395,396,397,398,400,401,402,403,404,405,406,407,408,409,410,411,414,415,420,421,422,423,424,425,426,427,428,429,430,431,432,433,437,438,439,448,458,461,471,477,478,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,714,757],[225,270,310,714,757],[351,352,353,354,714,757],[193,195,197,204,208,238,310,714,757],[197,198,208,271,272,310,351,714,757],[197,208,310,351,714,757],[197,204,208,310,351,714,757],[198,212,229,310,714,757],[213,226,348,714,757],[196,197,310,337,358,714,757],[196,197,216,310,311,338,714,757],[196,311,714,757],[196,197,310,311,312,315,714,757],[205,235,315,714,757],[197,204,232,310,714,757],[193,194,195,196,197,204,205,208,209,212,232,237,310,313,314,714,757],[197,204,335,714,757],[195,310,326,335,342,350,714,757],[206,207,210,211,230,714,757],[216,324,325,342,714,757],[280,325,326,714,757],[197,280,325,714,757],[197,216,310,316,338,342,714,757],[194,197,310,315,338,714,757],[209,211,304,714,757],[310,366,714,757],[208,209,210,714,757],[368,369,370,371,714,757],[209,259,338,714,757],[209,259,499,714,757],[209,236,259,714,757],[197,209,210,239,310,314,714,757],[319,338,714,757],[198,199,200,201,202,234,306,336,339,340,341,343,344,345,346,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,714,757],[335,714,757],[198,335,342,714,757],[200,335,338,339,342,714,757],[200,216,335,339,342,714,757],[198,199,200,335,342,714,757],[200,335,339,342,714,757],[197,200,335,339,342,714,757],[198,199,200,335,338,714,757],[198,205,335,378,379,714,757],[200,205,335,380,714,757],[200,205,312,335,380,714,757],[198,199,200,205,335,714,757],[197,200,205,335,380,714,757],[200,204,205,335,380,714,757],[198,199,200,335,714,757],[198,714,757],[198,333,335,714,757],[200,333,335,345,714,757],[198,335,342,343,376,378,384,385,714,757],[198,200,335,714,757],[342,714,757],[193,194,197,204,208,220,241,260,281,317,318,324,340,342,714,757],[319,340,714,757],[319,394,395,714,757],[319,714,757],[204,310,319,340,714,757],[320,714,757],[319,399,714,757],[319,340,399,714,757],[319,333,340,342,394,395,396,714,757],[193,194,197,207,213,214,216,225,226,272,305,310,338,348,714,757],[193,194,197,208,212,225,232,310,714,757],[197,208,213,272,404,714,757],[194,212,714,757],[226,229,310,714,757],[226,279,714,757],[193,194,208,212,714,757],[193,194,714,757],[335,342,410,714,757],[197,226,234,236,238,239,267,268,310,319,338,714,757],[197,272,714,757],[261,262,264,265,266,412,413,714,757],[204,238,240,241,259,261,263,266,342,714,757],[267,714,757],[193,197,204,260,266,267,342,714,757],[263,264,265,267,714,757],[197,198,204,238,240,261,266,310,338,714,757],[266,267,342,714,757],[197,238,240,259,261,266,338,714,757],[271,310,714,757],[322,323,324,416,417,418,419,714,757],[323,324,342,714,757],[319,320,321,322,323,326,338,342,714,757],[323,324,326,342,714,757],[280,338,424,714,757],[206,714,757],[208,714,757],[194,197,209,237,714,757],[217,218,714,757],[197,204,240,241,262,267,714,757],[280,326,714,757],[280,338,714,757],[195,714,757],[209,210,714,757],[206,208,209,714,757],[197,714,757],[193,197,213,214,220,225,310,338,714,757],[213,226,714,757],[193,714,757],[194,714,757],[238,714,757],[194,197,204,266,714,757],[317,714,757],[204,227,229,714,757],[330,331,714,757],[196,197,310,714,757],[206,208,229,714,757],[331,342,714,757],[331,714,757],[329,330,714,757],[194,335,714,757],[217,225,714,757],[193,217,220,225,226,310,714,757],[329,333,714,757],[333,714,757],[194,261,278,280,319,338,714,757],[194,278,280,338,714,757],[194,278,319,714,757],[194,233,278,714,757],[194,226,278,714,757],[194,278,407,714,757],[194,274,310,338,714,757],[194,338,714,757],[194,278,310,714,757],[194,197,232,310,714,757],[274,275,310,714,757],[197,204,243,393,394,714,757],[243,714,757],[204,221,225,226,227,228,310,714,757],[333,334,335,714,757],[194,278,714,757],[331,332,714,757],[225,227,270,271,310,714,757],[204,208,229,310,714,757],[198,225,310,319,329,331,332,335,340,342,434,435,436,714,757],[196,198,215,221,222,226,228,239,267,270,272,275,300,311,319,324,325,333,334,348,424,714,757],[310,338,714,757],[193,194,197,237,326,338,342,714,757],[270,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,440,441,442,443,444,445,446,447,714,757],[270,280,714,757],[259,281,283,284,285,287,289,297,338,714,757],[197,270,280,281,338,714,757],[280,281,282,283,289,291,292,293,294,296,300,324,338,714,757],[197,270,280,281,299,326,338,714,757],[220,270,281,297,298,299,326,338,714,757],[281,714,757],[289,298,338,449,453,454,455,714,757],[449,450,451,452,453,454,455,456,457,714,757],[281,289,291,296,450,453,454,714,757],[282,289,297,324,338,449,452,714,757],[281,287,324,449,714,757],[281,324,445,449,714,757],[270,338,447,449,714,757],[270,297,300,338,449,450,451,453,456,714,757],[281,289,290,338,714,757],[280,281,282,714,757],[281,286,324,714,757],[281,282,319,324,714,757],[281,282,714,757],[267,281,282,714,757],[281,283,324,338,714,757],[281,289,714,757],[280,281,283,714,757],[281,282,286,288,714,757],[281,288,289,714,757],[281,289,295,338,714,757],[282,284,285,286,287,288,289,290,291,292,294,295,296,440,441,442,443,444,445,714,757],[282,289,297,338,459,714,757],[300,338,460,714,757],[459,460,714,757],[270,280,281,714,757],[283,287,289,298,338,468,714,757],[282,289,297,324,338,462,463,464,465,467,714,757],[281,291,338,714,757],[281,324,445,714,757],[281,296,338,714,757],[270,326,338,447,462,714,757],[270,297,300,338,462,466,468,469,714,757],[462,463,464,465,466,467,468,469,470,714,757],[197,203,227,310,714,757],[227,301,310,714,757],[215,216,312,330,472,473,474,475,476,714,757],[215,326,335,342,714,757],[216,342,714,757],[215,329,331,335,714,757],[215,714,757],[215,333,335,714,757],[205,215,335,714,757],[249,310,316,714,757],[270,714,757],[479,480,714,757],[270,310,335,714,757],[310,714,757],[218,219,221,222,225,714,757],[217,219,221,223,225,714,757],[221,222,225,714,757],[193,194,203,207,208,209,217,218,221,225,226,305,310,317,318,386,428,714,757],[193,217,219,221,225,310,714,757],[269,714,757],[207,208,209,226,229,230,305,306,310,714,757],[197,203,204,208,214,225,227,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,714,757],[214,714,757],[197,204,208,714,757],[197,208,310,714,757],[216,223,224,714,757],[333,334,335,342,387,388,714,757],[333,335,346,714,757],[225,310,333,335,342,714,757],[225,233,310,335,714,757],[204,208,310,714,757],[198,205,225,272,325,327,328,332,333,334,342,714,757],[197,310,714,757],[193,194,197,201,202,203,204,205,208,210,212,214,221,225,226,227,228,231,233,237,269,270,272,273,274,275,276,277,279,300,302,303,307,308,309,316,335,338,342,343,714,757],[205,310,333,335,342,714,757],[208,229,230,234,310,714,757],[192,499,714,757],[110,180,714,757],[110,714,757],[714,757,769,770,807],[714,757,769],[135,145,146,147,171,172,173,714,757],[135,146,173,714,757],[135,145,146,173,714,757],[148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,714,757],[135,139,145,147,173,714,757],[90,534,714,757],[534,535,536,539,540,541,542,543,544,545,548,714,757],[534,714,757],[537,538,714,757],[90,532,534,714,757],[529,530,532,714,757],[525,528,530,532,714,757],[529,532,714,757],[90,520,521,522,525,526,527,529,530,531,532,714,757],[522,525,526,527,528,529,530,531,532,533,714,757],[529,714,757],[523,529,530,714,757],[523,524,714,757],[528,530,531,714,757],[528,714,757],[520,525,530,531,714,757],[546,547,714,757],[176,714,757],[90,135,144,173,175,714,757],[90,92,714,757],[664,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,682,683,714,757],[90,665,714,757],[90,667,714,757],[665,714,757],[664,714,757],[681,714,757],[684,714,757],[92,714,757],[173,174,714,757],[135,139,144,145,173,714,757],[141,714,757],[714,724,728,757,800],[714,724,757,789,800],[714,719,757],[714,721,724,757,797,800],[714,757,777,797],[714,757,807],[714,719,757,807],[714,721,724,757,777,800],[714,716,717,720,723,757,769,789,800],[714,724,731,757],[714,716,722,757],[714,724,745,746,757],[714,720,724,757,792,800,807],[714,745,757,807],[714,718,719,757,807],[714,724,757],[714,718,719,720,721,722,723,724,725,726,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,746,747,748,749,750,751,757],[714,724,739,757],[714,724,731,732,757],[714,722,724,732,733,757],[714,723,757],[714,716,719,724,757],[714,724,728,732,733,757],[714,728,757],[714,722,724,727,757,800],[714,716,721,724,731,757],[714,757,789],[714,719,724,745,757,805,807],[139,143,714,757],[134,139,140,142,144,714,757],[136,714,757],[137,138,714,757],[134,137,139,714,757],[85,714,757],[81,714,757],[82,714,757],[83,84,714,757],[635,714,757],[552,553,714,757],[550,551,552,554,555,560,714,757],[551,552,714,757],[560,714,757],[561,714,757],[552,714,757],[550,551,552,555,556,557,558,559,714,757],[550,551,562,714,757],[618,714,757],[618,630,714,757],[611,618,628,629,630,631,632,633,634,714,757],[618,628,714,757],[618,629,714,757],[564,566,567,568,569,714,757],[564,566,568,569,714,757],[564,566,568,714,757],[564,566,567,569,714,757],[564,566,569,714,757],[564,565,566,567,568,569,570,571,611,612,613,614,615,616,617,714,757],[566,569,714,757],[563,564,565,567,568,569,714,757],[566,612,616,714,757],[566,567,568,569,714,757],[568,714,757],[572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,714,757],[714,757,809],[90,91,99,105,108,124,128,186,512,650,652,654,657,658,663,686,714,757],[91,97,99,101,103,104,714,757],[90,91,108,109,128,132,714,757],[90,91,99,108,109,125,128,182,519,714,757],[90,91,109,120,128,654,656,714,757],[90,91,109,120,128,182,519,656,714,757],[91,659,698,714,757],[90,91,109,120,125,128,182,519,623,714,757],[90,91,500,501,502,714,757],[86,91,103,106,691,714,757],[90,91,109,505,506,507,714,757],[91,108,109,133,178,182,185,714,757],[86,90,91,99,101,102,105,108,109,125,182,187,189,190,191,503,508,509,510,511,714,757],[91,109,132,182,693,714,757],[90,91,99,109,182,549,620,623,626,627,637,638,714,757],[90,91,109,646,648,714,757],[90,91,105,108,109,132,182,519,639,645,714,757],[90,91,105,108,109,182,627,638,641,644,714,757],[91,637,638,639,645,646,649,714,757],[91,636,714,757],[90,91,105,108,109,125,132,182,190,647,714,757],[91,99,714,757],[90,91,109,125,182,623,644,647,714,757],[90,91,108,109,112,182,651,714,757],[90,91,108,187,189,501,714,757],[90,91,109,505,714,757],[91,108,109,177,714,757],[90,91,102,108,109,128,132,182,654,656,714,757],[91,109,128,182,714,757],[90,91,99,108,109,128,182,519,659,660,661,662,714,757],[90,91,109,112,701,714,757],[90,91,112,182,640,714,757],[90,91,112,695,714,757],[90,91,112,179,181,714,757],[90,91,112,714,757],[90,91,109,112,622,714,757],[90,91,109,112,643,714,757],[90,91,109,112,184,714,757],[90,91,112,179,549,624,625,714,757],[90,91,112,624,714,757],[90,91,109,112,685,714,757],[90,91,112,131,714,757],[90,91,109,112,655,714,757],[90,91,112,703,714,757],[90,91,112,705,714,757],[90,91,112,184,714,757],[91,109,182,501,519,714,757],[90,91,112,518,714,757],[91,109,644,696,714,757],[90,91,105,108,109,714,757],[90,91,109,714,757],[90,91,127,714,757],[90,91,128,653,714,757],[86,714,757],[90,91,120,124,125,126,714,757],[90,91,120,124,714,757],[90,91,190,714,757],[91,500,714,757],[91,120,714,757],[91,98,714,757],[91,99,101,714,757],[91,504,714,757],[90,91,714,757],[91,110,111,714,757],[86,90,91,106,108,125,501,687,688,714,757],[91,97,714,757],[91,97,100,714,757],[91,103,106,714,757],[91,101,102,103,107,714,757],[91,97,101,102,714,757],[91,112,120,121,123,714,757],[91,119,120,714,757],[91,120,121,122,124,714,757]],"fileInfos":[{"version":"69684132aeb9b5642cbcd9e22dff7818ff0ee1aa831728af0ecf97d3364d5546","affectsGlobalScope":true,"impliedFormat":1},{"version":"45b7ab580deca34ae9729e97c13cfd999df04416a79116c3bfb483804f85ded4","impliedFormat":1},{"version":"3facaf05f0c5fc569c5649dd359892c98a85557e3e0c847964caeb67076f4d75","impliedFormat":1},{"version":"e44bb8bbac7f10ecc786703fe0a6a4b952189f908707980ba8f3c8975a760962","impliedFormat":1},{"version":"5e1c4c362065a6b95ff952c0eab010f04dcd2c3494e813b493ecfd4fcb9fc0d8","impliedFormat":1},{"version":"68d73b4a11549f9c0b7d352d10e91e5dca8faa3322bfb77b661839c42b1ddec7","impliedFormat":1},{"version":"5efce4fc3c29ea84e8928f97adec086e3dc876365e0982cc8479a07954a3efd4","impliedFormat":1},{"version":"feecb1be483ed332fad555aff858affd90a48ab19ba7272ee084704eb7167569","impliedFormat":1},{"version":"ee7bad0c15b58988daa84371e0b89d313b762ab83cb5b31b8a2d1162e8eb41c2","impliedFormat":1},{"version":"27bdc30a0e32783366a5abeda841bc22757c1797de8681bbe81fbc735eeb1c10","impliedFormat":1},{"version":"8fd575e12870e9944c7e1d62e1f5a73fcf23dd8d3a321f2a2c74c20d022283fe","impliedFormat":1},{"version":"8bf8b5e44e3c9c36f98e1007e8b7018c0f38d8adc07aecef42f5200114547c70","impliedFormat":1},{"version":"092c2bfe125ce69dbb1223c85d68d4d2397d7d8411867b5cc03cec902c233763","affectsGlobalScope":true,"impliedFormat":1},{"version":"07f073f19d67f74d732b1adea08e1dc66b1b58d77cb5b43931dee3d798a2fd53","affectsGlobalScope":true,"impliedFormat":1},{"version":"c57796738e7f83dbc4b8e65132f11a377649c00dd3eee333f672b8f0a6bea671","affectsGlobalScope":true,"impliedFormat":1},{"version":"dc2df20b1bcdc8c2d34af4926e2c3ab15ffe1160a63e58b7e09833f616efff44","affectsGlobalScope":true,"impliedFormat":1},{"version":"515d0b7b9bea2e31ea4ec968e9edd2c39d3eebf4a2d5cbd04e88639819ae3b71","affectsGlobalScope":true,"impliedFormat":1},{"version":"0559b1f683ac7505ae451f9a96ce4c3c92bdc71411651ca6ddb0e88baaaad6a3","affectsGlobalScope":true,"impliedFormat":1},{"version":"0dc1e7ceda9b8b9b455c3a2d67b0412feab00bd2f66656cd8850e8831b08b537","affectsGlobalScope":true,"impliedFormat":1},{"version":"ce691fb9e5c64efb9547083e4a34091bcbe5bdb41027e310ebba8f7d96a98671","affectsGlobalScope":true,"impliedFormat":1},{"version":"8d697a2a929a5fcb38b7a65594020fcef05ec1630804a33748829c5ff53640d0","affectsGlobalScope":true,"impliedFormat":1},{"version":"4ff2a353abf8a80ee399af572debb8faab2d33ad38c4b4474cff7f26e7653b8d","affectsGlobalScope":true,"impliedFormat":1},{"version":"936e80ad36a2ee83fc3caf008e7c4c5afe45b3cf3d5c24408f039c1d47bdc1df","affectsGlobalScope":true,"impliedFormat":1},{"version":"d15bea3d62cbbdb9797079416b8ac375ae99162a7fba5de2c6c505446486ac0a","affectsGlobalScope":true,"impliedFormat":1},{"version":"68d18b664c9d32a7336a70235958b8997ebc1c3b8505f4f1ae2b7e7753b87618","affectsGlobalScope":true,"impliedFormat":1},{"version":"eb3d66c8327153d8fa7dd03f9c58d351107fe824c79e9b56b462935176cdf12a","affectsGlobalScope":true,"impliedFormat":1},{"version":"38f0219c9e23c915ef9790ab1d680440d95419ad264816fa15009a8851e79119","affectsGlobalScope":true,"impliedFormat":1},{"version":"69ab18c3b76cd9b1be3d188eaf8bba06112ebbe2f47f6c322b5105a6fbc45a2e","affectsGlobalScope":true,"impliedFormat":1},{"version":"fef8cfad2e2dc5f5b3d97a6f4f2e92848eb1b88e897bb7318cef0e2820bceaab","affectsGlobalScope":true,"impliedFormat":1},{"version":"2f11ff796926e0832f9ae148008138ad583bd181899ab7dd768a2666700b1893","affectsGlobalScope":true,"impliedFormat":1},{"version":"4de680d5bb41c17f7f68e0419412ca23c98d5749dcaaea1896172f06435891fc","affectsGlobalScope":true,"impliedFormat":1},{"version":"954296b30da6d508a104a3a0b5d96b76495c709785c1d11610908e63481ee667","affectsGlobalScope":true,"impliedFormat":1},{"version":"ac9538681b19688c8eae65811b329d3744af679e0bdfa5d842d0e32524c73e1c","affectsGlobalScope":true,"impliedFormat":1},{"version":"0a969edff4bd52585473d24995c5ef223f6652d6ef46193309b3921d65dd4376","affectsGlobalScope":true,"impliedFormat":1},{"version":"9e9fbd7030c440b33d021da145d3232984c8bb7916f277e8ffd3dc2e3eae2bdb","affectsGlobalScope":true,"impliedFormat":1},{"version":"811ec78f7fefcabbda4bfa93b3eb67d9ae166ef95f9bff989d964061cbf81a0c","affectsGlobalScope":true,"impliedFormat":1},{"version":"717937616a17072082152a2ef351cb51f98802fb4b2fdabd32399843875974ca","affectsGlobalScope":true,"impliedFormat":1},{"version":"d7e7d9b7b50e5f22c915b525acc5a49a7a6584cf8f62d0569e557c5cfc4b2ac2","affectsGlobalScope":true,"impliedFormat":1},{"version":"71c37f4c9543f31dfced6c7840e068c5a5aacb7b89111a4364b1d5276b852557","affectsGlobalScope":true,"impliedFormat":1},{"version":"576711e016cf4f1804676043e6a0a5414252560eb57de9faceee34d79798c850","affectsGlobalScope":true,"impliedFormat":1},{"version":"89c1b1281ba7b8a96efc676b11b264de7a8374c5ea1e6617f11880a13fc56dc6","affectsGlobalScope":true,"impliedFormat":1},{"version":"74f7fa2d027d5b33eb0471c8e82a6c87216223181ec31247c357a3e8e2fddc5b","affectsGlobalScope":true,"impliedFormat":1},{"version":"d6d7ae4d1f1f3772e2a3cde568ed08991a8ae34a080ff1151af28b7f798e22ca","affectsGlobalScope":true,"impliedFormat":1},{"version":"063600664504610fe3e99b717a1223f8b1900087fab0b4cad1496a114744f8df","affectsGlobalScope":true,"impliedFormat":1},{"version":"934019d7e3c81950f9a8426d093458b65d5aff2c7c1511233c0fd5b941e608ab","affectsGlobalScope":true,"impliedFormat":1},{"version":"52ada8e0b6e0482b728070b7639ee42e83a9b1c22d205992756fe020fd9f4a47","affectsGlobalScope":true,"impliedFormat":1},{"version":"3bdefe1bfd4d6dee0e26f928f93ccc128f1b64d5d501ff4a8cf3c6371200e5e6","affectsGlobalScope":true,"impliedFormat":1},{"version":"59fb2c069260b4ba00b5643b907ef5d5341b167e7d1dbf58dfd895658bda2867","affectsGlobalScope":true,"impliedFormat":1},{"version":"639e512c0dfc3fad96a84caad71b8834d66329a1f28dc95e3946c9b58176c73a","affectsGlobalScope":true,"impliedFormat":1},{"version":"368af93f74c9c932edd84c58883e736c9e3d53cec1fe24c0b0ff451f529ceab1","affectsGlobalScope":true,"impliedFormat":1},{"version":"af3dd424cf267428f30ccfc376f47a2c0114546b55c44d8c0f1d57d841e28d74","affectsGlobalScope":true,"impliedFormat":1},{"version":"995c005ab91a498455ea8dfb63aa9f83fa2ea793c3d8aa344be4a1678d06d399","affectsGlobalScope":true,"impliedFormat":1},{"version":"959d36cddf5e7d572a65045b876f2956c973a586da58e5d26cde519184fd9b8a","affectsGlobalScope":true,"impliedFormat":1},{"version":"965f36eae237dd74e6cca203a43e9ca801ce38824ead814728a2807b1910117d","affectsGlobalScope":true,"impliedFormat":1},{"version":"3925a6c820dcb1a06506c90b1577db1fdbf7705d65b62b99dce4be75c637e26b","affectsGlobalScope":true,"impliedFormat":1},{"version":"0a3d63ef2b853447ec4f749d3f368ce642264246e02911fcb1590d8c161b8005","affectsGlobalScope":true,"impliedFormat":1},{"version":"b5ce7a470bc3628408429040c4e3a53a27755022a32fd05e2cb694e7015386c7","affectsGlobalScope":true,"impliedFormat":1},{"version":"8444af78980e3b20b49324f4a16ba35024fef3ee069a0eb67616ea6ca821c47a","affectsGlobalScope":true,"impliedFormat":1},{"version":"3287d9d085fbd618c3971944b65b4be57859f5415f495b33a6adc994edd2f004","affectsGlobalScope":true,"impliedFormat":1},{"version":"b4b67b1a91182421f5df999988c690f14d813b9850b40acd06ed44691f6727ad","affectsGlobalScope":true,"impliedFormat":1},{"version":"df83c2a6c73228b625b0beb6669c7ee2a09c914637e2d35170723ad49c0f5cd4","affectsGlobalScope":true,"impliedFormat":1},{"version":"436aaf437562f276ec2ddbee2f2cdedac7664c1e4c1d2c36839ddd582eeb3d0a","affectsGlobalScope":true,"impliedFormat":1},{"version":"8e3c06ea092138bf9fa5e874a1fdbc9d54805d074bee1de31b99a11e2fec239d","affectsGlobalScope":true,"impliedFormat":1},{"version":"87dc0f382502f5bbce5129bdc0aea21e19a3abbc19259e0b43ae038a9fc4e326","affectsGlobalScope":true,"impliedFormat":1},{"version":"b1cb28af0c891c8c96b2d6b7be76bd394fddcfdb4709a20ba05a7c1605eea0f9","affectsGlobalScope":true,"impliedFormat":1},{"version":"2fef54945a13095fdb9b84f705f2b5994597640c46afeb2ce78352fab4cb3279","affectsGlobalScope":true,"impliedFormat":1},{"version":"ac77cb3e8c6d3565793eb90a8373ee8033146315a3dbead3bde8db5eaf5e5ec6","affectsGlobalScope":true,"impliedFormat":1},{"version":"56e4ed5aab5f5920980066a9409bfaf53e6d21d3f8d020c17e4de584d29600ad","affectsGlobalScope":true,"impliedFormat":1},{"version":"4ece9f17b3866cc077099c73f4983bddbcb1dc7ddb943227f1ec070f529dedd1","affectsGlobalScope":true,"impliedFormat":1},{"version":"0a6282c8827e4b9a95f4bf4f5c205673ada31b982f50572d27103df8ceb8013c","affectsGlobalScope":true,"impliedFormat":1},{"version":"1c9319a09485199c1f7b0498f2988d6d2249793ef67edda49d1e584746be9032","affectsGlobalScope":true,"impliedFormat":1},{"version":"e3a2a0cee0f03ffdde24d89660eba2685bfbdeae955a6c67e8c4c9fd28928eeb","affectsGlobalScope":true,"impliedFormat":1},{"version":"811c71eee4aa0ac5f7adf713323a5c41b0cf6c4e17367a34fbce379e12bbf0a4","affectsGlobalScope":true,"impliedFormat":1},{"version":"51ad4c928303041605b4d7ae32e0c1ee387d43a24cd6f1ebf4a2699e1076d4fa","affectsGlobalScope":true,"impliedFormat":1},{"version":"60037901da1a425516449b9a20073aa03386cce92f7a1fd902d7602be3a7c2e9","affectsGlobalScope":true,"impliedFormat":1},{"version":"d4b1d2c51d058fc21ec2629fff7a76249dec2e36e12960ea056e3ef89174080f","affectsGlobalScope":true,"impliedFormat":1},{"version":"22adec94ef7047a6c9d1af3cb96be87a335908bf9ef386ae9fd50eeb37f44c47","affectsGlobalScope":true,"impliedFormat":1},{"version":"4245fee526a7d1754529d19227ecbf3be066ff79ebb6a380d78e41648f2f224d","affectsGlobalScope":true,"impliedFormat":1},{"version":"8e7f8264d0fb4c5339605a15daadb037bf238c10b654bb3eee14208f860a32ea","affectsGlobalScope":true,"impliedFormat":1},{"version":"782dec38049b92d4e85c1585fbea5474a219c6984a35b004963b00beb1aab538","affectsGlobalScope":true,"impliedFormat":1},{"version":"a7ca8df4f2931bef2aa4118078584d84a0b16539598eaadf7dce9104dfaa381c","impliedFormat":1},{"version":"11443a1dcfaaa404c68d53368b5b818712b95dd19f188cab1669c39bee8b84b3","impliedFormat":1},{"version":"36977c14a7f7bfc8c0426ae4343875689949fb699f3f84ecbe5b300ebf9a2c55","impliedFormat":1},{"version":"7f698624bbbb060ece7c0e51b7236520ebada74b747d7523c7df376453ed6fea","impliedFormat":1},{"version":"19efad8495a7a6b064483fccd1d2b427403dd84e67819f86d1c6ee3d7abf749c","affectsGlobalScope":true,"impliedFormat":1},{"version":"1eef826bc4a19de22155487984e345a34c9cd511dd1170edc7a447cb8231dd4a","affectsGlobalScope":true,"impliedFormat":99},{"version":"424faf9241dd699dda995b367ed36665732da1e6ec1f33b2fd40394488ecac92","impliedFormat":1},{"version":"170d4db14678c68178ee8a3d5a990d5afb759ecb6ec44dbd885c50f6da6204f6","affectsGlobalScope":true,"impliedFormat":1},{"version":"8a8eb4ebffd85e589a1cc7c178e291626c359543403d58c9cd22b81fab5b1fb9","impliedFormat":1},{"version":"9e83685e23baf56b50eab5f89bcc46c66ccd709c4a44d32e635040196ad96603","impliedFormat":1},{"version":"42c169fb8c2d42f4f668c624a9a11e719d5d07dacbebb63cbcf7ef365b0a75b3","impliedFormat":1},{"version":"f734b58ea162765ff4d4a36f671ee06da898921e985a2064510f4925ec1ed062","affectsGlobalScope":true,"impliedFormat":1},{"version":"07cbc706c24fa086bcc20daee910b9afa5dc5294e14771355861686c9d5235fd","impliedFormat":1},{"version":"37f96daaddc2dd96712b2e86f3901f477ac01a5c2539b1bc07fd609d62039ee1","impliedFormat":1},{"version":"9c5c84c449a3d74e417343410ba9f1bd8bfeb32abd16945a1b3d0592ded31bc8","impliedFormat":1},{"version":"c0bd5112f5e51ab7dfa8660cdd22af3b4385a682f33eefde2a1be35b60d57eb1","impliedFormat":1},{"version":"be5bb7b563c09119bd9f32b3490ab988852ffe10d4016087c094a80ddf6a0e28","impliedFormat":1},{"version":"1fb2055d5cf1d4de01a143c1f3932e582edc5d1c2a0d46d6d86eedf00280753e","affectsGlobalScope":true,"impliedFormat":1},{"version":"5f638ce70c22cad472a559aa84afb8fe789c562654054d7658a2f084fa764ef0","impliedFormat":1},{"version":"eee7aaf5e34b9fa594aea6ea9178b27a7d005e028899da26a3ea16116fbeec57","impliedFormat":1},{"version":"327dd3070ca6596a1b248131ca58902b30c9ce8e5504879a4765c0a0e6cc6605","impliedFormat":1},{"version":"54744388ae295890df46ed1b8b786ef3afaae5e0c997851c82b3e0248a000347","impliedFormat":1},{"version":"d2aec7751d0e1a7ad0902319ede72aead362f5c261cb7a7c6400399d29eb08df","impliedFormat":1},{"version":"fca45fb6eacacee9fd55ec97cbbccddc1e90fc17f4ce9dd1e35e0788c394672e","impliedFormat":1},{"version":"138948acb050a0af116a5346329f5435936615363cfab5d9ad13c91be3d9e5b3","impliedFormat":1},{"version":"9b643d11b5bca11af760795e56096beae0ed29e9027fec409481f2ee1cb54bbc","impliedFormat":1},{"version":"cff2e2479b3ec50f6b9a4b3cd8517f3d5734b388e86e921a9e03160807e41195","impliedFormat":1},{"version":"80ccde91c62bb143dce6bf5fa839ac2c3c6723a804ad3c85fa80505324c9b16b","impliedFormat":1},{"version":"402f2498b4e4023a9e59f92e46d062bb8bdfba167099de06728e203c70f0847f","impliedFormat":1},{"version":"ef73bcfef9907c8b772a30e5a64a6bd86a5669cba3d210fcdcc6b625e3312459","impliedFormat":1},{"version":"8b15d05f236e8537d3ecbe4422ce46bf0de4e4cd40b2f909c91c5818af4ff17a","impliedFormat":1},{"version":"f3d8e124dfaeaf7cbbeb37f8800e9d1da7a69bbbc540fb942385d509516c73b5","impliedFormat":1},{"version":"4eac2fffcdcfadb1fb0cc5ae606547e41e9bd54c249d295c8481711911c91afa","impliedFormat":99},{"version":"56f62dd1bc409c16a0c35bb7b39051421e23a12e950662ff9fc8c62fedf6891d","impliedFormat":99},{"version":"18d9ef78658d6d59c8bb371560553da33a09bd7aea0a5edc2afae9fe37be37bc","impliedFormat":99},{"version":"fa3559e5fad216360e3494eddcc5043df1283e42ee695a2169cbdce7689f48e5","impliedFormat":99},{"version":"c67b024595155b14ce6d81bd101c6d3f45f7412c694f16dbb9831f7bd7d9714b","impliedFormat":99},{"version":"ec665d85cf6c3c9bff9571e04ce49bffcb348b5c60d2195c43c035a884d0aa01","impliedFormat":99},{"version":"978f04201d822679bddd50017b5ebdc9454ee6ff7f4a461add2bbd50c3dcd356","impliedFormat":99},{"version":"2083073dd960c387bf1c97b3bcf523674c32a0925d98ba6c94252f951088b9c3","impliedFormat":1},{"version":"d8d421dfd305dc41933081cce5e14d8f686c96ae81558a9127b8ce32f7236431","impliedFormat":1},{"version":"ad880ecb1bc5ed4c5a3a015ec4e09debd580f1fd388071a0ddda7e20bccb5098","impliedFormat":1},{"version":"d537cc3986e75b0fcf3e60539072a00e7f96a1233701fe3b41f08b8d564d3bb1","impliedFormat":1},{"version":"74ab24bd3ed06cb50c36630c80781244fa720c7c97d385c19434809c59bb4e89","affectsGlobalScope":true,"impliedFormat":1},{"version":"6aa2859da46f726a22040725e684ea964d7469a6b26f1c0a6634bb65e79062b0","impliedFormat":1},{"version":"17ac60332438bed348e31affbf6019f7b3b577fdcd91b8740f28115952014e6f","impliedFormat":1},{"version":"7a724ef6c8329a17b892ff22f3990aac575158c08c081147cc2eec9112ad4e20","impliedFormat":1},{"version":"e9ace0fdbda138ba3cb852ee7d66ebf4ebae98680bab721c4636b20ad4996460","impliedFormat":1},{"version":"a9373d52584b48809ffd61d74f5b3dfd127da846e3c4ee3c415560386df3994b","impliedFormat":1},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":1},{"version":"99d1a601593495371e798da1850b52877bf63d0678f15722d5f048e404f002e4","impliedFormat":1},{"version":"1404150dec097495863079577f898345fc34d0a064ba5c62071dde8ff0f4c35f","impliedFormat":1},{"version":"2897dd88df9f72325a8e988163657a79819f3cc7240df20ffe57a794e2ab4f08","affectsGlobalScope":true,"impliedFormat":1},{"version":"89121c1bf2990f5219bfd802a3e7fc557de447c62058d6af68d6b6348d64499a","impliedFormat":1},{"version":"79b4369233a12c6fa4a07301ecb7085802c98f3a77cf9ab97eee27e1656f82e6","impliedFormat":1},{"version":"5c5d901a999dfe64746ef4244618ae0628ac8afdb07975e3d5ed66e33c767ed0","impliedFormat":99},{"version":"85d08536e6cd9787f82261674e7d566421a84d286679db1503432a6ccf9e9625","impliedFormat":99},{"version":"5702b3c2f5d248290ed99419d77ca1cc3e6c29db5847172377659c50e6303768","impliedFormat":99},{"version":"9764b2eb5b4fc0b8951468fb3dbd6cd922d7752343ef5fbf1a7cd3dfcd54a75e","impliedFormat":99},{"version":"1fc2d3fe8f31c52c802c4dee6c0157c5a1d1f6be44ece83c49174e316cf931ad","impliedFormat":99},{"version":"dc4aae103a0c812121d9db1f7a5ea98231801ed405bf577d1c9c46a893177e36","impliedFormat":99},{"version":"106d3f40907ba68d2ad8ce143a68358bad476e1cc4a5c710c11c7dbaac878308","impliedFormat":99},{"version":"42ad582d92b058b88570d5be95393cf0a6c09a29ba9aa44609465b41d39d2534","impliedFormat":99},{"version":"36e051a1e0d2f2a808dbb164d846be09b5d98e8b782b37922a3b75f57ee66698","impliedFormat":99},{"version":"d4a22007b481fe2a2e6bfd3a42c00cd62d41edb36d30fc4697df2692e9891fc8","impliedFormat":1},{"version":"9d62e577adb05f5aafed137e747b3a1b26f8dce7b20f350d22f6fb3255a3c0ed","impliedFormat":99},{"version":"7ed92bcef308af6e3925b3b61c83ad6157a03ff15c7412cf325f24042fe5d363","impliedFormat":99},{"version":"3da9062d0c762c002b7ab88187d72e1978c0224db61832221edc8f4eb0b54414","impliedFormat":99},{"version":"84dbf6af43b0b5ad42c01e332fddf4c690038248140d7c4ccb74a424e9226d4d","impliedFormat":99},{"version":"00884fc0ea3731a9ffecffcde8b32e181b20e1039977a8ae93ae5bce3ab3d245","impliedFormat":99},{"version":"0bd8b6493d9bf244afe133ccb52d32d293de8d08d15437cca2089beed5f5a6b5","impliedFormat":99},{"version":"7fc3099c95752c6e7b0ea215915464c7203e835fcd6878210f2ce4f0dcbbfe67","impliedFormat":99},{"version":"83b5499dbc74ee1add93aef162f7d44b769dcef3a74afb5f80c70f9a5ce77cc0","impliedFormat":99},{"version":"8bf8b772b38fc4da471248320f49a2219c363a9669938c720e0e0a5a2531eabf","impliedFormat":99},{"version":"7da6e8c98eacf084c961e039255f7ebb9d97a43377e7eee2695cb77fec640c66","impliedFormat":99},{"version":"0b5b064c5145a48cd3e2a5d9528c63f49bac55aa4bc5f5b4e68a160066401375","impliedFormat":99},{"version":"702ff40d28906c05d9d60b23e646c2577ad1cc7cd177d5c0791255a2eab13c07","impliedFormat":99},{"version":"49ff0f30d6e757d865ae0b422103f42737234e624815eee2b7f523240aa0c8f8","impliedFormat":99},{"version":"0389aacf0ffd49a877a46814a21a4770f33fc33e99951a1584de866c8e971993","impliedFormat":99},{"version":"5cb7a51cf151c1056b61f078cf80b811e19787d1f29a33a2a6e4bf00334bbc10","impliedFormat":99},{"version":"215aa8915d707f97ad511b7abbf7eda51d3a7048e9a656955cf0dda767ae7db0","impliedFormat":99},{"version":"0d689a717fbef83da07ab4de33f83db5cbcec9bc4e3b04edb106c538a50a0210","impliedFormat":99},{"version":"d00bc73e8d1f4137f2f6238bb3aa2bbdad8573658cc95920e2cdfa7ad491a8d8","impliedFormat":99},{"version":"e3667aa9f5245d1a99fb4a2a1ac48daf1429040c29cc0d262e3843f9ae3b9d65","impliedFormat":99},{"version":"08c0f3222b50ec2b534be1a59392660102549129246425d33ec43f35aa051dc6","impliedFormat":99},{"version":"612fb780f312e6bb3c40f3cb2b827ea7455b922198f651c799d844fdd44cf2e9","impliedFormat":99},{"version":"bcd98e8f44bc76e4fcb41e4b1a8bab648161a942653a3d1f261775a891d258de","impliedFormat":99},{"version":"5abaa19aa91bb4f63ea58154ada5d021e33b1f39aa026ca56eb95f13b12c497a","impliedFormat":99},{"version":"356a18b0c50f297fee148f4a2c64b0affd352cbd6f21c7b6bfa569d30622c693","impliedFormat":99},{"version":"5876027679fd5257b92eb55d62efee634358012b9f25c5711ad02b918e52c837","impliedFormat":99},{"version":"f5622423ee5642dcf2b92d71b37967b458e8df3cf90b468675ff9fddaa532a0f","impliedFormat":99},{"version":"70265bc75baf24ec0d61f12517b91ea711732b9c349fceef71a446c4ff4a247a","impliedFormat":99},{"version":"41a4b2454b2d3a13b4fc4ec57d6a0a639127369f87da8f28037943019705d619","impliedFormat":99},{"version":"e9b82ac7186490d18dffaafda695f5d975dfee549096c0bf883387a8b6c3ab5a","impliedFormat":99},{"version":"eed9b5f5a6998abe0b408db4b8847a46eb401c9924ddc5b24b1cede3ebf4ee8c","impliedFormat":99},{"version":"af85fde8986fdad68e96e871ae2d5278adaf2922d9879043b9313b18fae920b1","impliedFormat":99},{"version":"8a1f5d2f7cf4bf851cc9baae82056c3316d3c6d29561df28aff525556095554b","impliedFormat":99},{"version":"b60cfa747437d5c621415dd4460912c7a9d1ee5ab21871ccd2e399dc698bc06a","impliedFormat":1},{"version":"a80ec72f5e178862476deaeed532c305bdfcd3627014ae7ac2901356d794fc93","impliedFormat":1},{"version":"2fbe402f0ee5aa8ab55367f88030f79d46211c0a0f342becaa9f648bf8534e9d","impliedFormat":1},{"version":"b94258ef37e67474ac5522e9c519489a55dcb3d4a8f645e335fc68ea2215fe88","impliedFormat":1},{"version":"9253429d871f4d8f15dbdd8cd5d33c0e83c8e6c8acb23ac012afe8700cd7df55","impliedFormat":1},{"version":"68b6a7501a56babd7bcd840e0d638ee7ec582f1e70b3c36ebf32e5e5836913c8","impliedFormat":1},{"version":"7a14bf21ae8a29d64c42173c08f026928daf418bed1b97b37ac4bb2aa197b89b","impliedFormat":1},{"version":"47e6d6b7d7cd8d58b620c1cb114923cd86e40bb7ebae74cff30852b21a779c51","impliedFormat":1},{"version":"aacc44e737e9083f6f75b09097ac7af67670f3d25577c248c6f5c44fa228115d","impliedFormat":1},{"version":"0e5cb10101858f8dc705f436c2910480a0268e1001c4f6d12a9dc179feaa4643","affectsGlobalScope":true,"impliedFormat":1},{"version":"2e5c41e56098ae93bc42a15473acb1a176f28b2ba95c38f3c67820434acd85b6","impliedFormat":1},{"version":"0f263eeea7877199808b1bc220df95b25a72695ec214eb96d740d4b06c7cc868","impliedFormat":1},{"version":"3efcfe53ab71364b0f3deaf270e3aed8cd721122d0c0c64380dbad615ffd5994","impliedFormat":1},{"version":"6142b0637c20d9a91fa84397fee6f3a0c653b453d2a912d94be5be10a609fbeb","impliedFormat":1},{"version":"4b629ef5627538c57225ddda88ec925bdf3d592749a1d21e3fa4673312500622","impliedFormat":1},{"version":"598cd49d61c1d28c58fa5cdf232c3a790377fc26c3cf0ddee96170e07dc41c91","impliedFormat":1},{"version":"bfbbdaa81edc12a7059cecd7f28d1a54b41c1c78d68ec8b8d1822f1c6288678e","impliedFormat":1},{"version":"1065378f8584ddfebb3ea37515d28013f37ac7f1d2e5cc44cb8e12d7b80fd1b4","impliedFormat":1},{"version":"6a393f391185c97733f384a19dcef146c6620f07b0f7267858891ff2e6535984","impliedFormat":1},{"version":"ad4b0a2e7a129fbf50cc1d4d4cc7eca7f9faf36fdb3130cacbb2660dc9e76fdf","impliedFormat":1},{"version":"b94b4c70069be55f7df17ece15ce58fc813edc10a2963eaf2a94aaf4bfb21463","impliedFormat":1},{"version":"b7498ab2cb65e533897b859bb3844942cb96cdec49005da20202f2606e8d64ba","impliedFormat":1},{"version":"c243a8464a70dfa85e5c0f75afe353d43c8a8075c3ae99393ea1808dfd1cfa07","impliedFormat":1},{"version":"3bad3a7ae989cb0b96a42297c52723f998b40840ccfa1ffa81fa2f87377b6487","impliedFormat":1},{"version":"663460f731ff21fae71639acb7048f80527efd8dacea796d0e663b9c5d2f7ebb","impliedFormat":1},{"version":"a8ac9d937da0035d015fc72c2975cf4317b6d3c945019f3d9b0532785eb9fd75","impliedFormat":1},{"version":"612e874a6f703edcb10a71147c63beafbd3435bb97ecb104f5752c37f40cf641","impliedFormat":1},{"version":"834c04ae733778f92c97890f7645e1a3f8bb3ae26c0e483e6a5fa7e273a6ed9e","impliedFormat":1},{"version":"e23a257ef79d4ed8b1c777b2db265bec281356a3e318795a47842c353b3c6fe3","impliedFormat":1},{"version":"64bb8f4569ce1cef37648273c618b998b031afb2a47d1afbb91469da8d7c6655","impliedFormat":1},{"version":"5ccd3721f77566515252585a1630630183b751742621c30778dbb9244f08c280","impliedFormat":1},{"version":"ae27dfcff160ec2ae3671fa7ae359af3ac000f60f8e6f960b8686b1bfd6b8951","impliedFormat":1},{"version":"a26883335b5004c383116e42850fe27503a8f15e9adf19cd5fc22d3535255f3c","impliedFormat":1},{"version":"17be1812e316b7324168e6ed881446009512fb6651aaa1d9623811702c96c08f","impliedFormat":1},{"version":"78ff9be0fbd2744bbd143302f6bf2a49101c476d908ff4d3c5fabe27d9ea5032","impliedFormat":1},{"version":"b0afdb11e042d946240ea1552dc98c6ccc31858d9e14799d1faab6fbe76720ef","impliedFormat":1},{"version":"39f5e05c42bf219cd142800819a1b595b131587512676f24dd8aab35a900c176","impliedFormat":1},{"version":"4024877347df3488b9468201d73fd13c9d93026dc981b47f21734a5f16d8b02a","impliedFormat":1},{"version":"079a489453504b3d7e277169b71b6c1d39922811e8ebb3100581b52802a9cdb1","impliedFormat":1},{"version":"addaf9820ab96167618f4a771eb76bf02409ce22d1c6d7b7929c67c7d3e3e268","impliedFormat":1},{"version":"e6a0a8cab1e15e183dbf370048d1960d33c8ed3cd932e9e4cfcefbfe2bdf3fd1","impliedFormat":1},{"version":"37549453bbf83b7baa1e18c564e6b21e1161c6a5a14051f204e4d85ddc28d46b","impliedFormat":1},{"version":"909d0c4a4ac4c53b523793b8dbc4d89ff11bc2cc5c4fcf8f8b247923024d0222","impliedFormat":1},{"version":"52cbfca7e1ded34f95705e1bcbb696783ea29f577b80ef04b31b814e110c8edf","impliedFormat":1},{"version":"5995aa547d9c4a6fb9be1f35bc7a0690e683df74b499eb6f87977f0de86d7b54","impliedFormat":1},{"version":"0a9fc7356fe4f1fd64c30d1f8e7d1639fb472ebd7c6b199b268c2140458c6807","impliedFormat":1},{"version":"b9bd374ad3af8a0201110cdf7cf07114d8a227f293a1f72ca4c544518da95e6b","impliedFormat":1},{"version":"d202fd26f9a25859ae6d4cd46c34e996a4834205c4740919d9c9e98485575dbf","impliedFormat":1},{"version":"1fe174b5ca577b3df41d151367735e6394c3ee6695a637e5578e4882365dde8f","impliedFormat":1},{"version":"fa4cb5942c32913270d8531937197f7079a00b30575ece9f9104d458322f11ea","impliedFormat":1},{"version":"7b2931a3dc2f5763f1c21e43ee77d84ac2948d856e898e82b5170afd3bb27f7d","impliedFormat":1},{"version":"f98c3ccc9432ac0bacc0bc6badb12c47c96d54047cf8354cb65f043676604908","impliedFormat":1},{"version":"bff981ec6fda1d51d623def8ec50eccdb1eed0c4aa590e59ed4cfef37937d58d","impliedFormat":1},{"version":"9d9a89f57de4a0b0b0edc7e4b52395641e706857d85265dd641393a50b7916cc","impliedFormat":1},{"version":"11930cdf44a5342fda183383f32c86a545ad1b44c59f82735712d96071ecbef5","impliedFormat":1},{"version":"ea52f717b11605a85c084e98df50fce512427239c1540abdf4d776ea209d2bd0","impliedFormat":1},{"version":"3bee467b848a4ce3f4fb0a0f5dfe98ad21b2a24f01f92f6ae13622f415a4337a","impliedFormat":1},{"version":"4e48c24bd34e243992a0c76e865960ad673968715f06ca538cdd8a3831078284","impliedFormat":1},{"version":"33e896d46ba37a73ffadcd2d152496b507df18d18f0f8ddf548226fbca4663df","impliedFormat":1},{"version":"2416fefc4e7619a88cb087cd924396f25f15a0a2d2d4508c48fd1e55ae495fac","impliedFormat":1},{"version":"0e11723ecf54e2f17340a22dae331a682c89d2018eadc12fcd283cb85f05d701","impliedFormat":1},{"version":"25f406f42f20b1ef646e7d00f30a2c0e54e13e8bf156b5c306b21f9c74d58ce6","impliedFormat":1},{"version":"440299b618dac08f25a7a1d03d06bb9930d20dc5911036cd75964acb404f0356","impliedFormat":1},{"version":"157e26d7f98dfe9c7c362161caadcd7cf00d78f929ccbe88079ab6e3452d7ed5","impliedFormat":1},{"version":"e12a0b0d8be6bd636d30de009d3db4026ff4e0cfd310f9aff358a36f037730b1","impliedFormat":1},{"version":"ccac0a50e62c647b8666bbfc81ae51713fafc2659b0a7fa995d7997ca06152aa","impliedFormat":1},{"version":"cc64154e7a9fabe3bb609a2bf2b795b4a48a6d41fab8bc9b1e35b5ef3566a2b5","impliedFormat":1},{"version":"4843d919bd38424546a4d254e616b82674f30ab7f515486cb2339234c5b5d354","impliedFormat":1},{"version":"06cc3f5a14e6da417bd0d7ca61cec620cbf0c008afff9350912cc0bf3e95a484","impliedFormat":1},{"version":"76a6e9828d050c96cccb5cf21036379fa3256f6a12429b329cab57eb2aab6b37","impliedFormat":1},{"version":"60c038ede51a9778431f0a1503a0be17950617d78df358e6243e4e1e1d68a3a9","impliedFormat":1},{"version":"c3d5bf4c14cef22b651b4e6d07bfac107915f3bbbe4b5d024a0bdf8dedf53764","impliedFormat":1},{"version":"cba4393b25991696dbcfc17efd678ef0797329f2440c971b9e27ed3c9a5c7791","impliedFormat":1},{"version":"1dbd2da310e9c51fda3c2b7303165b5c63ff51bdf572c3d461662367fade9d9d","impliedFormat":1},{"version":"8c5fc128c25036bd4d75f2a35340024dddf3d578f66e6b9bd3763a7794255dc9","impliedFormat":1},{"version":"99a383ac35180903faf7ed423d43e78bfe7ea0c5fdb7ae753138f7eaddf207e1","impliedFormat":1},{"version":"390c9a3738c95dce3c3f7ae08f3caad79ebcc9f303610a6bb2b8692a726d0864","impliedFormat":1},{"version":"9ed4423ca28d5ee00f98928f38aa92e66e91d414b10eaa0275e463ad809da18b","impliedFormat":1},{"version":"64539cee046b05e5e8c3ebd08555da25a0507265c3ddeebf9684c7c25490afac","impliedFormat":1},{"version":"5a156dccfc9e3b5ee1d90483da76f7e3c7b6f57767cedd5bd1cd3b98ff6b7d95","impliedFormat":1},{"version":"9cba07e73ec8e3e24566b1c8fa1e200d27c3cba6c663525be11c9ca461f3d8ae","impliedFormat":1},{"version":"b6bf3fb51b61996e6f3c867ea9a9be4f7119bd3587ff3c7e064a477e20d557c0","impliedFormat":1},{"version":"89af23ab75c75234f8ce2eda07b06f673b74377219475a6e26efee618c9e18fc","impliedFormat":1},{"version":"06215a040b3de7ca21884bd0813ba7f0f4f952f119baab2d47b22aab455c76e8","impliedFormat":1},{"version":"4654d31fe56a1d39189598a1573b0c0ca44df6386fb09a067e330d8bb92cfd97","impliedFormat":1},{"version":"c08cfd2f722834652e49619212385dab968550f4e3c65cd6fef7ced4a9db99e6","impliedFormat":1},{"version":"09e93e9ec9aa0fb3a773f7db69bf2dc6172c8940c525dc7ddc235bc25421e631","impliedFormat":1},{"version":"d1cfb5a16cc5840816aa8f79f9ddb822225ecfab8037b8948857632b54d62428","impliedFormat":1},{"version":"aa6887fa98b1ff44a9a7a15844c297192a69c31544e6d441f994effeb80a9656","impliedFormat":1},{"version":"01e1875576c402c55fba21c7baedbaace359590063b0a0ecb0e9a6b68b84c5d0","impliedFormat":1},{"version":"0669f5afe85ea27627148bd9f79c24ff9ebe1e044a5644c0bf7a9ff6f9d129c0","impliedFormat":1},{"version":"2c154b21888113f15d19bad996b2baff19e9606a06c0b9e9b5ac84cdac5aa2fd","impliedFormat":1},{"version":"f508570f9742651d3c4442289fd0c26aae65a3f5ca3eafc2dba42e2059ad3c58","impliedFormat":1},{"version":"b8bb685509bb16aea6fa4940e2be439abeb99dcb4536cf194a673dd8540ce6f5","impliedFormat":1},{"version":"dede904817a20083b21d9ea9db77194aa606cb36ea6514710d68cfaa98b6a2b4","impliedFormat":1},{"version":"585cdb6ccac34f76c3c87e74a44ea1ff8782e1c10db205670b54b7b746998bca","impliedFormat":1},{"version":"33cfcb18b5fc49ce357e115ca2e8e15621437e8d1aed6f637e9e0a172289a401","impliedFormat":1},{"version":"64b5c8a44571521baf8653e869afbc30498370fd5b8ccb72d40bc537592eec59","impliedFormat":1},{"version":"85c72d0ae508f70ac95ea420ff28c621d9e26907f3deec3b189ab4caf4460363","impliedFormat":1},{"version":"603086eae37e4f5e89f4d50999eaa4e8b1a681868af167ee3c64596c9a4bd39e","impliedFormat":1},{"version":"a730b338a9555eeb46dd7bc218c5adf2d919d2ea1372d415c79f77857fb5bc27","impliedFormat":1},{"version":"63adafaeea1ff08a930e72c28c6e1f718c431d45efce62b66f1f4dd7be20f695","impliedFormat":1},{"version":"7e1576d2961371775a8d18381b1aaabfc5e8149b36efa730b12f7b6f294fd83f","impliedFormat":1},{"version":"6d6101c035aeada94c99cd939c44a1e54d3a6d6aa087269c415139e26a141157","impliedFormat":1},{"version":"a51f5e7c625de14bedf977194dc842b6d900ac91489e4378a3c457f9adf9743f","impliedFormat":1},{"version":"dc29f5b002a93dd5ac6e38305772c956445f8385cc50f50474f882e3213f275b","impliedFormat":1},{"version":"c761d1f373b39d2cd63a774bcd37e48dfdcb24b135cf18fadea2350131286748","impliedFormat":1},{"version":"c49a57303d04ce935767bf1847cf9f0ea13dd3f1bfd7d56cc9d38d0048e43e3d","impliedFormat":1},{"version":"435960ade236d539fe83868ca82ab67bed5184f64e1fb9fdf96f408856f42371","impliedFormat":1},{"version":"ef8b784848aa05a9b99b390d0402c8ac29f21eb4ed91bab42c758c3ed38c358c","impliedFormat":1},{"version":"0bb6f1c50ae58270d7e24a66048b17f57bc125823f864b95cec560f6561ff1b1","impliedFormat":1},{"version":"3a50e263c986b54e09f2bde8a854794c63a8be7c1437f1f6071c936fc1b019e7","impliedFormat":1},{"version":"06f72f7d0e35d26f3dd47b6b57c8a9336a25c61b9f6b786f68cb4866bf3012cb","impliedFormat":1},{"version":"332f0b72cce4f5a3ee2f7887be934a15c695deeca8fb304f521efa5a86943127","impliedFormat":1},{"version":"08a10a4e6b6ed0e24767332627adaed2b2958b78696ed4d7dff97a317cd3946c","impliedFormat":1},{"version":"68561b31a64a4573fc2cbd922b30cb4dc2ae2fc4f6beb23de436a9ea9108f820","impliedFormat":1},{"version":"dfcd1d31f7ba84ba3edaae3aac584764207b66d76151f9af40e85ba620525179","impliedFormat":1},{"version":"f229614dbf0032bb720e9943d20cd0129eb98d590291a88b682d883263eec377","impliedFormat":1},{"version":"27cdd1d4c111d361a424ed15e36fa40077cfee493c9bc9f5237f5ec06c2bf50b","impliedFormat":1},{"version":"82e8ec085329e1d63a848eab740fbf88b95d21398c25cf8fa6f396aae6b1eaab","impliedFormat":1},{"version":"b6d01723410393a9e483a9d9ef141d9042a40b75debcab06b55a1a5aa46b4348","impliedFormat":1},{"version":"9ca105f96bc2276869df184bb15755577f15e8f8daf1089c5a8f8a39b07370dd","impliedFormat":1},{"version":"f9dca360f6cc359387f1865de34775a3022ea1b4f8ef0e80eeb92289809f4c58","impliedFormat":1},{"version":"3b00797c4162ff6737af0238991ac368ec617b2a8706ffd6a858b69567391784","impliedFormat":1},{"version":"4b08c4212f7ca2bdf32a6b07499c53d395ee2883b8b63d253f5cb9685e7ffdbe","impliedFormat":1},{"version":"e61c464a1d20c51cecfb486544c64efe954f678bc941f0cfdd5d8ea89463c74c","impliedFormat":1},{"version":"52ca5f549c59e5f2c61f9a7be4637736ed0194859e62c58490dcc56c2fd2a66f","impliedFormat":1},{"version":"b46401d4f052b77f1a7990bbdde52f8b769562f309d12c9d952a6774bccabcba","impliedFormat":1},{"version":"0d82354783e07f571c5201c11beeba2aa5fe231695c9774b362087969598f67b","impliedFormat":1},{"version":"a8f85a6a118f7d8e5a46730ec9c9516bbf51addc38c8ec71d760726983c3ea76","impliedFormat":1},{"version":"6672541dde7af1f5aaacd7d839926514bdf56fa4a3b41a46681c34e0f4d22f73","impliedFormat":1},{"version":"e804a651c3f9a9bd4fc41b2a8c8cf2fd2f42c91b9e2bbcf9fffc2eb5c786128e","impliedFormat":1},{"version":"c61189f3ae76bb34026919a459f56e4ed3a8250bb83ab197e2f4eeeaa2d011f4","impliedFormat":1},{"version":"70a4eae68f14e36cab972738120bb80da7f33b2cd154b8df4c2dad940dcf9011","impliedFormat":1},{"version":"5c3dae2ce3a109098c894cefdd2ebd7d53603def97a9ce684d712c980aa4e195","impliedFormat":1},{"version":"c1a5db5a0d9b320b8793fcb6fc192c7ea91c37cc281d8de4515b5668e8119137","impliedFormat":1},{"version":"b487c915d7c6ae60621329b636c8903f825e9f0298043203381fc0a8be32b035","impliedFormat":1},{"version":"cffafb72ee7193040dd4f0cf8fe01b6fa29c958406d913eb3ea44b51d9771bc8","impliedFormat":1},{"version":"789610eca8c7c3dc3253d6c96adaded28c01d7526c23cd23a96199863dcbfb44","impliedFormat":1},{"version":"ef9921f27669454f1bdbea03ed4adc249b9b60a5fd8e31d04187500bcc7c3455","impliedFormat":1},{"version":"8f21a84ba4c129891629349e5011a87dd6b2ca5878389af88f2cafbf5ed7371c","impliedFormat":1},{"version":"4700990c95ba3b9a4f66bd072d66836256ac0f0f9e7c9e5bca953d36f16de6a2","impliedFormat":1},{"version":"c604882c2fe653a2d0b2a4a684cdeb0f9dac15fca7846bc43f09b50009b437d8","impliedFormat":1},{"version":"6fd115938d9f324fc2272cad0abf9849698535423a2242449f5072f556ae3e3e","impliedFormat":1},{"version":"d41862577744a13d30eaaa35211dfecd41efff4f67045590138f8478ab37b0de","impliedFormat":1},{"version":"de44c2c27766769cedd67af2f32172fe3bc7479a88cc6734ae24df902efd219e","impliedFormat":1},{"version":"282bb499de9c1859f59d1b24ec83b6cb4281877ac334540f009eab821cde5a31","impliedFormat":1},{"version":"3fe13000ddaf7e1f48de39ebab62d44991a76d7e9327419681e143a11ae621d7","impliedFormat":1},{"version":"9b3f16d404593d1947f0608c2bbc5459893bc1a894ed12cc2fa2ee2dcfa4682c","impliedFormat":1},{"version":"a12300860b6638fe15cb21d33a6d951297f673127f316263eacf19fbedc18804","impliedFormat":1},{"version":"89dcbd539e286a9a18fb34587033c36368fa0bebc01f6dc9cb1612ac308ee5e7","impliedFormat":1},{"version":"18d5a807766f3e20a8de126f0ff6b5b47754198130ec210783d25a4da708dca1","impliedFormat":1},{"version":"bd8531446108a94ca23cdbb4ee43bed49fe36a3e57cdecc2222a2049b94ce397","impliedFormat":1},{"version":"26c43a1c84959ef47bd8a3a4e37d416b20dc171f6ff5c8ae31f8091b682789d4","impliedFormat":1},{"version":"299e7ebd102d94f275e271121219e3eeabd0d9823e00b3d5044a13a28c8777be","impliedFormat":1},{"version":"c848f0aaa8a8689865aac59c7862b98808d5d39ebe8b1fc8657689c3f4e8a717","impliedFormat":1},{"version":"bf489d3e13f696720dc69f94197e880d919c34d848b6cb4f2603358139a01979","impliedFormat":1},{"version":"de73ee94fa11e6251c1dd47cb83ded1d9431b039cda61ccfe6c8297b476d84f1","impliedFormat":1},{"version":"25969f8593fc8bbe1b9bc6e5dbe74bcc18b4e50dddad6fd57dd5663a0fba4479","impliedFormat":1},{"version":"948af0a408e814075bbbdea9e36e7111887df6c8fcd712554a6013164025b391","impliedFormat":1},{"version":"f14a4dd8284999df7f9003a7f97e0fbe12f07f799777949ef12f9071708c0626","impliedFormat":1},{"version":"46a251effd961c5f1b1d64296202f9e0d612d7f5f6d1eb005c4ebc87ffd5ffb0","impliedFormat":1},{"version":"0c975579b6a777da981e7c7d7e29380fa72fb37b033f70925079e2edc82e9f48","impliedFormat":1},{"version":"40667375363114a3be63b9f68eed8b7dfa8ccaaaf487583488fee958f3fbf12e","impliedFormat":1},{"version":"aef08c70e8a278e4a3665db88b1296e318dabf10ec419cb52826d7a91b250937","impliedFormat":1},{"version":"4e0ee10d03f6dcefd804f196edc88e3aba7177b5b8d378b84b32be57bf877869","impliedFormat":1},{"version":"3b42b52b1114d811068855eb3d3560037a83f179519b180dea1972ad95b2c50f","impliedFormat":1},{"version":"920d29cb1ea0578127f18660028c6f475ec07624e8e4e87b650ed4c9d531ffde","impliedFormat":1},{"version":"66543a201c8b02e54acdceb1df0bb660aa7b7f09568c22268e70f33249653a0e","impliedFormat":1},{"version":"e0ba45fb4053e8ad1b3f4d86426abbfcf6db0efd15f68334d091f3107161e000","impliedFormat":1},{"version":"dda2538c82452f2588fe1b7e38532b37c1b06e2d6b745c3e92e8340839f6d424","impliedFormat":1},{"version":"400d3e46dee9f0c4167184b42f5d42f52428aca2c99c5d1e432ddcd90e10cf52","impliedFormat":1},{"version":"e19c3d82aca40aae2010945d3fe6fd25c218144280338f23bfd1de38b035a686","impliedFormat":1},{"version":"974d7e20399031603df3cfe92a515917a9bece27eecad1edf66374cdd25509f8","impliedFormat":1},{"version":"638d6a8f69f8a34f82cf73077f954f9714ffed4b028631b27fd009e88eb69169","impliedFormat":1},{"version":"3e1688656894676cfcaf09521dd012b8eaf13504911d1d6691b95247dc6e9a22","impliedFormat":1},{"version":"4e63e52adcca36c8f0bcd5fc552b1cb06e6e596881f1d84c6cc11622949179db","impliedFormat":1},{"version":"c1e710d9452c99f9f71f474e35ec33fad5913fbb83434147c3d3524039a76fbc","impliedFormat":1},{"version":"f84f318fbd6369a31705a0d773ddcdd91a2bc652b4c3228a4b3307ba7fbcbfde","impliedFormat":1},{"version":"833ca2d22c42d2eaceff06990e259cacdf75b42949996b8253e2e93c6b6e130f","impliedFormat":1},{"version":"f314ac95c5aef8e1fa3c06c927dbd56e6cd8d2d6c58d77122af2ca7a256e7ff0","impliedFormat":1},{"version":"a72ff2573a2e7a67d9f4baea6797b693204bcd8355677fb13d823e0c25502f7c","impliedFormat":1},{"version":"65abe7bed0e8cb62737ff6caf34e01ac24f0e097ee7c6e7daa3c3ce18ffd1bb8","impliedFormat":1},{"version":"c38642771a6ba8ea9f2dd2f6f55d3108387e1c685542667b6206d20175ed3897","impliedFormat":1},{"version":"e0692b5a6927e8f6931cb7c5224e46442dd7b364585c34b7628fcf58ae28a1a9","impliedFormat":1},{"version":"2cc191154f30ea3208a6ba5b40d242b1310a2d0792090311eb305d6f8364ce09","impliedFormat":1},{"version":"71cd5e188ed23259ac548123fa6164d6c05f2ffb87ea556d70741519b96d6217","impliedFormat":1},{"version":"c1d2e55490307ddcdbab3e0f3b84e0207efd09a504a94042c47c2bf727213270","impliedFormat":1},{"version":"1d6fbadfccad98b47135816d55eb96591a0c83d65853b4b661c57ff6e29f1b93","impliedFormat":1},{"version":"d561d2b0bcdecd72adda823ff5ffe6fde57679437b2bb9dec57c3c5fc2a3d458","impliedFormat":1},{"version":"777de5e5d40b960693a724163d5bd0c26bec261eadfd3091d1179b06de3c9f16","impliedFormat":1},{"version":"b206fc1b08e25381593ec5dd1a24f2119219a3de6dcf83faab30adcc725a21ca","impliedFormat":1},{"version":"704780b49d8c8acd865a4ae1173614ee4e50ff302b1a0b6bd8cc0ede4ba24ff6","impliedFormat":1},{"version":"8d3cc5d08894674e0098aaf41cf21d3b614649e37a6aad8a5ee08f26f7bc5ae4","impliedFormat":1},{"version":"a3bd2688d426f203feb93d4fc4b0a07191c2deb4c7b9458e930499e25a469901","impliedFormat":1},{"version":"428fa5cdd913712477a0b40260daac8799845c07cad75197d2a6fcfbbe0941c8","impliedFormat":1},{"version":"5e43887723827bd79d122e3b92003e7c1a1891326ef411b5f159ca80f27ca9df","impliedFormat":1},{"version":"47a17d3eb855617b22b58aec440389ae31d117b624a487f71d7a445ae7c31766","impliedFormat":1},{"version":"e5d87b97f903dcd7655aab15b1a8e96d9835bfbecba09e62a481263690393043","impliedFormat":1},{"version":"7654414a4e0c95a22d34af230e057db437cc8ded99f950ba9829bec1a977fdb0","impliedFormat":1},{"version":"7cd8739db3c3ba7d36e005745ace3ed0be5f0117d08e65fb920eaaa66c9b1e83","impliedFormat":1},{"version":"58f57cef17ffc9c318cbcd46395e82ec6e4ae668eaee8243cfd4d35ae38bd102","impliedFormat":1},{"version":"5b544238e4ccafd1e53a07953a6082b45260a81cf91c2812357670f419979c17","impliedFormat":1},{"version":"5ef3faec43f77b6279e6cefca6ce15f09373ff2da39a0145a08a6e7ef47c9a55","impliedFormat":1},{"version":"8296ce504d5091c8e9679abbbb1e6b044d79b096927f6e5d37a2edb222cbea34","impliedFormat":1},{"version":"18fa03af639ffc9d01576d47ccf2161f2decb6bd18d4496904496fb78dedb1f9","impliedFormat":1},{"version":"b92d62dbd2ba77de2999f39d75d401974538f3b6764e5b8a5ec0ef33e306cee2","impliedFormat":1},{"version":"778e1fa2f8f95fa735c4005dc73ab8c6ca261f39e80ab6d927c75a6b01122644","impliedFormat":1},{"version":"9007f7269478f85c75703ceaf96966584f14d245785f78becd802ae9347e36dd","impliedFormat":1},{"version":"8217164e1d6157824d87b770009dee8b628d1f918cb9ab0d8f4fb585be739f3e","impliedFormat":1},{"version":"f8811d7c6c895ebcf107a8bd56a6d56840726770fff5730725ea0d6b7bc67ede","impliedFormat":1},{"version":"cf2e13410ce1cb7275d32624e0d174ae316c652f27f9bdd7bfc622f6b36a5a8b","impliedFormat":1},{"version":"41ffbb528b3ad54fe1455841d5f4fee190ea988b12818f78cdfb3139f605001d","impliedFormat":1},{"version":"21b6daacb70f14697d6fb8e080c1c5af967c83e48ae75be4d37af7f738d09c6a","impliedFormat":1},{"version":"63c6e774784dc8bf052f14d1689719543fbca5cdf80f1adafaac8439af7e93b2","impliedFormat":1},{"version":"9f05b6b1f4881b76f0838696b6a7a20ef372dbbe3ffa02edecebafee2cea5365","impliedFormat":1},{"version":"87886a4262b9411707ae89b00bde5af3413d988c7fa2068d03769a3c4d30e31d","impliedFormat":1},{"version":"b29f305030d9332ca12aa73efdcfbd5a20b829384ee75a1a2834700d69abfcda","impliedFormat":1},{"version":"c79665d5815e12300c1c0814cca578457ffc227b06163b7d0ae85fd503278492","impliedFormat":1},{"version":"7e25904b7e1555755b1add0d14da715806f47a448a3988b14a2d635d2a901399","impliedFormat":1},{"version":"71dfd307d37cc3221827fb2ccbd2b1bd83bd5c6547577337080028d7b7f5bc65","impliedFormat":1},{"version":"2e4ee33fdc0606c1f2f828184a0d5e5d9648db81d3a419a002f6cc8962c0e19b","impliedFormat":1},{"version":"b1b9d635fb4bfdc76600e5e2fa04089cce8bf7c2ecad022a8e167741286a8216","impliedFormat":1},{"version":"a1d1e789bbda38f77f8c02ffc1f74519dda120e3990236662a5e275ed39ddfcb","impliedFormat":1},{"version":"f98cd710b8522eadf95035c92b1e8e88cc9de202d4f373354b687ce6dd52aa8b","impliedFormat":1},{"version":"36602a018973de6bad54d41ef06ac815b6f3e2fc66c20a2b37f1217e4fb0f602","impliedFormat":1},{"version":"b0958ec1635b2c57cc60573f75ee2a09a8f551ff3a44f4dcdc1ae5b6bd32303e","impliedFormat":1},{"version":"bad1c5f4ce71b1f34a5955f66edb08b0c3c6d1a6cf9d4142395b17b580ddf59a","impliedFormat":1},{"version":"f90c46e1eafdbb70677a240763fa0a1b76b749fbf370e399a572695d016140a8","impliedFormat":1},{"version":"b2fc2f186c366bd55edc285b7bc732ea34174a6d48d3aa45ccace5263b5183c9","impliedFormat":1},{"version":"e698b0a9df5d822610bd68e81f07afb1662d6f28779ed34fc90e13ee1c9d68c6","impliedFormat":1},{"version":"cbfbcf035e9522c360d2901a1ded885c8df8bee0f8aa3401e5f7ce35adab0d01","impliedFormat":1},{"version":"10841f577aa5fe50a9a55ddf7af3be731dcfdfdeb7f3e6959b7f24011729405d","impliedFormat":1},{"version":"a46ff440b7a84f372a0b6e0ff425bd301c259483ae8d36c81112d9f3643684de","impliedFormat":1},{"version":"0f300bc9e507a76ffaa092981e712e53929b99cd487c43ce3ff23d535ec807ea","impliedFormat":1},{"version":"a6a4f30a730922d757d56bc923b28c25bf970184b45b2685965e3f763047ee87","impliedFormat":1},{"version":"db471c242af3991da0b5f0d44c92bf98baa93235fdf693b5e223141569b3b402","impliedFormat":1},{"version":"b7569461ece6fd0a4e2ad321403f0d3f31502c87cd3dbf50f4fdb2480020e062","impliedFormat":1},{"version":"d7cfb13c90fd5a8b71190161150cf340681e61bb6f5429c9149d8f6ff3d42165","impliedFormat":1},{"version":"24e1d23dc068149087215fbd9e97aa51f2e4107053ced1030c8ca40e920c963f","impliedFormat":1},{"version":"587833dfea22ea8a68f133bccd7de4b34c4540c5672f3efc67226645a130c656","impliedFormat":1},{"version":"936696a05e1359cbb70be55e8a06d21acf4397f4866a6c4aa1c275bf29c1b93a","impliedFormat":1},{"version":"7c9b2a3b1b0a2d2156d96108443475ca5ec54da8d7146d2ec774b9120a27e470","impliedFormat":1},{"version":"935b284e75c612e9fba0cb62de023662bb4f2c72a281feabc1bd4287217d15ac","impliedFormat":1},{"version":"68eb05e55f4a859accf4ae7995c65e082418abbcab61f95eab1e0d58cd31a16c","impliedFormat":1},{"version":"2a055a1b6ecb690c7118450173d81c6beaab67c83885ac07745c5f4a75e5af7f","impliedFormat":1},{"version":"659fea18af0a6c7d4ceb3181e690b03a83af98e8afa132ca5d255f682dccb6cf","impliedFormat":1},{"version":"d750ec5d4c4d9966b143a0b0e1dc8d7628930c3392792d8b830e802f9c29e876","impliedFormat":1},{"version":"fae92c75a209e06473dbaf7bdc524235e49c9b09e8e940cc4c05c67aaffd2cb5","impliedFormat":1},{"version":"5bfe5300abcd7be0738b58f07e9f96c8851a4a721f5c8fdd15d17a2e62cd2021","impliedFormat":1},{"version":"ae33156439dc439ca431b77d3cdb49a43df43244c104bc8bc2114b5bcb653c91","impliedFormat":1},{"version":"20045c6d228b9dc6ea3ffccad3ddd17a093f2a658e881b958c9192865cc75e54","impliedFormat":1},{"version":"9dc26b2ba05f3d519a4afa7374d7ab6d9a4887451f6eaaa072afbee4b440deee","impliedFormat":1},{"version":"5ed22d22379ad817d49e5f3eef03b8abebefe00668f14844e652d65238b1a242","impliedFormat":1},{"version":"bd341e8425a6006f2fe5ec1ca4812cf9f6150920e448907afa2c1dfd440ebf76","impliedFormat":1},{"version":"4d01a3827a89ee3d162adbb19e437f16158fa3df068810eed0136678d8564bf4","impliedFormat":1},{"version":"28ae9d666536a592bfe1febbeb1c0ff79899b6b10cdfd56f8922ad079a1d4667","impliedFormat":1},{"version":"5ec56a0a23a2f37ddc5aad3200c3ae1d7be8d31b66b0bef72af991179eb5914c","impliedFormat":1},{"version":"4bdf3869686676ffdfc30a5fb88ac7b43e1079db29dc1d37c50f6c0aa3f8b40f","impliedFormat":1},{"version":"e86e249853323d930573cde4ace8526a3104d3e47e999a430198c877dee2a394","impliedFormat":1},{"version":"efd992047503be590294653570b842847291a58f907a8616b3bab433e885a36a","impliedFormat":1},{"version":"e8f81efee48743f9381b279e78c91bb8b16d90c4450e5728f53ca4e95eb39c24","impliedFormat":1},{"version":"707205c9edb4bfbe5802ec030a68cc4259d4158223f88a0294182648064d6f5f","impliedFormat":1},{"version":"ac32f0a0c8639a2653b51c42a1f3740c9e8f34f15853c74d7054fa3b98b78693","impliedFormat":1},{"version":"72c668ec904792597d067d88acf55e453088d577f8c10a99f9f8c40862c25608","impliedFormat":1},{"version":"b6553795691b66d848fd5d848add5a49ef0d66364d2479d7ebcbd5e64eb56f96","impliedFormat":1},{"version":"6a697e35a1af52d8a1374c8837798424d700afb2eb7d9fbb92a8ec2cb2a3a338","impliedFormat":1},{"version":"de75853664b511c08775431138cdb495c1afcfcdc250eb960c6ee1f46e243547","impliedFormat":1},{"version":"446d5bf55f0fca6ba5e76e2f3873093453b63145539a81b41db129ec447f11f0","impliedFormat":1},{"version":"903047d330ea6dee2bfb97bd5edd2787be8d7c8d10e947d780daea3ebea827f2","impliedFormat":1},{"version":"ac8dd404572a2a02542d41ac450a77eee2800da19d1acf4201401bedb282568a","impliedFormat":1},{"version":"677251857b08766aeb88e4d4cff596dfbcf1dfa8fd0303c5dec2aa32a49bb720","impliedFormat":1},{"version":"a84cece5ef6579f5fc7e47964cb4d127d625ce3c617a8d3e62e9cf16db85b98f","impliedFormat":1},{"version":"28163bf385b5c2df16b457e65f8021ec4bbef669eb8374940e89305afeaf7436","impliedFormat":1},{"version":"0060d03c9ed27788d77e206a1d4f82447347f0d466cf971eeee71de58982544a","impliedFormat":1},{"version":"c17d57c6ef7d774e0348dd628ae1706189d9ba8149ebea6984f9fd9762a3a238","impliedFormat":1},{"version":"3a3cbd9222f32365b20ad68530f544b3a54bad13f5585c146e6ed902c6bd600f","impliedFormat":1},{"version":"d09dbfa43c16ddd9cdfcbef9fe3cdd0b70ccd8cca66af8bae4319887a36a7721","impliedFormat":1},{"version":"fd44ea17c48783598c3016202954770458813ce2058072ebd0d802a2fa170648","impliedFormat":1},{"version":"e4ade9c17d7b0709ab848dd970d57487e1e753343876251a31262ff4622a68f5","impliedFormat":1},{"version":"642b4b49135dde4adc5ccbaf33ac280bd7eb7dd3910a01b1eb3cf5d016d11ceb","impliedFormat":1},{"version":"c06f7cb162d97ad55200648516c86d00eb6fb1df2831306b92edfbecf8c82eb9","impliedFormat":1},{"version":"53a35a5a58accd7836eec8942fb9c77698632aca175c74c0c97b32baefb9a408","impliedFormat":1},{"version":"88acbbc99f8fc50d1ee88ba8d3231ff6543c4ca9352a42c4dfcb3708f667b0e8","impliedFormat":1},{"version":"09afe86c0df7e4468314ad1036d20130ea5164d4753933d8ca6f5011e43bcb33","impliedFormat":1},{"version":"337f186a35d7facfc38ff2015ae4148fa02077b054f752fa133708fb26a39524","impliedFormat":1},{"version":"222e2ab6901e979a2c28e6c179b2ffecc203d3bb362e8f9452c45b2f97bafdae","impliedFormat":1},{"version":"887f8af936e698ed41ca24c51ef69ffcacef24f9e682753da2d25a03b21b9604","impliedFormat":1},{"version":"b62f7bbb9633dca8e9453306ecaa51ef048c08c4f6819e070101588d58153831","impliedFormat":1},{"version":"e1028569bddd9979216bd1d9cb20c5a8945548768204a0c73c8732906e3e2da1","impliedFormat":1},{"version":"a48410f6ef6f7339b83e3509f2eed56f949c5a0809ca169268d16339ad63f63f","impliedFormat":1},{"version":"c8463e51ad9e12fb823b4d47f382e9835df3857746ae375e98fe2a56b07500d0","impliedFormat":1},{"version":"eac35b722302a87c456688b9404f66671b74af431c80856f2d869a757eb0477f","impliedFormat":1},{"version":"dd86481d34523ab04ea207b7928c8e35d1583d4cb99132db8089acdfc339a932","impliedFormat":1},{"version":"8b5c9823ef1dd3498ff35362237ff859d16bb63a53ac0aceae1444318bca074f","impliedFormat":1},{"version":"82c9a1e59d854feefb2d709c53045fa93dbd46f94102e3042f298c9e3af52397","impliedFormat":1},{"version":"bc7db89f094772891807a3d1f3eb2f7a33c2b89d22850fdf83d2b811ccc1df16","impliedFormat":1},{"version":"7a4fffc1cf5162b2fedb45dc930d8eb8ee09dd86335c4006fcb747f2006126d0","impliedFormat":1},{"version":"7f89d370e83de2bc12d862e038e2b866ddc693800c77d90e41fc8d9a35cc14c6","impliedFormat":1},{"version":"8342e27e4602a4bb00102b1d3c1437af09d405ebb50703bbe42d70f9dc728615","impliedFormat":1},{"version":"c6ac3d44686c16e4f668bc281a04492c812f932160556fbdc5698f70bea48b67","impliedFormat":1},{"version":"a6de1ed396618d836741334fde08d8378f8639837eded06447bd9e84ad876d56","impliedFormat":1},{"version":"1ab2cc945a4d7955a2699cbbc0a076300e813ae22acfa94b6df46a50cd54990d","impliedFormat":1},{"version":"c41364ddf1d8f9206da2a07db0303fb361360b8d34d5fa11801f38c06ac03f24","impliedFormat":1},{"version":"c8c83541b3d9a11fe4dd772e470940da8dca51c504141b55df8104a669bba823","impliedFormat":1},{"version":"acaaecd0b6be7cd04d93836f8ce62e8050ac7ea30e12e25e1827f0e0fc98d15d","impliedFormat":1},{"version":"281175f0f5fbd3997ef1c3465b1442360fcbbabe98449b0d4795c23db82dac63","impliedFormat":1},{"version":"1ea1a927ff48e8f628c47d76440faefa8ef51a273fedbbd8d3ecd7cadb8f93ac","impliedFormat":1},{"version":"abf8b03583cb35edfb9db635ed54a8fd9eda907d0fc0beddf82792a5dee5abbc","impliedFormat":1},{"version":"2afd178f0fb6995e148df3323f78538a919a74bd187a362a571c4adec430e3f2","impliedFormat":1},{"version":"e3cc97f69fa705920a1b23997ad8482c899134c74ee5c2f26700a79669df92bb","impliedFormat":1},{"version":"e8db29f898b4dadb807606a52f8ed402820a31dd5590886e92bcddeb723da72c","impliedFormat":1},{"version":"ae852be67f8c5b4640ad5c049ed64c698a9c052419e7fb2291d2f6e3dc4bfd04","impliedFormat":1},{"version":"34155fbd265a7d4acd8e9f6ad4ca4858b334b299bc50e2caad0da312dfc562ed","impliedFormat":1},{"version":"d1156e8968571d98842fd61c674dd5a4d2a5723091587aa9e5089c6cdb4f9721","impliedFormat":1},{"version":"f8f3d2463d660478c7edc8daa7836d22ea5198f4272a21b42488947f43aced26","impliedFormat":1},{"version":"5915038ce6e77f361ef5357830811c4df0d23f4e8292ec4cbcdde1d13d405fd8","impliedFormat":1},{"version":"e49dea023d8ff426c4b7d1afced98b800c0fa4409cb432b2532258e6d260aa9c","impliedFormat":1},{"version":"f1a4facb20321171798570566f2cce0e9b7ea6db78b923680b7f89fc3810463f","impliedFormat":1},{"version":"3ba42f812de6647f43595cf65421042458282748e664ec3d9d40397fe7ce1567","impliedFormat":1},{"version":"2864d71a69acac55de765156d753b14c3d3206815e3c0cbfb36a83147e01aac6","impliedFormat":1},{"version":"610da6c32d79ed9ab887f2439249e032b12e0d22f881486934deaaa87c74dd76","impliedFormat":1},{"version":"2a567cb3bb07dbb6866afbb58df882cfc0cf53179e01368afb23631d62f82101","impliedFormat":1},{"version":"d954a62d5394cc651837b0037b1b66250bf2c7923ec06a8d654e8479976ec3db","impliedFormat":1},{"version":"bdd08ccecabc6fd25962cd2db9a36badd9aacd22b76d6d6d94e9ebfb4a43b466","impliedFormat":1},{"version":"f7cd675804418069693463cb310ce0315badec17a5098aad870efff22876cdac","impliedFormat":1},"d3d8f730c75c806211521614ef42698788764f0bf669c6d5e05db35655bf221c",{"version":"142d45ecf32f49b9830eb1887f0701c3923e6baeff51b80babf3dee12492b6f3","impliedFormat":1},{"version":"17451d03049e65a91999272018443f1533bd0785a2d8b1cb063fe5ef4e0eec4e","impliedFormat":1},{"version":"8229c81098ece1e115dff78a43d77f952e99ec036323e861a2045bee469e3e8b","impliedFormat":1},{"version":"e70c0b2e57c5653628ad906ccc4b058282e33c7d5725088c1612e8417846b97f","impliedFormat":1},{"version":"9142f0acb28bbe07e00a36d38491d9bc2f5e50e0168de50120ba54949ec00478","impliedFormat":1},{"version":"540f6f22da24dad227bfc0943edbde97bc11fd048ab28c6359d7ce322b76ed5e","impliedFormat":1},{"version":"5abdaf037954149f4103c0660807d97d4d225ffdc53290ab16681980596df76f","affectsGlobalScope":true,"impliedFormat":1},{"version":"6a0d23fd7f1bddf86a98126f5d98367d9332f60249a5fc325493a3b3504f6ca3","impliedFormat":1},{"version":"7ec047b73f621c526468517fea779fec2007dd05baa880989def59126c98ef79","impliedFormat":1},{"version":"6b5f886fe41e2e767168e491fe6048398ed6439d44e006d9f51cc31265f08978","impliedFormat":1},{"version":"56a87e37f91f5625eb7d5f8394904f3f1e2a90fb08f347161dc94f1ae586bdd0","impliedFormat":1},{"version":"6b863463764ae572b9ada405bf77aac37b5e5089a3ab420d0862e4471051393b","impliedFormat":1},{"version":"904d6ad970b6bd825449480488a73d9b98432357ab38cf8d31ffd651ae376ff5","impliedFormat":1},{"version":"233267a4a036c64aee95f66a0d31e3e0ef048cccc57dd66f9cf87582b38691e4","impliedFormat":1},{"version":"84fa21db9e210f00c75d08a9a38527c65abaf012a5748090f1e342b3002d265e","impliedFormat":1},{"version":"91b4ce96f6ad631a0a6920eb0ab928159ff01a439ae0e266ecdc9ea83126a195","impliedFormat":1},{"version":"88efe27bebddb62da9655a9f093e0c27719647e96747f16650489dc9671075d6","impliedFormat":1},{"version":"e348f128032c4807ad9359a1fff29fcbc5f551c81be807bfa86db5a45649b7ba","impliedFormat":1},{"version":"8ee6b07974528da39b7835556e12dd3198c0a13e4a9de321217cd2044f3de22e","impliedFormat":1},{"version":"5e1d8a07714f909beaaaf4d0ffe507345a99f2db967493dd8ebbfbb4f18e83ca","impliedFormat":1},{"version":"5f12132800d430adbe59b49c2c0354d85a71ada7d756e34250a655baa8ad4ae5","impliedFormat":1},{"version":"1996d1cd7d585a8359a35878f67abdd73cc35b1f675c9c6b147b202fdd8dfc3f","impliedFormat":1},{"version":"5a50dbfc042633fdb558e53b30b0a005e0b78e142a1fe1147a8d6618ca69ec99","impliedFormat":1},{"version":"a8b0f3d8b205c32395727230bff7849c947150fdd6288855cbe75bc662c4e236","impliedFormat":1},{"version":"6fb55bb881f4a7167649e6925df076f64a1db2f50632df4674e4621a9445c954","impliedFormat":1},{"version":"4374cefdde5c6e9bad52b0436e887b8325b8f407c12035194ad02c28f1553a3a","impliedFormat":1},{"version":"9b70cad270593f676aecfe4d1611dc766464f0b8138527b0ebbf1ff773578d69","impliedFormat":1},{"version":"b4f85bfb7e831703ac81737361842f1ae4d924b42c5d1af2bff93cca521de4d1","impliedFormat":1},{"version":"5fea76008a2d537ca09d569ffae4e08b991b4a5ff90e9f4783bc983584454ede","impliedFormat":1},{"version":"21575cdeaca6a2c2a0beb8c2ecbc981d9deb95f879f82dc7d6e325fe8737b5ba","impliedFormat":1},{"version":"40ec58f0fadd0b3981b3d383e1c12fa0680115ae9f018387fc2cfc0bbcf23204","impliedFormat":1},{"version":"849b9e7283b7309a4556c9b90bb8e2dfc27751f157798065bbc513dcddb09a8c","impliedFormat":1},{"version":"10e109212c7be8a9f66e988e5d6c2a8900c9d14bf6beadf5fa70d32ada3425cf","impliedFormat":1},{"version":"2b821aeb31e690092f8eae671dd961a9d0fd598ff4883ce0a600c90e9e8fa716","impliedFormat":1},{"version":"26602933b613e4df3868a6c82e14fffa2393a08531cb333ed27b151923462981","impliedFormat":1},{"version":"f57a588d8f6b3ce5c8b494f2dc759a8885eaee18e80a4952df47de45403fedbe","impliedFormat":1},{"version":"34735727b3fe7a0ed0651a0f88d06449163d1989a2b2de7f047473adc7c1c383","impliedFormat":1},{"version":"a5b13abc88ab3186e713c445e59e2f6eee20c6167943517bc2f56985d89b8c55","impliedFormat":1},{"version":"3844b45a774bafe226260cf0772376dce72121ebb801d03902c70a7f11da832b","impliedFormat":1},{"version":"7ae65fe95b18205e241e6695cb2c61c0828d660aca7d08f68781b439a800e6b8","impliedFormat":1},{"version":"e025419f23ccceafd7f5ab3141a86a6bb9fc3b33c44fe62b288d7b19baffc95b","impliedFormat":1},{"version":"369b7270eeeb37982203b2cb18c7302947b89bf5818c1d3d2e95a0418f02b74e","impliedFormat":1},{"version":"94f95d223e2783b0aef4d15d7f6990a6a550fe17d099c501395f690337f7105e","impliedFormat":1},{"version":"039bd8d1e0d151570b66e75ee152877fb0e2f42eca43718632ac195e6884be34","impliedFormat":1},{"version":"89fb1e22c3c98cbb86dc3e5949012bdae217f2b5d768a2cc74e1c4b413c25ad2","impliedFormat":1},{"version":"d3cfde44f8089768ebb08098c96d01ca260b88bccf238d55eee93f1c620ff5a5","impliedFormat":1},{"version":"293eadad9dead44c6fd1db6de552663c33f215c55a1bfa2802a1bceed88ff0ec","impliedFormat":1},{"version":"206e73f49f16633113787cc651dc03dc900379395dfa02ab1ef4c9cbbcd5adc2","impliedFormat":1},{"version":"f12edf1672a94c578eca32216839604f1e1c16b40a1896198deabf99c882b340","impliedFormat":1},{"version":"e3498cf5e428e6c6b9e97bd88736f26d6cf147dedbfa5a8ad3ed8e05e059af8a","impliedFormat":1},{"version":"dba3f34531fd9b1b6e072928b6f885aa4d28dd6789cbd0e93563d43f4b62da53","impliedFormat":1},{"version":"f672c876c1a04a223cf2023b3d91e8a52bb1544c576b81bf64a8fec82be9969c","impliedFormat":1},{"version":"e4b03ddcf8563b1c0aee782a185286ed85a255ce8a30df8453aade2188bbc904","impliedFormat":1},{"version":"2329d90062487e1eaca87b5e06abcbbeeecf80a82f65f949fd332cfcf824b87b","impliedFormat":1},{"version":"25b3f581e12ede11e5739f57a86e8668fbc0124f6649506def306cad2c59d262","impliedFormat":1},{"version":"4fdb529707247a1a917a4626bfb6a293d52cd8ee57ccf03830ec91d39d606d6d","impliedFormat":1},{"version":"a9ebb67d6bbead6044b43714b50dcb77b8f7541ffe803046fdec1714c1eba206","impliedFormat":1},{"version":"833e92c058d033cde3f29a6c7603f517001d1ddd8020bc94d2067a3bc69b2a8e","impliedFormat":1},{"version":"309ebd217636d68cf8784cbc3272c16fb94fb8e969e18b6fe88c35200340aef1","impliedFormat":1},{"version":"91cf9887208be8641244827c18e620166edf7e1c53114930b54eaeaab588a5be","impliedFormat":1},{"version":"ef9b6279acc69002a779d0172916ef22e8be5de2d2469ff2f4bb019a21e89de2","impliedFormat":1},{"version":"9c20e0cce5b7f0a0a46c3a7717d3a9485456769ebfdfd6afa7b5babbcea6f86e","impliedFormat":1},{"version":"88863d76039cc550f8b7688a213dd051ae80d94a883eb99389d6bc4ce21c8688","impliedFormat":1},{"version":"b2732d3b39b116431fb2048679ba11805110bc94c7763d50bfbe98f2a1923882","impliedFormat":1},{"version":"243649afb10d950e7e83ee4d53bd2fbd615bb579a74cf6c1ce10e64402cdf9bb","impliedFormat":1},{"version":"35575179030368798cbcd50da928a275234445c9a0df32d4a2c694b2b3d20439","impliedFormat":1},{"version":"0cf1e5928aae1cca4dcd1a78e19a5833018b84829a116f8fbfab29dc63446a49","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"26384fb401f582cae1234213c3dc75fdc80e3d728a0a1c55b405be8a0c6dddbe","impliedFormat":1},{"version":"26384fb401f582cae1234213c3dc75fdc80e3d728a0a1c55b405be8a0c6dddbe","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"26384fb401f582cae1234213c3dc75fdc80e3d728a0a1c55b405be8a0c6dddbe","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"03268b4d02371bdf514f513797ed3c9eb0840b0724ff6778bda0ef74c35273be","impliedFormat":1},{"version":"3511847babb822e10715a18348d1cbb0dae73c4e4c0a1bcf7cbc12771b310d45","impliedFormat":1},{"version":"add0ce7b77ba5b308492fa68f77f24d1ed1d9148534bdf05ac17c30763fc1a79","impliedFormat":1},{"version":"53f00dc83ccceb8fad22eb3aade64e4bcdb082115f230c8ba3d40f79c835c30e","impliedFormat":1},{"version":"7d94df9d46f72799f956caf7409ae56bd7e754363b0ab6ea7bd865759b679011","impliedFormat":1},{"version":"9078205849121a5d37a642949d687565498da922508eacb0e5a0c3de427f0ae5","impliedFormat":1},{"version":"e8f8f095f137e96dc64b56e59556c02f3c31db4b354801d6ae3b90dceae60240","impliedFormat":1},{"version":"451abef2a26cebb6f54236e68de3c33691e3b47b548fd4c8fa05fd84ab2238ff","impliedFormat":1},{"version":"8e6427dd1a4321b0857499739c641b98657ea6dc7cc9a02c9b2c25a845c3c8e6","impliedFormat":1},{"version":"58da08d1fe876c79c47dcf88be37c5c3fab55d97b34c8c09a666599a2191208d","impliedFormat":1},{"version":"8dd450de6d756cee0761f277c6dc58b0b5a66b8c274b980949318b8cad26d712","impliedFormat":1},{"version":"dfcf16e716338e9fe8cf790ac7756f61c85b83b699861df970661e97bf482692","impliedFormat":1},{"version":"8aa083c7c379b528b52f8631af7e871cade80cdce7714450f8b0f916be3fb1a9","impliedFormat":1},{"version":"71acd198e19fa38447a3cbc5c33f2f5a719d933fccf314aaff0e8b0593271324","impliedFormat":1},{"version":"728210176ce194530dd0188e877bc371cfafdc415142e43b552421db2f53ae86","impliedFormat":1},{"version":"3579fbc9c3a50d12694f04b6003f917b6208520a86eb19ae6eda677a40e5154d","impliedFormat":1},{"version":"cee2aee40c059fcc87d3185838e70a6a3d4051f09f8621beb2f1609e86cee935","impliedFormat":1},{"version":"6042774c61ece4ba77b3bf375f15942eb054675b7957882a00c22c0e4fe5865c","impliedFormat":1},{"version":"41f185713d78f7af0253a339927dc04b485f46210d6bc0691cf908e3e8ded2a1","impliedFormat":1},{"version":"7390fbf07c0f9a8148db2824ce1a98dc59bb0156071bd7cb109dac908c120fab","impliedFormat":1},{"version":"ffc3e1064146c1cafda1b0686ae9679ba1fb706b2f415e057be01614bf918dba","impliedFormat":1},{"version":"e27451b24234dfed45f6cf22112a04955183a99c42a2691fb4936d63cfe42761","impliedFormat":1},{"version":"58d65a2803c3b6629b0e18c8bf1bc883a686fcf0333230dd0151ab6e85b74307","impliedFormat":1},{"version":"e818471014c77c103330aee11f00a7a00b37b35500b53ea6f337aefacd6174c9","impliedFormat":1},{"version":"dca963a986285211cfa75b9bb57914538de29585d34217d03b538e6473ac4c44","impliedFormat":1},{"version":"29f823cbe0166e10e7176a94afe609a24b9e5af3858628c541ff8ce1727023cd","impliedFormat":1},{"version":"e8ac9978254627080292510941044f198b5f5cfdbfff72ad9902bea291118e69","impliedFormat":1},{"version":"8ce1de69e7ab4958cb5e533392ed4c901cdc30ab9a546224f9703c63a5df4e78","impliedFormat":1},{"version":"dfb8b22512cabc48381767e72e07c6652ec64fcdaa63a4c795ab84359f1565d6","impliedFormat":1},{"version":"31c30cc54e8c3da37c8e2e40e5658471f65915df22d348990d1601901e8c9ff3","impliedFormat":1},{"version":"628b24344459b27c26563a0cec458b24b12b6cd2527baf7f78a2ebfadefa61b1","impliedFormat":1},{"version":"89783bd45ab35df55203b522f8271500189c3526976af533a599a86caaf31362","impliedFormat":1},{"version":"26e6c521a290630ea31f0205a46a87cab35faac96e2b30606f37bae7bcda4f9d","impliedFormat":1},{"version":"70f376fa1fa13fbc5960ca54377dcf934475df58e9ced444c8b8727608ff317c","impliedFormat":1},{"version":"cf9fde8a1b8a0ad7c9153ce1517853b83fc2080c531b74fcc4ffd0aa71e583d6","impliedFormat":1},{"version":"aed5d0374ed27516d3fce39ceb13ef72fd9964e379747455ae1855288f664215","impliedFormat":1},{"version":"de82d1ee854ca89e53d55b96de7c7f77b50ad54c4e73db31f82842b9065f86c7","impliedFormat":1},{"version":"adb04a3026a199e83186769ec75dc8d9985640022e1d0a2869ec1f9d1104e98d","impliedFormat":1},{"version":"dcc16b17381db0f204807521ce02406e9ffacac00acd1338bb92bd6ac9cb206c","impliedFormat":1},{"version":"4d10d2ad1e05bea9079a338d573960eed2919d56311767a8796f01b14093b521","impliedFormat":1},{"version":"8aa2aa090ba1fd7dc9ea9bd9276701a9ce1aa3daed981037de3e0c19fc658c34","impliedFormat":1},{"version":"3a635b1155985a218dff8cc16f0dbb452f29112b5bd4d0e10ba67939c58a18d5","impliedFormat":1},{"version":"b2b2e08eef3d923eeac72c6cef352e444cd32061df522d94a28033a4ddb582ca","affectsGlobalScope":true,"impliedFormat":1},{"version":"90a314cb709bc71326039786e6de0b0270c62ae67b628f1d320db06de4a52062","impliedFormat":1},{"version":"1179ef8174e0e4a09d35576199df04803b1db17c0fb35b9326442884bc0b0cce","impliedFormat":1},{"version":"7503a12571195b0f966f916d772d3a4347f60ab3a5ecfeee01274a6646241950","impliedFormat":1},{"version":"c2049e3f83a13a204dd3a5a2d8b1c005c177b8e333f751e63b7c9eef8e6e1836","impliedFormat":1},{"version":"0e29041c1e410acf1323905cb0c779dc1e43c3df88724c287191a666806e2fa3","impliedFormat":1},{"version":"b73eecf28f50b528c18de5c6f9f194f4c9dcc5d8e63ff6d850465e30d67508b3","impliedFormat":1},{"version":"f54dcb80773774ebc5195430ce5adfd5f83a224e2186a0bdf1fe2558a3e40919","impliedFormat":1},{"version":"d4a84ddee5564a39cca7cef721b6ae2d05642fae0eb74f8a9f64c16605404ee8","impliedFormat":1},{"version":"e0606be1fa7965e8f65f8dddc9fda88ea4f958b64055ccb1326718239914c0e4","impliedFormat":1},{"version":"d3c37a2c9612059193e2d82bef4b16f29249b41f5a2a7f3fa9594e6dead38ef0","signature":"db44151f0dd313d33429bdaf3f43b6d592b80904d01941d25026278befaaeb95","impliedFormat":1},{"version":"516f5cbe8a88c68a5493da43dae904e595fe7fb081608d42a7b226a3e1fc5753","impliedFormat":99},{"version":"348c13a1c9160681e41bc5cd3cc519dd8170d38a36a30480b41849f60f5bf8a0","impliedFormat":99},{"version":"576be63cb6921d0aafc8ce6af43f0f19185414fa2f0b4422d120f9d48d97e9a2","impliedFormat":99},{"version":"279248c34ecd223fc46224f86384ebf49c775eb69329ad644d3d99f1205f3e7d","impliedFormat":99},{"version":"74dedffc2d09627f5a4de02bbd7eedf634938c13c2cc4e92f0b4135573432783","impliedFormat":99},{"version":"1f2bbbe38d5e536607b385f04c3d2cbf1e678c5ded7e8c5871ad8ae91ef33c3d","impliedFormat":99},{"version":"54261223043b61b727fc82d218aa0dc2bd1009a5e545e4fecfb158a0c1bea45e","impliedFormat":99},{"version":"3aa3513d5e13d028202e788d763f021d2d113bd673087b42a2606ab50345492d","impliedFormat":99},{"version":"f012173d64d0579875aa60405de21ad379af7971b93bf46bee23acc5fa2b76a4","impliedFormat":99},{"version":"dcf5dc3ce399d472929c170de58422b549130dd540531623c830aaaaf3dd5f93","impliedFormat":99},{"version":"ec35f1490510239b89c745c948007c5dd00a8dca0861a836dcf0db5360679a2d","impliedFormat":99},{"version":"32868e4ec9b6bd4b1d96d24611343404b3a0a37064a7ac514b1d66b48325a911","impliedFormat":99},{"version":"4bbea07f21ff84bf3ceeb218b5a8c367c6e0f08014d3fd09e457d2ffb2826b9c","impliedFormat":99},{"version":"873a07dbeb0f8a3018791d245c0cf10c3289c8f7162cdbbb4a5b9cf723136185","impliedFormat":99},{"version":"43839af7f24edbd4b4e42e861eb7c0d85d80ec497095bb5002c93b451e9fcf88","impliedFormat":99},{"version":"54a7ee56aadecbe8126744f7787f54f79d1e110adab8fe7026ad83a9681f136a","impliedFormat":99},{"version":"6333c727ee2b79cdab55e9e10971e59cbfee26c73dfb350972cfd97712fc2162","impliedFormat":99},{"version":"8743b4356e522c26dc37f20cde4bcdb5ebd0a71a3afe156e81c099db7f34621d","impliedFormat":99},{"version":"af3d97c3a0da9491841efc4e25585247aa76772b840dd279dbff714c69d3a1ec","impliedFormat":99},{"version":"d9ac50fe802967929467413a79631698b8d8f4f2dc692b207e509b6bb3a92524","impliedFormat":99},{"version":"d00c8d21f782f32f55019f8622b37f1a2c73bd1ccc8e829f0fc405e1f22ab61f","impliedFormat":99},{"version":"b75d56703daaffcb31a7cdebf190856e07739a9481f01c2919f95bde99be9424","impliedFormat":99},{"version":"f862f969f96d2311d7fa1d70026d51eaf6160db25f5de2c431efc9aacff379c6","impliedFormat":1},{"version":"024a440e0e3e2164e7f040841b26b652cb408486cd42d910d231b1c5b489ade6","impliedFormat":1},{"version":"88e9caa9c5d2ba629240b5913842e7c57c5c0315383b8dc9d436ef2b60f1c391","impliedFormat":1},{"version":"9371d8d7761b664b5b20e24c4fa82b4d558e4e50bcd17344f0dba7cc09e84cca","impliedFormat":1},{"version":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","impliedFormat":1},{"version":"e7cf774db0fe42fe1903a463c61fed1e21fe3300144dceade0c8a662ce493d32","impliedFormat":1},{"version":"bf37fece4b6fda379e983f396d03a07f4e1383eaee5bc8103964641efa501dc5","impliedFormat":1},{"version":"a504c66b9e0b834ce439469185e343ab8684d41167ba8ad8ec0d5809a111b799","impliedFormat":1},{"version":"b7aa20f615f181d0057a23ad081ce33d4675daaac74198706367bf619c7edf45","impliedFormat":1},{"version":"8085954ba165e611c6230596078063627f3656fed3fb68ad1e36a414c4d7599a","impliedFormat":1},{"version":"7395811d012474ed9511a6c7235fbb444cf61b44c44aa6d8afec89d1ecc3a992","impliedFormat":1},{"version":"5ae8d0a9c74f62d19158db148460d1af2f8960dcba54dcd020609c6aadc098d4","impliedFormat":1},{"version":"2507764807cac07d16eefdc18fb329f8462fcdb881e1baa421e39421845edc95","impliedFormat":1},{"version":"3f88d7cb6622032524895c9730d32e3e454614644d4c470c6b45e9f3d8249e71","impliedFormat":1},{"version":"0943a6e4e026d0de8a4969ee975a7283e0627bf41aa4635d8502f6f24365ac9b","impliedFormat":1},{"version":"1461efc4aefd3e999244f238f59c9b9753a7e3dfede923ebe2b4a11d6e13a0d0","impliedFormat":1},{"version":"4e0000eac5905bfa478850584cff3723d41b2d4614f77172821858525bb2d4ef","impliedFormat":1},{"version":"9c580c6eae94f8c9a38373566e59d5c3282dc194aa266b23a50686fe10560159","impliedFormat":1},{"version":"d7f0ea688d1496dffe2838e71f00bcadd8cc9630a6ad95de50dd5328cf3ce17d","impliedFormat":1},{"version":"4a5aa16151dbec524bb043a5cbce2c3fec75957d175475c115a953aca53999a9","impliedFormat":1},{"version":"f7fc93ec8ea66b3f760846083f8136c90433c12baed72737fd1984f4ce84a06e","impliedFormat":1},{"version":"5ca6bc807f656c894023de9345db3a4468e522758a0cd564bca4af8ec28347f6","impliedFormat":1},{"version":"24bc700786a512d55001d7117f50c13f99804252eacae1487e495c5e72cae560","impliedFormat":1},{"version":"70521b6ab0dcba37539e5303104f29b721bfb2940b2776da4cc818c07e1fefc1","affectsGlobalScope":true,"impliedFormat":1},{"version":"030e350db2525514580ed054f712ffb22d273e6bc7eddc1bb7eda1e0ba5d395e","affectsGlobalScope":true,"impliedFormat":1},{"version":"d153a11543fd884b596587ccd97aebbeed950b26933ee000f94009f1ab142848","affectsGlobalScope":true,"impliedFormat":1},{"version":"21d819c173c0cf7cc3ce57c3276e77fd9a8a01d35a06ad87158781515c9a438a","impliedFormat":1},{"version":"a79e62f1e20467e11a904399b8b18b18c0c6eea6b50c1168bf215356d5bebfaf","affectsGlobalScope":true,"impliedFormat":1},{"version":"d802f0e6b5188646d307f070d83512e8eb94651858de8a82d1e47f60fb6da4e2","affectsGlobalScope":true,"impliedFormat":1},{"version":"8e9c23ba78aabc2e0a27033f18737a6df754067731e69dc5f52823957d60a4b6","impliedFormat":1},{"version":"5929864ce17fba74232584d90cb721a89b7ad277220627cc97054ba15a98ea8f","impliedFormat":1},{"version":"763fe0f42b3d79b440a9b6e51e9ba3f3f91352469c1e4b3b67bfa4ff6352f3f4","impliedFormat":1},{"version":"25c8056edf4314820382a5fdb4bb7816999acdcb929c8f75e3f39473b87e85bc","impliedFormat":1},{"version":"c464d66b20788266e5353b48dc4aa6bc0dc4a707276df1e7152ab0c9ae21fad8","impliedFormat":1},{"version":"78d0d27c130d35c60b5e5566c9f1e5be77caf39804636bc1a40133919a949f21","impliedFormat":1},{"version":"c6fd2c5a395f2432786c9cb8deb870b9b0e8ff7e22c029954fabdd692bff6195","impliedFormat":1},{"version":"1d6e127068ea8e104a912e42fc0a110e2aa5a66a356a917a163e8cf9a65e4a75","impliedFormat":1},{"version":"5ded6427296cdf3b9542de4471d2aa8d3983671d4cac0f4bf9c637208d1ced43","impliedFormat":1},{"version":"7f182617db458e98fc18dfb272d40aa2fff3a353c44a89b2c0ccb3937709bfb5","impliedFormat":1},{"version":"cadc8aced301244057c4e7e73fbcae534b0f5b12a37b150d80e5a45aa4bebcbd","impliedFormat":1},{"version":"385aab901643aa54e1c36f5ef3107913b10d1b5bb8cbcd933d4263b80a0d7f20","impliedFormat":1},{"version":"9670d44354bab9d9982eca21945686b5c24a3f893db73c0dae0fd74217a4c219","impliedFormat":1},{"version":"0b8a9268adaf4da35e7fa830c8981cfa22adbbe5b3f6f5ab91f6658899e657a7","impliedFormat":1},{"version":"11396ed8a44c02ab9798b7dca436009f866e8dae3c9c25e8c1fbc396880bf1bb","impliedFormat":1},{"version":"ba7bc87d01492633cb5a0e5da8a4a42a1c86270e7b3d2dea5d156828a84e4882","impliedFormat":1},{"version":"4893a895ea92c85345017a04ed427cbd6a1710453338df26881a6019432febdd","impliedFormat":1},{"version":"c21dc52e277bcfc75fac0436ccb75c204f9e1b3fa5e12729670910639f27343e","impliedFormat":1},{"version":"13f6f39e12b1518c6650bbb220c8985999020fe0f21d818e28f512b7771d00f9","impliedFormat":1},{"version":"9b5369969f6e7175740bf51223112ff209f94ba43ecd3bb09eefff9fd675624a","impliedFormat":1},{"version":"4fe9e626e7164748e8769bbf74b538e09607f07ed17c2f20af8d680ee49fc1da","impliedFormat":1},{"version":"24515859bc0b836719105bb6cc3d68255042a9f02a6022b3187948b204946bd2","impliedFormat":1},{"version":"ea0148f897b45a76544ae179784c95af1bd6721b8610af9ffa467a518a086a43","impliedFormat":1},{"version":"24c6a117721e606c9984335f71711877293a9651e44f59f3d21c1ea0856f9cc9","impliedFormat":1},{"version":"dd3273ead9fbde62a72949c97dbec2247ea08e0c6952e701a483d74ef92d6a17","impliedFormat":1},{"version":"405822be75ad3e4d162e07439bac80c6bcc6dbae1929e179cf467ec0b9ee4e2e","impliedFormat":1},{"version":"0db18c6e78ea846316c012478888f33c11ffadab9efd1cc8bcc12daded7a60b6","impliedFormat":1},{"version":"e61be3f894b41b7baa1fbd6a66893f2579bfad01d208b4ff61daef21493ef0a8","impliedFormat":1},{"version":"bd0532fd6556073727d28da0edfd1736417a3f9f394877b6d5ef6ad88fba1d1a","impliedFormat":1},{"version":"89167d696a849fce5ca508032aabfe901c0868f833a8625d5a9c6e861ef935d2","impliedFormat":1},{"version":"615ba88d0128ed16bf83ef8ccbb6aff05c3ee2db1cc0f89ab50a4939bfc1943f","impliedFormat":1},{"version":"a4d551dbf8746780194d550c88f26cf937caf8d56f102969a110cfaed4b06656","impliedFormat":1},{"version":"8bd86b8e8f6a6aa6c49b71e14c4ffe1211a0e97c80f08d2c8cc98838006e4b88","impliedFormat":1},{"version":"317e63deeb21ac07f3992f5b50cdca8338f10acd4fbb7257ebf56735bf52ab00","impliedFormat":1},{"version":"4732aec92b20fb28c5fe9ad99521fb59974289ed1e45aecb282616202184064f","impliedFormat":1},{"version":"2e85db9e6fd73cfa3d7f28e0ab6b55417ea18931423bd47b409a96e4a169e8e6","impliedFormat":1},{"version":"c46e079fe54c76f95c67fb89081b3e399da2c7d109e7dca8e4b58d83e332e605","impliedFormat":1},{"version":"bf67d53d168abc1298888693338cb82854bdb2e69ef83f8a0092093c2d562107","impliedFormat":1},{"version":"a4ef5ccfd69b5bc2a2c29896aa07daaff7c5924a12e70cb3d9819145c06897db","affectsGlobalScope":true,"impliedFormat":1},{"version":"a38efe83ff77c34e0f418a806a01ca3910c02ee7d64212a59d59bca6c2c38fa1","impliedFormat":1},{"version":"7394959e5a741b185456e1ef5d64599c36c60a323207450991e7a42e08911419","impliedFormat":1},{"version":"3fe4022ba1e738034e38ad9afacbf0f1f16b458ed516326f5bf9e4a31e9be1dc","impliedFormat":1},{"version":"a957197054b074bcdf5555d26286e8461680c7c878040d0f4e2d5509a7524944","affectsGlobalScope":true,"impliedFormat":1},{"version":"4314c7a11517e221f7296b46547dbc4df047115b182f544d072bdccffa57fc72","impliedFormat":1},{"version":"e9b97d69510658d2f4199b7d384326b7c4053b9e6645f5c19e1c2a54ede427fc","impliedFormat":1},{"version":"c2510f124c0293ab80b1777c44d80f812b75612f297b9857406468c0f4dafe29","affectsGlobalScope":true,"impliedFormat":1},{"version":"5524481e56c48ff486f42926778c0a3cce1cc85dc46683b92b1271865bcf015a","impliedFormat":1},{"version":"f478f6f5902dc144c0d6d7bdc919c5177cac4d17a8ca8653c2daf6d7dc94317f","affectsGlobalScope":true,"impliedFormat":1},{"version":"19d5f8d3930e9f99aa2c36258bf95abbe5adf7e889e6181872d1cdba7c9a7dd5","impliedFormat":1},{"version":"9855e02d837744303391e5623a531734443a5f8e6e8755e018c41d63ad797db2","impliedFormat":1},{"version":"a6bf63d17324010ca1fbf0389cab83f93389bb0b9a01dc8a346d092f65b3605f","impliedFormat":1},{"version":"e009777bef4b023a999b2e5b9a136ff2cde37dc3f77c744a02840f05b18be8ff","impliedFormat":1},{"version":"1e0d1f8b0adfa0b0330e028c7941b5a98c08b600efe7f14d2d2a00854fb2f393","impliedFormat":1},{"version":"71450bbc2d82821d24ca05699a533e72758964e9852062c53b30f31c36978ab8","affectsGlobalScope":true,"impliedFormat":1},{"version":"88bc59b32d0d5b4e5d9632ac38edea23454057e643684c3c0b94511296f2998c","affectsGlobalScope":true,"impliedFormat":1},{"version":"a0a1dda070290b92da5a50113b73ecc4dd6bcbffad66e3c86503d483eafbadcf","impliedFormat":1},{"version":"59dcad36c4549175a25998f6a8b33c1df8e18df9c12ebad1dfb25af13fd4b1ce","impliedFormat":1},{"version":"206a70e72af3e24688397b81304358526ce70d020e4c2606c4acfd1fa1e81fb2","impliedFormat":1},{"version":"017caf5d2a8ef581cf94f678af6ce7415e06956317946315560f1487b9a56167","impliedFormat":1},{"version":"528b62e4272e3ddfb50e8eed9e359dedea0a4d171c3eb8f337f4892aac37b24b","impliedFormat":1},{"version":"d71535813e39c23baa113bc4a29a0e187b87d1105ccc8c5a6ebaca38d9a9bff2","impliedFormat":1},{"version":"4a1c5b43d4d408cb0df0a6cc82ca7be314553d37e432fc1fd801bae1a9ab2cb8","affectsGlobalScope":true,"impliedFormat":1},{"version":"f72bc8fe16da67e4e3268599295797b202b95e54bd215a03f97e925dd1502a36","impliedFormat":1},{"version":"b1b6ee0d012aeebe11d776a155d8979730440082797695fc8e2a5c326285678f","impliedFormat":1},{"version":"45875bcae57270aeb3ebc73a5e3fb4c7b9d91d6b045f107c1d8513c28ece71c0","impliedFormat":1},{"version":"915e18c559321c0afaa8d34674d3eb77e1ded12c3e85bf2a9891ec48b07a1ca5","affectsGlobalScope":true,"impliedFormat":1},{"version":"636302a00dfd1f9fe6e8e91e4e9350c6518dcc8d51a474e4fc3a9ba07135100b","affectsGlobalScope":true,"impliedFormat":1},{"version":"3f16a7e4deafa527ed9995a772bb380eb7d3c2c0fd4ae178c5263ed18394db2c","impliedFormat":1},{"version":"933921f0bb0ec12ef45d1062a1fc0f27635318f4d294e4d99de9a5493e618ca2","impliedFormat":1},{"version":"71a0f3ad612c123b57239a7749770017ecfe6b66411488000aba83e4546fde25","impliedFormat":1},{"version":"8145e07aad6da5f23f2fcd8c8e4c5c13fb26ee986a79d03b0829b8fce152d8b2","impliedFormat":1},{"version":"e1120271ebbc9952fdc7b2dd3e145560e52e06956345e6fdf91d70ca4886464f","impliedFormat":1},{"version":"814118df420c4e38fe5ae1b9a3bafb6e9c2aa40838e528cde908381867be6466","impliedFormat":1},{"version":"e1ce1d622f1e561f6cdf246372ead3bbc07ce0342024d0e9c7caf3136f712698","impliedFormat":1},{"version":"199c8269497136f3a0f4da1d1d90ab033f899f070e0dd801946f2a241c8abba2","impliedFormat":1},{"version":"37ba7b45141a45ce6e80e66f2a96c8a5ab1bcef0fc2d0f56bb58df96ec67e972","impliedFormat":1},{"version":"125d792ec6c0c0f657d758055c494301cc5fdb327d9d9d5960b3f129aff76093","impliedFormat":1},{"version":"27e4532aaaa1665d0dd19023321e4dc12a35a741d6b8e1ca3517fcc2544e0efe","affectsGlobalScope":true,"impliedFormat":1},{"version":"2754d8221d77c7b382096651925eb476f1066b3348da4b73fe71ced7801edada","impliedFormat":1},{"version":"8c2ad42d5d1a2e8e6112625767f8794d9537f1247907378543106f7ba6c7df90","affectsGlobalScope":true,"impliedFormat":1},{"version":"f0be1b8078cd549d91f37c30c222c2a187ac1cf981d994fb476a1adc61387b14","affectsGlobalScope":true,"impliedFormat":1},{"version":"0aaed1d72199b01234152f7a60046bc947f1f37d78d182e9ae09c4289e06a592","impliedFormat":1},{"version":"98ffdf93dfdd206516971d28e3e473f417a5cfd41172e46b4ce45008f640588e","impliedFormat":1},{"version":"66ba1b2c3e3a3644a1011cd530fb444a96b1b2dfe2f5e837a002d41a1a799e60","impliedFormat":1},{"version":"7e514f5b852fdbc166b539fdd1f4e9114f29911592a5eb10a94bb3a13ccac3c4","impliedFormat":1},{"version":"7d6ff413e198d25639f9f01f16673e7df4e4bd2875a42455afd4ecc02ef156da","affectsGlobalScope":true,"impliedFormat":1},{"version":"a7692a54334fd08960cd0c610ff509c2caa93998e0dcefa54021489bcc67c22d","affectsGlobalScope":true,"impliedFormat":1},{"version":"74736930d108365d7bbe740c7154706ccfb1b2a3855a897963ab3e5c07ecbf19","impliedFormat":1},{"version":"3a051941721a7f905544732b0eb819c8d88333a96576b13af08b82c4f17581e4","impliedFormat":1},{"version":"ac5ed35e649cdd8143131964336ab9076937fa91802ec760b3ea63b59175c10a","impliedFormat":1},{"version":"c6ab0dd29bf74b71a54ff2bbce509eb8ae3c4294d57cc54940f443c01cd1baae","affectsGlobalScope":true,"impliedFormat":1},{"version":"3797dd6f4ea3dc15f356f8cdd3128bfa18122213b38a80d6c1f05d8e13cbdad8","impliedFormat":1},{"version":"ad90122e1cb599b3bc06a11710eb5489101be678f2920f2322b0ac3e195af78d","impliedFormat":1},{"version":"94a0fcd4f758fe669bc78f1c9146f5fc07879783787364ca89ce486b0cf37920","affectsGlobalScope":true,"impliedFormat":1},{"version":"2329508bb462ba8f17cc60c4ed5b346618a42eefcaaddcbb0fcbf7f09cfd0a87","impliedFormat":1},{"version":"5e61438eb006e10021f98522d987fdc9457e4b1570de6e6245fa5becb837d4c4","affectsGlobalScope":true,"impliedFormat":1},{"version":"d88b3dc8b7055665059ea06ffafce9467fc4bdfa7cb2d7a6f4262556bb482b0d","impliedFormat":1},{"version":"b6d03c9cfe2cf0ba4c673c209fcd7c46c815b2619fd2aad59fc4229aaef2ed43","impliedFormat":1},{"version":"32ddc6ad753ae79571bbf28cebff7a383bf7f562ac5ef5d25c94ef7f71609d49","impliedFormat":1},{"version":"670a76db379b27c8ff42f1ba927828a22862e2ab0b0908e38b671f0e912cc5ed","impliedFormat":1},{"version":"81df92841a7a12d551fcbc7e4e83dbb7d54e0c73f33a82162d13e9ae89700079","impliedFormat":1},{"version":"069bebfee29864e3955378107e243508b163e77ab10de6a5ee03ae06939f0bb9","impliedFormat":1},{"version":"42baf4ca38c38deaf411ea73f37bc39ff56c6e5c761a968b64ac1b25c92b5cd8","impliedFormat":1},{"version":"d7dbe0ad36bdca8a6ecf143422a48e72cc8927bab7b23a1a2485c2f78a7022c6","impliedFormat":1},{"version":"8718fa41d7cf4aa91de4e8f164c90f88e0bf343aa92a1b9b725a9c675c64e16b","impliedFormat":1},{"version":"f992cd6cc0bcbaa4e6c810468c90f2d8595f8c6c3cf050c806397d3de8585562","impliedFormat":1},{"version":"fb893a0dfc3c9fb0f9ca93d0648694dd95f33cbad2c0f2c629f842981dfd4e2e","impliedFormat":1},{"version":"3eb11dbf3489064a47a2e1cf9d261b1f100ef0b3b50ffca6c44dd99d6dd81ac1","impliedFormat":1},{"version":"151ff381ef9ff8da2da9b9663ebf657eac35c4c9a19183420c05728f31a6761d","impliedFormat":1},{"version":"5d08a179b846f5ee674624b349ebebe2121c455e3a265dc93da4e8d9e89722b4","impliedFormat":1},{"version":"ed19da84b7dbf00952ad0b98ce5c194f1903bcf7c94d8103e8e0d63b271543ae","impliedFormat":1},{"version":"f3d8c757e148ad968f0d98697987db363070abada5f503da3c06aefd9d4248c1","impliedFormat":1},{"version":"fec943fdb3275eb6e006b35e04a8e2e99e9adf3f4b969ddf15315ac7575a93e4","impliedFormat":1},{"version":"a0acca63c9e39580f32a10945df231815f0fe554c074da96ba6564010ffbd2d8","impliedFormat":1},{"version":"7fa8d75d229eeaee235a801758d9c694e94405013fe77d5d1dd8e3201fc414f1","impliedFormat":1},{"version":"74d5a87c3616cd5d8691059d531504403aa857e09cbaecb1c64dfb9ace0db185","impliedFormat":1}],"root":[87,[98,105],107,108,112,[120,124],[126,128],132,133,178,182,185,186,190,191,[501,503],[505,512],519,623,[625,627],[637,639],641,[644,654],[656,663],686,687,689,690,[692,694],[696,699],702,704,[706,708],810],"options":{"composite":true,"esModuleInterop":true,"jsx":4,"module":199,"noImplicitAny":false,"noImplicitReturns":true,"noUnusedLocals":true,"noUnusedParameters":true,"skipLibCheck":true,"sourceMap":false,"strict":true,"target":99},"referencedMap":[[117,1],[114,2],[115,1],[118,3],[119,4],[113,2],[116,1],[813,5],[811,2],[809,6],[620,7],[619,8],[188,9],[189,10],[701,11],[640,12],[514,13],[695,14],[700,14],[129,15],[622,16],[513,13],[643,17],[621,13],[624,13],[642,18],[516,19],[517,13],[130,15],[183,14],[131,14],[655,20],[703,13],[179,15],[705,14],[184,21],[518,22],[515,2],[97,23],[96,24],[816,25],[812,5],[814,26],[815,5],[820,27],[822,28],[824,29],[823,2],[825,30],[135,31],[818,2],[826,2],[827,32],[145,31],[821,2],[754,33],[755,33],[756,34],[714,35],[757,36],[758,37],[759,38],[709,2],[712,39],[710,2],[711,2],[760,40],[761,41],[762,42],[763,43],[764,44],[765,45],[766,45],[768,2],[767,46],[769,47],[770,48],[771,49],[753,50],[713,2],[772,51],[773,52],[774,53],[807,54],[775,55],[776,56],[777,57],[778,58],[779,59],[780,60],[781,61],[782,62],[783,63],[784,64],[785,64],[786,65],[787,2],[788,2],[789,66],[791,67],[790,68],[792,69],[793,70],[794,71],[795,72],[796,73],[797,74],[798,75],[799,76],[800,77],[801,78],[802,79],[803,80],[804,81],[805,82],[806,83],[688,15],[828,15],[88,2],[90,84],[91,15],[819,85],[134,2],[829,2],[830,86],[192,2],[342,87],[347,88],[349,89],[338,90],[499,91],[271,92],[350,2],[203,2],[355,93],[351,94],[352,95],[353,96],[354,97],[356,98],[357,99],[359,100],[337,101],[358,102],[313,103],[236,104],[235,105],[315,106],[205,107],[360,108],[231,109],[361,2],[326,110],[327,111],[328,112],[321,2],[362,2],[363,113],[364,2],[316,114],[365,2],[305,115],[367,116],[304,117],[372,118],[368,119],[369,120],[370,121],[371,122],[373,123],[391,124],[198,125],[339,126],[340,127],[343,128],[341,128],[374,129],[375,130],[376,131],[377,132],[234,129],[380,133],[381,134],[382,134],[378,135],[379,135],[383,136],[384,137],[385,138],[336,139],[201,139],[386,139],[306,139],[199,140],[345,141],[346,142],[387,142],[388,142],[389,142],[202,139],[200,2],[390,143],[344,144],[242,145],[319,146],[392,147],[396,148],[397,149],[399,150],[320,149],[398,151],[400,152],[401,149],[402,153],[403,154],[404,155],[233,156],[405,157],[213,158],[406,159],[491,160],[407,161],[408,157],[409,162],[411,163],[269,164],[273,165],[414,166],[262,167],[412,168],[261,169],[266,170],[264,171],[413,172],[265,173],[415,174],[420,175],[322,2],[416,176],[417,176],[324,177],[323,2],[418,178],[419,176],[425,179],[207,180],[212,181],[238,182],[219,183],[263,184],[206,2],[325,185],[424,186],[237,2],[196,187],[314,2],[211,188],[210,189],[209,190],[239,190],[226,191],[348,192],[194,193],[193,194],[240,195],[267,196],[318,197],[434,2],[228,198],[426,2],[278,194],[427,2],[329,199],[311,200],[230,201],[435,202],[332,203],[331,204],[220,2],[232,2],[195,205],[218,206],[241,2],[215,125],[428,2],[221,207],[217,194],[429,208],[334,209],[333,125],[492,210],[493,211],[494,212],[495,213],[496,214],[497,215],[275,216],[274,217],[498,218],[430,2],[421,99],[276,219],[431,2],[277,220],[395,221],[393,2],[394,222],[229,223],[432,2],[410,224],[279,225],[436,226],[272,227],[433,228],[437,229],[438,230],[439,231],[280,232],[448,233],[281,234],[298,235],[299,236],[297,237],[447,238],[300,239],[449,240],[456,241],[458,242],[450,240],[455,243],[453,244],[454,245],[457,246],[451,247],[452,248],[282,240],[291,249],[283,250],[440,251],[284,252],[441,253],[285,254],[288,253],[287,251],[286,255],[292,256],[442,253],[290,257],[293,257],[295,257],[443,253],[289,258],[294,259],[444,253],[445,251],[296,260],[446,261],[460,262],[459,263],[461,264],[462,265],[469,266],[468,267],[463,268],[470,269],[464,253],[465,270],[466,271],[467,272],[471,273],[301,274],[302,275],[422,99],[477,276],[216,277],[472,278],[473,2],[330,279],[474,280],[475,281],[312,282],[476,125],[478,2],[317,283],[270,2],[479,284],[481,285],[480,284],[303,286],[366,287],[223,288],[482,289],[224,290],[483,291],[222,292],[260,2],[484,293],[307,294],[259,295],[243,2],[244,2],[245,2],[197,2],[246,2],[247,296],[423,162],[248,2],[249,2],[250,2],[227,2],[251,2],[252,2],[208,190],[204,2],[253,2],[254,297],[214,2],[255,298],[256,2],[225,299],[257,2],[258,2],[485,300],[486,301],[487,302],[488,303],[489,304],[335,305],[308,287],[268,306],[310,307],[490,308],[309,309],[500,310],[715,2],[181,311],[180,312],[110,2],[89,2],[808,313],[93,2],[817,314],[109,15],[173,315],[147,316],[148,317],[149,317],[150,317],[151,317],[152,317],[153,317],[154,317],[155,317],[156,317],[157,317],[171,318],[158,317],[159,317],[160,317],[161,317],[162,317],[163,317],[164,317],[165,317],[167,317],[168,317],[166,317],[169,317],[170,317],[172,317],[146,319],[187,2],[520,2],[535,320],[536,320],[549,321],[537,322],[538,322],[539,323],[533,324],[531,325],[522,2],[526,326],[530,327],[528,328],[534,329],[523,330],[524,331],[525,332],[527,333],[529,334],[532,335],[540,322],[541,322],[542,322],[543,320],[544,322],[545,322],[521,322],[546,2],[548,336],[547,322],[177,337],[176,338],[106,339],[669,2],[670,2],[684,340],[664,15],[666,341],[668,342],[667,343],[665,2],[671,2],[672,2],[673,2],[674,2],[675,2],[676,2],[677,2],[678,2],[679,2],[680,344],[682,345],[683,345],[681,2],[685,346],[691,15],[95,347],[92,2],[175,348],[174,349],[94,2],[125,15],[111,2],[142,350],[141,2],[79,2],[80,2],[13,2],[14,2],[16,2],[15,2],[2,2],[17,2],[18,2],[19,2],[20,2],[21,2],[22,2],[23,2],[24,2],[3,2],[25,2],[26,2],[4,2],[27,2],[31,2],[28,2],[29,2],[30,2],[32,2],[33,2],[34,2],[5,2],[35,2],[36,2],[37,2],[38,2],[6,2],[42,2],[39,2],[40,2],[41,2],[43,2],[7,2],[44,2],[49,2],[50,2],[45,2],[46,2],[47,2],[48,2],[8,2],[54,2],[51,2],[52,2],[53,2],[55,2],[9,2],[56,2],[57,2],[58,2],[60,2],[59,2],[61,2],[62,2],[10,2],[63,2],[64,2],[65,2],[11,2],[66,2],[67,2],[68,2],[69,2],[70,2],[1,2],[71,2],[72,2],[12,2],[76,2],[74,2],[78,2],[73,2],[77,2],[75,2],[731,351],[741,352],[730,351],[751,353],[722,354],[721,355],[750,356],[744,357],[749,358],[724,359],[738,360],[723,361],[747,362],[719,363],[718,356],[748,364],[720,365],[725,366],[726,2],[729,366],[716,2],[752,367],[742,368],[733,369],[734,370],[736,371],[732,372],[735,373],[745,356],[727,374],[728,375],[737,376],[717,377],[740,368],[739,366],[743,2],[746,378],[144,379],[140,2],[143,380],[137,381],[136,31],[139,382],[138,383],[86,384],[82,385],[81,2],[83,386],[84,2],[85,387],[636,388],[554,389],[561,390],[556,2],[557,2],[555,391],[558,392],[550,2],[551,2],[562,393],[553,394],[559,2],[560,395],[552,396],[631,397],[634,398],[632,398],[628,397],[635,399],[633,398],[629,400],[630,401],[615,402],[567,403],[569,404],[613,2],[568,405],[614,406],[618,407],[616,2],[570,403],[571,2],[612,408],[566,409],[563,2],[617,410],[564,411],[565,2],[572,412],[573,412],[574,412],[575,412],[576,412],[577,412],[578,412],[579,412],[580,412],[581,412],[582,412],[584,412],[583,412],[585,412],[586,412],[587,412],[611,413],[588,412],[589,412],[590,412],[591,412],[592,412],[593,412],[594,412],[595,412],[596,412],[598,412],[597,412],[599,412],[600,412],[601,412],[602,412],[603,412],[604,412],[605,412],[606,412],[607,412],[608,412],[609,412],[610,412],[810,414],[687,415],[504,24],[104,24],[105,416],[690,24],[133,417],[659,418],[660,419],[698,420],[699,421],[661,422],[503,423],[692,424],[508,425],[186,426],[512,427],[694,428],[639,429],[649,430],[646,431],[645,432],[650,433],[637,434],[648,435],[638,436],[651,437],[652,438],[509,439],[507,440],[178,441],[657,442],[658,443],[663,444],[702,445],[641,446],[696,447],[182,448],[693,449],[623,450],[644,451],[510,452],[626,453],[627,449],[625,454],[686,455],[132,456],[656,457],[704,458],[706,459],[185,460],[707,461],[519,462],[697,463],[662,464],[511,465],[128,466],[654,467],[87,468],[127,469],[126,470],[647,471],[502,472],[708,473],[99,474],[190,475],[505,476],[653,24],[501,477],[112,478],[191,24],[98,24],[506,24],[689,479],[100,480],[102,481],[101,481],[107,482],[108,483],[103,484],[124,485],[121,486],[123,487],[120,24],[122,473]],"affectedFilesPendingEmit":[[687,17],[104,17],[105,17],[690,17],[133,17],[659,17],[660,17],[698,17],[699,17],[661,17],[503,17],[692,17],[508,17],[186,17],[512,17],[694,17],[639,17],[649,17],[646,17],[645,17],[650,17],[637,17],[648,17],[638,17],[651,17],[652,17],[509,17],[507,17],[178,17],[657,17],[658,17],[663,17],[702,17],[641,17],[696,17],[182,17],[693,17],[623,17],[644,17],[510,17],[626,17],[627,17],[625,17],[686,17],[132,17],[656,17],[704,17],[706,17],[185,17],[707,17],[519,17],[697,17],[662,17],[511,17],[128,17],[654,17],[127,17],[126,17],[647,17],[502,17],[708,17],[99,17],[190,17],[505,17],[653,17],[501,17],[112,17],[191,17],[98,17],[506,17],[689,17],[100,17],[102,17],[101,17],[107,17],[108,17],[103,17],[124,17],[121,17],[123,17],[120,17],[122,17]],"emitSignatures":[98,99,100,101,102,103,104,105,107,108,112,120,121,122,123,124,126,127,128,132,133,178,182,185,186,190,191,501,502,503,505,506,507,508,509,510,511,512,519,623,625,626,627,637,638,639,641,644,645,646,647,648,649,650,651,652,653,654,656,657,658,659,660,661,662,663,686,687,689,690,692,693,694,696,697,698,699,702,704,706,707,708],"version":"5.8.3"}
\ No newline at end of file
+{"fileNames":["./node_modules/typescript/lib/lib.es5.d.ts","./node_modules/typescript/lib/lib.es2015.d.ts","./node_modules/typescript/lib/lib.es2016.d.ts","./node_modules/typescript/lib/lib.es2017.d.ts","./node_modules/typescript/lib/lib.es2018.d.ts","./node_modules/typescript/lib/lib.es2019.d.ts","./node_modules/typescript/lib/lib.es2020.d.ts","./node_modules/typescript/lib/lib.es2021.d.ts","./node_modules/typescript/lib/lib.es2022.d.ts","./node_modules/typescript/lib/lib.es2023.d.ts","./node_modules/typescript/lib/lib.es2024.d.ts","./node_modules/typescript/lib/lib.esnext.d.ts","./node_modules/typescript/lib/lib.dom.d.ts","./node_modules/typescript/lib/lib.dom.iterable.d.ts","./node_modules/typescript/lib/lib.es2015.core.d.ts","./node_modules/typescript/lib/lib.es2015.collection.d.ts","./node_modules/typescript/lib/lib.es2015.generator.d.ts","./node_modules/typescript/lib/lib.es2015.iterable.d.ts","./node_modules/typescript/lib/lib.es2015.promise.d.ts","./node_modules/typescript/lib/lib.es2015.proxy.d.ts","./node_modules/typescript/lib/lib.es2015.reflect.d.ts","./node_modules/typescript/lib/lib.es2015.symbol.d.ts","./node_modules/typescript/lib/lib.es2015.symbol.wellknown.d.ts","./node_modules/typescript/lib/lib.es2016.array.include.d.ts","./node_modules/typescript/lib/lib.es2016.intl.d.ts","./node_modules/typescript/lib/lib.es2017.arraybuffer.d.ts","./node_modules/typescript/lib/lib.es2017.date.d.ts","./node_modules/typescript/lib/lib.es2017.object.d.ts","./node_modules/typescript/lib/lib.es2017.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2017.string.d.ts","./node_modules/typescript/lib/lib.es2017.intl.d.ts","./node_modules/typescript/lib/lib.es2017.typedarrays.d.ts","./node_modules/typescript/lib/lib.es2018.asyncgenerator.d.ts","./node_modules/typescript/lib/lib.es2018.asynciterable.d.ts","./node_modules/typescript/lib/lib.es2018.intl.d.ts","./node_modules/typescript/lib/lib.es2018.promise.d.ts","./node_modules/typescript/lib/lib.es2018.regexp.d.ts","./node_modules/typescript/lib/lib.es2019.array.d.ts","./node_modules/typescript/lib/lib.es2019.object.d.ts","./node_modules/typescript/lib/lib.es2019.string.d.ts","./node_modules/typescript/lib/lib.es2019.symbol.d.ts","./node_modules/typescript/lib/lib.es2019.intl.d.ts","./node_modules/typescript/lib/lib.es2020.bigint.d.ts","./node_modules/typescript/lib/lib.es2020.date.d.ts","./node_modules/typescript/lib/lib.es2020.promise.d.ts","./node_modules/typescript/lib/lib.es2020.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2020.string.d.ts","./node_modules/typescript/lib/lib.es2020.symbol.wellknown.d.ts","./node_modules/typescript/lib/lib.es2020.intl.d.ts","./node_modules/typescript/lib/lib.es2020.number.d.ts","./node_modules/typescript/lib/lib.es2021.promise.d.ts","./node_modules/typescript/lib/lib.es2021.string.d.ts","./node_modules/typescript/lib/lib.es2021.weakref.d.ts","./node_modules/typescript/lib/lib.es2021.intl.d.ts","./node_modules/typescript/lib/lib.es2022.array.d.ts","./node_modules/typescript/lib/lib.es2022.error.d.ts","./node_modules/typescript/lib/lib.es2022.intl.d.ts","./node_modules/typescript/lib/lib.es2022.object.d.ts","./node_modules/typescript/lib/lib.es2022.string.d.ts","./node_modules/typescript/lib/lib.es2022.regexp.d.ts","./node_modules/typescript/lib/lib.es2023.array.d.ts","./node_modules/typescript/lib/lib.es2023.collection.d.ts","./node_modules/typescript/lib/lib.es2023.intl.d.ts","./node_modules/typescript/lib/lib.es2024.arraybuffer.d.ts","./node_modules/typescript/lib/lib.es2024.collection.d.ts","./node_modules/typescript/lib/lib.es2024.object.d.ts","./node_modules/typescript/lib/lib.es2024.promise.d.ts","./node_modules/typescript/lib/lib.es2024.regexp.d.ts","./node_modules/typescript/lib/lib.es2024.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2024.string.d.ts","./node_modules/typescript/lib/lib.esnext.array.d.ts","./node_modules/typescript/lib/lib.esnext.collection.d.ts","./node_modules/typescript/lib/lib.esnext.intl.d.ts","./node_modules/typescript/lib/lib.esnext.disposable.d.ts","./node_modules/typescript/lib/lib.esnext.promise.d.ts","./node_modules/typescript/lib/lib.esnext.decorators.d.ts","./node_modules/typescript/lib/lib.esnext.iterator.d.ts","./node_modules/typescript/lib/lib.esnext.float16.d.ts","./node_modules/typescript/lib/lib.decorators.d.ts","./node_modules/typescript/lib/lib.decorators.legacy.d.ts","./node_modules/vite/types/hmrPayload.d.ts","./node_modules/vite/types/customEvent.d.ts","./node_modules/vite/types/hot.d.ts","./node_modules/vite/types/importGlob.d.ts","./node_modules/vite/types/importMeta.d.ts","./node_modules/vite/client.d.ts","./src/renderer/src/env.d.ts","./node_modules/@types/react/global.d.ts","./node_modules/csstype/index.d.ts","./node_modules/@types/react/index.d.ts","./node_modules/@types/react/jsx-runtime.d.ts","./node_modules/sonner/dist/index.d.ts","./node_modules/redux/dist/redux.d.ts","./node_modules/immer/dist/immer.d.ts","./node_modules/reselect/dist/reselect.d.ts","./node_modules/redux-thunk/dist/redux-thunk.d.ts","./node_modules/@reduxjs/toolkit/dist/uncheckedindexed.ts","./node_modules/@reduxjs/toolkit/dist/index.d.ts","./src/renderer/src/redux/createAppSlice.ts","./src/renderer/src/redux/fileSlice.ts","./src/renderer/src/redux/editorSlice.ts","./src/renderer/src/redux/notificationsSlice.ts","./src/renderer/src/redux/store.ts","./src/renderer/src/lib/notify.ts","./node_modules/clsx/clsx.d.ts","./node_modules/tailwind-merge/dist/types.d.ts","./src/renderer/src/lib/utils.tsx","./node_modules/@mister-industries/shared/dist/types.d.ts","./node_modules/@mister-industries/shared/dist/constants.d.ts","./node_modules/@mister-industries/shared/dist/factory.d.ts","./node_modules/@mister-industries/shared/dist/validator.d.ts","./node_modules/@mister-industries/shared/dist/client.d.ts","./node_modules/@mister-industries/shared/dist/hooks/useTinyService.d.ts","./node_modules/@mister-industries/shared/dist/index.d.ts","./src/renderer/src/services/arduino/types.ts","./src/renderer/src/lib/webCache.ts","./src/renderer/src/lib/webFileSystem.ts","./src/renderer/src/lib/virtualFileSystem.ts","./src/renderer/src/services/arduino/WebSocketArduinoService.ts","./src/renderer/src/services/arduino/ElectronArduinoService.ts","./src/renderer/src/services/arduino/WebArduinoService.ts","./src/renderer/src/services/arduino/index.ts","./src/renderer/src/services/arduino/ArduinoServiceFactory.ts","./node_modules/react-redux/dist/react-redux.d.ts","./src/renderer/src/redux/hooks.ts","./src/renderer/src/redux/index.ts","./src/renderer/src/components/BackendPrompt.tsx","./src/renderer/src/lib/fileSystem.ts","./src/renderer/src/lib/github.ts","./src/renderer/src/commands/command.ts","./src/renderer/src/commands/fileCommands.ts","./src/renderer/src/lib/projectRouting.ts","./node_modules/lucide-react/dist/lucide-react.d.ts","./src/renderer/src/lib/agentTypes.ts","./src/renderer/src/hooks/useArduinoAgent.ts","./src/renderer/src/hooks/useArduino.ts","./src/renderer/src/contexts/ArduinoContext.tsx","./node_modules/@radix-ui/react-slot/dist/index.d.ts","./node_modules/class-variance-authority/dist/types.d.ts","./node_modules/class-variance-authority/dist/index.d.ts","./src/renderer/src/components/ui/Button.tsx","./node_modules/@iconify/types/types.d.ts","./node_modules/@iconify/utils/lib/colors/types.d.ts","./node_modules/@iconify/utils/lib/colors/index.d.ts","./node_modules/@iconify/utils/lib/colors/keywords.d.ts","./node_modules/@iconify/utils/lib/css/types.d.ts","./node_modules/@iconify/utils/lib/css/icon.d.ts","./node_modules/@iconify/utils/lib/css/icons.d.ts","./node_modules/@iconify/utils/lib/customisations/bool.d.ts","./node_modules/@iconify/utils/lib/customisations/defaults.d.ts","./node_modules/@iconify/utils/lib/customisations/flip.d.ts","./node_modules/@iconify/utils/lib/customisations/merge.d.ts","./node_modules/@iconify/utils/lib/customisations/rotate.d.ts","./node_modules/@iconify/utils/lib/emoji/cleanup.d.ts","./node_modules/@iconify/utils/lib/emoji/convert.d.ts","./node_modules/@iconify/utils/lib/emoji/format.d.ts","./node_modules/@iconify/utils/lib/emoji/parse.d.ts","./node_modules/@iconify/utils/lib/emoji/regex/create.d.ts","./node_modules/@iconify/utils/lib/emoji/replace/find.d.ts","./node_modules/@iconify/utils/lib/emoji/replace/replace.d.ts","./node_modules/@iconify/utils/lib/emoji/test/parse.d.ts","./node_modules/@iconify/utils/lib/emoji/data.d.ts","./node_modules/@iconify/utils/lib/emoji/test/components.d.ts","./node_modules/@iconify/utils/lib/emoji/test/name.d.ts","./node_modules/@iconify/utils/lib/emoji/test/similar.d.ts","./node_modules/@iconify/utils/lib/emoji/test/tree.d.ts","./node_modules/@iconify/utils/lib/emoji/test/missing.d.ts","./node_modules/@iconify/utils/lib/emoji/test/variations.d.ts","./node_modules/@iconify/utils/lib/icon-set/convert-info.d.ts","./node_modules/@iconify/utils/lib/icon-set/expand.d.ts","./node_modules/@iconify/utils/lib/icon-set/get-icon.d.ts","./node_modules/@iconify/utils/lib/icon-set/get-icons.d.ts","./node_modules/@iconify/utils/lib/icon-set/minify.d.ts","./node_modules/@iconify/utils/lib/icon-set/parse.d.ts","./node_modules/@iconify/utils/lib/icon-set/tree.d.ts","./node_modules/@iconify/utils/lib/icon-set/validate-basic.d.ts","./node_modules/@iconify/utils/lib/icon-set/validate.d.ts","./node_modules/@iconify/utils/lib/icon/defaults.d.ts","./node_modules/@iconify/utils/lib/icon/merge.d.ts","./node_modules/@iconify/utils/lib/icon/name.d.ts","./node_modules/@iconify/utils/lib/svg/viewbox.d.ts","./node_modules/@iconify/utils/lib/icon/square.d.ts","./node_modules/@iconify/utils/lib/icon/transformations.d.ts","./node_modules/@iconify/utils/lib/svg/build.d.ts","./node_modules/@iconify/utils/lib/svg/defs.d.ts","./node_modules/@iconify/utils/lib/svg/id.d.ts","./node_modules/@iconify/utils/lib/svg/size.d.ts","./node_modules/@iconify/utils/lib/svg/encode-svg-for-css.d.ts","./node_modules/@iconify/utils/lib/svg/trim.d.ts","./node_modules/@iconify/utils/lib/svg/pretty.d.ts","./node_modules/@iconify/utils/lib/svg/html.d.ts","./node_modules/@iconify/utils/lib/svg/url.d.ts","./node_modules/@iconify/utils/lib/svg/inner-html.d.ts","./node_modules/@iconify/utils/lib/svg/parse.d.ts","./node_modules/@iconify/utils/lib/loader/types.d.ts","./node_modules/@iconify/utils/lib/loader/utils.d.ts","./node_modules/@iconify/utils/lib/loader/custom.d.ts","./node_modules/@iconify/utils/lib/loader/modern.d.ts","./node_modules/@iconify/utils/lib/loader/loader.d.ts","./node_modules/@iconify/utils/lib/misc/strings.d.ts","./node_modules/@iconify/utils/lib/misc/objects.d.ts","./node_modules/@iconify/utils/lib/misc/title.d.ts","./node_modules/@iconify/utils/lib/index.d.ts","./node_modules/mermaid/dist/rendering-util/icons.d.ts","./node_modules/@types/trusted-types/lib/index.d.ts","./node_modules/dompurify/dist/purify.es.d.mts","./node_modules/mermaid/dist/config.type.d.ts","./node_modules/@types/d3-array/index.d.ts","./node_modules/@types/d3-selection/index.d.ts","./node_modules/@types/d3-axis/index.d.ts","./node_modules/@types/d3-brush/index.d.ts","./node_modules/@types/d3-chord/index.d.ts","./node_modules/@types/d3-color/index.d.ts","./node_modules/@types/geojson/index.d.ts","./node_modules/@types/d3-contour/index.d.ts","./node_modules/@types/d3-delaunay/index.d.ts","./node_modules/@types/d3-dispatch/index.d.ts","./node_modules/@types/d3-drag/index.d.ts","./node_modules/@types/d3-dsv/index.d.ts","./node_modules/@types/d3-ease/index.d.ts","./node_modules/@types/d3-fetch/index.d.ts","./node_modules/@types/d3-force/index.d.ts","./node_modules/@types/d3-format/index.d.ts","./node_modules/@types/d3-geo/index.d.ts","./node_modules/@types/d3-hierarchy/index.d.ts","./node_modules/@types/d3-interpolate/index.d.ts","./node_modules/@types/d3-path/index.d.ts","./node_modules/@types/d3-polygon/index.d.ts","./node_modules/@types/d3-quadtree/index.d.ts","./node_modules/@types/d3-random/index.d.ts","./node_modules/@types/d3-time/index.d.ts","./node_modules/@types/d3-scale/index.d.ts","./node_modules/@types/d3-scale-chromatic/index.d.ts","./node_modules/@types/d3-shape/index.d.ts","./node_modules/@types/d3-time-format/index.d.ts","./node_modules/@types/d3-timer/index.d.ts","./node_modules/@types/d3-transition/index.d.ts","./node_modules/@types/d3-zoom/index.d.ts","./node_modules/@types/d3/index.d.ts","./node_modules/type-fest/source/basic.d.ts","./node_modules/type-fest/source/except.d.ts","./node_modules/type-fest/source/mutable.d.ts","./node_modules/type-fest/source/merge.d.ts","./node_modules/type-fest/source/merge-exclusive.d.ts","./node_modules/type-fest/source/require-at-least-one.d.ts","./node_modules/type-fest/source/require-exactly-one.d.ts","./node_modules/type-fest/source/partial-deep.d.ts","./node_modules/type-fest/source/readonly-deep.d.ts","./node_modules/type-fest/source/literal-union.d.ts","./node_modules/type-fest/source/promisable.d.ts","./node_modules/type-fest/source/opaque.d.ts","./node_modules/type-fest/source/set-optional.d.ts","./node_modules/type-fest/source/set-required.d.ts","./node_modules/type-fest/source/value-of.d.ts","./node_modules/type-fest/source/promise-value.d.ts","./node_modules/type-fest/source/async-return-type.d.ts","./node_modules/type-fest/source/conditional-keys.d.ts","./node_modules/type-fest/source/conditional-except.d.ts","./node_modules/type-fest/source/conditional-pick.d.ts","./node_modules/type-fest/source/union-to-intersection.d.ts","./node_modules/type-fest/source/stringified.d.ts","./node_modules/type-fest/source/package-json.d.ts","./node_modules/type-fest/source/tsconfig-json.d.ts","./node_modules/type-fest/index.d.ts","./node_modules/mermaid/dist/types.d.ts","./node_modules/mermaid/dist/utils.d.ts","./node_modules/mermaid/dist/Diagram.d.ts","./node_modules/mermaid/dist/diagrams/git/gitGraphTypes.d.ts","./node_modules/mermaid/dist/diagram-api/types.d.ts","./node_modules/mermaid/dist/diagram-api/detectType.d.ts","./node_modules/mermaid/dist/errors.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/clusters.d.ts","./node_modules/mermaid/dist/rendering-util/types.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/anchor.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/bowTieRect.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/card.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/choice.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/circle.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/crossedCircle.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/curlyBraceLeft.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/curlyBraceRight.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/curlyBraces.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/curvedTrapezoid.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/cylinder.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/datastore.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/dividedRect.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/doubleCircle.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/filledCircle.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/flippedTriangle.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/forkJoin.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/halfRoundedRectangle.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/hexagon.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/hourglass.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/icon.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/iconCircle.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/iconRounded.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/iconSquare.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/imageSquare.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/invertedTrapezoid.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/labelRect.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/leanLeft.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/leanRight.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/lightningBolt.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/linedCylinder.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/linedWaveEdgedRect.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/multiRect.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/multiWaveEdgedRectangle.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/note.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/question.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/rectLeftInvArrow.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/rectWithTitle.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/roundedRect.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/shadedProcess.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/slopedRect.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/squareRect.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/stadium.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/state.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/stateEnd.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/stateStart.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/subroutine.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/taggedRect.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/taggedWaveEdgedRectangle.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/text.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/tiltedCylinder.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/trapezoid.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/trapezoidalPentagon.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/triangle.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/waveEdgedRectangle.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/waveRectangle.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/windowPane.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/erBox.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/classBox.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/requirementBox.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/kanbanItem.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/bang.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/cloud.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/defaultMindmapNode.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes/mindmapCircle.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/shapes.d.ts","./node_modules/dagre-d3-es/src/graphlib/graph.d.ts","./node_modules/dagre-d3-es/src/graphlib/index.d.ts","./node_modules/dagre-d3-es/src/dagre-js/intersect/intersect-node.d.ts","./node_modules/dagre-d3-es/src/dagre-js/intersect/intersect-circle.d.ts","./node_modules/dagre-d3-es/src/dagre-js/intersect/intersect-ellipse.d.ts","./node_modules/dagre-d3-es/src/dagre-js/intersect/intersect-polygon.d.ts","./node_modules/dagre-d3-es/src/dagre-js/intersect/intersect-rect.d.ts","./node_modules/dagre-d3-es/src/dagre-js/intersect/index.d.ts","./node_modules/dagre-d3-es/src/dagre-js/render.d.ts","./node_modules/dagre-d3-es/src/index.d.ts","./node_modules/mermaid/dist/rendering-util/rendering-elements/nodes.d.ts","./node_modules/mermaid/dist/logger.d.ts","./node_modules/mermaid/dist/internals.d.ts","./node_modules/mermaid/dist/mermaidAPI.d.ts","./node_modules/mermaid/dist/rendering-util/render.d.ts","./node_modules/mermaid/dist/mermaid.d.ts","./node_modules/@types/unist/index.d.ts","./node_modules/@types/hast/index.d.ts","./node_modules/vfile-message/lib/index.d.ts","./node_modules/vfile-message/index.d.ts","./node_modules/vfile/lib/index.d.ts","./node_modules/vfile/index.d.ts","./node_modules/unified/lib/callable-instance.d.ts","./node_modules/trough/lib/index.d.ts","./node_modules/trough/index.d.ts","./node_modules/unified/lib/index.d.ts","./node_modules/unified/index.d.ts","./node_modules/@types/mdast/index.d.ts","./node_modules/mdast-util-to-hast/lib/state.d.ts","./node_modules/mdast-util-to-hast/lib/footer.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/blockquote.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/break.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/code.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/delete.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/emphasis.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/heading.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/html.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/image-reference.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/image.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/inline-code.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/link-reference.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/link.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/list-item.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/list.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/paragraph.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/root.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/strong.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/table.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/table-cell.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/table-row.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/text.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/thematic-break.d.ts","./node_modules/mdast-util-to-hast/lib/handlers/index.d.ts","./node_modules/mdast-util-to-hast/lib/index.d.ts","./node_modules/mdast-util-to-hast/index.d.ts","./node_modules/remark-rehype/lib/index.d.ts","./node_modules/remark-rehype/index.d.ts","./node_modules/react-markdown/lib/index.d.ts","./node_modules/react-markdown/index.d.ts","./node_modules/micromark-util-types/index.d.ts","./node_modules/micromark-extension-gfm-footnote/lib/html.d.ts","./node_modules/micromark-extension-gfm-footnote/lib/syntax.d.ts","./node_modules/micromark-extension-gfm-footnote/index.d.ts","./node_modules/micromark-extension-gfm-strikethrough/lib/html.d.ts","./node_modules/micromark-extension-gfm-strikethrough/lib/syntax.d.ts","./node_modules/micromark-extension-gfm-strikethrough/index.d.ts","./node_modules/micromark-extension-gfm/index.d.ts","./node_modules/mdast-util-from-markdown/lib/types.d.ts","./node_modules/mdast-util-from-markdown/lib/index.d.ts","./node_modules/mdast-util-from-markdown/index.d.ts","./node_modules/mdast-util-to-markdown/lib/types.d.ts","./node_modules/mdast-util-to-markdown/lib/index.d.ts","./node_modules/mdast-util-to-markdown/lib/handle/blockquote.d.ts","./node_modules/mdast-util-to-markdown/lib/handle/break.d.ts","./node_modules/mdast-util-to-markdown/lib/handle/code.d.ts","./node_modules/mdast-util-to-markdown/lib/handle/definition.d.ts","./node_modules/mdast-util-to-markdown/lib/handle/emphasis.d.ts","./node_modules/mdast-util-to-markdown/lib/handle/heading.d.ts","./node_modules/mdast-util-to-markdown/lib/handle/html.d.ts","./node_modules/mdast-util-to-markdown/lib/handle/image.d.ts","./node_modules/mdast-util-to-markdown/lib/handle/image-reference.d.ts","./node_modules/mdast-util-to-markdown/lib/handle/inline-code.d.ts","./node_modules/mdast-util-to-markdown/lib/handle/link.d.ts","./node_modules/mdast-util-to-markdown/lib/handle/link-reference.d.ts","./node_modules/mdast-util-to-markdown/lib/handle/list.d.ts","./node_modules/mdast-util-to-markdown/lib/handle/list-item.d.ts","./node_modules/mdast-util-to-markdown/lib/handle/paragraph.d.ts","./node_modules/mdast-util-to-markdown/lib/handle/root.d.ts","./node_modules/mdast-util-to-markdown/lib/handle/strong.d.ts","./node_modules/mdast-util-to-markdown/lib/handle/text.d.ts","./node_modules/mdast-util-to-markdown/lib/handle/thematic-break.d.ts","./node_modules/mdast-util-to-markdown/lib/handle/index.d.ts","./node_modules/mdast-util-to-markdown/index.d.ts","./node_modules/mdast-util-gfm-footnote/lib/index.d.ts","./node_modules/mdast-util-gfm-footnote/index.d.ts","./node_modules/markdown-table/index.d.ts","./node_modules/mdast-util-gfm-table/lib/index.d.ts","./node_modules/mdast-util-gfm-table/index.d.ts","./node_modules/mdast-util-gfm/lib/index.d.ts","./node_modules/mdast-util-gfm/index.d.ts","./node_modules/remark-gfm/lib/index.d.ts","./node_modules/remark-gfm/index.d.ts","./src/renderer/src/components/Markdown.tsx","./node_modules/@radix-ui/react-context/dist/index.d.ts","./node_modules/@radix-ui/react-primitive/dist/index.d.ts","./node_modules/@radix-ui/react-dismissable-layer/dist/index.d.ts","./node_modules/@radix-ui/react-focus-scope/dist/index.d.ts","./node_modules/@radix-ui/react-portal/dist/index.d.ts","./node_modules/@radix-ui/react-dialog/dist/index.d.ts","./src/renderer/src/components/ui/Dialog.tsx","./src/renderer/src/components/ui/Input.tsx","./node_modules/@radix-ui/react-scroll-area/dist/index.d.ts","./src/renderer/src/components/ui/ScrollArea.tsx","./src/renderer/src/components/AIAssistant.tsx","./src/renderer/src/lib/examples.ts","./src/renderer/src/components/ui/Card.tsx","./src/renderer/src/components/ExamplesContent.tsx","./src/renderer/src/components/ReferenceContent.tsx","./node_modules/@radix-ui/react-roving-focus/dist/index.d.ts","./node_modules/@radix-ui/react-tabs/dist/index.d.ts","./src/renderer/src/components/ui/Tabs.tsx","./src/renderer/src/components/DocsPanel.tsx","./node_modules/monaco-editor/esm/vs/editor/editor.api.d.ts","./node_modules/@monaco-editor/loader/lib/types.d.ts","./node_modules/@monaco-editor/react/dist/index.d.ts","./src/renderer/src/lib/visualExport.ts","./node_modules/blockly/blocks.d.ts","./node_modules/blockly/core/interfaces/i_focusable_tree.d.ts","./node_modules/blockly/core/interfaces/i_focusable_node.d.ts","./node_modules/blockly/core/interfaces/i_selectable.d.ts","./node_modules/blockly/core/interfaces/i_copyable.d.ts","./node_modules/blockly/core/utils/coordinate.d.ts","./node_modules/blockly/core/events/events_abstract.d.ts","./node_modules/blockly/core/events/events_ui_base.d.ts","./node_modules/blockly/core/events/type.d.ts","./node_modules/blockly/core/events/events_theme_change.d.ts","./node_modules/blockly/core/events/events_viewport.d.ts","./node_modules/blockly/core/browser_events.d.ts","./node_modules/blockly/core/utils/size.d.ts","./node_modules/blockly/core/comments/workspace_comment.d.ts","./node_modules/blockly/core/interfaces/i_component.d.ts","./node_modules/blockly/core/interfaces/i_autohideable.d.ts","./node_modules/blockly/core/utils/rect.d.ts","./node_modules/blockly/core/interfaces/i_draggable.d.ts","./node_modules/blockly/core/interfaces/i_drag_target.d.ts","./node_modules/blockly/core/interfaces/i_delete_area.d.ts","./node_modules/blockly/core/interfaces/i_bounded_element.d.ts","./node_modules/blockly/core/flyout_item.d.ts","./node_modules/blockly/core/utils/svg.d.ts","./node_modules/blockly/core/interfaces/i_serializer.d.ts","./node_modules/blockly/core/serialization/blocks.d.ts","./node_modules/blockly/core/interfaces/i_toolbox_item.d.ts","./node_modules/blockly/core/interfaces/i_selectable_toolbox_item.d.ts","./node_modules/blockly/core/interfaces/i_collapsible_toolbox_item.d.ts","./node_modules/blockly/core/interfaces/i_registrable.d.ts","./node_modules/blockly/core/interfaces/i_toolbox.d.ts","./node_modules/blockly/core/toolbox/toolbox_item.d.ts","./node_modules/blockly/core/toolbox/category.d.ts","./node_modules/blockly/core/toolbox/separator.d.ts","./node_modules/blockly/core/utils/toolbox.d.ts","./node_modules/blockly/core/interfaces/i_flyout.d.ts","./node_modules/blockly/core/utils/metrics.d.ts","./node_modules/blockly/core/interfaces/i_metrics_manager.d.ts","./node_modules/blockly/core/metrics_manager.d.ts","./node_modules/blockly/core/interfaces/i_positionable.d.ts","./node_modules/blockly/core/component_manager.d.ts","./node_modules/blockly/core/interfaces/i_rendered_element.d.ts","./node_modules/blockly/core/flyout_button.d.ts","./node_modules/blockly/core/events/events_click.d.ts","./node_modules/blockly/core/comments/comment_view.d.ts","./node_modules/blockly/core/comments.d.ts","./node_modules/blockly/core/interfaces/i_contextmenu.d.ts","./node_modules/blockly/core/interfaces/i_bubble.d.ts","./node_modules/blockly/core/interfaces/i_dragger.d.ts","./node_modules/blockly/core/interfaces/i_has_bubble.d.ts","./node_modules/blockly/core/interfaces/i_serializable.d.ts","./node_modules/blockly/core/extensions.d.ts","./node_modules/blockly/core/utils/aria.d.ts","./node_modules/blockly/core/utils/array.d.ts","./node_modules/blockly/core/utils/colour.d.ts","./node_modules/blockly/core/utils/deprecation.d.ts","./node_modules/blockly/core/utils/dom.d.ts","./node_modules/blockly/core/utils/idgenerator.d.ts","./node_modules/blockly/core/utils/keycodes.d.ts","./node_modules/blockly/core/utils/math.d.ts","./node_modules/blockly/core/utils/object.d.ts","./node_modules/blockly/core/utils/parsing.d.ts","./node_modules/blockly/core/utils/string.d.ts","./node_modules/blockly/core/utils/style.d.ts","./node_modules/blockly/core/utils/svg_math.d.ts","./node_modules/blockly/core/utils/svg_paths.d.ts","./node_modules/blockly/core/utils/useragent.d.ts","./node_modules/blockly/core/utils/xml.d.ts","./node_modules/blockly/core/utils.d.ts","./node_modules/blockly/core/tooltip.d.ts","./node_modules/blockly/core/icons/icon.d.ts","./node_modules/blockly/core/icons/comment_icon.d.ts","./node_modules/blockly/core/interfaces/i_comment_icon.d.ts","./node_modules/blockly/core/icons/mutator_icon.d.ts","./node_modules/blockly/core/icons/warning_icon.d.ts","./node_modules/blockly/core/icons/icon_types.d.ts","./node_modules/blockly/core/interfaces/i_icon.d.ts","./node_modules/blockly/core/workspace_dragger.d.ts","./node_modules/blockly/core/gesture.d.ts","./node_modules/blockly/core/theme.d.ts","./node_modules/blockly/core/blockly_options.d.ts","./node_modules/blockly/core/options.d.ts","./node_modules/blockly/core/grid.d.ts","./node_modules/blockly/core/keyboard_nav/marker.d.ts","./node_modules/blockly/core/keyboard_nav/line_cursor.d.ts","./node_modules/blockly/core/layer_manager.d.ts","./node_modules/blockly/core/marker_manager.d.ts","./node_modules/blockly/core/interfaces/i_navigation_policy.d.ts","./node_modules/blockly/core/navigator.d.ts","./node_modules/blockly/core/rendered_connection.d.ts","./node_modules/blockly/core/renderers/common/constants.d.ts","./node_modules/blockly/core/renderers/measurables/base.d.ts","./node_modules/blockly/core/renderers/measurables/connection.d.ts","./node_modules/blockly/core/renderers/measurables/field.d.ts","./node_modules/blockly/core/renderers/measurables/icon.d.ts","./node_modules/blockly/core/renderers/measurables/input_connection.d.ts","./node_modules/blockly/core/renderers/measurables/inline_input.d.ts","./node_modules/blockly/core/renderers/measurables/in_row_spacer.d.ts","./node_modules/blockly/core/renderers/measurables/row.d.ts","./node_modules/blockly/core/renderers/measurables/next_connection.d.ts","./node_modules/blockly/core/renderers/measurables/bottom_row.d.ts","./node_modules/blockly/core/renderers/measurables/input_row.d.ts","./node_modules/blockly/core/renderers/measurables/output_connection.d.ts","./node_modules/blockly/core/renderers/measurables/spacer_row.d.ts","./node_modules/blockly/core/renderers/measurables/previous_connection.d.ts","./node_modules/blockly/core/renderers/measurables/top_row.d.ts","./node_modules/blockly/core/renderers/common/info.d.ts","./node_modules/blockly/core/renderers/common/drawer.d.ts","./node_modules/blockly/core/renderers/common/i_path_object.d.ts","./node_modules/blockly/core/renderers/common/renderer.d.ts","./node_modules/blockly/core/scrollbar.d.ts","./node_modules/blockly/core/scrollbar_pair.d.ts","./node_modules/blockly/core/theme_manager.d.ts","./node_modules/blockly/core/drag_target.d.ts","./node_modules/blockly/core/delete_area.d.ts","./node_modules/blockly/core/events/events_trashcan_open.d.ts","./node_modules/blockly/core/trashcan.d.ts","./node_modules/blockly/core/workspace_audio.d.ts","./node_modules/blockly/core/zoom_controls.d.ts","./node_modules/blockly/core/workspace_svg.d.ts","./node_modules/blockly/core/interfaces/i_paster.d.ts","./node_modules/blockly/core/serialization/workspace_comments.d.ts","./node_modules/blockly/core/clipboard/workspace_comment_paster.d.ts","./node_modules/blockly/core/interfaces/i_deletable.d.ts","./node_modules/blockly/core/comments/rendered_workspace_comment.d.ts","./node_modules/blockly/core/contextmenu_registry.d.ts","./node_modules/blockly/core/shortcut_registry.d.ts","./node_modules/blockly/core/interfaces/i_keyboard_accessible.d.ts","./node_modules/blockly/core/field.d.ts","./node_modules/blockly/core/field_label.d.ts","./node_modules/blockly/core/connection_type.d.ts","./node_modules/blockly/core/inputs/align.d.ts","./node_modules/blockly/core/inputs/input_types.d.ts","./node_modules/blockly/core/inputs/input.d.ts","./node_modules/blockly/core/interfaces/i_connection_checker.d.ts","./node_modules/blockly/core/connection.d.ts","./node_modules/blockly/core/connection_checker.d.ts","./node_modules/blockly/core/connection_db.d.ts","./node_modules/blockly/core/interfaces/i_parameter_model.d.ts","./node_modules/blockly/core/serialization/procedures.d.ts","./node_modules/blockly/core/interfaces/i_procedure_model.d.ts","./node_modules/blockly/core/interfaces/i_procedure_map.d.ts","./node_modules/blockly/core/interfaces/i_variable_model.d.ts","./node_modules/blockly/core/interfaces/i_variable_map.d.ts","./node_modules/blockly/core/workspace.d.ts","./node_modules/blockly/core/events/events_selected.d.ts","./node_modules/blockly/core/clipboard/block_paster.d.ts","./node_modules/blockly/core/block_svg.d.ts","./node_modules/blockly/core/events/events_block_base.d.ts","./node_modules/blockly/core/events/events_block_change.d.ts","./node_modules/blockly/core/events/events_block_delete.d.ts","./node_modules/blockly/core/block.d.ts","./node_modules/blockly/core/events/events_block_create.d.ts","./node_modules/blockly/core/events/workspace_events.d.ts","./node_modules/blockly/core/events/events_var_base.d.ts","./node_modules/blockly/core/events/events_var_create.d.ts","./node_modules/blockly/core/block_animations.d.ts","./node_modules/blockly/core/interfaces/i_flyout_inflater.d.ts","./node_modules/blockly/core/block_flyout_inflater.d.ts","./node_modules/blockly/core/blocks.d.ts","./node_modules/blockly/core/bubbles/bubble.d.ts","./node_modules/blockly/core/bubbles/mini_workspace_bubble.d.ts","./node_modules/blockly/core/bubbles/text_bubble.d.ts","./node_modules/blockly/core/bubbles/textinput_bubble.d.ts","./node_modules/blockly/core/bubbles.d.ts","./node_modules/blockly/core/bump_objects.d.ts","./node_modules/blockly/core/button_flyout_inflater.d.ts","./node_modules/blockly/core/clipboard/registry.d.ts","./node_modules/blockly/core/clipboard.d.ts","./node_modules/blockly/core/common.d.ts","./node_modules/blockly/core/config.d.ts","./node_modules/blockly/core/constants.d.ts","./node_modules/blockly/core/contextmenu.d.ts","./node_modules/blockly/core/contextmenu_items.d.ts","./node_modules/blockly/core/css.d.ts","./node_modules/blockly/core/toast.d.ts","./node_modules/blockly/core/dialog.d.ts","./node_modules/blockly/core/dragging/block_drag_strategy.d.ts","./node_modules/blockly/core/dragging/bubble_drag_strategy.d.ts","./node_modules/blockly/core/dragging/comment_drag_strategy.d.ts","./node_modules/blockly/core/dragging/dragger.d.ts","./node_modules/blockly/core/dragging.d.ts","./node_modules/blockly/core/dropdowndiv.d.ts","./node_modules/blockly/core/events/events_block_drag.d.ts","./node_modules/blockly/core/events/events_block_field_intermediate_change.d.ts","./node_modules/blockly/core/events/events_block_move.d.ts","./node_modules/blockly/core/events/events_bubble_open.d.ts","./node_modules/blockly/core/events/events_comment_create.d.ts","./node_modules/blockly/core/events/events_comment_delete.d.ts","./node_modules/blockly/core/events/events_comment_base.d.ts","./node_modules/blockly/core/events/events_comment_change.d.ts","./node_modules/blockly/core/events/events_comment_collapse.d.ts","./node_modules/blockly/core/events/events_comment_drag.d.ts","./node_modules/blockly/core/events/events_comment_move.d.ts","./node_modules/blockly/core/events/events_comment_resize.d.ts","./node_modules/blockly/core/events/events_toolbox_item_select.d.ts","./node_modules/blockly/core/events/events_var_delete.d.ts","./node_modules/blockly/core/events/events_var_rename.d.ts","./node_modules/blockly/core/events/events_var_type_change.d.ts","./node_modules/blockly/core/events/utils.d.ts","./node_modules/blockly/core/events/events.d.ts","./node_modules/blockly/core/field_checkbox.d.ts","./node_modules/blockly/core/menu_separator.d.ts","./node_modules/blockly/core/menuitem.d.ts","./node_modules/blockly/core/menu.d.ts","./node_modules/blockly/core/field_dropdown.d.ts","./node_modules/blockly/core/field_image.d.ts","./node_modules/blockly/core/field_label_serializable.d.ts","./node_modules/blockly/core/field_input.d.ts","./node_modules/blockly/core/field_number.d.ts","./node_modules/blockly/core/field_registry.d.ts","./node_modules/blockly/core/field_textinput.d.ts","./node_modules/blockly/core/field_variable.d.ts","./node_modules/blockly/core/flyout_base.d.ts","./node_modules/blockly/core/flyout_horizontal.d.ts","./node_modules/blockly/core/flyout_metrics_manager.d.ts","./node_modules/blockly/core/flyout_separator.d.ts","./node_modules/blockly/core/flyout_vertical.d.ts","./node_modules/blockly/core/focus_manager.d.ts","./node_modules/blockly/core/names.d.ts","./node_modules/blockly/core/generator.d.ts","./node_modules/blockly/core/icons/exceptions.d.ts","./node_modules/blockly/core/icons/registry.d.ts","./node_modules/blockly/core/icons.d.ts","./node_modules/blockly/core/inject.d.ts","./node_modules/blockly/core/inputs/dummy_input.d.ts","./node_modules/blockly/core/inputs/end_row_input.d.ts","./node_modules/blockly/core/inputs/statement_input.d.ts","./node_modules/blockly/core/inputs/value_input.d.ts","./node_modules/blockly/core/inputs.d.ts","./node_modules/blockly/core/label_flyout_inflater.d.ts","./node_modules/blockly/core/separator_flyout_inflater.d.ts","./node_modules/blockly/core/utils/focusable_tree_traverser.d.ts","./node_modules/blockly/core/interfaces/i_connection_previewer.d.ts","./node_modules/blockly/core/insertion_marker_previewer.d.ts","./node_modules/blockly/core/interfaces/i_movable.d.ts","./node_modules/blockly/core/interfaces/i_observable.d.ts","./node_modules/blockly/core/interfaces/i_styleable.d.ts","./node_modules/blockly/core/interfaces/i_variable_backed_parameter_model.d.ts","./node_modules/blockly/core/keyboard_navigation_controller.d.ts","./node_modules/blockly/core/layers.d.ts","./node_modules/blockly/core/msg.d.ts","./node_modules/blockly/core/positionable_helpers.d.ts","./node_modules/blockly/core/interfaces/i_legacy_procedure_blocks.d.ts","./node_modules/blockly/core/interfaces/i_procedure_block.d.ts","./node_modules/blockly/core/observable_procedure_map.d.ts","./node_modules/blockly/core/procedures.d.ts","./node_modules/blockly/core/registry.d.ts","./node_modules/blockly/core/render_management.d.ts","./node_modules/blockly/core/renderers/measurables/external_value_input.d.ts","./node_modules/blockly/core/renderers/measurables/hat.d.ts","./node_modules/blockly/core/renderers/measurables/jagged_edge.d.ts","./node_modules/blockly/core/renderers/measurables/round_corner.d.ts","./node_modules/blockly/core/renderers/measurables/square_corner.d.ts","./node_modules/blockly/core/renderers/measurables/statement_input.d.ts","./node_modules/blockly/core/renderers/measurables/types.d.ts","./node_modules/blockly/core/renderers/common/path_object.d.ts","./node_modules/blockly/core/renderers/common/block_rendering.d.ts","./node_modules/blockly/core/renderers/geras/constants.d.ts","./node_modules/blockly/core/renderers/geras/highlight_constants.d.ts","./node_modules/blockly/core/renderers/geras/path_object.d.ts","./node_modules/blockly/core/renderers/geras/renderer.d.ts","./node_modules/blockly/core/renderers/geras/info.d.ts","./node_modules/blockly/core/renderers/geras/measurables/inline_input.d.ts","./node_modules/blockly/core/renderers/geras/highlighter.d.ts","./node_modules/blockly/core/renderers/geras/drawer.d.ts","./node_modules/blockly/core/renderers/geras/measurables/statement_input.d.ts","./node_modules/blockly/core/renderers/geras/geras.d.ts","./node_modules/blockly/core/renderers/thrasos/renderer.d.ts","./node_modules/blockly/core/renderers/thrasos/info.d.ts","./node_modules/blockly/core/renderers/thrasos/thrasos.d.ts","./node_modules/blockly/core/renderers/zelos/constants.d.ts","./node_modules/blockly/core/renderers/zelos/measurables/bottom_row.d.ts","./node_modules/blockly/core/renderers/zelos/measurables/row_elements.d.ts","./node_modules/blockly/core/renderers/zelos/measurables/top_row.d.ts","./node_modules/blockly/core/renderers/zelos/path_object.d.ts","./node_modules/blockly/core/renderers/zelos/renderer.d.ts","./node_modules/blockly/core/renderers/zelos/info.d.ts","./node_modules/blockly/core/renderers/zelos/drawer.d.ts","./node_modules/blockly/core/renderers/zelos/measurables/inputs.d.ts","./node_modules/blockly/core/renderers/zelos/zelos.d.ts","./node_modules/blockly/core/serialization/exceptions.d.ts","./node_modules/blockly/core/serialization/priorities.d.ts","./node_modules/blockly/core/serialization/registry.d.ts","./node_modules/blockly/core/serialization/variables.d.ts","./node_modules/blockly/core/serialization/workspaces.d.ts","./node_modules/blockly/core/serialization.d.ts","./node_modules/blockly/core/shortcut_items.d.ts","./node_modules/blockly/core/theme/classic.d.ts","./node_modules/blockly/core/theme/zelos.d.ts","./node_modules/blockly/core/theme/themes.d.ts","./node_modules/blockly/core/toolbox/collapsible_category.d.ts","./node_modules/blockly/core/toolbox/toolbox.d.ts","./node_modules/blockly/core/touch.d.ts","./node_modules/blockly/core/variable_map.d.ts","./node_modules/blockly/core/variable_model.d.ts","./node_modules/blockly/core/variables.d.ts","./node_modules/blockly/core/variables_dynamic.d.ts","./node_modules/blockly/core/widgetdiv.d.ts","./node_modules/blockly/core/xml.d.ts","./node_modules/blockly/core/flyout_navigator.d.ts","./node_modules/blockly/core/keyboard_nav/block_navigation_policy.d.ts","./node_modules/blockly/core/keyboard_nav/connection_navigation_policy.d.ts","./node_modules/blockly/core/keyboard_nav/field_navigation_policy.d.ts","./node_modules/blockly/core/keyboard_nav/flyout_button_navigation_policy.d.ts","./node_modules/blockly/core/keyboard_nav/flyout_navigation_policy.d.ts","./node_modules/blockly/core/keyboard_nav/flyout_separator_navigation_policy.d.ts","./node_modules/blockly/core/keyboard_nav/workspace_navigation_policy.d.ts","./node_modules/blockly/core/blockly.d.ts","./node_modules/blockly/index.d.ts","./src/renderer/src/lib/ThemeProvider.tsx","./src/renderer/src/lib/arduinoBlocks.ts","./src/renderer/src/components/BlocklyEditor.tsx","./src/renderer/src/circuit/core/model.ts","./src/renderer/src/circuit/core/routing.ts","./src/renderer/src/circuit/core/nets.ts","./src/renderer/src/circuit/core/commands.ts","./src/renderer/src/circuit/core/store.ts","./src/renderer/src/circuit/core/geometry.ts","./src/renderer/src/circuit/core/refdes.ts","./src/renderer/src/circuit/core/clipboard.ts","./src/renderer/src/circuit/parts/svg.ts","./src/renderer/src/circuit/index.ts","./src/renderer/src/assets/parts/index.json","./src/renderer/src/lib/partsLibrary.ts","./src/renderer/src/lib/userParts.ts","./src/renderer/src/circuit/parts/svgUnits.ts","./src/renderer/src/circuit/parts/zip.ts","./src/renderer/src/circuit/parts/fzpz.ts","./src/renderer/src/components/PartsEditor.tsx","./src/renderer/src/circuit/core/netlist.ts","./src/renderer/src/circuit/core/erc.ts","./src/renderer/src/circuit/parts/breadboard.ts","./src/renderer/src/circuit/parts/simParts.ts","./src/renderer/src/circuit/parts/simProbes.ts","./src/renderer/src/circuit/parts/packs.ts","./src/renderer/src/circuit/views/packs/PackManager.tsx","./src/renderer/src/circuit/parts/netLabels.ts","./src/renderer/src/circuit/parts/symbols.ts","./src/renderer/src/circuit/parts/resistorBands.ts","./src/renderer/src/circuit/views/partsAdapter.ts","./src/renderer/src/circuit/views/canvas/Canvas.tsx","./src/renderer/src/circuit/views/exportImage.ts","./src/renderer/src/circuit/views/palette/Palette.tsx","./src/renderer/src/circuit/views/inspector/Inspector.tsx","./src/renderer/src/circuit/sim/backend.ts","./src/renderer/src/circuit/core/probes.ts","./src/renderer/src/circuit/sim/engine.ts","./src/renderer/src/circuit/sim/index.ts","./node_modules/uplot/dist/uPlot.d.ts","./src/renderer/src/circuit/views/sim/Plot.tsx","./src/renderer/src/circuit/views/sim/SimPanel.tsx","./src/renderer/src/circuit/views/CircuitView.tsx","./src/renderer/src/components/MonacoEditor.tsx","./src/renderer/src/components/ui/FileTab.tsx","./src/renderer/src/components/ui/IconButton.tsx","./src/renderer/src/components/VisualPreview.tsx","./src/renderer/src/components/EditorPanel.tsx","./src/renderer/src/components/ErrorBoundary.tsx","./node_modules/@radix-ui/react-arrow/dist/index.d.ts","./node_modules/@radix-ui/rect/dist/index.d.ts","./node_modules/@radix-ui/react-popper/dist/index.d.ts","./node_modules/@radix-ui/react-tooltip/dist/index.d.ts","./src/renderer/src/components/ui/Tooltip.tsx","./node_modules/react-hook-form/dist/constants.d.ts","./node_modules/react-hook-form/dist/utils/createSubject.d.ts","./node_modules/react-hook-form/dist/types/events.d.ts","./node_modules/react-hook-form/dist/types/path/common.d.ts","./node_modules/react-hook-form/dist/types/path/eager.d.ts","./node_modules/react-hook-form/dist/types/path/index.d.ts","./node_modules/react-hook-form/dist/types/fieldArray.d.ts","./node_modules/react-hook-form/dist/types/resolvers.d.ts","./node_modules/react-hook-form/dist/types/form.d.ts","./node_modules/react-hook-form/dist/types/utils.d.ts","./node_modules/react-hook-form/dist/types/fields.d.ts","./node_modules/react-hook-form/dist/types/errors.d.ts","./node_modules/react-hook-form/dist/types/validator.d.ts","./node_modules/react-hook-form/dist/types/controller.d.ts","./node_modules/react-hook-form/dist/types/index.d.ts","./node_modules/react-hook-form/dist/controller.d.ts","./node_modules/react-hook-form/dist/form.d.ts","./node_modules/react-hook-form/dist/logic/appendErrors.d.ts","./node_modules/react-hook-form/dist/logic/createFormControl.d.ts","./node_modules/react-hook-form/dist/logic/index.d.ts","./node_modules/react-hook-form/dist/useController.d.ts","./node_modules/react-hook-form/dist/useFieldArray.d.ts","./node_modules/react-hook-form/dist/useForm.d.ts","./node_modules/react-hook-form/dist/useFormContext.d.ts","./node_modules/react-hook-form/dist/useFormState.d.ts","./node_modules/react-hook-form/dist/useWatch.d.ts","./node_modules/react-hook-form/dist/utils/get.d.ts","./node_modules/react-hook-form/dist/utils/set.d.ts","./node_modules/react-hook-form/dist/utils/index.d.ts","./node_modules/react-hook-form/dist/index.d.ts","./node_modules/zod/v3/helpers/typeAliases.d.cts","./node_modules/zod/v3/helpers/util.d.cts","./node_modules/zod/v3/ZodError.d.cts","./node_modules/zod/v3/locales/en.d.cts","./node_modules/zod/v3/errors.d.cts","./node_modules/zod/v3/helpers/parseUtil.d.cts","./node_modules/zod/v3/helpers/enumUtil.d.cts","./node_modules/zod/v3/helpers/errorUtil.d.cts","./node_modules/zod/v3/helpers/partialUtil.d.cts","./node_modules/zod/v3/standard-schema.d.cts","./node_modules/zod/v3/types.d.cts","./node_modules/zod/v3/external.d.cts","./node_modules/zod/v3/index.d.cts","./node_modules/zod/v4/core/standard-schema.d.cts","./node_modules/zod/v4/core/util.d.cts","./node_modules/zod/v4/core/versions.d.cts","./node_modules/zod/v4/core/schemas.d.cts","./node_modules/zod/v4/core/checks.d.cts","./node_modules/zod/v4/core/errors.d.cts","./node_modules/zod/v4/core/core.d.cts","./node_modules/zod/v4/core/parse.d.cts","./node_modules/zod/v4/core/regexes.d.cts","./node_modules/zod/v4/locales/ar.d.cts","./node_modules/zod/v4/locales/az.d.cts","./node_modules/zod/v4/locales/be.d.cts","./node_modules/zod/v4/locales/ca.d.cts","./node_modules/zod/v4/locales/cs.d.cts","./node_modules/zod/v4/locales/de.d.cts","./node_modules/zod/v4/locales/en.d.cts","./node_modules/zod/v4/locales/eo.d.cts","./node_modules/zod/v4/locales/es.d.cts","./node_modules/zod/v4/locales/fa.d.cts","./node_modules/zod/v4/locales/fi.d.cts","./node_modules/zod/v4/locales/fr.d.cts","./node_modules/zod/v4/locales/fr-CA.d.cts","./node_modules/zod/v4/locales/he.d.cts","./node_modules/zod/v4/locales/hu.d.cts","./node_modules/zod/v4/locales/id.d.cts","./node_modules/zod/v4/locales/it.d.cts","./node_modules/zod/v4/locales/ja.d.cts","./node_modules/zod/v4/locales/kh.d.cts","./node_modules/zod/v4/locales/ko.d.cts","./node_modules/zod/v4/locales/mk.d.cts","./node_modules/zod/v4/locales/ms.d.cts","./node_modules/zod/v4/locales/nl.d.cts","./node_modules/zod/v4/locales/no.d.cts","./node_modules/zod/v4/locales/ota.d.cts","./node_modules/zod/v4/locales/ps.d.cts","./node_modules/zod/v4/locales/pl.d.cts","./node_modules/zod/v4/locales/pt.d.cts","./node_modules/zod/v4/locales/ru.d.cts","./node_modules/zod/v4/locales/sl.d.cts","./node_modules/zod/v4/locales/sv.d.cts","./node_modules/zod/v4/locales/ta.d.cts","./node_modules/zod/v4/locales/th.d.cts","./node_modules/zod/v4/locales/tr.d.cts","./node_modules/zod/v4/locales/ua.d.cts","./node_modules/zod/v4/locales/ur.d.cts","./node_modules/zod/v4/locales/vi.d.cts","./node_modules/zod/v4/locales/zh-CN.d.cts","./node_modules/zod/v4/locales/zh-TW.d.cts","./node_modules/zod/v4/locales/index.d.cts","./node_modules/zod/v4/core/registries.d.cts","./node_modules/zod/v4/core/doc.d.cts","./node_modules/zod/v4/core/function.d.cts","./node_modules/zod/v4/core/api.d.cts","./node_modules/zod/v4/core/json-schema.d.cts","./node_modules/zod/v4/core/to-json-schema.d.cts","./node_modules/zod/v4/core/index.d.cts","./node_modules/@hookform/resolvers/zod/dist/zod.d.ts","./node_modules/@hookform/resolvers/zod/dist/index.d.ts","./node_modules/@radix-ui/react-label/dist/index.d.ts","./src/renderer/src/components/ui/Label.tsx","./src/renderer/src/components/ui/Form.tsx","./node_modules/zod/v4/classic/errors.d.cts","./node_modules/zod/v4/classic/parse.d.cts","./node_modules/zod/v4/classic/schemas.d.cts","./node_modules/zod/v4/classic/checks.d.cts","./node_modules/zod/v4/classic/compat.d.cts","./node_modules/zod/v4/classic/iso.d.cts","./node_modules/zod/v4/classic/coerce.d.cts","./node_modules/zod/v4/classic/external.d.cts","./node_modules/zod/index.d.cts","./src/renderer/src/components/FileExplorer/schemas.ts","./src/renderer/src/components/FileExplorer/utils.ts","./src/renderer/src/components/FileExplorer/CreateProjectDialog.tsx","./node_modules/@radix-ui/react-alert-dialog/dist/index.d.ts","./src/renderer/src/components/ui/AlertDialog.tsx","./node_modules/@radix-ui/react-menu/dist/index.d.ts","./node_modules/@radix-ui/react-dropdown-menu/dist/index.d.ts","./src/renderer/src/components/ui/DropdownMenu.tsx","./src/renderer/src/components/FileExplorer/FileTreeItem.tsx","./src/renderer/src/components/FileExplorer/FileExplorerContent.tsx","./src/renderer/src/hooks/useGitHubAccount.ts","./src/renderer/src/components/FileExplorer/SourceControl.tsx","./src/renderer/src/components/FileExplorer/FileExplorer.tsx","./src/renderer/src/components/FileExplorer/index.ts","./src/renderer/src/components/GitHubAccountButton.tsx","./src/renderer/src/components/Header.tsx","./src/renderer/src/lib/serialBus.ts","./src/renderer/src/contexts/SerialContext.tsx","./node_modules/@radix-ui/react-select/dist/index.d.ts","./src/renderer/src/components/ui/Select.tsx","./src/renderer/src/components/SerialMonitor.tsx","./package.json","./src/renderer/src/components/ui/Badge.tsx","./src/renderer/src/components/ui/StatusPill.tsx","./src/renderer/src/components/StatusBar.tsx","./src/renderer/src/components/arduino/ArduinoButtons.tsx","./src/renderer/src/components/arduino/BoardManager.tsx","./src/renderer/src/components/arduino/BoardControls.tsx","./src/renderer/src/components/arduino/LibraryManager.tsx","./src/renderer/src/components/ViewSegment.tsx","./src/renderer/src/components/Toolbar.tsx","./node_modules/react-resizable-panels/dist/declarations/src/Panel.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/types.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/PanelGroup.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/PanelResizeHandleRegistry.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/PanelResizeHandle.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/constants.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/hooks/usePanelGroupContext.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/assert.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/csp.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/cursor.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/dom/getPanelElement.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/dom/getPanelElementsForGroup.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/dom/getPanelGroupElement.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/dom/getResizeHandleElement.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/dom/getResizeHandleElementIndex.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/dom/getResizeHandleElementsForGroup.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/dom/getResizeHandlePanelIds.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/rects/types.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/rects/getIntersectingRectangle.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/utils/rects/intersects.d.ts","./node_modules/react-resizable-panels/dist/declarations/src/index.d.ts","./node_modules/react-resizable-panels/dist/react-resizable-panels.d.ts","./src/renderer/src/components/ui/Resizable.tsx","./src/renderer/src/App.tsx","./node_modules/@types/react-dom/client.d.ts","./src/renderer/src/main.tsx","./src/renderer/src/circuit/__tests__/breadboard.test.ts","./src/renderer/src/circuit/__tests__/clipboard.test.ts","./src/renderer/src/circuit/__tests__/erc.test.ts","./src/renderer/src/circuit/__tests__/exportSch.test.ts","./src/renderer/src/circuit/__tests__/fzpz.test.ts","./src/renderer/src/circuit/__tests__/m1.test.ts","./src/renderer/src/circuit/__tests__/model.test.ts","./src/renderer/src/circuit/__tests__/netLabels.test.ts","./src/renderer/src/circuit/__tests__/netlist.test.ts","./src/renderer/src/circuit/__tests__/nets.test.ts","./src/renderer/src/circuit/__tests__/packs.test.ts","./src/renderer/src/circuit/__tests__/probes.test.ts","./src/renderer/src/circuit/__tests__/resistorBands.test.ts","./src/renderer/src/circuit/__tests__/routing.test.ts","./src/renderer/src/circuit/__tests__/sim.test.ts","./src/renderer/src/circuit/__tests__/store.test.ts","./src/renderer/src/circuit/__tests__/svg.test.ts","./src/renderer/src/circuit/__tests__/symbols.test.ts","./node_modules/eecircuit-engine/dist/main.d.ts","./src/renderer/src/circuit/sim/simWorker.ts","./src/renderer/src/commands/index.ts","./node_modules/@radix-ui/react-avatar/dist/index.d.ts","./src/renderer/src/components/ui/Avatar.tsx","./src/renderer/src/components/UserMenu.tsx","./src/renderer/src/components/WelcomeDialog.tsx","./src/renderer/src/components/arduino/BoardSelect.tsx","./src/renderer/src/components/arduino/index.ts","./node_modules/@radix-ui/react-collapsible/dist/index.d.ts","./node_modules/@radix-ui/react-accordion/dist/index.d.ts","./src/renderer/src/components/ui/Accordion.tsx","./src/renderer/src/components/ui/Checkbox.tsx","./src/renderer/src/components/ui/Radio.tsx","./node_modules/@radix-ui/react-separator/dist/index.d.ts","./src/renderer/src/components/ui/Separator.tsx","./node_modules/@radix-ui/react-switch/dist/index.d.ts","./src/renderer/src/components/ui/Switch.tsx","./src/renderer/src/components/ui/Tag.tsx","./src/renderer/src/components/ui/ThemeToggle.tsx","./src/renderer/src/lib/arduinoFileUtils.ts","./src/renderer/src/lib/wireRouting.ts","./src/renderer/src/lib/circuitNets.ts","./node_modules/@types/node/compatibility/disposable.d.ts","./node_modules/@types/node/compatibility/indexable.d.ts","./node_modules/@types/node/compatibility/iterators.d.ts","./node_modules/@types/node/compatibility/index.d.ts","./node_modules/@types/node/globals.typedarray.d.ts","./node_modules/@types/node/buffer.buffer.d.ts","./node_modules/undici-types/header.d.ts","./node_modules/undici-types/readable.d.ts","./node_modules/undici-types/file.d.ts","./node_modules/undici-types/fetch.d.ts","./node_modules/undici-types/formdata.d.ts","./node_modules/undici-types/connector.d.ts","./node_modules/undici-types/client.d.ts","./node_modules/undici-types/errors.d.ts","./node_modules/undici-types/dispatcher.d.ts","./node_modules/undici-types/global-dispatcher.d.ts","./node_modules/undici-types/global-origin.d.ts","./node_modules/undici-types/pool-stats.d.ts","./node_modules/undici-types/pool.d.ts","./node_modules/undici-types/handlers.d.ts","./node_modules/undici-types/balanced-pool.d.ts","./node_modules/undici-types/agent.d.ts","./node_modules/undici-types/mock-interceptor.d.ts","./node_modules/undici-types/mock-agent.d.ts","./node_modules/undici-types/mock-client.d.ts","./node_modules/undici-types/mock-pool.d.ts","./node_modules/undici-types/mock-errors.d.ts","./node_modules/undici-types/proxy-agent.d.ts","./node_modules/undici-types/env-http-proxy-agent.d.ts","./node_modules/undici-types/retry-handler.d.ts","./node_modules/undici-types/retry-agent.d.ts","./node_modules/undici-types/api.d.ts","./node_modules/undici-types/interceptors.d.ts","./node_modules/undici-types/util.d.ts","./node_modules/undici-types/cookies.d.ts","./node_modules/undici-types/patch.d.ts","./node_modules/undici-types/websocket.d.ts","./node_modules/undici-types/eventsource.d.ts","./node_modules/undici-types/filereader.d.ts","./node_modules/undici-types/diagnostics-channel.d.ts","./node_modules/undici-types/content-type.d.ts","./node_modules/undici-types/cache.d.ts","./node_modules/undici-types/index.d.ts","./node_modules/@types/node/globals.d.ts","./node_modules/@types/node/assert.d.ts","./node_modules/@types/node/assert/strict.d.ts","./node_modules/@types/node/async_hooks.d.ts","./node_modules/@types/node/buffer.d.ts","./node_modules/@types/node/child_process.d.ts","./node_modules/@types/node/cluster.d.ts","./node_modules/@types/node/console.d.ts","./node_modules/@types/node/constants.d.ts","./node_modules/@types/node/crypto.d.ts","./node_modules/@types/node/dgram.d.ts","./node_modules/@types/node/diagnostics_channel.d.ts","./node_modules/@types/node/dns.d.ts","./node_modules/@types/node/dns/promises.d.ts","./node_modules/@types/node/domain.d.ts","./node_modules/@types/node/dom-events.d.ts","./node_modules/@types/node/events.d.ts","./node_modules/@types/node/fs.d.ts","./node_modules/@types/node/fs/promises.d.ts","./node_modules/@types/node/http.d.ts","./node_modules/@types/node/http2.d.ts","./node_modules/@types/node/https.d.ts","./node_modules/@types/node/inspector.d.ts","./node_modules/@types/node/module.d.ts","./node_modules/@types/node/net.d.ts","./node_modules/@types/node/os.d.ts","./node_modules/@types/node/path.d.ts","./node_modules/@types/node/perf_hooks.d.ts","./node_modules/@types/node/process.d.ts","./node_modules/@types/node/punycode.d.ts","./node_modules/@types/node/querystring.d.ts","./node_modules/@types/node/readline.d.ts","./node_modules/@types/node/readline/promises.d.ts","./node_modules/@types/node/repl.d.ts","./node_modules/@types/node/sea.d.ts","./node_modules/@types/node/sqlite.d.ts","./node_modules/@types/node/stream.d.ts","./node_modules/@types/node/stream/promises.d.ts","./node_modules/@types/node/stream/consumers.d.ts","./node_modules/@types/node/stream/web.d.ts","./node_modules/@types/node/string_decoder.d.ts","./node_modules/@types/node/test.d.ts","./node_modules/@types/node/timers.d.ts","./node_modules/@types/node/timers/promises.d.ts","./node_modules/@types/node/tls.d.ts","./node_modules/@types/node/trace_events.d.ts","./node_modules/@types/node/tty.d.ts","./node_modules/@types/node/url.d.ts","./node_modules/@types/node/util.d.ts","./node_modules/@types/node/v8.d.ts","./node_modules/@types/node/vm.d.ts","./node_modules/@types/node/wasi.d.ts","./node_modules/@types/node/worker_threads.d.ts","./node_modules/@types/node/zlib.d.ts","./node_modules/@types/node/index.d.ts","./node_modules/electron/electron.d.ts","./node_modules/@electron-toolkit/preload/dist/index.d.ts","./src/preload/index.d.ts","./node_modules/@babel/types/lib/index.d.ts","./node_modules/@types/babel__generator/index.d.ts","./node_modules/@babel/parser/typings/babel-parser.d.ts","./node_modules/@types/babel__template/index.d.ts","./node_modules/@types/babel__traverse/index.d.ts","./node_modules/@types/babel__core/index.d.ts","./node_modules/keyv/src/index.d.ts","./node_modules/@types/http-cache-semantics/index.d.ts","./node_modules/@types/responselike/index.d.ts","./node_modules/@types/cacheable-request/index.d.ts","./node_modules/@types/ms/index.d.ts","./node_modules/@types/debug/index.d.ts","./node_modules/@types/estree/index.d.ts","./node_modules/@types/estree-jsx/index.d.ts","./node_modules/@types/fs-extra/index.d.ts","./node_modules/@types/json-schema/index.d.ts","./node_modules/@types/keyv/index.d.ts","./node_modules/@types/react-dom/index.d.ts","./node_modules/@types/trusted-types/index.d.ts","./node_modules/@types/use-sync-external-store/index.d.ts"],"fileIdsList":[[1046,1088,1142],[1046,1088],[1046,1088,1139],[929,1046,1088],[859,872,928,1046,1088],[143,1046,1088],[142,146,1046,1088],[142,1046,1088],[150,1046,1088],[159,1046,1088],[161,162,1046,1088],[166,1046,1088],[163,1046,1088],[161,163,164,1046,1088],[162,165,1046,1088],[178,1046,1088],[142,181,1046,1088],[144,145,147,148,149,150,151,152,153,154,155,156,157,158,160,161,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,1046,1088],[195,1046,1088],[142,195,1046,1088],[142,150,1046,1088],[150,178,181,1046,1088],[142,184,1046,1088],[108,1046,1088],[108,112,1046,1088],[108,109,110,111,112,113,1046,1088],[463,1046,1088],[90,463,464,1046,1088],[90,444,445,1027,1046,1088],[90,444,449,1046,1088],[90,445,1046,1088],[90,444,445,1046,1088],[90,1046,1088],[90,444,445,446,447,448,1046,1088],[90,444,445,948,1046,1088],[90,444,445,446,447,448,459,827,1046,1088],[90,444,445,825,826,1046,1088],[90,444,445,446,447,448,827,1046,1088],[90,444,445,459,1046,1088],[90,444,445,446,448,827,1046,1088],[93,94,95,96,97,1046,1088],[91,1046,1088],[1046,1088,1142,1143,1144,1145,1146],[1046,1088,1142,1144],[1046,1088,1100,1103,1131,1138,1148,1149,1150],[209,237,1046,1088],[208,214,1046,1088],[219,1046,1088],[214,1046,1088],[213,1046,1088],[231,1046,1088],[227,1046,1088],[209,226,237,1046,1088],[208,209,210,211,212,213,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,1046,1088],[1046,1088,1152],[1046,1088,1154,1155],[1046,1088,1101,1138],[356,1046,1088],[1046,1088,1100,1138],[1046,1085,1088],[1046,1087,1088],[1088],[1046,1088,1093,1123],[1046,1088,1089,1094,1100,1101,1108,1120,1131],[1046,1088,1089,1090,1100,1108],[1041,1042,1043,1046,1088],[1046,1088,1091,1132],[1046,1088,1092,1093,1101,1109],[1046,1088,1093,1120,1128],[1046,1088,1094,1096,1100,1108],[1046,1087,1088,1095],[1046,1088,1096,1097],[1046,1088,1098,1100],[1046,1087,1088,1100],[1046,1088,1100,1101,1102,1120,1131],[1046,1088,1100,1101,1102,1115,1120,1123],[1046,1083,1088],[1046,1083,1088,1096,1100,1103,1108,1120,1131],[1046,1088,1100,1101,1103,1104,1108,1120,1128,1131],[1046,1088,1103,1105,1120,1128,1131],[1044,1045,1046,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137],[1046,1088,1100,1106],[1046,1088,1107,1131],[1046,1088,1096,1100,1108,1120],[1046,1088,1109],[1046,1088,1110],[1046,1087,1088,1111],[1046,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137],[1046,1088,1113],[1046,1088,1114],[1046,1088,1100,1115,1116],[1046,1088,1115,1117,1132,1134],[1046,1088,1100,1120,1121,1123],[1046,1088,1122,1123],[1046,1088,1120,1121],[1046,1088,1123],[1046,1088,1124],[1046,1085,1088,1120],[1046,1088,1100,1126,1127],[1046,1088,1126,1127],[1046,1088,1093,1108,1120,1128],[1046,1088,1129],[1046,1088,1108,1130],[1046,1088,1103,1114,1131],[1046,1088,1093,1132],[1046,1088,1120,1133],[1046,1088,1107,1134],[1046,1088,1135],[1046,1088,1100,1102,1111,1120,1123,1131,1134,1136],[1046,1088,1120,1137],[88,89,1046,1088],[1046,1088,1103,1120,1138],[205,1046,1088],[472,473,479,535,539,541,542,594,596,599,601,608,610,615,616,618,1046,1088],[613,1046,1088],[478,488,500,501,585,613,623,1046,1088],[468,469,471,472,483,484,487,500,512,539,541,542,545,555,574,585,589,591,596,599,601,610,611,612,617,1046,1088],[468,469,470,471,474,478,481,482,484,485,486,487,488,492,493,494,495,496,497,498,499,501,503,504,505,506,507,508,511,512,513,514,515,516,517,534,535,542,543,544,545,546,547,548,549,550,551,552,553,554,555,576,577,578,579,580,582,583,584,585,586,589,591,592,593,594,595,596,599,600,601,602,603,608,609,610,613,617,618,619,621,622,623,624,625,630,631,632,634,635,636,637,638,639,640,641,642,647,648,666,667,669,670,671,672,673,675,676,677,678,679,680,681,682,683,684,685,686,689,690,695,696,697,698,699,700,701,702,703,704,705,706,707,708,712,713,714,723,733,736,746,752,753,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,1046,1088],[500,545,585,1046,1088],[626,627,628,629,1046,1088],[468,470,472,479,483,513,585,1046,1088],[472,473,483,546,547,585,626,1046,1088],[472,483,585,626,1046,1088],[472,479,483,585,626,1046,1088],[473,487,504,585,1046,1088],[488,501,623,1046,1088],[471,472,585,612,633,1046,1088],[471,472,491,585,586,613,1046,1088],[471,586,1046,1088],[471,472,585,586,587,590,1046,1088],[480,510,590,1046,1088],[472,479,507,585,1046,1088],[468,469,470,471,472,479,480,483,484,487,507,512,585,588,589,1046,1088],[472,479,610,1046,1088],[470,585,601,610,617,625,1046,1088],[481,482,485,486,505,1046,1088],[491,599,600,617,1046,1088],[555,600,601,1046,1088],[472,555,600,1046,1088],[472,491,585,591,613,617,1046,1088],[469,472,585,590,613,1046,1088],[484,486,579,1046,1088],[585,641,1046,1088],[483,484,485,1046,1088],[643,644,645,646,1046,1088],[484,534,613,1046,1088],[484,534,774,1046,1088],[484,511,534,1046,1088],[472,484,485,514,585,589,1046,1088],[594,613,1046,1088],[473,474,475,476,477,509,581,611,614,615,616,618,619,620,621,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,1046,1088],[610,1046,1088],[473,610,617,1046,1088],[475,610,613,614,617,1046,1088],[475,491,610,614,617,1046,1088],[473,474,475,610,617,1046,1088],[475,610,614,617,1046,1088],[472,475,610,614,617,1046,1088],[473,474,475,610,613,1046,1088],[473,480,610,653,654,1046,1088],[475,480,610,655,1046,1088],[475,480,587,610,655,1046,1088],[473,474,475,480,610,1046,1088],[472,475,480,610,655,1046,1088],[475,479,480,610,655,1046,1088],[473,474,475,610,1046,1088],[473,1046,1088],[473,608,610,1046,1088],[475,608,610,620,1046,1088],[473,610,617,618,651,653,659,660,1046,1088],[473,475,610,1046,1088],[617,1046,1088],[468,469,472,479,483,495,516,535,556,592,593,599,615,617,1046,1088],[594,615,1046,1088],[594,669,670,1046,1088],[594,1046,1088],[479,585,594,615,1046,1088],[595,1046,1088],[594,674,1046,1088],[594,615,674,1046,1088],[594,608,615,617,669,670,671,1046,1088],[468,469,472,482,488,489,491,500,501,547,580,585,613,623,1046,1088],[468,469,472,483,487,500,507,585,1046,1088],[472,483,488,547,679,1046,1088],[469,487,1046,1088],[501,504,585,1046,1088],[501,554,1046,1088],[468,469,483,487,1046,1088],[468,469,1046,1088],[610,617,685,1046,1088],[472,501,509,511,513,514,542,543,585,594,613,1046,1088],[472,547,1046,1088],[536,537,539,540,541,687,688,1046,1088],[479,513,515,516,534,536,538,541,617,1046,1088],[542,1046,1088],[468,472,479,535,541,542,617,1046,1088],[538,539,540,542,1046,1088],[472,473,479,513,515,536,541,585,613,1046,1088],[541,542,617,1046,1088],[472,513,515,534,536,541,613,1046,1088],[546,585,1046,1088],[597,598,599,691,692,693,694,1046,1088],[598,599,617,1046,1088],[594,595,596,597,598,601,613,617,1046,1088],[598,599,601,617,1046,1088],[555,613,699,1046,1088],[481,1046,1088],[483,1046,1088],[469,472,484,512,1046,1088],[492,493,1046,1088],[472,479,515,516,537,542,1046,1088],[555,601,1046,1088],[555,613,1046,1088],[470,1046,1088],[484,485,1046,1088],[481,483,484,1046,1088],[472,1046,1088],[468,472,488,489,495,500,585,613,1046,1088],[488,501,1046,1088],[468,1046,1088],[469,1046,1088],[513,1046,1088],[469,472,479,541,1046,1088],[592,1046,1088],[479,502,504,1046,1088],[605,606,1046,1088],[471,472,585,1046,1088],[481,483,504,1046,1088],[606,617,1046,1088],[606,1046,1088],[604,605,1046,1088],[469,610,1046,1088],[492,500,1046,1088],[468,492,495,500,501,585,1046,1088],[604,608,1046,1088],[608,1046,1088],[469,536,553,555,594,613,1046,1088],[469,553,555,613,1046,1088],[469,553,594,1046,1088],[469,508,553,1046,1088],[469,501,553,1046,1088],[469,553,682,1046,1088],[469,549,585,613,1046,1088],[469,613,1046,1088],[469,553,585,1046,1088],[469,472,507,585,1046,1088],[549,550,585,1046,1088],[472,479,518,668,669,1046,1088],[518,1046,1088],[479,496,500,501,502,503,585,1046,1088],[608,609,610,1046,1088],[469,553,1046,1088],[606,607,1046,1088],[500,502,545,546,585,1046,1088],[479,483,504,585,1046,1088],[473,500,585,594,604,606,607,610,615,617,709,710,711,1046,1088],[471,473,490,496,497,501,503,514,542,545,547,550,575,586,594,599,600,608,609,623,699,1046,1088],[585,613,1046,1088],[468,469,472,512,601,613,617,1046,1088],[545,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,715,716,717,718,719,720,721,722,1046,1088],[545,555,1046,1088],[534,556,558,559,560,562,564,572,613,1046,1088],[472,545,555,556,613,1046,1088],[555,556,557,558,564,566,567,568,569,571,575,599,613,1046,1088],[472,545,555,556,574,601,613,1046,1088],[495,545,556,572,573,574,601,613,1046,1088],[556,1046,1088],[564,573,613,724,728,729,730,1046,1088],[724,725,726,727,728,729,730,731,732,1046,1088],[556,564,566,571,725,728,729,1046,1088],[557,564,572,599,613,724,727,1046,1088],[556,562,599,724,1046,1088],[556,599,720,724,1046,1088],[545,613,722,724,1046,1088],[545,572,575,613,724,725,726,728,731,1046,1088],[556,564,565,613,1046,1088],[555,556,557,1046,1088],[556,561,599,1046,1088],[556,557,594,599,1046,1088],[556,557,1046,1088],[542,556,557,1046,1088],[556,558,599,613,1046,1088],[556,564,1046,1088],[555,556,558,1046,1088],[556,557,561,563,1046,1088],[556,563,564,1046,1088],[556,564,570,613,1046,1088],[557,559,560,561,562,563,564,565,566,567,569,570,571,715,716,717,718,719,720,1046,1088],[557,564,572,613,734,1046,1088],[575,613,735,1046,1088],[734,735,1046,1088],[545,555,556,1046,1088],[558,562,564,573,613,743,1046,1088],[557,564,572,599,613,737,738,739,740,742,1046,1088],[556,566,613,1046,1088],[556,599,720,1046,1088],[556,571,613,1046,1088],[545,601,613,722,737,1046,1088],[545,572,575,613,737,741,743,744,1046,1088],[737,738,739,740,741,742,743,744,745,1046,1088],[472,478,502,585,1046,1088],[502,576,585,1046,1088],[490,491,587,605,747,748,749,750,751,1046,1088],[490,601,610,617,1046,1088],[491,617,1046,1088],[490,604,606,610,1046,1088],[490,1046,1088],[490,608,610,1046,1088],[480,490,610,1046,1088],[524,585,591,1046,1088],[545,1046,1088],[754,755,1046,1088],[545,585,610,1046,1088],[585,1046,1088],[493,494,496,497,500,1046,1088],[492,494,496,498,500,1046,1088],[496,497,500,1046,1088],[468,469,478,482,483,484,492,493,496,500,501,580,585,592,593,661,703,1046,1088],[468,492,494,496,500,585,1046,1088],[544,1046,1088],[482,483,484,501,504,505,580,581,585,1046,1088],[472,478,479,483,489,500,502,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,1046,1088],[489,1046,1088],[472,479,483,1046,1088],[472,483,585,1046,1088],[491,498,499,1046,1088],[608,609,610,617,662,663,1046,1088],[608,610,621,1046,1088],[500,585,608,610,617,1046,1088],[500,508,585,610,1046,1088],[479,483,585,1046,1088],[473,480,500,547,600,602,603,607,608,609,617,1046,1088],[472,585,1046,1088],[468,469,472,476,477,478,479,480,483,485,487,489,496,500,501,502,503,506,508,512,544,545,547,548,549,550,551,552,554,575,577,578,582,583,584,591,610,613,617,618,1046,1088],[480,585,608,610,617,1046,1088],[483,504,505,509,585,1046,1088],[467,774,1046,1088],[105,139,1046,1088],[105,1046,1088],[342,343,344,345,346,1046,1088],[340,1046,1088],[341,347,348,1046,1088],[1046,1088,1100,1101,1138],[1046,1088,1100],[400,403,406,408,409,410,1046,1088],[367,395,400,403,406,408,410,1046,1088],[367,395,400,403,406,410,1046,1088],[433,434,438,1046,1088],[410,433,435,438,1046,1088],[410,433,435,437,1046,1088],[367,395,410,433,435,436,438,1046,1088],[435,438,439,1046,1088],[410,433,435,438,440,1046,1088],[357,367,368,369,393,394,395,1046,1088],[357,368,395,1046,1088],[357,367,368,395,1046,1088],[370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,1046,1088],[357,361,367,369,395,1046,1088],[411,412,432,1046,1088],[367,395,433,435,438,1046,1088],[367,395,1046,1088],[413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,1046,1088],[356,367,395,1046,1088],[266,269,1046,1088],[206,1046,1088],[207,269,1046,1088],[207,239,264,267,268,1046,1088],[207,209,237,265,266,273,350,351,1046,1088],[204,207,265,266,267,269,270,271,273,352,353,354,1046,1088],[207,265,267,269,1046,1088],[142,203,1046,1088],[269,273,352,1046,1088],[273,1046,1088],[209,237,265,273,339,349,355,1046,1088],[265,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,1046,1088],[209,237,265,273,1046,1088],[207,265,272,339,1046,1088],[207,1046,1088],[207,209,237,239,265,1046,1088],[400,401,402,406,410,1046,1088],[400,403,406,410,1046,1088],[400,403,404,405,410,1046,1088],[90,844,1046,1088],[844,845,846,849,850,851,852,853,854,855,858,1046,1088],[844,1046,1088],[847,848,1046,1088],[90,842,844,1046,1088],[839,840,842,1046,1088],[835,838,840,842,1046,1088],[839,842,1046,1088],[90,830,831,832,835,836,837,839,840,841,842,1046,1088],[832,835,836,837,838,839,840,841,842,843,1046,1088],[839,1046,1088],[833,839,840,1046,1088],[833,834,1046,1088],[838,840,841,1046,1088],[838,1046,1088],[830,835,840,841,1046,1088],[856,857,1046,1088],[398,1046,1088],[90,357,366,395,397,1046,1088],[90,93,1046,1088],[90,975,1046,1088],[90,977,1046,1088],[975,1046,1088],[974,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,992,993,1046,1088],[974,1046,1088],[991,1046,1088],[994,1046,1088],[93,1046,1088],[407,440,441,1046,1088],[442,1046,1088],[395,396,1046,1088],[357,361,366,367,395,1046,1088],[363,1046,1088],[240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,1046,1088],[255,1046,1088],[241,257,1046,1088],[257,1046,1088],[240,1046,1088],[241,1046,1088],[264,1046,1088],[1046,1055,1059,1088,1131],[1046,1055,1088,1120,1131],[1046,1050,1088],[1046,1052,1055,1088,1128,1131],[1046,1088,1108,1128],[1046,1088,1138],[1046,1050,1088,1138],[1046,1052,1055,1088,1108,1131],[1046,1047,1048,1051,1054,1088,1100,1120,1131],[1046,1055,1062,1088],[1046,1047,1053,1088],[1046,1055,1076,1077,1088],[1046,1051,1055,1088,1123,1131,1138],[1046,1076,1088,1138],[1046,1049,1050,1088,1138],[1046,1055,1088],[1046,1049,1050,1051,1052,1053,1054,1055,1056,1057,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1077,1078,1079,1080,1081,1082,1088],[1046,1055,1070,1088],[1046,1055,1062,1063,1088],[1046,1053,1055,1063,1064,1088],[1046,1054,1088],[1046,1047,1050,1055,1088],[1046,1055,1059,1063,1064,1088],[1046,1059,1088],[1046,1053,1055,1058,1088,1131],[1046,1047,1052,1055,1062,1088],[1046,1088,1120],[1046,1050,1055,1076,1088,1136,1138],[361,365,1046,1088],[356,361,362,364,366,1046,1088],[358,1046,1088],[359,360,1046,1088],[356,359,361,1046,1088],[85,1046,1088],[81,1046,1088],[82,1046,1088],[83,84,1046,1088],[941,1046,1088],[860,861,872,1046,1088],[862,863,1046,1088],[860,861,862,864,865,870,1046,1088],[861,862,1046,1088],[870,1046,1088],[871,1046,1088],[862,1046,1088],[860,861,862,865,866,867,868,869,1046,1088],[928,1046,1088],[928,936,1046,1088],[921,928,934,935,936,937,938,939,940,1046,1088],[928,934,1046,1088],[928,935,1046,1088],[874,876,877,878,879,1046,1088],[874,876,878,879,1046,1088],[874,876,878,1046,1088],[874,876,877,879,1046,1088],[874,876,879,1046,1088],[874,875,876,877,878,879,880,881,921,922,923,924,925,926,927,1046,1088],[876,879,1046,1088],[873,874,875,877,878,879,1046,1088],[876,922,926,1046,1088],[876,877,878,879,1046,1088],[878,1046,1088],[882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,1046,1088],[1046,1088,1140],[90,91,104,123,126,127,128,131,132,137,462,823,824,956,958,960,963,967,973,995,996,1046,1088],[91,779,781,798,1046,1086,1088,1125],[91,779,786,1046,1086,1088,1125],[91,779,780,781,797,1046,1085,1088,1125],[91,779,780,808,1046,1086,1088,1125],[91,792,793,1046,1086,1088,1125,1137],[91,779,782,783,1046,1086,1088,1125],[91,779,1046,1085,1088,1125],[91,779,803,1046,1085,1088,1125],[91,779,781,796,1046,1086,1088,1125],[91,779,781,1046,1085,1088,1125],[91,790,801,1046,1086,1088,1125],[91,779,781,796,811,812,1046,1086,1088,1125],[91,805,1046,1086,1088,1125],[91,780,1046,1085,1088,1125],[91,779,781,796,1046,1086,1088,1110,1125,1131],[91,779,782,783,785,1046,1085,1088,1125],[91,787,1046,1086,1088,1125],[91,779,790,804,1046,1086,1088,1125],[91,779,1046,1088],[91,779,781,1046,1088],[91,779,781,796,811,1046,1088],[91,779,782,1046,1088],[91,779,780,781,782,783,784,785,786,787,1046,1088],[91,779,790,1046,1088],[91,790,792,793,1046,1088],[91,779,784,790,1046,1088],[91,790,791,1046,1088],[86,91,811,1046,1088],[91,811,813,1046,1088],[91,811,1018,1046,1088],[90,91,92,133,779,781,782,783,785,790,791,794,795,796,797,798,799,800,802,803,806,807,808,809,810,817,1046,1088],[90,91,133,779,780,781,782,783,786,798,803,806,1046,1088],[91,779,787,798,803,806,1046,1088],[90,91,133,779,781,782,783,785,790,796,798,806,807,809,1046,1088],[90,91,92,133,801,1046,1088],[90,91,133,779,790,803,804,1046,1088],[91,779,780,781,782,784,790,797,798,803,804,805,1046,1088],[86,90,91,814,815,1046,1088],[90,91,133,779,781,782,783,796,812,814,816,1046,1088],[91,98,100,101,103,118,128,129,130,1046,1088],[90,91,100,126,133,134,137,141,443,450,451,453,1046,1088],[90,91,92,107,123,126,1046,1088],[90,91,775,776,777,1046,1088],[91,101,126,133,454,457,458,461,1046,1088],[90,91,100,101,104,126,128,129,131,133,141,450,451,463,465,466,778,788,818,819,820,821,822,1046,1088],[90,91,133,141,1046,1088],[90,91,104,132,133,141,453,455,456,1046,1088],[90,91,128,133,141,450,451,859,930,933,943,944,1046,1088],[90,91,133,952,954,1046,1088],[90,91,126,131,133,141,453,829,945,951,1046,1088],[90,91,126,131,133,141,451,944,947,950,1046,1088],[90,91,104,126,129,131,133,141,453,953,1046,1088],[91,943,944,945,951,952,955,1046,1088],[91,942,1046,1088],[91,128,1046,1088],[90,91,104,133,141,450,451,950,953,1046,1088],[90,91,107,126,133,141,776,829,957,1046,1088],[90,91,355,399,442,1046,1088],[90,91,126,463,465,776,1046,1088],[90,91,133,790,1046,1088],[91,126,133,443,1046,1088],[90,91,101,126,133,137,141,453,821,960,962,1046,1088],[90,91,126,133,137,960,964,965,966,1046,1088],[90,91,126,128,133,137,821,829,968,969,970,971,972,1046,1088],[91,133,950,1022,1046,1088],[90,91,126,131,133,1046,1088],[90,91,104,107,126,131,132,133,141,450,455,1046,1088],[90,91,104,126,128,133,137,141,829,1046,1088],[90,91,133,137,960,962,1046,1088],[90,91,104,115,133,137,141,450,962,1046,1088],[90,91,115,133,137,141,829,962,1046,1088],[90,91,104,115,133,137,141,450,829,1046,1088],[91,968,969,970,1025,1046,1088],[90,91,107,133,1028,1046,1088],[90,91,107,141,946,1046,1088],[90,91,107,1021,1046,1088],[90,91,107,1046,1088],[90,91,107,138,140,1046,1088],[90,91,107,133,1046,1088],[90,91,107,133,449,1046,1088],[90,91,107,133,949,1046,1088],[90,91,107,133,460,1046,1088],[90,91,107,138,859,931,932,1046,1088],[90,91,107,931,1046,1088],[90,91,107,133,995,1046,1088],[90,91,107,452,1046,1088],[90,91,107,133,961,1046,1088],[90,91,107,1032,1046,1088],[90,91,107,1034,1046,1088],[90,91,107,460,1046,1088],[91,133,141,776,829,1046,1088],[90,91,107,828,1046,1088],[90,91,136,1046,1088],[90,91,137,959,1046,1088],[86,1046,1088],[90,91,92,115,123,135,1046,1088],[90,91,115,123,1046,1088],[90,91,129,1046,1088],[90,91,1046,1088],[91,775,1046,1088],[91,115,1046,1088],[91,1039,1046,1088],[91,128,129,1046,1088],[91,116,117,118,1046,1088],[91,100,128,1046,1088],[91,92,102,103,1046,1088],[91,789,1046,1088],[91,131,1046,1088],[91,790,1046,1088],[91,105,106,1046,1088],[91,116,117,1046,1088],[86,90,91,92,124,126,776,824,997,998,1046,1088],[91,98,1046,1088],[91,98,99,1046,1088],[91,103,124,1046,1088],[91,100,101,102,103,125,1046,1088],[91,98,100,101,102,1046,1088],[91,107,115,120,122,1046,1088],[91,119,1046,1088],[91,114,115,118,1046,1088],[91,115,120,121,123,1046,1088]],"fileInfos":[{"version":"69684132aeb9b5642cbcd9e22dff7818ff0ee1aa831728af0ecf97d3364d5546","affectsGlobalScope":true,"impliedFormat":1},{"version":"45b7ab580deca34ae9729e97c13cfd999df04416a79116c3bfb483804f85ded4","impliedFormat":1},{"version":"3facaf05f0c5fc569c5649dd359892c98a85557e3e0c847964caeb67076f4d75","impliedFormat":1},{"version":"e44bb8bbac7f10ecc786703fe0a6a4b952189f908707980ba8f3c8975a760962","impliedFormat":1},{"version":"5e1c4c362065a6b95ff952c0eab010f04dcd2c3494e813b493ecfd4fcb9fc0d8","impliedFormat":1},{"version":"68d73b4a11549f9c0b7d352d10e91e5dca8faa3322bfb77b661839c42b1ddec7","impliedFormat":1},{"version":"5efce4fc3c29ea84e8928f97adec086e3dc876365e0982cc8479a07954a3efd4","impliedFormat":1},{"version":"feecb1be483ed332fad555aff858affd90a48ab19ba7272ee084704eb7167569","impliedFormat":1},{"version":"ee7bad0c15b58988daa84371e0b89d313b762ab83cb5b31b8a2d1162e8eb41c2","impliedFormat":1},{"version":"27bdc30a0e32783366a5abeda841bc22757c1797de8681bbe81fbc735eeb1c10","impliedFormat":1},{"version":"8fd575e12870e9944c7e1d62e1f5a73fcf23dd8d3a321f2a2c74c20d022283fe","impliedFormat":1},{"version":"8bf8b5e44e3c9c36f98e1007e8b7018c0f38d8adc07aecef42f5200114547c70","impliedFormat":1},{"version":"092c2bfe125ce69dbb1223c85d68d4d2397d7d8411867b5cc03cec902c233763","affectsGlobalScope":true,"impliedFormat":1},{"version":"07f073f19d67f74d732b1adea08e1dc66b1b58d77cb5b43931dee3d798a2fd53","affectsGlobalScope":true,"impliedFormat":1},{"version":"c57796738e7f83dbc4b8e65132f11a377649c00dd3eee333f672b8f0a6bea671","affectsGlobalScope":true,"impliedFormat":1},{"version":"dc2df20b1bcdc8c2d34af4926e2c3ab15ffe1160a63e58b7e09833f616efff44","affectsGlobalScope":true,"impliedFormat":1},{"version":"515d0b7b9bea2e31ea4ec968e9edd2c39d3eebf4a2d5cbd04e88639819ae3b71","affectsGlobalScope":true,"impliedFormat":1},{"version":"0559b1f683ac7505ae451f9a96ce4c3c92bdc71411651ca6ddb0e88baaaad6a3","affectsGlobalScope":true,"impliedFormat":1},{"version":"0dc1e7ceda9b8b9b455c3a2d67b0412feab00bd2f66656cd8850e8831b08b537","affectsGlobalScope":true,"impliedFormat":1},{"version":"ce691fb9e5c64efb9547083e4a34091bcbe5bdb41027e310ebba8f7d96a98671","affectsGlobalScope":true,"impliedFormat":1},{"version":"8d697a2a929a5fcb38b7a65594020fcef05ec1630804a33748829c5ff53640d0","affectsGlobalScope":true,"impliedFormat":1},{"version":"4ff2a353abf8a80ee399af572debb8faab2d33ad38c4b4474cff7f26e7653b8d","affectsGlobalScope":true,"impliedFormat":1},{"version":"936e80ad36a2ee83fc3caf008e7c4c5afe45b3cf3d5c24408f039c1d47bdc1df","affectsGlobalScope":true,"impliedFormat":1},{"version":"d15bea3d62cbbdb9797079416b8ac375ae99162a7fba5de2c6c505446486ac0a","affectsGlobalScope":true,"impliedFormat":1},{"version":"68d18b664c9d32a7336a70235958b8997ebc1c3b8505f4f1ae2b7e7753b87618","affectsGlobalScope":true,"impliedFormat":1},{"version":"eb3d66c8327153d8fa7dd03f9c58d351107fe824c79e9b56b462935176cdf12a","affectsGlobalScope":true,"impliedFormat":1},{"version":"38f0219c9e23c915ef9790ab1d680440d95419ad264816fa15009a8851e79119","affectsGlobalScope":true,"impliedFormat":1},{"version":"69ab18c3b76cd9b1be3d188eaf8bba06112ebbe2f47f6c322b5105a6fbc45a2e","affectsGlobalScope":true,"impliedFormat":1},{"version":"fef8cfad2e2dc5f5b3d97a6f4f2e92848eb1b88e897bb7318cef0e2820bceaab","affectsGlobalScope":true,"impliedFormat":1},{"version":"2f11ff796926e0832f9ae148008138ad583bd181899ab7dd768a2666700b1893","affectsGlobalScope":true,"impliedFormat":1},{"version":"4de680d5bb41c17f7f68e0419412ca23c98d5749dcaaea1896172f06435891fc","affectsGlobalScope":true,"impliedFormat":1},{"version":"954296b30da6d508a104a3a0b5d96b76495c709785c1d11610908e63481ee667","affectsGlobalScope":true,"impliedFormat":1},{"version":"ac9538681b19688c8eae65811b329d3744af679e0bdfa5d842d0e32524c73e1c","affectsGlobalScope":true,"impliedFormat":1},{"version":"0a969edff4bd52585473d24995c5ef223f6652d6ef46193309b3921d65dd4376","affectsGlobalScope":true,"impliedFormat":1},{"version":"9e9fbd7030c440b33d021da145d3232984c8bb7916f277e8ffd3dc2e3eae2bdb","affectsGlobalScope":true,"impliedFormat":1},{"version":"811ec78f7fefcabbda4bfa93b3eb67d9ae166ef95f9bff989d964061cbf81a0c","affectsGlobalScope":true,"impliedFormat":1},{"version":"717937616a17072082152a2ef351cb51f98802fb4b2fdabd32399843875974ca","affectsGlobalScope":true,"impliedFormat":1},{"version":"d7e7d9b7b50e5f22c915b525acc5a49a7a6584cf8f62d0569e557c5cfc4b2ac2","affectsGlobalScope":true,"impliedFormat":1},{"version":"71c37f4c9543f31dfced6c7840e068c5a5aacb7b89111a4364b1d5276b852557","affectsGlobalScope":true,"impliedFormat":1},{"version":"576711e016cf4f1804676043e6a0a5414252560eb57de9faceee34d79798c850","affectsGlobalScope":true,"impliedFormat":1},{"version":"89c1b1281ba7b8a96efc676b11b264de7a8374c5ea1e6617f11880a13fc56dc6","affectsGlobalScope":true,"impliedFormat":1},{"version":"74f7fa2d027d5b33eb0471c8e82a6c87216223181ec31247c357a3e8e2fddc5b","affectsGlobalScope":true,"impliedFormat":1},{"version":"d6d7ae4d1f1f3772e2a3cde568ed08991a8ae34a080ff1151af28b7f798e22ca","affectsGlobalScope":true,"impliedFormat":1},{"version":"063600664504610fe3e99b717a1223f8b1900087fab0b4cad1496a114744f8df","affectsGlobalScope":true,"impliedFormat":1},{"version":"934019d7e3c81950f9a8426d093458b65d5aff2c7c1511233c0fd5b941e608ab","affectsGlobalScope":true,"impliedFormat":1},{"version":"52ada8e0b6e0482b728070b7639ee42e83a9b1c22d205992756fe020fd9f4a47","affectsGlobalScope":true,"impliedFormat":1},{"version":"3bdefe1bfd4d6dee0e26f928f93ccc128f1b64d5d501ff4a8cf3c6371200e5e6","affectsGlobalScope":true,"impliedFormat":1},{"version":"59fb2c069260b4ba00b5643b907ef5d5341b167e7d1dbf58dfd895658bda2867","affectsGlobalScope":true,"impliedFormat":1},{"version":"639e512c0dfc3fad96a84caad71b8834d66329a1f28dc95e3946c9b58176c73a","affectsGlobalScope":true,"impliedFormat":1},{"version":"368af93f74c9c932edd84c58883e736c9e3d53cec1fe24c0b0ff451f529ceab1","affectsGlobalScope":true,"impliedFormat":1},{"version":"af3dd424cf267428f30ccfc376f47a2c0114546b55c44d8c0f1d57d841e28d74","affectsGlobalScope":true,"impliedFormat":1},{"version":"995c005ab91a498455ea8dfb63aa9f83fa2ea793c3d8aa344be4a1678d06d399","affectsGlobalScope":true,"impliedFormat":1},{"version":"959d36cddf5e7d572a65045b876f2956c973a586da58e5d26cde519184fd9b8a","affectsGlobalScope":true,"impliedFormat":1},{"version":"965f36eae237dd74e6cca203a43e9ca801ce38824ead814728a2807b1910117d","affectsGlobalScope":true,"impliedFormat":1},{"version":"3925a6c820dcb1a06506c90b1577db1fdbf7705d65b62b99dce4be75c637e26b","affectsGlobalScope":true,"impliedFormat":1},{"version":"0a3d63ef2b853447ec4f749d3f368ce642264246e02911fcb1590d8c161b8005","affectsGlobalScope":true,"impliedFormat":1},{"version":"b5ce7a470bc3628408429040c4e3a53a27755022a32fd05e2cb694e7015386c7","affectsGlobalScope":true,"impliedFormat":1},{"version":"8444af78980e3b20b49324f4a16ba35024fef3ee069a0eb67616ea6ca821c47a","affectsGlobalScope":true,"impliedFormat":1},{"version":"3287d9d085fbd618c3971944b65b4be57859f5415f495b33a6adc994edd2f004","affectsGlobalScope":true,"impliedFormat":1},{"version":"b4b67b1a91182421f5df999988c690f14d813b9850b40acd06ed44691f6727ad","affectsGlobalScope":true,"impliedFormat":1},{"version":"df83c2a6c73228b625b0beb6669c7ee2a09c914637e2d35170723ad49c0f5cd4","affectsGlobalScope":true,"impliedFormat":1},{"version":"436aaf437562f276ec2ddbee2f2cdedac7664c1e4c1d2c36839ddd582eeb3d0a","affectsGlobalScope":true,"impliedFormat":1},{"version":"8e3c06ea092138bf9fa5e874a1fdbc9d54805d074bee1de31b99a11e2fec239d","affectsGlobalScope":true,"impliedFormat":1},{"version":"87dc0f382502f5bbce5129bdc0aea21e19a3abbc19259e0b43ae038a9fc4e326","affectsGlobalScope":true,"impliedFormat":1},{"version":"b1cb28af0c891c8c96b2d6b7be76bd394fddcfdb4709a20ba05a7c1605eea0f9","affectsGlobalScope":true,"impliedFormat":1},{"version":"2fef54945a13095fdb9b84f705f2b5994597640c46afeb2ce78352fab4cb3279","affectsGlobalScope":true,"impliedFormat":1},{"version":"ac77cb3e8c6d3565793eb90a8373ee8033146315a3dbead3bde8db5eaf5e5ec6","affectsGlobalScope":true,"impliedFormat":1},{"version":"56e4ed5aab5f5920980066a9409bfaf53e6d21d3f8d020c17e4de584d29600ad","affectsGlobalScope":true,"impliedFormat":1},{"version":"4ece9f17b3866cc077099c73f4983bddbcb1dc7ddb943227f1ec070f529dedd1","affectsGlobalScope":true,"impliedFormat":1},{"version":"0a6282c8827e4b9a95f4bf4f5c205673ada31b982f50572d27103df8ceb8013c","affectsGlobalScope":true,"impliedFormat":1},{"version":"1c9319a09485199c1f7b0498f2988d6d2249793ef67edda49d1e584746be9032","affectsGlobalScope":true,"impliedFormat":1},{"version":"e3a2a0cee0f03ffdde24d89660eba2685bfbdeae955a6c67e8c4c9fd28928eeb","affectsGlobalScope":true,"impliedFormat":1},{"version":"811c71eee4aa0ac5f7adf713323a5c41b0cf6c4e17367a34fbce379e12bbf0a4","affectsGlobalScope":true,"impliedFormat":1},{"version":"51ad4c928303041605b4d7ae32e0c1ee387d43a24cd6f1ebf4a2699e1076d4fa","affectsGlobalScope":true,"impliedFormat":1},{"version":"60037901da1a425516449b9a20073aa03386cce92f7a1fd902d7602be3a7c2e9","affectsGlobalScope":true,"impliedFormat":1},{"version":"d4b1d2c51d058fc21ec2629fff7a76249dec2e36e12960ea056e3ef89174080f","affectsGlobalScope":true,"impliedFormat":1},{"version":"22adec94ef7047a6c9d1af3cb96be87a335908bf9ef386ae9fd50eeb37f44c47","affectsGlobalScope":true,"impliedFormat":1},{"version":"4245fee526a7d1754529d19227ecbf3be066ff79ebb6a380d78e41648f2f224d","affectsGlobalScope":true,"impliedFormat":1},{"version":"8e7f8264d0fb4c5339605a15daadb037bf238c10b654bb3eee14208f860a32ea","affectsGlobalScope":true,"impliedFormat":1},{"version":"782dec38049b92d4e85c1585fbea5474a219c6984a35b004963b00beb1aab538","affectsGlobalScope":true,"impliedFormat":1},{"version":"a7ca8df4f2931bef2aa4118078584d84a0b16539598eaadf7dce9104dfaa381c","impliedFormat":1},{"version":"11443a1dcfaaa404c68d53368b5b818712b95dd19f188cab1669c39bee8b84b3","impliedFormat":1},{"version":"36977c14a7f7bfc8c0426ae4343875689949fb699f3f84ecbe5b300ebf9a2c55","impliedFormat":1},{"version":"7f698624bbbb060ece7c0e51b7236520ebada74b747d7523c7df376453ed6fea","impliedFormat":1},{"version":"19efad8495a7a6b064483fccd1d2b427403dd84e67819f86d1c6ee3d7abf749c","affectsGlobalScope":true,"impliedFormat":1},{"version":"1eef826bc4a19de22155487984e345a34c9cd511dd1170edc7a447cb8231dd4a","affectsGlobalScope":true,"impliedFormat":99},{"version":"424faf9241dd699dda995b367ed36665732da1e6ec1f33b2fd40394488ecac92","impliedFormat":1},{"version":"170d4db14678c68178ee8a3d5a990d5afb759ecb6ec44dbd885c50f6da6204f6","affectsGlobalScope":true,"impliedFormat":1},{"version":"8a8eb4ebffd85e589a1cc7c178e291626c359543403d58c9cd22b81fab5b1fb9","impliedFormat":1},{"version":"9e83685e23baf56b50eab5f89bcc46c66ccd709c4a44d32e635040196ad96603","impliedFormat":1},{"version":"42c169fb8c2d42f4f668c624a9a11e719d5d07dacbebb63cbcf7ef365b0a75b3","impliedFormat":1},{"version":"6aa2859da46f726a22040725e684ea964d7469a6b26f1c0a6634bb65e79062b0","impliedFormat":1},{"version":"f734b58ea162765ff4d4a36f671ee06da898921e985a2064510f4925ec1ed062","affectsGlobalScope":true,"impliedFormat":1},{"version":"07cbc706c24fa086bcc20daee910b9afa5dc5294e14771355861686c9d5235fd","impliedFormat":1},{"version":"37f96daaddc2dd96712b2e86f3901f477ac01a5c2539b1bc07fd609d62039ee1","impliedFormat":1},{"version":"9c5c84c449a3d74e417343410ba9f1bd8bfeb32abd16945a1b3d0592ded31bc8","impliedFormat":1},{"version":"c0bd5112f5e51ab7dfa8660cdd22af3b4385a682f33eefde2a1be35b60d57eb1","impliedFormat":1},{"version":"be5bb7b563c09119bd9f32b3490ab988852ffe10d4016087c094a80ddf6a0e28","impliedFormat":1},{"version":"eee7aaf5e34b9fa594aea6ea9178b27a7d005e028899da26a3ea16116fbeec57","impliedFormat":1},{"version":"c707859245a0657964ba22eb08cbeb22d279487665c73e28a759a67714627201","impliedFormat":1},{"version":"dd38f678a4f0b5768156b941bf8c4a07a5451dc9ef4e9dc0919b22d799f1d759","impliedFormat":1},{"version":"28f0de26cb0e8ca34c2b3f83fcaf3903c83a8de997c0089410f8c2bdbf11cf04","impliedFormat":1},{"version":"279690870900b2a02501b3fe61202331cbf4e4b0a6e49cd7a40c044b9ea967ef","impliedFormat":1},{"version":"63a365901ec3cedce3dc3ba008ba002f65500d7fbf29c5ceb628a1fd4a68542d","impliedFormat":1},{"version":"ef73bcfef9907c8b772a30e5a64a6bd86a5669cba3d210fcdcc6b625e3312459","impliedFormat":1},{"version":"8b15d05f236e8537d3ecbe4422ce46bf0de4e4cd40b2f909c91c5818af4ff17a","impliedFormat":1},{"version":"f3d8e124dfaeaf7cbbeb37f8800e9d1da7a69bbbc540fb942385d509516c73b5","impliedFormat":1},{"version":"49d149f86dc0ebe6121de4952ba0a5306965a7429e29766594e8efd053ac86f5","impliedFormat":99},{"version":"3160293bef95a26d613b2a9f24d3c33e0103d98c5a7d445c46a3f9ce8948e7e6","impliedFormat":99},{"version":"e57153b9ac3ec9cea04d4dd2fe070b2d10f3d343a09ac2aa4c3f6f588b672d5e","impliedFormat":99},{"version":"2fdcf54b4c94246b25877993e8f32d61fd1e04094c92b1abe328343a59596507","impliedFormat":99},{"version":"39f084f2c06f5ae8fdf8e529b0585478c37f204f3de4978d0945b0d129e19198","impliedFormat":99},{"version":"ec665d85cf6c3c9bff9571e04ce49bffcb348b5c60d2195c43c035a884d0aa01","impliedFormat":99},{"version":"ad5a3bc698d5df2ddb620dcc570ff48757a8fcbbe9230df5dcb113ada0d432be","impliedFormat":99},{"version":"21a689bed0e1f4b833968835d2ccf6e53b6b4915ffb3feda6f0e9bcc71e86dfe","impliedFormat":1},{"version":"02a8cb8d462a0d17bea3c8dbafd7378e1efc0e212ab76500dff6a819a6b30e5c","impliedFormat":1},{"version":"1fb2055d5cf1d4de01a143c1f3932e582edc5d1c2a0d46d6d86eedf00280753e","affectsGlobalScope":true,"impliedFormat":1},{"version":"eb3989d27ae550dded957a391141130e2d16351bdda80970b79b16e79716b5dc","impliedFormat":1},{"version":"e23f6eed3d20e6d69d56a3de5aa698e88eed89ef55fffb8ca3cddc046febd191","impliedFormat":1},{"version":"a2959c2c6d2c028a0aa9b2d1e406945eef017fc6fd9085c04736cbd0e07df37d","impliedFormat":1},{"version":"c0dff36db106955798e471bc8c05dba3d2dba624304a9ec4d657c2823b28e65a","impliedFormat":1},{"version":"d537cc3986e75b0fcf3e60539072a00e7f96a1233701fe3b41f08b8d564d3bb1","impliedFormat":1},{"version":"62fca6471762967aecc0776c7a4bfd25d9d6f17b5a2ca71fd088dda3315ea77b","affectsGlobalScope":true,"impliedFormat":1},{"version":"9b643d11b5bca11af760795e56096beae0ed29e9027fec409481f2ee1cb54bbc","impliedFormat":1},{"version":"cff2e2479b3ec50f6b9a4b3cd8517f3d5734b388e86e921a9e03160807e41195","impliedFormat":1},{"version":"2a5ea42fdda18b753e9d36dcd1547a90f32e977594b6f0ae5aece0a232209e56","impliedFormat":1},{"version":"a11050e98768c78eb8fb08d1ba9e362f2e7136733c6c2abecb419e41d89d7bba","impliedFormat":1},{"version":"da0ddd3540c3e8f1870a95bbe8ad0c86c0b79dca14459466c774fc7cb59d3819","impliedFormat":1},{"version":"b2df8e9f1e38485f7835a233c422c14c74e087fedfe8cd4ccc3bcb5d3963ce5d","impliedFormat":1},{"version":"fca45fb6eacacee9fd55ec97cbbccddc1e90fc17f4ce9dd1e35e0788c394672e","impliedFormat":1},{"version":"61f88f540d2d93d0da03f5dcd5453afbf4a264811eee067d8a3b871c47506d15","impliedFormat":1},{"version":"4a1dd5626b6ecaadd7231a591e43a411e8d43d4175f3e3a9575c4f558fc89ea8","impliedFormat":1},{"version":"402f2498b4e4023a9e59f92e46d062bb8bdfba167099de06728e203c70f0847f","impliedFormat":1},{"version":"60ab4cdbae4be410ddf1b0550e8816c15eaaba5818908d2eed2c5af2ca16b550","impliedFormat":1},{"version":"17ac60332438bed348e31affbf6019f7b3b577fdcd91b8740f28115952014e6f","impliedFormat":1},{"version":"acb3307b5770948e2b3658559a9ab183df82e48aad49da089e075fad7f1cfdd4","impliedFormat":1},{"version":"e9ace0fdbda138ba3cb852ee7d66ebf4ebae98680bab721c4636b20ad4996460","impliedFormat":1},{"version":"a80ec72f5e178862476deaeed532c305bdfcd3627014ae7ac2901356d794fc93","impliedFormat":1},{"version":"2fbe402f0ee5aa8ab55367f88030f79d46211c0a0f342becaa9f648bf8534e9d","impliedFormat":1},{"version":"b94258ef37e67474ac5522e9c519489a55dcb3d4a8f645e335fc68ea2215fe88","impliedFormat":1},{"version":"fd9712ab81ea33e9c69e4d30c4bc5b018add73543b586595439abef64f59aab9","signature":"12fbbf6b2b09557754a30a2ff2954237c37796de28c2d1360e1591c9a4d8e54c","impliedFormat":1},{"version":"12baec7a4e2c3acddd09ab665e0ae262395044396e41ecde616fefdd33dc75ff","impliedFormat":99},{"version":"a5b88a3dd2d88189df04e242aa103b7d380d6f3226cb709e6231b1714ab32367","impliedFormat":99},{"version":"df7f432ecf21d01c1c49ed921e1e2e40cfae0aeceee78ab3e9327c8fe0945854","impliedFormat":99},{"version":"7078c77d332326a372c1a2bf1a82aa5d1a75f2ef0aee6ace01c0caf509d682e6","impliedFormat":99},{"version":"3c655c148cc91a10ac5cd7e037a043225da3df41be908f5ff4970c27f5019e41","impliedFormat":99},{"version":"1c2895fbfa6cd25406f29fcdd75c2e2105e8c8df1a4944fbba9ccace6211c893","impliedFormat":99},{"version":"81e8f8a08f31dd6766ef203bfe8d9e1f2fdd42e22ddebba6607c569ee750f611","impliedFormat":99},{"version":"8cab328fafd8141b097260fa1bb4478477ccb4215b83fe710bb863d639eeaad7","impliedFormat":99},{"version":"b71c133a200ec0f58e2fed163ffd7195727fa60ad82e2f04b23f3d0358d11c69","impliedFormat":99},{"version":"2a6056297dcd95be218af4da343508fb6f669b1847a0bd0a61ab565555e9bff4","impliedFormat":99},{"version":"4f8d052e63e35abab5461f3d2243ffbfcbd5746c82d915f2eec6a56a92f2de2f","impliedFormat":99},{"version":"ea80607028bdbddc6cedd31518df127b1c1d8d36e61602c1ab087a143f6cf35e","impliedFormat":99},{"version":"0807e49c4834ee58f77dfd4c3b383f578e0a2734b33a0b3eba685595b3942c81","impliedFormat":99},{"version":"32f8862973a256b9f0b87978e1a8999456dd86d70b0dcc0b56cb1cf416ee5c27","impliedFormat":99},{"version":"b71d05a8d89c62d2e9110b16a413ccbf72a6c6c745a46b1c98684a3f5a11d9af","impliedFormat":99},{"version":"6295f18d7bb4eb63ba14059092e89b7b7af51fbe4308c9605af84d5770b63aa0","impliedFormat":99},{"version":"dcea451fd572ddd0ed46c322042eaa0bfcf9ec27eb3c6253d60903a58463c78c","impliedFormat":99},{"version":"d2bc6aceb7e558385033d069e9b6263df719a54d17f2a9672c9c675e106c4ff2","impliedFormat":99},{"version":"3e9f400911379b8eba9a2a1346fa1cce3cc21ee2587cedb14c0636d2956ec3a5","impliedFormat":99},{"version":"2cab545dabda94fe5419bd6bdfae4d9aabd6f40b46bb0040c417ef570b32b13f","impliedFormat":99},{"version":"9014f6ae62567a1a2edf9be5278d1c192c69df50dfa0bb2e2b130f4fab6eb2a3","impliedFormat":99},{"version":"d6b3c97a7d31d1ea76c8680ff11b0b07185e1f6222d3e6f29d7a13b6911127ab","impliedFormat":99},{"version":"0ddd9ab937cef821a908be8581c73874105b34a61b6debaaa89c5c5cf25594a1","impliedFormat":99},{"version":"f8f112dfc0427d63a94413a12bca3cc858b4359e70e1e30d3f3709bef76f1c52","impliedFormat":99},{"version":"26c42de693907fa56842e6ebf39007334e1c6dbae30388a71d715179a527edb2","impliedFormat":99},{"version":"cceba3e6626d0d5a6b743b5f7f150f92323173a42d25269e731080a3ff36d31a","impliedFormat":99},{"version":"698f3f181d2eb5a09ba7cbd78e9ffd6bd21b48873972f64764ff774c86e411c1","impliedFormat":99},{"version":"81d272285c96d6be6287c6217a6f7fd9daaa86bdb9b0592f3831bbcf149ec6c2","impliedFormat":99},{"version":"3fbed1bc84290ae6bad246a668e41aa6308cb9f54c499b29297ff639a9833b7e","impliedFormat":99},{"version":"67c4642b72f0769f2900ed67a9b004165a0821359f79dab12c9f686df9c4319c","impliedFormat":99},{"version":"02933889d4b0d3b26342b240f71c10f0ffb75fa66742b7e4c3884e6e3e134908","impliedFormat":99},{"version":"55555ba42cc8a2104c5bfe9fa1f86d2db480f7db20648eaca3d24aed203af504","impliedFormat":99},{"version":"a6b1ed3b5c123319781d5ea0e22ff29ccb13620226b6ca95c3358eeef802f57d","impliedFormat":99},{"version":"458365eb8f4451650cd49e7bf4506f5aec20c0ea00828249b7392c5cc1be244b","impliedFormat":99},{"version":"7aeb46eb0a4c9cdcdec142780cb9adf1726f9a321ae7e648b6b164a9438beaf5","impliedFormat":99},{"version":"0745b484b1fc809a9e1ca8970298126bdb653f17232beb096dfedcc0d880d494","impliedFormat":99},{"version":"b7e920dd47009291e1e0d4875d78f403aa5b67bcc9553e6efce0ffd77aeb6712","impliedFormat":99},{"version":"40efa8b89da5f84d101a2e11d3bde07ceba84d2151a46362d51af9fcac38a300","impliedFormat":99},{"version":"7584bebefa39b6befd2f53b682a7f78837c2bb156cdfdf45967e8849e0d55dd8","impliedFormat":99},{"version":"86f06b955ff10b08571f46f3ced5cbb8b13c1ad049d5532f7ee2956ac3f2beb1","impliedFormat":99},{"version":"85b303f253aa1ace057cb95c4877ab0284733266b2659721776c8bce3123ee52","impliedFormat":99},{"version":"d986ec1523a115dee85f6b0887b6f2fd9c442963f80bbb4ee0fc4283668c370f","impliedFormat":99},{"version":"94599e64d23ffdf775213a6d58dc5c168fdccc183b99a25638fad6cac404aed9","impliedFormat":99},{"version":"51fe1fa188fcd12d95d6bb8585f562e402ecf1cfe20468bf26b16705f601a5d3","impliedFormat":99},{"version":"b73eb11c71dafdf51786a0130eec118a10fb5745f53b3ce6d2e91c7b57350cbc","impliedFormat":99},{"version":"623cfc15d5f796ad146ff31ab9f2c6b0f9a87546df41ad899ca250a49602cb73","impliedFormat":99},{"version":"153638de5f15083b920bc363ce6466625d28507e2c6ca321404d10ad394a8c68","impliedFormat":99},{"version":"aa8e3b222985e2dff4f056802cb68ef6e798f60761758a0ce2aa9be8ba964a08","impliedFormat":99},{"version":"f2f1da2c3c170f8f88b158926c9c36f3cdb9e178dfb82c76ccfcc4ce49607f7d","impliedFormat":99},{"version":"79926764aeff0993b4c5572388a26a0c8840b7019e95d0c413f8bfa28faa9a11","impliedFormat":99},{"version":"f0e4415f13da8dbcb3ca10e18aa243d97bf3448a75f14fe2ade07a3462684539","impliedFormat":99},{"version":"407894b66b2b266e4ac9f85f9d561132461b22e912a9391f86a0f5e49929d468","impliedFormat":99},{"version":"5c26337066b61988acd1cde0a41da915efa0cbd4059ca78098e356b52a61451f","impliedFormat":99},{"version":"a9a23e467d5bfa83c2bdc7afa4df834555254e6ab14cb237b4b6bfc81a9a9e89","impliedFormat":99},{"version":"dd1dc5a0dc05019eca6225e42d8a1e8056d63000c15337e6fcd518dd2e545aa4","impliedFormat":99},{"version":"a853fefc5b7f2491746cf1c612a1eaaa00d459c3196e7ab19c851785264e8795","impliedFormat":99},{"version":"48a465f5c5355b19f0c392918c93f8b7e49aaaedb95b3834d9b4c81e0d1cd344","impliedFormat":99},{"version":"ae02342d343890e389173008232602886260a423bf0ce4050dc4f069a865387d","impliedFormat":99},{"version":"3a9add1125746158416c8fe8b07798bfe63dcf27c9fb81b07e110a80357a2f3b","impliedFormat":99},{"version":"4dc4c65d064c762de00721f3e475c72875d010a12eb00991adca4951003cae1f","impliedFormat":99},{"version":"cca32394edecf4a3e67183b41246fbfddbc5697d71acf3e838cc89deb69fea1d","impliedFormat":99},{"version":"701ec0d71462ea20989852e37555e9061ad6b6b66d0c1e26137108929605f0ca","impliedFormat":99},{"version":"5d295ab177882992e3dee531b9bc2eba4b8855831db351f9bbf6705eae2495c8","impliedFormat":99},{"version":"15fe687c59d62741b4494d5e623d497d55eb38966ecf5bea7f36e48fc3fbe15e","impliedFormat":1},{"version":"bc0da5ebb57968476122bcc0467fbe624bf8a96e13a717c3c38552fa06554358","impliedFormat":99},{"version":"6df63f03764be1e9621f14df2a6a01a92cef6da7a6f2f1d8111ac6fbd9afaf5c","impliedFormat":99},{"version":"b1538a92b9bae8d230267210c5db38c2eb6bdb352128a3ce3aa8c6acf9fc9622","impliedFormat":1},{"version":"469532350a366536390c6eb3bde6839ec5c81fe1227a6b7b6a70202954d70c40","impliedFormat":1},{"version":"17c9f569be89b4c3c17dc17a9fb7909b6bab34f73da5a9a02d160f502624e2e8","impliedFormat":1},{"version":"003df7b9a77eaeb7a524b795caeeb0576e624e78dea5e362b053cb96ae89132a","impliedFormat":1},{"version":"7ba17571f91993b87c12b5e4ecafe66b1a1e2467ac26fcb5b8cee900f6cf8ff4","impliedFormat":1},{"version":"6fc1a4f64372593767a9b7b774e9b3b92bf04e8785c3f9ea98973aa9f4bbe490","impliedFormat":1},{"version":"d30e67059f5c545c5f8f0cc328a36d2e03b8c4a091b4301bc1d6afb2b1491a3a","impliedFormat":1},{"version":"8b219399c6a743b7c526d4267800bd7c84cf8e27f51884c86ad032d662218a9d","impliedFormat":1},{"version":"bad6d83a581dbd97677b96ee3270a5e7d91b692d220b87aab53d63649e47b9ad","impliedFormat":1},{"version":"324726a1827e34c0c45c43c32ecf73d235b01e76ef6d0f44c2c0270628df746a","impliedFormat":1},{"version":"54e79224429e911b5d6aeb3cf9097ec9fd0f140d5a1461bbdece3066b17c232c","impliedFormat":1},{"version":"e1b666b145865bc8d0d843134b21cf589c13beba05d333c7568e7c30309d933a","impliedFormat":1},{"version":"ff09b6fbdcf74d8af4e131b8866925c5e18d225540b9b19ce9485ca93e574d84","impliedFormat":1},{"version":"c836b5d8d84d990419548574fc037c923284df05803b098fe5ddaa49f88b898a","impliedFormat":1},{"version":"3a2b8ed9d6b687ab3e1eac3350c40b1624632f9e837afe8a4b5da295acf491cb","impliedFormat":1},{"version":"189266dd5f90a981910c70d7dfa05e2bca901a4f8a2680d7030c3abbfb5b1e23","impliedFormat":1},{"version":"5ec8dcf94c99d8f1ed7bb042cdfa4ef6a9810ca2f61d959be33bcaf3f309debe","impliedFormat":1},{"version":"a80e02af710bdac31f2d8308890ac4de4b6a221aafcbce808123bfc2903c5dc2","impliedFormat":1},{"version":"d5895252efa27a50f134a9b580aa61f7def5ab73d0a8071f9b5bf9a317c01c2d","impliedFormat":1},{"version":"2c378d9368abcd2eba8c29b294d40909845f68557bc0b38117e4f04fc56e5f9c","impliedFormat":1},{"version":"0f345151cece7be8d10df068b58983ea8bcbfead1b216f0734037a6c63d8af87","impliedFormat":1},{"version":"37fd7bde9c88aa142756d15aeba872498f45ad149e0d1e56f3bccc1af405c520","impliedFormat":1},{"version":"2a920fd01157f819cf0213edfb801c3fb970549228c316ce0a4b1885020bad35","impliedFormat":1},{"version":"56208c500dcb5f42be7e18e8cb578f257a1a89b94b3280c506818fed06391805","impliedFormat":1},{"version":"0c94c2e497e1b9bcfda66aea239d5d36cd980d12a6d9d59e66f4be1fa3da5d5a","impliedFormat":1},{"version":"a67774ceb500c681e1129b50a631fa210872bd4438fae55e5e8698bac7036b19","impliedFormat":1},{"version":"9b048390bcffe88c023a4cd742a720b41d4cd7df83bc9270e6f2339bf38de278","affectsGlobalScope":true,"impliedFormat":1},{"version":"dd8936160e41420264a9d5fade0ff95cc92cab56032a84c74a46b4c38e43121e","impliedFormat":1},{"version":"1f366bde16e0513fa7b64f87f86689c4d36efd85afce7eb24753e9c99b91c319","impliedFormat":1},{"version":"421c3f008f6ef4a5db2194d58a7b960ef6f33e94b033415649cd557be09ef619","impliedFormat":1},{"version":"57568ff84b8ba1a4f8c817141644b49252cc39ec7b899e4bfba0ec0557c910a0","impliedFormat":1},{"version":"e6f10f9a770dedf552ca0946eef3a3386b9bfb41509233a30fc8ca47c49db71c","impliedFormat":1},{"version":"f20c9c09c8a0fea4784952305a937bdb092417908bad669dc789d3e54d8a5386","affectsGlobalScope":true,"impliedFormat":1},{"version":"c58be3e560989a877531d3ff7c9e5db41c5dd9282480ccf197abfcc708a95b8d","impliedFormat":1},{"version":"91f23ddc3971b1c8938c638fb55601a339483953e1eb800675fa5b5e8113db72","impliedFormat":1},{"version":"50d22844db90a0dcd359afeb59dd1e9a384d977b4b363c880b4e65047237a29e","impliedFormat":1},{"version":"d33782b82eea0ee17b99ca563bd19b38259a3aaf096d306ceaf59cd4422629be","impliedFormat":1},{"version":"7f7f1420c69806e268ab7820cbe31a2dcb2f836f28b3d09132a2a95b4a454b80","impliedFormat":1},{"version":"2d14198b25428b7b8010a895085add8edfaae476ab863c0c15fe2867fc214fe4","impliedFormat":1},{"version":"61046f12c3cfafd353d2d03febc96b441c1a0e3bb82a5a88de78cc1be9e10520","impliedFormat":1},{"version":"f4e7f5824ac7b35539efc3bef36b3e6be89603b88224cb5c0ad3526a454fc895","impliedFormat":1},{"version":"091af8276fbc70609a00e296840bd284a2fe29df282f0e8dae2de9f0a706685f","impliedFormat":1},{"version":"537aff717746703d2157ec563b5de4f6393ce9f69a84ae62b49e9b6c80b6e587","impliedFormat":1},{"version":"d4220a16027ddf0cc7d105d80cbb01f5070ca7ddd8b2d007cfb024b27e22b912","impliedFormat":1},{"version":"fb3aa3fb5f4fcd0d57d389a566c962e92dbfdaea3c38e3eaf27d466e168871c6","impliedFormat":1},{"version":"0af1485d84516c1a080c1f4569fea672caac8051e29f33733bf8d01df718d213","impliedFormat":1},{"version":"69630ad0e50189fb7a6b8f138c5492450394cb45424a903c8b53b2d5dd1dbce2","impliedFormat":1},{"version":"c2d56efa50f7d0ac8e4e7125fe5e213c1f13228117a70c54e79d23d5529c3fc8","impliedFormat":1},{"version":"8e067d3c170e56dfe3502fc8ebd092ae76a5235baad6f825726f3bbcc8a3836a","impliedFormat":1},{"version":"ae7f57067310d6c4acbc4862b91b5799e88831f4ab77f865443a9bc5057b540a","impliedFormat":1},{"version":"955d0c60502897e9735fcd08d2c1ad484b6166786328b89386074aebcd735776","impliedFormat":1},{"version":"2fa69d202a513f2a6553f263d473cba85d598ce250261715d78e8aab42df6b93","impliedFormat":1},{"version":"c17d5f8e1f0d7cb88000577b29579e758d94fe2d655db41fed16183498860f60","impliedFormat":1},{"version":"3c19e77a05c092cab5f4fd57f6864aa2657f3ad524882f917a05fdb025905199","impliedFormat":1},{"version":"09759a6d77fcbbc42729c6ad12c78bd1603e7ef516fc2830b0f7900ae0c45293","impliedFormat":1},{"version":"8e358d80ac052e9f4e5cc16d06c946628834b47718a4bd101ef2087603b8e5c7","impliedFormat":1},{"version":"113ae3c00b4b6c8cede732e154504f5d265c7794d96440bbe81ca88473c60459","impliedFormat":1},{"version":"05ce92b890e2120483d7346cb0377877803b22c626900222b6cf0d6b6d06bbc0","impliedFormat":99},{"version":"fe5b08c96ddcd1b6d4c3b940095615716a6d43cb1a01028ada664e14b6493cb2","impliedFormat":99},{"version":"5aa8b50a334af93ff1bb3da686178871a7e27e03791d07fd6107980076ddb90e","impliedFormat":99},{"version":"62423031f8a01e15a8a7141b5786fd450d57b6a921032366c09c81d11e167306","impliedFormat":99},{"version":"472af829e276e87f1f50c5470e11d1d229ee097065a10377049af69b8d8936f8","impliedFormat":99},{"version":"25c1448dafc60e4ee55022d86c9deb322b669b93743a01f415c7f3974e5eb265","impliedFormat":99},{"version":"43ac78f8e0c5defecc2e501f77d1e61d078c79975af401702c16b9828ab12ca8","impliedFormat":99},{"version":"37cab6748de506bd7a2493ab2f4240b2236983bb546bae4b67a4aef2a8737fad","impliedFormat":99},{"version":"66102192a22501568299af73b0f11342c22bd621118fa7e883a3babe5a19d34a","impliedFormat":99},{"version":"dcab5635cd67fbabb85fff25d7cebbe7f5ab4aaecba0d076376a467a628a892d","impliedFormat":99},{"version":"c8698ce13a61d68036ac8eb97141c168b619d80f3c1a5c6c435fe5b7700a7ece","impliedFormat":99},{"version":"7b90746131607190763112f9edb5f3319b6b2a695c2fa7a8d0227d9486e934c7","impliedFormat":99},{"version":"269b06e0b7605316080b5e34602dee2f228400076950bd58c56ffad1300a1ff1","impliedFormat":99},{"version":"2000d0ab5e4203f1909f85426212757fbcd94a0e91cfb4a47d44c297a8545379","impliedFormat":99},{"version":"73e7fad963b6273a64a9db125286890871f8cf11c8e8a0c6ace94f2fa476c260","impliedFormat":99},{"version":"8496476b1f719d9f197069fe18932133870a73e3aacf7e234c460e886e33a04d","impliedFormat":99},{"version":"3cb5ccb27576538fb71adba1fa647da73fae5d80c6cf6a76e1a229a0a8580ede","impliedFormat":99},{"version":"e66490a581bea6aeaa5779a10f3b59e2d021a46c1920713ae063baaba89e9a57","impliedFormat":99},{"version":"aea830b89cbed15feb1a4f82e944a18e4de8cecc8e1fbfaf480946265714e94e","impliedFormat":99},{"version":"1600536cd61f84efed3bb5e803df52c3fc13b3e1727d3230738476bcb179f176","impliedFormat":99},{"version":"f0b4a2c075bfab425785a420fe61796d1d0fb4c2e970a9e7bba9b8d6cfe5446b","impliedFormat":99},{"version":"b350b567766483689603b5df1b91ccaab40bb0b1089835265c21e1c290370e7e","impliedFormat":99},{"version":"d5a3e982d9d5610f7711be40d0c5da0f06bbb6bd50c154012ac1e6ce534561da","impliedFormat":99},{"version":"ddbe1301fdf5670f0319b7fb1d2567dc08da0343cb16bf95dc63108922c781dc","impliedFormat":99},{"version":"ff5321e692b2310e1eb714e2bc787d30c45f7b47b96665549953ccfd5b0b6d55","impliedFormat":99},{"version":"8a0e4db16deae4e4d8c91ee6e5027b85899b6431ace9f2d5cec7d590170d83cd","impliedFormat":99},{"version":"c6d6182d16bf45a4875bf8e64a755eb3997faeb1dfc7ef6c5ead3096f4922cb6","impliedFormat":99},{"version":"d5585e9bae6909f69918ea370d6003887ea379663001afccca14c0f1f9e3243f","impliedFormat":99},{"version":"2103118e29cf7d25535bde1bae30667a27891aae1e6898df5f42fd84775ae852","impliedFormat":99},{"version":"58c28d9cb640cac0b9a3e46449e134b137ec132c315f8cb8041a1132202c6ff1","impliedFormat":99},{"version":"d7efb2609ff11f5b746238d42a621afcfb489a9f26ac31da9dff1ab3c55fc8f3","impliedFormat":99},{"version":"556b4615c5bf4e83a73cbf5b8670cb9b8fd46ee2439e2da75e869f29e79c4145","impliedFormat":99},{"version":"51fc38fbb3e2793ec77ef8ffa886530b1fed9118df02943679f1c4a7479f565d","impliedFormat":99},{"version":"03a4f9132fe1ffa58f1889e3a2f8ae047dcb6d0a1a52aa2454de84edc705e918","impliedFormat":99},{"version":"437dd98ff7257140b495b4ff5911da0363a26f2d59df1042d6849ecb42c1ee84","impliedFormat":99},{"version":"8345eadc4cceddc707e9e386c4ad19df40ed6a1e47f07e3f44d8ecf4fe06d37f","impliedFormat":99},{"version":"2df69f11080a8916d3d570f75ddf5c51e701fc408fd1f07629c2f9a20f37f1ea","impliedFormat":99},{"version":"2c19fb4e886b618b989d1f28d4ee4bee16296f0521d800b93fd20e7c013344fe","impliedFormat":99},{"version":"61085fe7d6889b5fc65c30c49506a240f5fbb1d51024f4b79eef12254e374e76","impliedFormat":99},{"version":"aad42bbf26fe21915c6a0f90ef5c8f1e9972771a22f0ea0e0f3658e696d01717","impliedFormat":99},{"version":"7a504df16e0b4b65f4c1f20f584df45bc75301e8e35c8a800bcdec83fc59e340","impliedFormat":99},{"version":"37077b8bf4928dcc3effd21898b9b54fa7b4b55ff40d2e0df844c11aed58197b","impliedFormat":99},{"version":"a508144cd34322c6ad98f75b909ba18fa764db86c32e7098f6a786a5dcca7e03","impliedFormat":99},{"version":"021bf96e46520559d2d9cc3d6d12fb03ca82598e910876fdb7ee2f708add4ce9","impliedFormat":99},{"version":"44cbc604b6e5c96d23704a6b3228bd7ca970b8b982f7b240b1c6d975b2753e4c","impliedFormat":99},{"version":"7bfb0450c4de8f1d62b11e05bbfdc3b25ccb9d0c39ae730233b6c93d1d47aea2","impliedFormat":99},{"version":"51696f7c8c3794dcf5f0250f43eda013d588f0db74b102def76d3055e039afff","impliedFormat":99},{"version":"9b375269243aef22e5511f058198c8bd580fdc0f537668dd9aec5755a2878021","impliedFormat":99},{"version":"39d8d14a745c2a567b8c25d24bb06d76dbffc5409ab1f348fde5bc1290abd690","impliedFormat":99},{"version":"6d9aeea6853ed156d226f2411d82cb1951c8bb81c7a882eeb92083f974f15197","impliedFormat":99},{"version":"1fed41ee4ba0fb55df2fbf9c26ec1b560179ea6227709742ec83f415cebef33e","impliedFormat":99},{"version":"d5982015553b9672974a08f12fc21dcee67d812eeb626fcaf19930bc25c2a709","impliedFormat":99},{"version":"6ad9d297c0feca586c7b55e52dbd5015f0e92001a80105059b092a1d3ecfc105","impliedFormat":99},{"version":"13fa4f4ee721c2740a26fe7058501c9ba10c34398cdf47ad73431b3951eea4e2","impliedFormat":99},{"version":"3a9b807bd0e0b0cd0e4b6028bec2301838a8d172bcc7f18f2205b9974c5d1ecc","impliedFormat":99},{"version":"8c5b994a640ef2a5f6c551d1b53b00fbbd893a1743cbae010e922ac32e207737","impliedFormat":99},{"version":"688424fbbef17ee891e1066c3fb04d61d0d0f68be31a70123415f824b633720a","impliedFormat":99},{"version":"25eafa9f24b7d938a895ab15ed5d295bc000187d4a6aa5bfd310f32ba2d4eea5","impliedFormat":99},{"version":"d9df062c57b3795e2cae045c72a881fb24c4137cea283557669d3e393aa10031","impliedFormat":99},{"version":"72f4b1dc4c34418935d4d87a90486b86d5450286139e4c25eeee8b905d2886b2","impliedFormat":99},{"version":"92efd5d38691eece63952e89297adcc9cb4c9b8878d635c76d5473c20489fd4d","impliedFormat":99},{"version":"a4b4d0ac8882e2d857f76f75ca33694d315715cdc19d275ac37e9ef2a8d8693b","impliedFormat":99},{"version":"e185a44b6e46dc9621704f471ed0a39b56ce5b5027dbc81949b67cbcb59da7d0","impliedFormat":99},{"version":"5102e449a65c1f816d6ac1199b683f9ddf21b107f4eec5ce8316e957350d1b8d","impliedFormat":99},{"version":"73397fcaa8afa955ae1ac27c8ff5473418195ecacc90b275abbac0b8099b7e91","impliedFormat":99},{"version":"3a8b3e4e8ee1784e46e8151b4b0717b8a22e045b20257ad4491815f7cdb3ab22","impliedFormat":99},{"version":"823a190056fa78cfe888a24a0679624cfc36cab0ce9cfc875b1856e8a535bc9f","impliedFormat":99},{"version":"28b5d252374af23b8db3d80154078d76ab4af7635d6f20ec892cf86651bb5f52","impliedFormat":99},{"version":"d6d72de42c0a81f3d22b71fca1ff348f4bc3a50deb9382ebdfd71214794ec58e","impliedFormat":99},{"version":"1a4fae85bd066e1f57250ecd3be398f45c0ee35fd639d1a91f2b816ad37cf4db","impliedFormat":99},{"version":"e8065cc0b1c821d3dcd8b045a03412ab03e6002bbbfd5b379e0a8e3624c1a2f7","impliedFormat":99},{"version":"8fd5a1b91763e73f5d30ecdfe66da4400b6b6c18af619e7f7230d72e49959935","impliedFormat":99},{"version":"be02a1d8cdd4905919e1a26ce668a51e726f381ed12e8f4236f000b9f8ec126b","impliedFormat":99},{"version":"8dd4181760665479df5a7b45c09142c96296fe9dee0f7df9013408b909c508bf","impliedFormat":99},{"version":"e3acb0d4a33fa94925f137d7fe5f73ca3b927691a8aadbd6a3a184086009b737","impliedFormat":99},{"version":"f2a8430828ee32b6f05f69670872ef08b49c9acd85a817892911de24f87ebc68","impliedFormat":99},{"version":"c6fb620f7d3160662e9bae07262b192fd257259220c46b090c84b7e7f02e2da3","impliedFormat":99},{"version":"2a7bd12de58b9b8cb10dabf6c1eb933b4d4efe1d1b57dcc541f43061d0e0f70b","impliedFormat":99},{"version":"0e8e5b2568b6b1bebacc2b4a10d84badf973554f069ded173c88c59d74ce7524","impliedFormat":99},{"version":"f3159181773938d1ecd732e44ce25abe7e5c08dd1d90770e2fd9f8b92fab6c22","impliedFormat":99},{"version":"a574154c958cdaaee26294e338024932d9cc403bae2d85ff1de76363aad04bbe","impliedFormat":99},{"version":"5fa60c104a981a5430b937b09b5b9a06ceb392f6bb724d4a2f527c60f6f768b8","impliedFormat":99},{"version":"006dabdcdcc1f1fa70b71da50791f380603dd2fe2ef3da9dec4f70c8c7a72fd9","impliedFormat":99},{"version":"bcd511f2a2c83fc41059e90ed7305e7210cbd071752968fd0ca6a591b165ff97","impliedFormat":99},{"version":"e351fc610efbbdbe1d92a7df4b75e0bc4b7678ee3585f416df1e0cc8894d2b20","impliedFormat":99},{"version":"33c06a102df241666a34e69fe5f9a6808e575d684fcfcf95886d470517a456cd","impliedFormat":99},{"version":"404818f4f7cfc01054eeb0a3568da67a02b67b9ed375e745fdc20c2c22ad9f9b","impliedFormat":99},{"version":"d6ea20b2ffd56043261ee6ff3512e19a0f90cde5b095a8175f44776962f5bb84","impliedFormat":99},{"version":"dcff28456976dcc3658cea21bcda551e6683fdca640f106655badea211d3bedc","impliedFormat":99},{"version":"ad4b3aa66c7d3c3e7a5fb2126ca0aedafcded91b2d175fca89f50fcb6d3a1258","impliedFormat":99},{"version":"3ece6e9c2534a3f95304b7d415d270ccf040091e76dee3f6146164010b420139","impliedFormat":99},{"version":"89121c1bf2990f5219bfd802a3e7fc557de447c62058d6af68d6b6348d64499a","impliedFormat":1},{"version":"79b4369233a12c6fa4a07301ecb7085802c98f3a77cf9ab97eee27e1656f82e6","impliedFormat":1},{"version":"5c5d901a999dfe64746ef4244618ae0628ac8afdb07975e3d5ed66e33c767ed0","impliedFormat":99},{"version":"85d08536e6cd9787f82261674e7d566421a84d286679db1503432a6ccf9e9625","impliedFormat":99},{"version":"5702b3c2f5d248290ed99419d77ca1cc3e6c29db5847172377659c50e6303768","impliedFormat":99},{"version":"9764b2eb5b4fc0b8951468fb3dbd6cd922d7752343ef5fbf1a7cd3dfcd54a75e","impliedFormat":99},{"version":"1fc2d3fe8f31c52c802c4dee6c0157c5a1d1f6be44ece83c49174e316cf931ad","impliedFormat":99},{"version":"dc4aae103a0c812121d9db1f7a5ea98231801ed405bf577d1c9c46a893177e36","impliedFormat":99},{"version":"106d3f40907ba68d2ad8ce143a68358bad476e1cc4a5c710c11c7dbaac878308","impliedFormat":99},{"version":"42ad582d92b058b88570d5be95393cf0a6c09a29ba9aa44609465b41d39d2534","impliedFormat":99},{"version":"36e051a1e0d2f2a808dbb164d846be09b5d98e8b782b37922a3b75f57ee66698","impliedFormat":99},{"version":"d4a22007b481fe2a2e6bfd3a42c00cd62d41edb36d30fc4697df2692e9891fc8","impliedFormat":1},{"version":"9d62e577adb05f5aafed137e747b3a1b26f8dce7b20f350d22f6fb3255a3c0ed","impliedFormat":99},{"version":"7ed92bcef308af6e3925b3b61c83ad6157a03ff15c7412cf325f24042fe5d363","impliedFormat":99},{"version":"3da9062d0c762c002b7ab88187d72e1978c0224db61832221edc8f4eb0b54414","impliedFormat":99},{"version":"84dbf6af43b0b5ad42c01e332fddf4c690038248140d7c4ccb74a424e9226d4d","impliedFormat":99},{"version":"00884fc0ea3731a9ffecffcde8b32e181b20e1039977a8ae93ae5bce3ab3d245","impliedFormat":99},{"version":"0bd8b6493d9bf244afe133ccb52d32d293de8d08d15437cca2089beed5f5a6b5","impliedFormat":99},{"version":"7fc3099c95752c6e7b0ea215915464c7203e835fcd6878210f2ce4f0dcbbfe67","impliedFormat":99},{"version":"83b5499dbc74ee1add93aef162f7d44b769dcef3a74afb5f80c70f9a5ce77cc0","impliedFormat":99},{"version":"8bf8b772b38fc4da471248320f49a2219c363a9669938c720e0e0a5a2531eabf","impliedFormat":99},{"version":"7da6e8c98eacf084c961e039255f7ebb9d97a43377e7eee2695cb77fec640c66","impliedFormat":99},{"version":"0b5b064c5145a48cd3e2a5d9528c63f49bac55aa4bc5f5b4e68a160066401375","impliedFormat":99},{"version":"702ff40d28906c05d9d60b23e646c2577ad1cc7cd177d5c0791255a2eab13c07","impliedFormat":99},{"version":"49ff0f30d6e757d865ae0b422103f42737234e624815eee2b7f523240aa0c8f8","impliedFormat":99},{"version":"0389aacf0ffd49a877a46814a21a4770f33fc33e99951a1584de866c8e971993","impliedFormat":99},{"version":"5cb7a51cf151c1056b61f078cf80b811e19787d1f29a33a2a6e4bf00334bbc10","impliedFormat":99},{"version":"215aa8915d707f97ad511b7abbf7eda51d3a7048e9a656955cf0dda767ae7db0","impliedFormat":99},{"version":"0d689a717fbef83da07ab4de33f83db5cbcec9bc4e3b04edb106c538a50a0210","impliedFormat":99},{"version":"d00bc73e8d1f4137f2f6238bb3aa2bbdad8573658cc95920e2cdfa7ad491a8d8","impliedFormat":99},{"version":"e3667aa9f5245d1a99fb4a2a1ac48daf1429040c29cc0d262e3843f9ae3b9d65","impliedFormat":99},{"version":"08c0f3222b50ec2b534be1a59392660102549129246425d33ec43f35aa051dc6","impliedFormat":99},{"version":"612fb780f312e6bb3c40f3cb2b827ea7455b922198f651c799d844fdd44cf2e9","impliedFormat":99},{"version":"bcd98e8f44bc76e4fcb41e4b1a8bab648161a942653a3d1f261775a891d258de","impliedFormat":99},{"version":"5abaa19aa91bb4f63ea58154ada5d021e33b1f39aa026ca56eb95f13b12c497a","impliedFormat":99},{"version":"356a18b0c50f297fee148f4a2c64b0affd352cbd6f21c7b6bfa569d30622c693","impliedFormat":99},{"version":"5876027679fd5257b92eb55d62efee634358012b9f25c5711ad02b918e52c837","impliedFormat":99},{"version":"f5622423ee5642dcf2b92d71b37967b458e8df3cf90b468675ff9fddaa532a0f","impliedFormat":99},{"version":"70265bc75baf24ec0d61f12517b91ea711732b9c349fceef71a446c4ff4a247a","impliedFormat":99},{"version":"41a4b2454b2d3a13b4fc4ec57d6a0a639127369f87da8f28037943019705d619","impliedFormat":99},{"version":"e9b82ac7186490d18dffaafda695f5d975dfee549096c0bf883387a8b6c3ab5a","impliedFormat":99},{"version":"eed9b5f5a6998abe0b408db4b8847a46eb401c9924ddc5b24b1cede3ebf4ee8c","impliedFormat":99},{"version":"af85fde8986fdad68e96e871ae2d5278adaf2922d9879043b9313b18fae920b1","impliedFormat":99},{"version":"8a1f5d2f7cf4bf851cc9baae82056c3316d3c6d29561df28aff525556095554b","impliedFormat":99},{"version":"a5dbd4c9941b614526619bad31047ddd5f504ec4cdad88d6117b549faef34dd3","impliedFormat":99},{"version":"e87873f06fa094e76ac439c7756b264f3c76a41deb8bc7d39c1d30e0f03ef547","impliedFormat":99},{"version":"488861dc4f870c77c2f2f72c1f27a63fa2e81106f308e3fc345581938928f925","impliedFormat":99},{"version":"eff73acfacda1d3e62bb3cb5bc7200bb0257ea0c8857ce45b3fee5bfec38ad12","impliedFormat":99},{"version":"aff4ac6e11917a051b91edbb9a18735fe56bcfd8b1802ea9dbfb394ad8f6ce8e","impliedFormat":99},{"version":"1f68aed2648740ac69c6634c112fcaae4252fbae11379d6eabee09c0fbf00286","impliedFormat":99},{"version":"5e7c2eff249b4a86fb31e6b15e4353c3ddd5c8aefc253f4c3e4d9caeb4a739d4","impliedFormat":99},{"version":"14c8d1819e24a0ccb0aa64f85c61a6436c403eaf44c0e733cdaf1780fed5ec9f","impliedFormat":99},{"version":"011423c04bfafb915ceb4faec12ea882d60acbe482780a667fa5095796c320f8","impliedFormat":99},{"version":"f8eb2909590ec619643841ead2fc4b4b183fbd859848ef051295d35fef9d8469","impliedFormat":99},{"version":"fe784567dd721417e2c4c7c1d7306f4b8611a4f232f5b7ce734382cf34b417d2","impliedFormat":99},{"version":"45d1e8fb4fd3e265b15f5a77866a8e21870eae4c69c473c33289a4b971e93704","impliedFormat":99},{"version":"cd40919f70c875ca07ecc5431cc740e366c008bcbe08ba14b8c78353fb4680df","impliedFormat":99},{"version":"ddfd9196f1f83997873bbe958ce99123f11b062f8309fc09d9c9667b2c284391","impliedFormat":99},{"version":"2999ba314a310f6a333199848166d008d088c6e36d090cbdcc69db67d8ae3154","impliedFormat":99},{"version":"62c1e573cd595d3204dfc02b96eba623020b181d2aa3ce6a33e030bc83bebb41","impliedFormat":99},{"version":"ca1616999d6ded0160fea978088a57df492b6c3f8c457a5879837a7e68d69033","impliedFormat":99},{"version":"835e3d95251bbc48918bb874768c13b8986b87ea60471ad8eceb6e38ddd8845e","impliedFormat":99},{"version":"de54e18f04dbcc892a4b4241b9e4c233cfce9be02ac5f43a631bbc25f479cd84","impliedFormat":99},{"version":"453fb9934e71eb8b52347e581b36c01d7751121a75a5cd1a96e3237e3fd9fc7e","impliedFormat":99},{"version":"bc1a1d0eba489e3eb5c2a4aa8cd986c700692b07a76a60b73a3c31e52c7ef983","impliedFormat":99},{"version":"4098e612efd242b5e203c5c0b9afbf7473209905ab2830598be5c7b3942643d0","impliedFormat":99},{"version":"28410cfb9a798bd7d0327fbf0afd4c4038799b1d6a3f86116dc972e31156b6d2","impliedFormat":99},{"version":"514ae9be6724e2164eb38f2a903ef56cf1d0e6ddb62d0d40f155f32d1317c116","impliedFormat":99},{"version":"970e5e94a9071fd5b5c41e2710c0ef7d73e7f7732911681592669e3f7bd06308","impliedFormat":99},{"version":"491fb8b0e0aef777cec1339cb8f5a1a599ed4973ee22a2f02812dd0f48bd78c1","impliedFormat":99},{"version":"6acf0b3018881977d2cfe4382ac3e3db7e103904c4b634be908f1ade06eb302d","impliedFormat":99},{"version":"2dbb2e03b4b7f6524ad5683e7b5aa2e6aef9c83cab1678afd8467fde6d5a3a92","impliedFormat":99},{"version":"135b12824cd5e495ea0a8f7e29aba52e1adb4581bb1e279fb179304ba60c0a44","impliedFormat":99},{"version":"e4c784392051f4bbb80304d3a909da18c98bc58b093456a09b3e3a1b7b10937f","impliedFormat":99},{"version":"2e87c3480512f057f2e7f44f6498b7e3677196e84e0884618fc9e8b6d6228bed","impliedFormat":99},{"version":"66984309d771b6b085e3369227077da237b40e798570f0a2ddbfea383db39812","impliedFormat":99},{"version":"e41be8943835ad083a4f8a558bd2a89b7fe39619ed99f1880187c75e231d033e","impliedFormat":99},{"version":"260558fff7344e4985cfc78472ae58cbc2487e406d23c1ddaf4d484618ce4cfd","impliedFormat":99},{"version":"413d50bc66826f899c842524e5f50f42d45c8cb3b26fd478a62f26ac8da3d90e","impliedFormat":99},{"version":"d9083e10a491b6f8291c7265555ba0e9d599d1f76282812c399ab7639019f365","impliedFormat":99},{"version":"09de774ebab62974edad71cb3c7c6fa786a3fda2644e6473392bd4b600a9c79c","impliedFormat":99},{"version":"e8bcc823792be321f581fcdd8d0f2639d417894e67604d884c38b699284a1a2a","impliedFormat":99},{"version":"7c99839c518dcf5ab8a741a97c190f0703c0a71e30c6d44f0b7921b0deec9f67","impliedFormat":99},{"version":"44c14e4da99cd71f9fe4e415756585cec74b9e7dc47478a837d5bedfb7db1e04","impliedFormat":99},{"version":"1f46ee2b76d9ae1159deb43d14279d04bcebcb9b75de4012b14b1f7486e36f82","impliedFormat":99},{"version":"2838028b54b421306639f4419606306b940a5c5fcc5bc485954cbb0ab84d90f4","impliedFormat":99},{"version":"7116e0399952e03afe9749a77ceaca29b0e1950989375066a9ddc9cb0b7dd252","impliedFormat":99},{"version":"6c6cce29a8914b89b4f7a77e2acbd11e04f1303c599cf556b823f2d31ae75528","impliedFormat":1},{"version":"a9373d52584b48809ffd61d74f5b3dfd127da846e3c4ee3c415560386df3994b","impliedFormat":1},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":1},{"version":"7ec047b73f621c526468517fea779fec2007dd05baa880989def59126c98ef79","impliedFormat":1},{"version":"8dd450de6d756cee0761f277c6dc58b0b5a66b8c274b980949318b8cad26d712","impliedFormat":1},{"version":"904d6ad970b6bd825449480488a73d9b98432357ab38cf8d31ffd651ae376ff5","impliedFormat":1},{"version":"dfcf16e716338e9fe8cf790ac7756f61c85b83b699861df970661e97bf482692","impliedFormat":1},{"version":"5b4e6cc16515d06d938e449bb5e59124edf2410fc5dd7377d83b2ad7c3201d60","impliedFormat":1},{"version":"43aa726d9b2f29b813750a5badbb9796adc48dd02d85705edcf16cc925170d97","impliedFormat":1},{"version":"99d1a601593495371e798da1850b52877bf63d0678f15722d5f048e404f002e4","impliedFormat":1},{"version":"1404150dec097495863079577f898345fc34d0a064ba5c62071dde8ff0f4c35f","impliedFormat":1},{"version":"db8a4498982360d285a5a7276dd91a2497b32aa5fbf727b1bd931da1e4f16da1","impliedFormat":1},{"version":"ed94fbaa5536af16a52406c86220482435da0d9a897944dc6a8b3aec01d54081","impliedFormat":1},{"version":"c216ec05821759c396af085bbfd7db294ac00f74d4c82fe21e87d677149286cb","impliedFormat":1},{"version":"6482fa5d8eb8b640fa48701dee22627d8b3832bb28a6b5f94bcce80da265b7e9","impliedFormat":1},{"version":"e723c93b143ec94ee3f03023c89a61b4ed09273559d46f6f6be253fc218c2fe5","impliedFormat":1},{"version":"68b6a7501a56babd7bcd840e0d638ee7ec582f1e70b3c36ebf32e5e5836913c8","impliedFormat":1},{"version":"7a14bf21ae8a29d64c42173c08f026928daf418bed1b97b37ac4bb2aa197b89b","impliedFormat":1},{"version":"ee9a26d39e3f7b9a39a91020bb4137ef940465812e5fe80a44c6f6fa84a86611","impliedFormat":1},{"version":"7dc8b2f8cf58bbfb72fecda09096334c0bf36ae1f508fbbc9ae2d309e07a6b53","impliedFormat":1},{"version":"0e5cb10101858f8dc705f436c2910480a0268e1001c4f6d12a9dc179feaa4643","affectsGlobalScope":true,"impliedFormat":1},{"version":"2e5c41e56098ae93bc42a15473acb1a176f28b2ba95c38f3c67820434acd85b6","impliedFormat":1},{"version":"0f263eeea7877199808b1bc220df95b25a72695ec214eb96d740d4b06c7cc868","impliedFormat":1},{"version":"6142b0637c20d9a91fa84397fee6f3a0c653b453d2a912d94be5be10a609fbeb","impliedFormat":1},{"version":"4b629ef5627538c57225ddda88ec925bdf3d592749a1d21e3fa4673312500622","impliedFormat":1},{"version":"598cd49d61c1d28c58fa5cdf232c3a790377fc26c3cf0ddee96170e07dc41c91","impliedFormat":1},{"version":"bfbbdaa81edc12a7059cecd7f28d1a54b41c1c78d68ec8b8d1822f1c6288678e","impliedFormat":1},{"version":"1065378f8584ddfebb3ea37515d28013f37ac7f1d2e5cc44cb8e12d7b80fd1b4","impliedFormat":1},{"version":"6a393f391185c97733f384a19dcef146c6620f07b0f7267858891ff2e6535984","impliedFormat":1},{"version":"ad4b0a2e7a129fbf50cc1d4d4cc7eca7f9faf36fdb3130cacbb2660dc9e76fdf","impliedFormat":1},{"version":"b94b4c70069be55f7df17ece15ce58fc813edc10a2963eaf2a94aaf4bfb21463","impliedFormat":1},{"version":"b7498ab2cb65e533897b859bb3844942cb96cdec49005da20202f2606e8d64ba","impliedFormat":1},{"version":"c243a8464a70dfa85e5c0f75afe353d43c8a8075c3ae99393ea1808dfd1cfa07","impliedFormat":1},{"version":"3bad3a7ae989cb0b96a42297c52723f998b40840ccfa1ffa81fa2f87377b6487","impliedFormat":1},{"version":"663460f731ff21fae71639acb7048f80527efd8dacea796d0e663b9c5d2f7ebb","impliedFormat":1},{"version":"a8ac9d937da0035d015fc72c2975cf4317b6d3c945019f3d9b0532785eb9fd75","impliedFormat":1},{"version":"612e874a6f703edcb10a71147c63beafbd3435bb97ecb104f5752c37f40cf641","impliedFormat":1},{"version":"834c04ae733778f92c97890f7645e1a3f8bb3ae26c0e483e6a5fa7e273a6ed9e","impliedFormat":1},{"version":"e23a257ef79d4ed8b1c777b2db265bec281356a3e318795a47842c353b3c6fe3","impliedFormat":1},{"version":"64bb8f4569ce1cef37648273c618b998b031afb2a47d1afbb91469da8d7c6655","impliedFormat":1},{"version":"5ccd3721f77566515252585a1630630183b751742621c30778dbb9244f08c280","impliedFormat":1},{"version":"ae27dfcff160ec2ae3671fa7ae359af3ac000f60f8e6f960b8686b1bfd6b8951","impliedFormat":1},{"version":"a26883335b5004c383116e42850fe27503a8f15e9adf19cd5fc22d3535255f3c","impliedFormat":1},{"version":"17be1812e316b7324168e6ed881446009512fb6651aaa1d9623811702c96c08f","impliedFormat":1},{"version":"78ff9be0fbd2744bbd143302f6bf2a49101c476d908ff4d3c5fabe27d9ea5032","impliedFormat":1},{"version":"b0afdb11e042d946240ea1552dc98c6ccc31858d9e14799d1faab6fbe76720ef","impliedFormat":1},{"version":"39f5e05c42bf219cd142800819a1b595b131587512676f24dd8aab35a900c176","impliedFormat":1},{"version":"4024877347df3488b9468201d73fd13c9d93026dc981b47f21734a5f16d8b02a","impliedFormat":1},{"version":"079a489453504b3d7e277169b71b6c1d39922811e8ebb3100581b52802a9cdb1","impliedFormat":1},{"version":"addaf9820ab96167618f4a771eb76bf02409ce22d1c6d7b7929c67c7d3e3e268","impliedFormat":1},{"version":"e6a0a8cab1e15e183dbf370048d1960d33c8ed3cd932e9e4cfcefbfe2bdf3fd1","impliedFormat":1},{"version":"37549453bbf83b7baa1e18c564e6b21e1161c6a5a14051f204e4d85ddc28d46b","impliedFormat":1},{"version":"909d0c4a4ac4c53b523793b8dbc4d89ff11bc2cc5c4fcf8f8b247923024d0222","impliedFormat":1},{"version":"52cbfca7e1ded34f95705e1bcbb696783ea29f577b80ef04b31b814e110c8edf","impliedFormat":1},{"version":"5995aa547d9c4a6fb9be1f35bc7a0690e683df74b499eb6f87977f0de86d7b54","impliedFormat":1},{"version":"0a9fc7356fe4f1fd64c30d1f8e7d1639fb472ebd7c6b199b268c2140458c6807","impliedFormat":1},{"version":"b9bd374ad3af8a0201110cdf7cf07114d8a227f293a1f72ca4c544518da95e6b","impliedFormat":1},{"version":"d202fd26f9a25859ae6d4cd46c34e996a4834205c4740919d9c9e98485575dbf","impliedFormat":1},{"version":"1fe174b5ca577b3df41d151367735e6394c3ee6695a637e5578e4882365dde8f","impliedFormat":1},{"version":"fa4cb5942c32913270d8531937197f7079a00b30575ece9f9104d458322f11ea","impliedFormat":1},{"version":"7b2931a3dc2f5763f1c21e43ee77d84ac2948d856e898e82b5170afd3bb27f7d","impliedFormat":1},{"version":"f98c3ccc9432ac0bacc0bc6badb12c47c96d54047cf8354cb65f043676604908","impliedFormat":1},{"version":"bff981ec6fda1d51d623def8ec50eccdb1eed0c4aa590e59ed4cfef37937d58d","impliedFormat":1},{"version":"9d9a89f57de4a0b0b0edc7e4b52395641e706857d85265dd641393a50b7916cc","impliedFormat":1},{"version":"11930cdf44a5342fda183383f32c86a545ad1b44c59f82735712d96071ecbef5","impliedFormat":1},{"version":"ea52f717b11605a85c084e98df50fce512427239c1540abdf4d776ea209d2bd0","impliedFormat":1},{"version":"3bee467b848a4ce3f4fb0a0f5dfe98ad21b2a24f01f92f6ae13622f415a4337a","impliedFormat":1},{"version":"4e48c24bd34e243992a0c76e865960ad673968715f06ca538cdd8a3831078284","impliedFormat":1},{"version":"33e896d46ba37a73ffadcd2d152496b507df18d18f0f8ddf548226fbca4663df","impliedFormat":1},{"version":"2416fefc4e7619a88cb087cd924396f25f15a0a2d2d4508c48fd1e55ae495fac","impliedFormat":1},{"version":"0e11723ecf54e2f17340a22dae331a682c89d2018eadc12fcd283cb85f05d701","impliedFormat":1},{"version":"25f406f42f20b1ef646e7d00f30a2c0e54e13e8bf156b5c306b21f9c74d58ce6","impliedFormat":1},{"version":"440299b618dac08f25a7a1d03d06bb9930d20dc5911036cd75964acb404f0356","impliedFormat":1},{"version":"157e26d7f98dfe9c7c362161caadcd7cf00d78f929ccbe88079ab6e3452d7ed5","impliedFormat":1},{"version":"e12a0b0d8be6bd636d30de009d3db4026ff4e0cfd310f9aff358a36f037730b1","impliedFormat":1},{"version":"ccac0a50e62c647b8666bbfc81ae51713fafc2659b0a7fa995d7997ca06152aa","impliedFormat":1},{"version":"cc64154e7a9fabe3bb609a2bf2b795b4a48a6d41fab8bc9b1e35b5ef3566a2b5","impliedFormat":1},{"version":"4843d919bd38424546a4d254e616b82674f30ab7f515486cb2339234c5b5d354","impliedFormat":1},{"version":"06cc3f5a14e6da417bd0d7ca61cec620cbf0c008afff9350912cc0bf3e95a484","impliedFormat":1},{"version":"76a6e9828d050c96cccb5cf21036379fa3256f6a12429b329cab57eb2aab6b37","impliedFormat":1},{"version":"60c038ede51a9778431f0a1503a0be17950617d78df358e6243e4e1e1d68a3a9","impliedFormat":1},{"version":"c3d5bf4c14cef22b651b4e6d07bfac107915f3bbbe4b5d024a0bdf8dedf53764","impliedFormat":1},{"version":"cba4393b25991696dbcfc17efd678ef0797329f2440c971b9e27ed3c9a5c7791","impliedFormat":1},{"version":"1dbd2da310e9c51fda3c2b7303165b5c63ff51bdf572c3d461662367fade9d9d","impliedFormat":1},{"version":"8c5fc128c25036bd4d75f2a35340024dddf3d578f66e6b9bd3763a7794255dc9","impliedFormat":1},{"version":"99a383ac35180903faf7ed423d43e78bfe7ea0c5fdb7ae753138f7eaddf207e1","impliedFormat":1},{"version":"390c9a3738c95dce3c3f7ae08f3caad79ebcc9f303610a6bb2b8692a726d0864","impliedFormat":1},{"version":"9ed4423ca28d5ee00f98928f38aa92e66e91d414b10eaa0275e463ad809da18b","impliedFormat":1},{"version":"64539cee046b05e5e8c3ebd08555da25a0507265c3ddeebf9684c7c25490afac","impliedFormat":1},{"version":"5a156dccfc9e3b5ee1d90483da76f7e3c7b6f57767cedd5bd1cd3b98ff6b7d95","impliedFormat":1},{"version":"9cba07e73ec8e3e24566b1c8fa1e200d27c3cba6c663525be11c9ca461f3d8ae","impliedFormat":1},{"version":"b6bf3fb51b61996e6f3c867ea9a9be4f7119bd3587ff3c7e064a477e20d557c0","impliedFormat":1},{"version":"89af23ab75c75234f8ce2eda07b06f673b74377219475a6e26efee618c9e18fc","impliedFormat":1},{"version":"06215a040b3de7ca21884bd0813ba7f0f4f952f119baab2d47b22aab455c76e8","impliedFormat":1},{"version":"4654d31fe56a1d39189598a1573b0c0ca44df6386fb09a067e330d8bb92cfd97","impliedFormat":1},{"version":"c08cfd2f722834652e49619212385dab968550f4e3c65cd6fef7ced4a9db99e6","impliedFormat":1},{"version":"09e93e9ec9aa0fb3a773f7db69bf2dc6172c8940c525dc7ddc235bc25421e631","impliedFormat":1},{"version":"d1cfb5a16cc5840816aa8f79f9ddb822225ecfab8037b8948857632b54d62428","impliedFormat":1},{"version":"aa6887fa98b1ff44a9a7a15844c297192a69c31544e6d441f994effeb80a9656","impliedFormat":1},{"version":"01e1875576c402c55fba21c7baedbaace359590063b0a0ecb0e9a6b68b84c5d0","impliedFormat":1},{"version":"0669f5afe85ea27627148bd9f79c24ff9ebe1e044a5644c0bf7a9ff6f9d129c0","impliedFormat":1},{"version":"2c154b21888113f15d19bad996b2baff19e9606a06c0b9e9b5ac84cdac5aa2fd","impliedFormat":1},{"version":"f508570f9742651d3c4442289fd0c26aae65a3f5ca3eafc2dba42e2059ad3c58","impliedFormat":1},{"version":"b8bb685509bb16aea6fa4940e2be439abeb99dcb4536cf194a673dd8540ce6f5","impliedFormat":1},{"version":"dede904817a20083b21d9ea9db77194aa606cb36ea6514710d68cfaa98b6a2b4","impliedFormat":1},{"version":"585cdb6ccac34f76c3c87e74a44ea1ff8782e1c10db205670b54b7b746998bca","impliedFormat":1},{"version":"33cfcb18b5fc49ce357e115ca2e8e15621437e8d1aed6f637e9e0a172289a401","impliedFormat":1},{"version":"64b5c8a44571521baf8653e869afbc30498370fd5b8ccb72d40bc537592eec59","impliedFormat":1},{"version":"85c72d0ae508f70ac95ea420ff28c621d9e26907f3deec3b189ab4caf4460363","impliedFormat":1},{"version":"603086eae37e4f5e89f4d50999eaa4e8b1a681868af167ee3c64596c9a4bd39e","impliedFormat":1},{"version":"a730b338a9555eeb46dd7bc218c5adf2d919d2ea1372d415c79f77857fb5bc27","impliedFormat":1},{"version":"63adafaeea1ff08a930e72c28c6e1f718c431d45efce62b66f1f4dd7be20f695","impliedFormat":1},{"version":"7e1576d2961371775a8d18381b1aaabfc5e8149b36efa730b12f7b6f294fd83f","impliedFormat":1},{"version":"6d6101c035aeada94c99cd939c44a1e54d3a6d6aa087269c415139e26a141157","impliedFormat":1},{"version":"a51f5e7c625de14bedf977194dc842b6d900ac91489e4378a3c457f9adf9743f","impliedFormat":1},{"version":"dc29f5b002a93dd5ac6e38305772c956445f8385cc50f50474f882e3213f275b","impliedFormat":1},{"version":"c761d1f373b39d2cd63a774bcd37e48dfdcb24b135cf18fadea2350131286748","impliedFormat":1},{"version":"c49a57303d04ce935767bf1847cf9f0ea13dd3f1bfd7d56cc9d38d0048e43e3d","impliedFormat":1},{"version":"435960ade236d539fe83868ca82ab67bed5184f64e1fb9fdf96f408856f42371","impliedFormat":1},{"version":"ef8b784848aa05a9b99b390d0402c8ac29f21eb4ed91bab42c758c3ed38c358c","impliedFormat":1},{"version":"0bb6f1c50ae58270d7e24a66048b17f57bc125823f864b95cec560f6561ff1b1","impliedFormat":1},{"version":"3a50e263c986b54e09f2bde8a854794c63a8be7c1437f1f6071c936fc1b019e7","impliedFormat":1},{"version":"06f72f7d0e35d26f3dd47b6b57c8a9336a25c61b9f6b786f68cb4866bf3012cb","impliedFormat":1},{"version":"332f0b72cce4f5a3ee2f7887be934a15c695deeca8fb304f521efa5a86943127","impliedFormat":1},{"version":"08a10a4e6b6ed0e24767332627adaed2b2958b78696ed4d7dff97a317cd3946c","impliedFormat":1},{"version":"68561b31a64a4573fc2cbd922b30cb4dc2ae2fc4f6beb23de436a9ea9108f820","impliedFormat":1},{"version":"dfcd1d31f7ba84ba3edaae3aac584764207b66d76151f9af40e85ba620525179","impliedFormat":1},{"version":"f229614dbf0032bb720e9943d20cd0129eb98d590291a88b682d883263eec377","impliedFormat":1},{"version":"27cdd1d4c111d361a424ed15e36fa40077cfee493c9bc9f5237f5ec06c2bf50b","impliedFormat":1},{"version":"82e8ec085329e1d63a848eab740fbf88b95d21398c25cf8fa6f396aae6b1eaab","impliedFormat":1},{"version":"b6d01723410393a9e483a9d9ef141d9042a40b75debcab06b55a1a5aa46b4348","impliedFormat":1},{"version":"9ca105f96bc2276869df184bb15755577f15e8f8daf1089c5a8f8a39b07370dd","impliedFormat":1},{"version":"f9dca360f6cc359387f1865de34775a3022ea1b4f8ef0e80eeb92289809f4c58","impliedFormat":1},{"version":"3b00797c4162ff6737af0238991ac368ec617b2a8706ffd6a858b69567391784","impliedFormat":1},{"version":"4b08c4212f7ca2bdf32a6b07499c53d395ee2883b8b63d253f5cb9685e7ffdbe","impliedFormat":1},{"version":"e61c464a1d20c51cecfb486544c64efe954f678bc941f0cfdd5d8ea89463c74c","impliedFormat":1},{"version":"52ca5f549c59e5f2c61f9a7be4637736ed0194859e62c58490dcc56c2fd2a66f","impliedFormat":1},{"version":"b46401d4f052b77f1a7990bbdde52f8b769562f309d12c9d952a6774bccabcba","impliedFormat":1},{"version":"0d82354783e07f571c5201c11beeba2aa5fe231695c9774b362087969598f67b","impliedFormat":1},{"version":"a8f85a6a118f7d8e5a46730ec9c9516bbf51addc38c8ec71d760726983c3ea76","impliedFormat":1},{"version":"6672541dde7af1f5aaacd7d839926514bdf56fa4a3b41a46681c34e0f4d22f73","impliedFormat":1},{"version":"e804a651c3f9a9bd4fc41b2a8c8cf2fd2f42c91b9e2bbcf9fffc2eb5c786128e","impliedFormat":1},{"version":"c61189f3ae76bb34026919a459f56e4ed3a8250bb83ab197e2f4eeeaa2d011f4","impliedFormat":1},{"version":"70a4eae68f14e36cab972738120bb80da7f33b2cd154b8df4c2dad940dcf9011","impliedFormat":1},{"version":"5c3dae2ce3a109098c894cefdd2ebd7d53603def97a9ce684d712c980aa4e195","impliedFormat":1},{"version":"c1a5db5a0d9b320b8793fcb6fc192c7ea91c37cc281d8de4515b5668e8119137","impliedFormat":1},{"version":"b487c915d7c6ae60621329b636c8903f825e9f0298043203381fc0a8be32b035","impliedFormat":1},{"version":"cffafb72ee7193040dd4f0cf8fe01b6fa29c958406d913eb3ea44b51d9771bc8","impliedFormat":1},{"version":"789610eca8c7c3dc3253d6c96adaded28c01d7526c23cd23a96199863dcbfb44","impliedFormat":1},{"version":"ef9921f27669454f1bdbea03ed4adc249b9b60a5fd8e31d04187500bcc7c3455","impliedFormat":1},{"version":"8f21a84ba4c129891629349e5011a87dd6b2ca5878389af88f2cafbf5ed7371c","impliedFormat":1},{"version":"4700990c95ba3b9a4f66bd072d66836256ac0f0f9e7c9e5bca953d36f16de6a2","impliedFormat":1},{"version":"c604882c2fe653a2d0b2a4a684cdeb0f9dac15fca7846bc43f09b50009b437d8","impliedFormat":1},{"version":"6fd115938d9f324fc2272cad0abf9849698535423a2242449f5072f556ae3e3e","impliedFormat":1},{"version":"d41862577744a13d30eaaa35211dfecd41efff4f67045590138f8478ab37b0de","impliedFormat":1},{"version":"de44c2c27766769cedd67af2f32172fe3bc7479a88cc6734ae24df902efd219e","impliedFormat":1},{"version":"282bb499de9c1859f59d1b24ec83b6cb4281877ac334540f009eab821cde5a31","impliedFormat":1},{"version":"3fe13000ddaf7e1f48de39ebab62d44991a76d7e9327419681e143a11ae621d7","impliedFormat":1},{"version":"9b3f16d404593d1947f0608c2bbc5459893bc1a894ed12cc2fa2ee2dcfa4682c","impliedFormat":1},{"version":"a12300860b6638fe15cb21d33a6d951297f673127f316263eacf19fbedc18804","impliedFormat":1},{"version":"89dcbd539e286a9a18fb34587033c36368fa0bebc01f6dc9cb1612ac308ee5e7","impliedFormat":1},{"version":"18d5a807766f3e20a8de126f0ff6b5b47754198130ec210783d25a4da708dca1","impliedFormat":1},{"version":"bd8531446108a94ca23cdbb4ee43bed49fe36a3e57cdecc2222a2049b94ce397","impliedFormat":1},{"version":"26c43a1c84959ef47bd8a3a4e37d416b20dc171f6ff5c8ae31f8091b682789d4","impliedFormat":1},{"version":"299e7ebd102d94f275e271121219e3eeabd0d9823e00b3d5044a13a28c8777be","impliedFormat":1},{"version":"c848f0aaa8a8689865aac59c7862b98808d5d39ebe8b1fc8657689c3f4e8a717","impliedFormat":1},{"version":"bf489d3e13f696720dc69f94197e880d919c34d848b6cb4f2603358139a01979","impliedFormat":1},{"version":"de73ee94fa11e6251c1dd47cb83ded1d9431b039cda61ccfe6c8297b476d84f1","impliedFormat":1},{"version":"25969f8593fc8bbe1b9bc6e5dbe74bcc18b4e50dddad6fd57dd5663a0fba4479","impliedFormat":1},{"version":"948af0a408e814075bbbdea9e36e7111887df6c8fcd712554a6013164025b391","impliedFormat":1},{"version":"f14a4dd8284999df7f9003a7f97e0fbe12f07f799777949ef12f9071708c0626","impliedFormat":1},{"version":"46a251effd961c5f1b1d64296202f9e0d612d7f5f6d1eb005c4ebc87ffd5ffb0","impliedFormat":1},{"version":"0c975579b6a777da981e7c7d7e29380fa72fb37b033f70925079e2edc82e9f48","impliedFormat":1},{"version":"40667375363114a3be63b9f68eed8b7dfa8ccaaaf487583488fee958f3fbf12e","impliedFormat":1},{"version":"aef08c70e8a278e4a3665db88b1296e318dabf10ec419cb52826d7a91b250937","impliedFormat":1},{"version":"4e0ee10d03f6dcefd804f196edc88e3aba7177b5b8d378b84b32be57bf877869","impliedFormat":1},{"version":"3b42b52b1114d811068855eb3d3560037a83f179519b180dea1972ad95b2c50f","impliedFormat":1},{"version":"920d29cb1ea0578127f18660028c6f475ec07624e8e4e87b650ed4c9d531ffde","impliedFormat":1},{"version":"66543a201c8b02e54acdceb1df0bb660aa7b7f09568c22268e70f33249653a0e","impliedFormat":1},{"version":"e0ba45fb4053e8ad1b3f4d86426abbfcf6db0efd15f68334d091f3107161e000","impliedFormat":1},{"version":"dda2538c82452f2588fe1b7e38532b37c1b06e2d6b745c3e92e8340839f6d424","impliedFormat":1},{"version":"400d3e46dee9f0c4167184b42f5d42f52428aca2c99c5d1e432ddcd90e10cf52","impliedFormat":1},{"version":"e19c3d82aca40aae2010945d3fe6fd25c218144280338f23bfd1de38b035a686","impliedFormat":1},{"version":"974d7e20399031603df3cfe92a515917a9bece27eecad1edf66374cdd25509f8","impliedFormat":1},{"version":"638d6a8f69f8a34f82cf73077f954f9714ffed4b028631b27fd009e88eb69169","impliedFormat":1},{"version":"3e1688656894676cfcaf09521dd012b8eaf13504911d1d6691b95247dc6e9a22","impliedFormat":1},{"version":"4e63e52adcca36c8f0bcd5fc552b1cb06e6e596881f1d84c6cc11622949179db","impliedFormat":1},{"version":"c1e710d9452c99f9f71f474e35ec33fad5913fbb83434147c3d3524039a76fbc","impliedFormat":1},{"version":"f84f318fbd6369a31705a0d773ddcdd91a2bc652b4c3228a4b3307ba7fbcbfde","impliedFormat":1},{"version":"833ca2d22c42d2eaceff06990e259cacdf75b42949996b8253e2e93c6b6e130f","impliedFormat":1},{"version":"f314ac95c5aef8e1fa3c06c927dbd56e6cd8d2d6c58d77122af2ca7a256e7ff0","impliedFormat":1},{"version":"a72ff2573a2e7a67d9f4baea6797b693204bcd8355677fb13d823e0c25502f7c","impliedFormat":1},{"version":"65abe7bed0e8cb62737ff6caf34e01ac24f0e097ee7c6e7daa3c3ce18ffd1bb8","impliedFormat":1},{"version":"c38642771a6ba8ea9f2dd2f6f55d3108387e1c685542667b6206d20175ed3897","impliedFormat":1},{"version":"e0692b5a6927e8f6931cb7c5224e46442dd7b364585c34b7628fcf58ae28a1a9","impliedFormat":1},{"version":"2cc191154f30ea3208a6ba5b40d242b1310a2d0792090311eb305d6f8364ce09","impliedFormat":1},{"version":"71cd5e188ed23259ac548123fa6164d6c05f2ffb87ea556d70741519b96d6217","impliedFormat":1},{"version":"c1d2e55490307ddcdbab3e0f3b84e0207efd09a504a94042c47c2bf727213270","impliedFormat":1},{"version":"1d6fbadfccad98b47135816d55eb96591a0c83d65853b4b661c57ff6e29f1b93","impliedFormat":1},{"version":"d561d2b0bcdecd72adda823ff5ffe6fde57679437b2bb9dec57c3c5fc2a3d458","impliedFormat":1},{"version":"777de5e5d40b960693a724163d5bd0c26bec261eadfd3091d1179b06de3c9f16","impliedFormat":1},{"version":"b206fc1b08e25381593ec5dd1a24f2119219a3de6dcf83faab30adcc725a21ca","impliedFormat":1},{"version":"704780b49d8c8acd865a4ae1173614ee4e50ff302b1a0b6bd8cc0ede4ba24ff6","impliedFormat":1},{"version":"8d3cc5d08894674e0098aaf41cf21d3b614649e37a6aad8a5ee08f26f7bc5ae4","impliedFormat":1},{"version":"a3bd2688d426f203feb93d4fc4b0a07191c2deb4c7b9458e930499e25a469901","impliedFormat":1},{"version":"428fa5cdd913712477a0b40260daac8799845c07cad75197d2a6fcfbbe0941c8","impliedFormat":1},{"version":"5e43887723827bd79d122e3b92003e7c1a1891326ef411b5f159ca80f27ca9df","impliedFormat":1},{"version":"47a17d3eb855617b22b58aec440389ae31d117b624a487f71d7a445ae7c31766","impliedFormat":1},{"version":"e5d87b97f903dcd7655aab15b1a8e96d9835bfbecba09e62a481263690393043","impliedFormat":1},{"version":"7654414a4e0c95a22d34af230e057db437cc8ded99f950ba9829bec1a977fdb0","impliedFormat":1},{"version":"7cd8739db3c3ba7d36e005745ace3ed0be5f0117d08e65fb920eaaa66c9b1e83","impliedFormat":1},{"version":"58f57cef17ffc9c318cbcd46395e82ec6e4ae668eaee8243cfd4d35ae38bd102","impliedFormat":1},{"version":"5b544238e4ccafd1e53a07953a6082b45260a81cf91c2812357670f419979c17","impliedFormat":1},{"version":"5ef3faec43f77b6279e6cefca6ce15f09373ff2da39a0145a08a6e7ef47c9a55","impliedFormat":1},{"version":"8296ce504d5091c8e9679abbbb1e6b044d79b096927f6e5d37a2edb222cbea34","impliedFormat":1},{"version":"18fa03af639ffc9d01576d47ccf2161f2decb6bd18d4496904496fb78dedb1f9","impliedFormat":1},{"version":"b92d62dbd2ba77de2999f39d75d401974538f3b6764e5b8a5ec0ef33e306cee2","impliedFormat":1},{"version":"778e1fa2f8f95fa735c4005dc73ab8c6ca261f39e80ab6d927c75a6b01122644","impliedFormat":1},{"version":"9007f7269478f85c75703ceaf96966584f14d245785f78becd802ae9347e36dd","impliedFormat":1},{"version":"8217164e1d6157824d87b770009dee8b628d1f918cb9ab0d8f4fb585be739f3e","impliedFormat":1},{"version":"f8811d7c6c895ebcf107a8bd56a6d56840726770fff5730725ea0d6b7bc67ede","impliedFormat":1},{"version":"cf2e13410ce1cb7275d32624e0d174ae316c652f27f9bdd7bfc622f6b36a5a8b","impliedFormat":1},{"version":"41ffbb528b3ad54fe1455841d5f4fee190ea988b12818f78cdfb3139f605001d","impliedFormat":1},{"version":"21b6daacb70f14697d6fb8e080c1c5af967c83e48ae75be4d37af7f738d09c6a","impliedFormat":1},{"version":"63c6e774784dc8bf052f14d1689719543fbca5cdf80f1adafaac8439af7e93b2","impliedFormat":1},{"version":"9f05b6b1f4881b76f0838696b6a7a20ef372dbbe3ffa02edecebafee2cea5365","impliedFormat":1},{"version":"87886a4262b9411707ae89b00bde5af3413d988c7fa2068d03769a3c4d30e31d","impliedFormat":1},{"version":"b29f305030d9332ca12aa73efdcfbd5a20b829384ee75a1a2834700d69abfcda","impliedFormat":1},{"version":"c79665d5815e12300c1c0814cca578457ffc227b06163b7d0ae85fd503278492","impliedFormat":1},{"version":"7e25904b7e1555755b1add0d14da715806f47a448a3988b14a2d635d2a901399","impliedFormat":1},{"version":"71dfd307d37cc3221827fb2ccbd2b1bd83bd5c6547577337080028d7b7f5bc65","impliedFormat":1},{"version":"2e4ee33fdc0606c1f2f828184a0d5e5d9648db81d3a419a002f6cc8962c0e19b","impliedFormat":1},{"version":"b1b9d635fb4bfdc76600e5e2fa04089cce8bf7c2ecad022a8e167741286a8216","impliedFormat":1},{"version":"a1d1e789bbda38f77f8c02ffc1f74519dda120e3990236662a5e275ed39ddfcb","impliedFormat":1},{"version":"f98cd710b8522eadf95035c92b1e8e88cc9de202d4f373354b687ce6dd52aa8b","impliedFormat":1},{"version":"36602a018973de6bad54d41ef06ac815b6f3e2fc66c20a2b37f1217e4fb0f602","impliedFormat":1},{"version":"b0958ec1635b2c57cc60573f75ee2a09a8f551ff3a44f4dcdc1ae5b6bd32303e","impliedFormat":1},{"version":"bad1c5f4ce71b1f34a5955f66edb08b0c3c6d1a6cf9d4142395b17b580ddf59a","impliedFormat":1},{"version":"f90c46e1eafdbb70677a240763fa0a1b76b749fbf370e399a572695d016140a8","impliedFormat":1},{"version":"b2fc2f186c366bd55edc285b7bc732ea34174a6d48d3aa45ccace5263b5183c9","impliedFormat":1},{"version":"e698b0a9df5d822610bd68e81f07afb1662d6f28779ed34fc90e13ee1c9d68c6","impliedFormat":1},{"version":"cbfbcf035e9522c360d2901a1ded885c8df8bee0f8aa3401e5f7ce35adab0d01","impliedFormat":1},{"version":"10841f577aa5fe50a9a55ddf7af3be731dcfdfdeb7f3e6959b7f24011729405d","impliedFormat":1},{"version":"a46ff440b7a84f372a0b6e0ff425bd301c259483ae8d36c81112d9f3643684de","impliedFormat":1},{"version":"0f300bc9e507a76ffaa092981e712e53929b99cd487c43ce3ff23d535ec807ea","impliedFormat":1},{"version":"a6a4f30a730922d757d56bc923b28c25bf970184b45b2685965e3f763047ee87","impliedFormat":1},{"version":"db471c242af3991da0b5f0d44c92bf98baa93235fdf693b5e223141569b3b402","impliedFormat":1},{"version":"b7569461ece6fd0a4e2ad321403f0d3f31502c87cd3dbf50f4fdb2480020e062","impliedFormat":1},{"version":"d7cfb13c90fd5a8b71190161150cf340681e61bb6f5429c9149d8f6ff3d42165","impliedFormat":1},{"version":"24e1d23dc068149087215fbd9e97aa51f2e4107053ced1030c8ca40e920c963f","impliedFormat":1},{"version":"587833dfea22ea8a68f133bccd7de4b34c4540c5672f3efc67226645a130c656","impliedFormat":1},{"version":"936696a05e1359cbb70be55e8a06d21acf4397f4866a6c4aa1c275bf29c1b93a","impliedFormat":1},{"version":"7c9b2a3b1b0a2d2156d96108443475ca5ec54da8d7146d2ec774b9120a27e470","impliedFormat":1},{"version":"935b284e75c612e9fba0cb62de023662bb4f2c72a281feabc1bd4287217d15ac","impliedFormat":1},{"version":"68eb05e55f4a859accf4ae7995c65e082418abbcab61f95eab1e0d58cd31a16c","impliedFormat":1},{"version":"2a055a1b6ecb690c7118450173d81c6beaab67c83885ac07745c5f4a75e5af7f","impliedFormat":1},{"version":"659fea18af0a6c7d4ceb3181e690b03a83af98e8afa132ca5d255f682dccb6cf","impliedFormat":1},{"version":"d750ec5d4c4d9966b143a0b0e1dc8d7628930c3392792d8b830e802f9c29e876","impliedFormat":1},{"version":"fae92c75a209e06473dbaf7bdc524235e49c9b09e8e940cc4c05c67aaffd2cb5","impliedFormat":1},{"version":"5bfe5300abcd7be0738b58f07e9f96c8851a4a721f5c8fdd15d17a2e62cd2021","impliedFormat":1},{"version":"ae33156439dc439ca431b77d3cdb49a43df43244c104bc8bc2114b5bcb653c91","impliedFormat":1},{"version":"20045c6d228b9dc6ea3ffccad3ddd17a093f2a658e881b958c9192865cc75e54","impliedFormat":1},{"version":"9dc26b2ba05f3d519a4afa7374d7ab6d9a4887451f6eaaa072afbee4b440deee","impliedFormat":1},{"version":"5ed22d22379ad817d49e5f3eef03b8abebefe00668f14844e652d65238b1a242","impliedFormat":1},{"version":"bd341e8425a6006f2fe5ec1ca4812cf9f6150920e448907afa2c1dfd440ebf76","impliedFormat":1},{"version":"4d01a3827a89ee3d162adbb19e437f16158fa3df068810eed0136678d8564bf4","impliedFormat":1},{"version":"28ae9d666536a592bfe1febbeb1c0ff79899b6b10cdfd56f8922ad079a1d4667","impliedFormat":1},{"version":"5ec56a0a23a2f37ddc5aad3200c3ae1d7be8d31b66b0bef72af991179eb5914c","impliedFormat":1},{"version":"4bdf3869686676ffdfc30a5fb88ac7b43e1079db29dc1d37c50f6c0aa3f8b40f","impliedFormat":1},{"version":"e86e249853323d930573cde4ace8526a3104d3e47e999a430198c877dee2a394","impliedFormat":1},{"version":"efd992047503be590294653570b842847291a58f907a8616b3bab433e885a36a","impliedFormat":1},{"version":"e8f81efee48743f9381b279e78c91bb8b16d90c4450e5728f53ca4e95eb39c24","impliedFormat":1},{"version":"707205c9edb4bfbe5802ec030a68cc4259d4158223f88a0294182648064d6f5f","impliedFormat":1},{"version":"ac32f0a0c8639a2653b51c42a1f3740c9e8f34f15853c74d7054fa3b98b78693","impliedFormat":1},{"version":"72c668ec904792597d067d88acf55e453088d577f8c10a99f9f8c40862c25608","impliedFormat":1},{"version":"b6553795691b66d848fd5d848add5a49ef0d66364d2479d7ebcbd5e64eb56f96","impliedFormat":1},{"version":"6a697e35a1af52d8a1374c8837798424d700afb2eb7d9fbb92a8ec2cb2a3a338","impliedFormat":1},{"version":"de75853664b511c08775431138cdb495c1afcfcdc250eb960c6ee1f46e243547","impliedFormat":1},{"version":"446d5bf55f0fca6ba5e76e2f3873093453b63145539a81b41db129ec447f11f0","impliedFormat":1},{"version":"903047d330ea6dee2bfb97bd5edd2787be8d7c8d10e947d780daea3ebea827f2","impliedFormat":1},{"version":"ac8dd404572a2a02542d41ac450a77eee2800da19d1acf4201401bedb282568a","impliedFormat":1},{"version":"677251857b08766aeb88e4d4cff596dfbcf1dfa8fd0303c5dec2aa32a49bb720","impliedFormat":1},{"version":"a84cece5ef6579f5fc7e47964cb4d127d625ce3c617a8d3e62e9cf16db85b98f","impliedFormat":1},{"version":"28163bf385b5c2df16b457e65f8021ec4bbef669eb8374940e89305afeaf7436","impliedFormat":1},{"version":"0060d03c9ed27788d77e206a1d4f82447347f0d466cf971eeee71de58982544a","impliedFormat":1},{"version":"c17d57c6ef7d774e0348dd628ae1706189d9ba8149ebea6984f9fd9762a3a238","impliedFormat":1},{"version":"3a3cbd9222f32365b20ad68530f544b3a54bad13f5585c146e6ed902c6bd600f","impliedFormat":1},{"version":"d09dbfa43c16ddd9cdfcbef9fe3cdd0b70ccd8cca66af8bae4319887a36a7721","impliedFormat":1},{"version":"fd44ea17c48783598c3016202954770458813ce2058072ebd0d802a2fa170648","impliedFormat":1},{"version":"e4ade9c17d7b0709ab848dd970d57487e1e753343876251a31262ff4622a68f5","impliedFormat":1},{"version":"642b4b49135dde4adc5ccbaf33ac280bd7eb7dd3910a01b1eb3cf5d016d11ceb","impliedFormat":1},{"version":"c06f7cb162d97ad55200648516c86d00eb6fb1df2831306b92edfbecf8c82eb9","impliedFormat":1},{"version":"53a35a5a58accd7836eec8942fb9c77698632aca175c74c0c97b32baefb9a408","impliedFormat":1},{"version":"88acbbc99f8fc50d1ee88ba8d3231ff6543c4ca9352a42c4dfcb3708f667b0e8","impliedFormat":1},{"version":"09afe86c0df7e4468314ad1036d20130ea5164d4753933d8ca6f5011e43bcb33","impliedFormat":1},{"version":"337f186a35d7facfc38ff2015ae4148fa02077b054f752fa133708fb26a39524","impliedFormat":1},{"version":"222e2ab6901e979a2c28e6c179b2ffecc203d3bb362e8f9452c45b2f97bafdae","impliedFormat":1},{"version":"887f8af936e698ed41ca24c51ef69ffcacef24f9e682753da2d25a03b21b9604","impliedFormat":1},{"version":"b62f7bbb9633dca8e9453306ecaa51ef048c08c4f6819e070101588d58153831","impliedFormat":1},{"version":"e1028569bddd9979216bd1d9cb20c5a8945548768204a0c73c8732906e3e2da1","impliedFormat":1},{"version":"a48410f6ef6f7339b83e3509f2eed56f949c5a0809ca169268d16339ad63f63f","impliedFormat":1},{"version":"c8463e51ad9e12fb823b4d47f382e9835df3857746ae375e98fe2a56b07500d0","impliedFormat":1},{"version":"eac35b722302a87c456688b9404f66671b74af431c80856f2d869a757eb0477f","impliedFormat":1},{"version":"dd86481d34523ab04ea207b7928c8e35d1583d4cb99132db8089acdfc339a932","impliedFormat":1},{"version":"8b5c9823ef1dd3498ff35362237ff859d16bb63a53ac0aceae1444318bca074f","impliedFormat":1},{"version":"82c9a1e59d854feefb2d709c53045fa93dbd46f94102e3042f298c9e3af52397","impliedFormat":1},{"version":"bc7db89f094772891807a3d1f3eb2f7a33c2b89d22850fdf83d2b811ccc1df16","impliedFormat":1},{"version":"7a4fffc1cf5162b2fedb45dc930d8eb8ee09dd86335c4006fcb747f2006126d0","impliedFormat":1},{"version":"7f89d370e83de2bc12d862e038e2b866ddc693800c77d90e41fc8d9a35cc14c6","impliedFormat":1},{"version":"8342e27e4602a4bb00102b1d3c1437af09d405ebb50703bbe42d70f9dc728615","impliedFormat":1},{"version":"c6ac3d44686c16e4f668bc281a04492c812f932160556fbdc5698f70bea48b67","impliedFormat":1},{"version":"a6de1ed396618d836741334fde08d8378f8639837eded06447bd9e84ad876d56","impliedFormat":1},{"version":"1ab2cc945a4d7955a2699cbbc0a076300e813ae22acfa94b6df46a50cd54990d","impliedFormat":1},{"version":"c41364ddf1d8f9206da2a07db0303fb361360b8d34d5fa11801f38c06ac03f24","impliedFormat":1},{"version":"c8c83541b3d9a11fe4dd772e470940da8dca51c504141b55df8104a669bba823","impliedFormat":1},{"version":"acaaecd0b6be7cd04d93836f8ce62e8050ac7ea30e12e25e1827f0e0fc98d15d","impliedFormat":1},{"version":"281175f0f5fbd3997ef1c3465b1442360fcbbabe98449b0d4795c23db82dac63","impliedFormat":1},{"version":"1ea1a927ff48e8f628c47d76440faefa8ef51a273fedbbd8d3ecd7cadb8f93ac","impliedFormat":1},{"version":"abf8b03583cb35edfb9db635ed54a8fd9eda907d0fc0beddf82792a5dee5abbc","impliedFormat":1},{"version":"2afd178f0fb6995e148df3323f78538a919a74bd187a362a571c4adec430e3f2","impliedFormat":1},{"version":"e3cc97f69fa705920a1b23997ad8482c899134c74ee5c2f26700a79669df92bb","impliedFormat":1},{"version":"e8db29f898b4dadb807606a52f8ed402820a31dd5590886e92bcddeb723da72c","impliedFormat":1},{"version":"ae852be67f8c5b4640ad5c049ed64c698a9c052419e7fb2291d2f6e3dc4bfd04","impliedFormat":1},{"version":"34155fbd265a7d4acd8e9f6ad4ca4858b334b299bc50e2caad0da312dfc562ed","impliedFormat":1},{"version":"d1156e8968571d98842fd61c674dd5a4d2a5723091587aa9e5089c6cdb4f9721","impliedFormat":1},{"version":"f8f3d2463d660478c7edc8daa7836d22ea5198f4272a21b42488947f43aced26","impliedFormat":1},{"version":"5915038ce6e77f361ef5357830811c4df0d23f4e8292ec4cbcdde1d13d405fd8","impliedFormat":1},{"version":"e49dea023d8ff426c4b7d1afced98b800c0fa4409cb432b2532258e6d260aa9c","impliedFormat":1},{"version":"f1a4facb20321171798570566f2cce0e9b7ea6db78b923680b7f89fc3810463f","impliedFormat":1},{"version":"3ba42f812de6647f43595cf65421042458282748e664ec3d9d40397fe7ce1567","impliedFormat":1},{"version":"2864d71a69acac55de765156d753b14c3d3206815e3c0cbfb36a83147e01aac6","impliedFormat":1},{"version":"610da6c32d79ed9ab887f2439249e032b12e0d22f881486934deaaa87c74dd76","impliedFormat":1},{"version":"2a567cb3bb07dbb6866afbb58df882cfc0cf53179e01368afb23631d62f82101","impliedFormat":1},{"version":"d954a62d5394cc651837b0037b1b66250bf2c7923ec06a8d654e8479976ec3db","impliedFormat":1},{"version":"bdd08ccecabc6fd25962cd2db9a36badd9aacd22b76d6d6d94e9ebfb4a43b466","impliedFormat":1},{"version":"f7cd675804418069693463cb310ce0315badec17a5098aad870efff22876cdac","impliedFormat":1},{"version":"01ad28210b908b8416a7dd106be1e968db03210c1122ab5e721bc5519358eef6","impliedFormat":1},{"version":"9397213e432d3ac459cf1c5a35f32f4dd9294c77a4ff5231174603c0398d69b0","impliedFormat":1},{"version":"e1268f86a6cbb46f922a399e27c4a7d9f1a27c39d40871ae6673da0ad6062e47","impliedFormat":1},{"version":"10757cbc65d362ed155977cdec5112d241924bdd340f0c07493160dcf5ff4e83","impliedFormat":1},{"version":"73335226b094df55be24fb3bf59776ba6657e745bc47adc1ba756f378ab6e1e0","impliedFormat":1},{"version":"0d1cab35788e8f8108db82d674c9d9dbfcdcd5d0a0133155426ac225f22e3816","impliedFormat":1},{"version":"c266616f4d8275ca5d856c963057a24f4f46e86763dffdd6db608393aa3f7822","impliedFormat":1},{"version":"c4d03edaf216fca77dd9c57bfb3e87f232880f83ddf761f5397ad7b09b972e06","impliedFormat":1},{"version":"a5dad8776c0a696296450dcee6a433c0014798f5c9ed6df91d92b075d28a365f","impliedFormat":1},{"version":"d4a1ab6454edabb047a652224d2d4e388e357565daa5168dc565ce42dbb96a0e","impliedFormat":1},"7d9756e457e159ca8f370fe38454a0b84914cf822d4f899e513ebbac8b3791d3",{"version":"9ea6e9ab532fa8de8810e8a9052c9eab2296a296502378f47f737e0582269872","impliedFormat":1},{"version":"74f605503adcd6a36cf1de181206d2ab5880521c051981553a7c9d7d236ef49d","impliedFormat":1},{"version":"a7450dded063e9622cf8d4dd92de4400434258d667a743de781220406de12c1d","impliedFormat":1},{"version":"b95c9d0fe17c1ec6eb23966dc163ef425891848120d7a5ff14606ce6dae5c6c2","impliedFormat":1},{"version":"21538fa5cdd8205ddc750b0d2fa6f6e7407f3f6eb31c5925c47d24e293aa3f96","impliedFormat":1},{"version":"1ce8936c6da4ad1a5f9c2b78425b1f4abf5ffb47008eebbaf569ce0c54c1f6ab","impliedFormat":1},{"version":"bfcb3cc3d30f1ddea7675576620ea2c6c05ee64a6a46a8f72055bde3a638430c","impliedFormat":1},{"version":"96553316f1b94ecf6bee92cf1fd87f13b0ffc3d40f9f85b870461a590f01bda2","impliedFormat":1},{"version":"4e02b9b69da20dee1a03f02aa3870e0c6587e3670470796e2910158fe29bd880","impliedFormat":1},{"version":"1ef57cc01aa0900b8d872bd61c5bd47e77c068fc27eb8cfb1db0e7300fb79072","impliedFormat":1},{"version":"76e24948763837ac222399b0a31dfc659dc258e415a087e79a675d7cf9d3d180","impliedFormat":1},{"version":"a85c634563da2073b2c7714c122810df4516b88a2841d72adf22ea48dd6d451f","impliedFormat":1},{"version":"2d8af7ff014049ae4fe5aa8f3b64d7aa1c95f0191acfa66d51558ed3a3342c72","impliedFormat":1},{"version":"ce4ad3c4c4d37518449fc4b9d617adf515c609bdb75edd55a848ab21c58344e5","impliedFormat":1},{"version":"5accf437c8038d6a292e04f35e5d0b81f016ee12687fdb407ecf10f0be16d696","impliedFormat":1},{"version":"3f2ebc0aa42308186cfea7fb982137bf187616eb2a25fa461f4cfe7c808c7b24","impliedFormat":1},{"version":"cf552c5b05127517927f7092dfc0e5f8b8cb44da89ca9b143f138e440da83928","impliedFormat":1},{"version":"609c626748b80087df8491b74babb00ee2aa240da00c707ef2dceb917a6fc7e7","impliedFormat":1},{"version":"691e9cb62082b933fac7fd42df816df92f860469d8070ff7a66b53728a5e9a79","impliedFormat":1},{"version":"0a3614638926e7ffacf176e84f79416c7b4deba493eff135b64b525a729229c9","impliedFormat":1},{"version":"c67acdb037e34ade075e9a5298ff969e08bcb429c968d605b210507ba15c9367","impliedFormat":1},{"version":"fddba56dbe419a1056aff38674a143f7ca37d4e0558209dfc1474b4bd37ec2dc","impliedFormat":1},{"version":"aed6460bd45a438fb63120348a7c32f3cfcc3ae737d2bb7b33eb598526a86722","impliedFormat":1},{"version":"db636302bb5d286792aa04218f6ae24b717c86f3ef1a31f203ebcdbb7c3e205e","impliedFormat":1},{"version":"f6b359783c9abfae7b92c5b433c8cc908273f77ab7a3b7396eb5d786f1db32e5","impliedFormat":1},{"version":"af44374f6e808be4f7f3fa5888b9c7574dca9f8a15a66d54b6763535802c8080","impliedFormat":1},{"version":"d679d04560a300b608e18b29ffd200be59eea60c261c41bb2794cea9f74a9da5","impliedFormat":1},{"version":"7d19bc397e6c40f2cd44ec11876460e7ddef830b129b0e059dced7b28b56da23","impliedFormat":1},{"version":"20ae63a113bcfe50ff806ef4e9803ac0b464fe7ec2b490935a2177ea5d493478","impliedFormat":1},{"version":"45c146e5a3036b19c085457b46e207ca75044cdcf45e43b198dd68b01a1b10a5","impliedFormat":1},{"version":"ed33ce2989c14f8e72dd41d55b2a2e05a6280cef2cbdd1bb7cc870c81e801294","impliedFormat":1},{"version":"11f17c6203548910b58f2e2e8615df667207b3cf5af6210388ad30e753bcaa2b","impliedFormat":1},{"version":"d90e650ae3dcfbbc64c08002687e278d1f852c8336e5d3c1bf00ed2f7deadaff","affectsGlobalScope":true,"impliedFormat":1},{"version":"92541023be764ea118531d03719227ce832df6db2d36e8d16c6e73b1e94ede2e","impliedFormat":1},{"version":"dad14cbc46bd93480c9786cf2d1fb326a749e13f284049854760c7fc29a1dfcf","impliedFormat":1},{"version":"6b5f886fe41e2e767168e491fe6048398ed6439d44e006d9f51cc31265f08978","impliedFormat":1},{"version":"56a87e37f91f5625eb7d5f8394904f3f1e2a90fb08f347161dc94f1ae586bdd0","impliedFormat":1},{"version":"6b863463764ae572b9ada405bf77aac37b5e5089a3ab420d0862e4471051393b","impliedFormat":1},{"version":"233267a4a036c64aee95f66a0d31e3e0ef048cccc57dd66f9cf87582b38691e4","impliedFormat":1},{"version":"f4c6585fd872613167fc1a0b7897cd48cee1ee266798fe8a913da848bac2fdf4","impliedFormat":1},{"version":"91b4ce96f6ad631a0a6920eb0ab928159ff01a439ae0e266ecdc9ea83126a195","impliedFormat":1},{"version":"88efe27bebddb62da9655a9f093e0c27719647e96747f16650489dc9671075d6","impliedFormat":1},{"version":"e348f128032c4807ad9359a1fff29fcbc5f551c81be807bfa86db5a45649b7ba","impliedFormat":1},{"version":"8ee6b07974528da39b7835556e12dd3198c0a13e4a9de321217cd2044f3de22e","impliedFormat":1},{"version":"5e1d8a07714f909beaaaf4d0ffe507345a99f2db967493dd8ebbfbb4f18e83ca","impliedFormat":1},{"version":"5f12132800d430adbe59b49c2c0354d85a71ada7d756e34250a655baa8ad4ae5","impliedFormat":1},{"version":"1996d1cd7d585a8359a35878f67abdd73cc35b1f675c9c6b147b202fdd8dfc3f","impliedFormat":1},{"version":"5a50dbfc042633fdb558e53b30b0a005e0b78e142a1fe1147a8d6618ca69ec99","impliedFormat":1},{"version":"a8b0f3d8b205c32395727230bff7849c947150fdd6288855cbe75bc662c4e236","impliedFormat":1},{"version":"6fb55bb881f4a7167649e6925df076f64a1db2f50632df4674e4621a9445c954","impliedFormat":1},{"version":"4374cefdde5c6e9bad52b0436e887b8325b8f407c12035194ad02c28f1553a3a","impliedFormat":1},{"version":"9b70cad270593f676aecfe4d1611dc766464f0b8138527b0ebbf1ff773578d69","impliedFormat":1},{"version":"b4f85bfb7e831703ac81737361842f1ae4d924b42c5d1af2bff93cca521de4d1","impliedFormat":1},{"version":"5fea76008a2d537ca09d569ffae4e08b991b4a5ff90e9f4783bc983584454ede","impliedFormat":1},{"version":"21575cdeaca6a2c2a0beb8c2ecbc981d9deb95f879f82dc7d6e325fe8737b5ba","impliedFormat":1},{"version":"40ec58f0fadd0b3981b3d383e1c12fa0680115ae9f018387fc2cfc0bbcf23204","impliedFormat":1},{"version":"849b9e7283b7309a4556c9b90bb8e2dfc27751f157798065bbc513dcddb09a8c","impliedFormat":1},{"version":"10e109212c7be8a9f66e988e5d6c2a8900c9d14bf6beadf5fa70d32ada3425cf","impliedFormat":1},{"version":"2b821aeb31e690092f8eae671dd961a9d0fd598ff4883ce0a600c90e9e8fa716","impliedFormat":1},{"version":"26602933b613e4df3868a6c82e14fffa2393a08531cb333ed27b151923462981","impliedFormat":1},{"version":"f57a588d8f6b3ce5c8b494f2dc759a8885eaee18e80a4952df47de45403fedbe","impliedFormat":1},{"version":"34735727b3fe7a0ed0651a0f88d06449163d1989a2b2de7f047473adc7c1c383","impliedFormat":1},{"version":"a5b13abc88ab3186e713c445e59e2f6eee20c6167943517bc2f56985d89b8c55","impliedFormat":1},{"version":"3844b45a774bafe226260cf0772376dce72121ebb801d03902c70a7f11da832b","impliedFormat":1},{"version":"7ae65fe95b18205e241e6695cb2c61c0828d660aca7d08f68781b439a800e6b8","impliedFormat":1},{"version":"e025419f23ccceafd7f5ab3141a86a6bb9fc3b33c44fe62b288d7b19baffc95b","impliedFormat":1},{"version":"369b7270eeeb37982203b2cb18c7302947b89bf5818c1d3d2e95a0418f02b74e","impliedFormat":1},{"version":"94f95d223e2783b0aef4d15d7f6990a6a550fe17d099c501395f690337f7105e","impliedFormat":1},{"version":"039bd8d1e0d151570b66e75ee152877fb0e2f42eca43718632ac195e6884be34","impliedFormat":1},{"version":"89fb1e22c3c98cbb86dc3e5949012bdae217f2b5d768a2cc74e1c4b413c25ad2","impliedFormat":1},{"version":"d3cfde44f8089768ebb08098c96d01ca260b88bccf238d55eee93f1c620ff5a5","impliedFormat":1},{"version":"293eadad9dead44c6fd1db6de552663c33f215c55a1bfa2802a1bceed88ff0ec","impliedFormat":1},{"version":"206e73f49f16633113787cc651dc03dc900379395dfa02ab1ef4c9cbbcd5adc2","impliedFormat":1},{"version":"f12edf1672a94c578eca32216839604f1e1c16b40a1896198deabf99c882b340","impliedFormat":1},{"version":"e3498cf5e428e6c6b9e97bd88736f26d6cf147dedbfa5a8ad3ed8e05e059af8a","impliedFormat":1},{"version":"dba3f34531fd9b1b6e072928b6f885aa4d28dd6789cbd0e93563d43f4b62da53","impliedFormat":1},{"version":"f672c876c1a04a223cf2023b3d91e8a52bb1544c576b81bf64a8fec82be9969c","impliedFormat":1},{"version":"e4b03ddcf8563b1c0aee782a185286ed85a255ce8a30df8453aade2188bbc904","impliedFormat":1},{"version":"2329d90062487e1eaca87b5e06abcbbeeecf80a82f65f949fd332cfcf824b87b","impliedFormat":1},{"version":"25b3f581e12ede11e5739f57a86e8668fbc0124f6649506def306cad2c59d262","impliedFormat":1},{"version":"4fdb529707247a1a917a4626bfb6a293d52cd8ee57ccf03830ec91d39d606d6d","impliedFormat":1},{"version":"a9ebb67d6bbead6044b43714b50dcb77b8f7541ffe803046fdec1714c1eba206","impliedFormat":1},{"version":"833e92c058d033cde3f29a6c7603f517001d1ddd8020bc94d2067a3bc69b2a8e","impliedFormat":1},{"version":"309ebd217636d68cf8784cbc3272c16fb94fb8e969e18b6fe88c35200340aef1","impliedFormat":1},{"version":"91cf9887208be8641244827c18e620166edf7e1c53114930b54eaeaab588a5be","impliedFormat":1},{"version":"ef9b6279acc69002a779d0172916ef22e8be5de2d2469ff2f4bb019a21e89de2","impliedFormat":1},{"version":"9c20e0cce5b7f0a0a46c3a7717d3a9485456769ebfdfd6afa7b5babbcea6f86e","impliedFormat":1},{"version":"88863d76039cc550f8b7688a213dd051ae80d94a883eb99389d6bc4ce21c8688","impliedFormat":1},{"version":"b2732d3b39b116431fb2048679ba11805110bc94c7763d50bfbe98f2a1923882","impliedFormat":1},{"version":"243649afb10d950e7e83ee4d53bd2fbd615bb579a74cf6c1ce10e64402cdf9bb","impliedFormat":1},{"version":"35575179030368798cbcd50da928a275234445c9a0df32d4a2c694b2b3d20439","impliedFormat":1},{"version":"0cf1e5928aae1cca4dcd1a78e19a5833018b84829a116f8fbfab29dc63446a49","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"26384fb401f582cae1234213c3dc75fdc80e3d728a0a1c55b405be8a0c6dddbe","impliedFormat":1},{"version":"26384fb401f582cae1234213c3dc75fdc80e3d728a0a1c55b405be8a0c6dddbe","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"26384fb401f582cae1234213c3dc75fdc80e3d728a0a1c55b405be8a0c6dddbe","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"b42d3651103a532f7492e719a828647af97306b2356ae757ebb7f17f4a8c41e5","impliedFormat":1},{"version":"03268b4d02371bdf514f513797ed3c9eb0840b0724ff6778bda0ef74c35273be","impliedFormat":1},{"version":"3511847babb822e10715a18348d1cbb0dae73c4e4c0a1bcf7cbc12771b310d45","impliedFormat":1},{"version":"add0ce7b77ba5b308492fa68f77f24d1ed1d9148534bdf05ac17c30763fc1a79","impliedFormat":1},{"version":"53f00dc83ccceb8fad22eb3aade64e4bcdb082115f230c8ba3d40f79c835c30e","impliedFormat":1},{"version":"7d94df9d46f72799f956caf7409ae56bd7e754363b0ab6ea7bd865759b679011","impliedFormat":1},{"version":"9078205849121a5d37a642949d687565498da922508eacb0e5a0c3de427f0ae5","impliedFormat":1},{"version":"e8f8f095f137e96dc64b56e59556c02f3c31db4b354801d6ae3b90dceae60240","impliedFormat":1},{"version":"451abef2a26cebb6f54236e68de3c33691e3b47b548fd4c8fa05fd84ab2238ff","impliedFormat":1},{"version":"8e6427dd1a4321b0857499739c641b98657ea6dc7cc9a02c9b2c25a845c3c8e6","impliedFormat":1},{"version":"58da08d1fe876c79c47dcf88be37c5c3fab55d97b34c8c09a666599a2191208d","impliedFormat":1},{"version":"71acd198e19fa38447a3cbc5c33f2f5a719d933fccf314aaff0e8b0593271324","impliedFormat":1},{"version":"728210176ce194530dd0188e877bc371cfafdc415142e43b552421db2f53ae86","impliedFormat":1},{"version":"3579fbc9c3a50d12694f04b6003f917b6208520a86eb19ae6eda677a40e5154d","impliedFormat":1},{"version":"6042774c61ece4ba77b3bf375f15942eb054675b7957882a00c22c0e4fe5865c","impliedFormat":1},{"version":"41f185713d78f7af0253a339927dc04b485f46210d6bc0691cf908e3e8ded2a1","impliedFormat":1},{"version":"7390fbf07c0f9a8148db2824ce1a98dc59bb0156071bd7cb109dac908c120fab","impliedFormat":1},{"version":"ffc3e1064146c1cafda1b0686ae9679ba1fb706b2f415e057be01614bf918dba","impliedFormat":1},{"version":"e27451b24234dfed45f6cf22112a04955183a99c42a2691fb4936d63cfe42761","impliedFormat":1},{"version":"58d65a2803c3b6629b0e18c8bf1bc883a686fcf0333230dd0151ab6e85b74307","impliedFormat":1},{"version":"e818471014c77c103330aee11f00a7a00b37b35500b53ea6f337aefacd6174c9","impliedFormat":1},{"version":"dca963a986285211cfa75b9bb57914538de29585d34217d03b538e6473ac4c44","impliedFormat":1},{"version":"29f823cbe0166e10e7176a94afe609a24b9e5af3858628c541ff8ce1727023cd","impliedFormat":1},{"version":"e8ac9978254627080292510941044f198b5f5cfdbfff72ad9902bea291118e69","impliedFormat":1},{"version":"8ce1de69e7ab4958cb5e533392ed4c901cdc30ab9a546224f9703c63a5df4e78","impliedFormat":1},{"version":"dfb8b22512cabc48381767e72e07c6652ec64fcdaa63a4c795ab84359f1565d6","impliedFormat":1},{"version":"31c30cc54e8c3da37c8e2e40e5658471f65915df22d348990d1601901e8c9ff3","impliedFormat":1},{"version":"c946e094f499b021f43a3f3370301e7a5c9e0a243bd5f93cf68f2a8ff53c2400","impliedFormat":1},{"version":"89783bd45ab35df55203b522f8271500189c3526976af533a599a86caaf31362","impliedFormat":1},{"version":"26e6c521a290630ea31f0205a46a87cab35faac96e2b30606f37bae7bcda4f9d","impliedFormat":1},{"version":"70f376fa1fa13fbc5960ca54377dcf934475df58e9ced444c8b8727608ff317c","impliedFormat":1},{"version":"ca089e254c910d60f64fd89ecf5f7ff317c3e46b717cd559ebe574920a4e6b0f","impliedFormat":1},{"version":"3460aae63957dc499119df5a7a4c2aec3f8681399bd33d0a7e964ff17a55c045","impliedFormat":1},{"version":"de82d1ee854ca89e53d55b96de7c7f77b50ad54c4e73db31f82842b9065f86c7","impliedFormat":1},{"version":"424e6ccfc8aa04bb3e99d8eb3b5253fb66bc7acc850bef0a70d31331a15a36c3","impliedFormat":1},{"version":"d96c74af430b70d287d3c0060203b554e67760dc9698288c42bf5e6250229ce3","impliedFormat":1},{"version":"4d10d2ad1e05bea9079a338d573960eed2919d56311767a8796f01b14093b521","impliedFormat":1},{"version":"b97bb9701448c80ad4676e524a975e55e45217331cba01629a63e8309d401fff","impliedFormat":1},{"version":"81ca953deeb951a5685ed98d03101d21445499713452fd0e328f1b0c03213415","impliedFormat":1},{"version":"b2b2e08eef3d923eeac72c6cef352e444cd32061df522d94a28033a4ddb582ca","affectsGlobalScope":true,"impliedFormat":1},{"version":"fdeb2f20be3d9a425fff7db2f1071a42bb666ce9bf375a97c12983a64303cf08","impliedFormat":1},{"version":"1179ef8174e0e4a09d35576199df04803b1db17c0fb35b9326442884bc0b0cce","impliedFormat":1},{"version":"064beebda02cc2d49244c112fef0cec330f917469446888fc7d47cf626a68aff","impliedFormat":1},{"version":"48f116877c42db7ec3e5706d7f173bc67eab30fb75dfb9827be3dffa7132a768","impliedFormat":1},"b8f3114cab023ee26ced948eafd8b55b612a81d936495807a742e9c17fc742ac",{"version":"3ed92a15fb9f82a4c1dd3dd0ec6b8a17528e03b32ffef4723a521f691af737f0","impliedFormat":1},{"version":"5b122ff18807e1f86669c2cfeb8028c11a015c96066d102cd60f15f587bc4816","impliedFormat":1},{"version":"caf208a0fee7f1ff128fb9bb056c48bdf24053bb266e8f49046af23516355075","impliedFormat":1},{"version":"93c41a60134747e543cd69e229b55aeb0dae5b526b422d89b046b66765929dee","impliedFormat":1},{"version":"06080047b204b0dccaca8d8aa65839a4ee850c483638dc9f841699a9e044155c","impliedFormat":1},{"version":"2be9a4eaab5676f6d9247abeab262a23e67b0a63690d78553b08ff37f22087f0","impliedFormat":1},{"version":"1f1e1dfb84d3b264f6b293eb74cddf0f0abe6167b30c371a78d65c43a76ccf16","impliedFormat":1},{"version":"4f9f152d0614311a0956c204cb30f7c7d3dd3ced99e33384eff2afad61abb11d","impliedFormat":1},{"version":"b70a5bf59b4582cadc7d509055c02a293cbba1ab5a39f09208189fe338a2a9f5","impliedFormat":1},{"version":"516f5cbe8a88c68a5493da43dae904e595fe7fb081608d42a7b226a3e1fc5753","impliedFormat":99},{"version":"348c13a1c9160681e41bc5cd3cc519dd8170d38a36a30480b41849f60f5bf8a0","impliedFormat":99},{"version":"576be63cb6921d0aafc8ce6af43f0f19185414fa2f0b4422d120f9d48d97e9a2","impliedFormat":99},{"version":"279248c34ecd223fc46224f86384ebf49c775eb69329ad644d3d99f1205f3e7d","impliedFormat":99},{"version":"74dedffc2d09627f5a4de02bbd7eedf634938c13c2cc4e92f0b4135573432783","impliedFormat":99},{"version":"1f2bbbe38d5e536607b385f04c3d2cbf1e678c5ded7e8c5871ad8ae91ef33c3d","impliedFormat":99},{"version":"54261223043b61b727fc82d218aa0dc2bd1009a5e545e4fecfb158a0c1bea45e","impliedFormat":99},{"version":"3aa3513d5e13d028202e788d763f021d2d113bd673087b42a2606ab50345492d","impliedFormat":99},{"version":"f012173d64d0579875aa60405de21ad379af7971b93bf46bee23acc5fa2b76a4","impliedFormat":99},{"version":"dcf5dc3ce399d472929c170de58422b549130dd540531623c830aaaaf3dd5f93","impliedFormat":99},{"version":"ec35f1490510239b89c745c948007c5dd00a8dca0861a836dcf0db5360679a2d","impliedFormat":99},{"version":"32868e4ec9b6bd4b1d96d24611343404b3a0a37064a7ac514b1d66b48325a911","impliedFormat":99},{"version":"4bbea07f21ff84bf3ceeb218b5a8c367c6e0f08014d3fd09e457d2ffb2826b9c","impliedFormat":99},{"version":"873a07dbeb0f8a3018791d245c0cf10c3289c8f7162cdbbb4a5b9cf723136185","impliedFormat":99},{"version":"43839af7f24edbd4b4e42e861eb7c0d85d80ec497095bb5002c93b451e9fcf88","impliedFormat":99},{"version":"54a7ee56aadecbe8126744f7787f54f79d1e110adab8fe7026ad83a9681f136a","impliedFormat":99},{"version":"6333c727ee2b79cdab55e9e10971e59cbfee26c73dfb350972cfd97712fc2162","impliedFormat":99},{"version":"8743b4356e522c26dc37f20cde4bcdb5ebd0a71a3afe156e81c099db7f34621d","impliedFormat":99},{"version":"af3d97c3a0da9491841efc4e25585247aa76772b840dd279dbff714c69d3a1ec","impliedFormat":99},{"version":"d9ac50fe802967929467413a79631698b8d8f4f2dc692b207e509b6bb3a92524","impliedFormat":99},{"version":"d00c8d21f782f32f55019f8622b37f1a2c73bd1ccc8e829f0fc405e1f22ab61f","impliedFormat":99},{"version":"b75d56703daaffcb31a7cdebf190856e07739a9481f01c2919f95bde99be9424","impliedFormat":99},{"version":"5d96abfba21d23de6d7b8fd72ce82f8f629655d05dd7dbf0aef014752388a646","impliedFormat":1},{"version":"0b3966c6f02e960565424bc8a448c67561a302e6ec2feb18ee717750b89b02d3","impliedFormat":1},{"version":"88e9caa9c5d2ba629240b5913842e7c57c5c0315383b8dc9d436ef2b60f1c391","impliedFormat":1},{"version":"66abaa063057efc875949f01df500f30d5e74e657498dca6112591a1377517b0","impliedFormat":1},{"version":"41d2b0e37d45d91dc0b8b78f22793558214f73bea2bf1e6c4734f88fc73a1abb","impliedFormat":1},{"version":"7e6f89e1e4f58c111436e061ff736a02ed87299db775e844fb5b219cace04cfb","impliedFormat":1},{"version":"94f9fd0713f4db66047aadf3faa10d073b1402e08c21bd19f9d2afb0293555b6","impliedFormat":1},{"version":"c49746421055b4d8c8dc578294db596c299edb399bfe247ad8f9953deb1578be","impliedFormat":1},{"version":"2f017a7f5c602218d9be7c2209261c292f76525b6d2b45169f36da71e5ff5e5a","impliedFormat":1},{"version":"487c48235e27770303573e1e21b88a72d4e2df3c4d325a299cb19c5a0dc4932f","impliedFormat":1},{"version":"8ff577a0014c6a1aa2c24b03f67b18b19e0879d35a47e8e9730b699de27ee4b0","impliedFormat":1},{"version":"970db1cfd6fc276c3ae13a1f19c57fd52a72e6dd770a781d5bf940e7da5c9730","impliedFormat":1},{"version":"77616d56bb434ef7e1d5cacdc235d6b82ae37109da1cf5f2961dcbe1f621d14a","impliedFormat":1},{"version":"721cedefff6f4f5a2618f009285ec25d5ca0cafa42675ec34ca1862f44f22234","impliedFormat":1},{"version":"41892a66fa459e6aed9012465e9ba0699a36abf6adbea66a6b83737eefb5488a","impliedFormat":1},{"version":"ce52d99cd22b95bb2553e764805c665ca9e713cca702cf83a1c48c16b7f66291","impliedFormat":1},{"version":"30905ecac19f2ef5c9bd7cf50ed3fe5c19acd1729354701a3bd6a847df51a34b","impliedFormat":1},{"version":"bcd66431c7004db8c1b335cf4dd303e4b502f24b0e7f489ca65d0cccb1680760","impliedFormat":1},{"version":"8dc65fdcf3749d89561a665a306b9314c54c925dbeb2b9f4a1e23abaa42fa194","impliedFormat":1},{"version":"d295f0cfe29e2ba22d96df361169d59036dc88a4808548c9ad561821cdaa4f17","impliedFormat":1},{"version":"719d5cee7dc75b4dcc5c8ebf7b5e57ef9b5ee337d219b82d87ea2cde911dac36","impliedFormat":1},{"version":"3bea19afe661852238fd171bd4b7784a92c476aa23fd8d4f6dfa4ede093012ab","impliedFormat":1},{"version":"920e38b56c65fb795c8ef7f27d5eabc643a78c9350c7a1c92db8e34d94c90a6f","impliedFormat":1},{"version":"977500036ff9cff73a99581ebcab04f2de0408e071667e6d436a301a915ac2c8","impliedFormat":1},{"version":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","impliedFormat":1},{"version":"8085954ba165e611c6230596078063627f3656fed3fb68ad1e36a414c4d7599a","impliedFormat":1},{"version":"7395811d012474ed9511a6c7235fbb444cf61b44c44aa6d8afec89d1ecc3a992","impliedFormat":1},{"version":"5ae8d0a9c74f62d19158db148460d1af2f8960dcba54dcd020609c6aadc098d4","impliedFormat":1},{"version":"d801d35486bf25ed55fd5ec4d712f7594406fc88ba8d343943453f61cb204b00","impliedFormat":1},{"version":"2507764807cac07d16eefdc18fb329f8462fcdb881e1baa421e39421845edc95","impliedFormat":1},{"version":"eb0c1263f5c5f52b4f5833d06cf608af4beaf8b420e015dae17bc7b21ccb3237","impliedFormat":1},{"version":"0943a6e4e026d0de8a4969ee975a7283e0627bf41aa4635d8502f6f24365ac9b","impliedFormat":1},{"version":"1461efc4aefd3e999244f238f59c9b9753a7e3dfede923ebe2b4a11d6e13a0d0","impliedFormat":1},{"version":"4e0000eac5905bfa478850584cff3723d41b2d4614f77172821858525bb2d4ef","impliedFormat":1},{"version":"c7cbb96cef832d7e4fd984497462ec0fb86c2de63bffe1b3cae75854f5e534c6","impliedFormat":1},{"version":"5f9e6acc51300a1231536076132ed47bb5cd68018b50642d9b9ebe2bd2e8aba7","impliedFormat":1},{"version":"9c580c6eae94f8c9a38373566e59d5c3282dc194aa266b23a50686fe10560159","impliedFormat":1},{"version":"d7f0ea688d1496dffe2838e71f00bcadd8cc9630a6ad95de50dd5328cf3ce17d","impliedFormat":1},{"version":"4a5aa16151dbec524bb043a5cbce2c3fec75957d175475c115a953aca53999a9","impliedFormat":1},{"version":"e9a4a3435625049d3378f4154365961cd4efd09a3b91d579ca4c959ecaa13206","impliedFormat":1},{"version":"1ab49e8e0a5a1f1ea8a0bb5443579134d2da6af9509038cb3b954bc146bb898f","impliedFormat":1},{"version":"5ca6bc807f656c894023de9345db3a4468e522758a0cd564bca4af8ec28347f6","impliedFormat":1},{"version":"24bc700786a512d55001d7117f50c13f99804252eacae1487e495c5e72cae560","impliedFormat":1},{"version":"a4d9b1808d727f1b3178204061c394d0e5f4a4359e8a75be6bd05d9daac53fac","impliedFormat":1},{"version":"40538c49ae142862c7296a4d6405ce8f9083ff09ea7c6195b7ee4a93adedd783","impliedFormat":1},{"version":"70521b6ab0dcba37539e5303104f29b721bfb2940b2776da4cc818c07e1fefc1","affectsGlobalScope":true,"impliedFormat":1},{"version":"030e350db2525514580ed054f712ffb22d273e6bc7eddc1bb7eda1e0ba5d395e","affectsGlobalScope":true,"impliedFormat":1},{"version":"d153a11543fd884b596587ccd97aebbeed950b26933ee000f94009f1ab142848","affectsGlobalScope":true,"impliedFormat":1},{"version":"21d819c173c0cf7cc3ce57c3276e77fd9a8a01d35a06ad87158781515c9a438a","impliedFormat":1},{"version":"a79e62f1e20467e11a904399b8b18b18c0c6eea6b50c1168bf215356d5bebfaf","affectsGlobalScope":true,"impliedFormat":1},{"version":"d802f0e6b5188646d307f070d83512e8eb94651858de8a82d1e47f60fb6da4e2","affectsGlobalScope":true,"impliedFormat":1},{"version":"5929864ce17fba74232584d90cb721a89b7ad277220627cc97054ba15a98ea8f","impliedFormat":1},{"version":"763fe0f42b3d79b440a9b6e51e9ba3f3f91352469c1e4b3b67bfa4ff6352f3f4","impliedFormat":1},{"version":"25c8056edf4314820382a5fdb4bb7816999acdcb929c8f75e3f39473b87e85bc","impliedFormat":1},{"version":"c464d66b20788266e5353b48dc4aa6bc0dc4a707276df1e7152ab0c9ae21fad8","impliedFormat":1},{"version":"78d0d27c130d35c60b5e5566c9f1e5be77caf39804636bc1a40133919a949f21","impliedFormat":1},{"version":"c6fd2c5a395f2432786c9cb8deb870b9b0e8ff7e22c029954fabdd692bff6195","impliedFormat":1},{"version":"1d6e127068ea8e104a912e42fc0a110e2aa5a66a356a917a163e8cf9a65e4a75","impliedFormat":1},{"version":"5ded6427296cdf3b9542de4471d2aa8d3983671d4cac0f4bf9c637208d1ced43","impliedFormat":1},{"version":"7f182617db458e98fc18dfb272d40aa2fff3a353c44a89b2c0ccb3937709bfb5","impliedFormat":1},{"version":"cadc8aced301244057c4e7e73fbcae534b0f5b12a37b150d80e5a45aa4bebcbd","impliedFormat":1},{"version":"385aab901643aa54e1c36f5ef3107913b10d1b5bb8cbcd933d4263b80a0d7f20","impliedFormat":1},{"version":"9670d44354bab9d9982eca21945686b5c24a3f893db73c0dae0fd74217a4c219","impliedFormat":1},{"version":"0b8a9268adaf4da35e7fa830c8981cfa22adbbe5b3f6f5ab91f6658899e657a7","impliedFormat":1},{"version":"11396ed8a44c02ab9798b7dca436009f866e8dae3c9c25e8c1fbc396880bf1bb","impliedFormat":1},{"version":"ba7bc87d01492633cb5a0e5da8a4a42a1c86270e7b3d2dea5d156828a84e4882","impliedFormat":1},{"version":"4893a895ea92c85345017a04ed427cbd6a1710453338df26881a6019432febdd","impliedFormat":1},{"version":"c21dc52e277bcfc75fac0436ccb75c204f9e1b3fa5e12729670910639f27343e","impliedFormat":1},{"version":"13f6f39e12b1518c6650bbb220c8985999020fe0f21d818e28f512b7771d00f9","impliedFormat":1},{"version":"9b5369969f6e7175740bf51223112ff209f94ba43ecd3bb09eefff9fd675624a","impliedFormat":1},{"version":"4fe9e626e7164748e8769bbf74b538e09607f07ed17c2f20af8d680ee49fc1da","impliedFormat":1},{"version":"24515859bc0b836719105bb6cc3d68255042a9f02a6022b3187948b204946bd2","impliedFormat":1},{"version":"ea0148f897b45a76544ae179784c95af1bd6721b8610af9ffa467a518a086a43","impliedFormat":1},{"version":"24c6a117721e606c9984335f71711877293a9651e44f59f3d21c1ea0856f9cc9","impliedFormat":1},{"version":"dd3273ead9fbde62a72949c97dbec2247ea08e0c6952e701a483d74ef92d6a17","impliedFormat":1},{"version":"405822be75ad3e4d162e07439bac80c6bcc6dbae1929e179cf467ec0b9ee4e2e","impliedFormat":1},{"version":"0db18c6e78ea846316c012478888f33c11ffadab9efd1cc8bcc12daded7a60b6","impliedFormat":1},{"version":"e61be3f894b41b7baa1fbd6a66893f2579bfad01d208b4ff61daef21493ef0a8","impliedFormat":1},{"version":"bd0532fd6556073727d28da0edfd1736417a3f9f394877b6d5ef6ad88fba1d1a","impliedFormat":1},{"version":"89167d696a849fce5ca508032aabfe901c0868f833a8625d5a9c6e861ef935d2","impliedFormat":1},{"version":"615ba88d0128ed16bf83ef8ccbb6aff05c3ee2db1cc0f89ab50a4939bfc1943f","impliedFormat":1},{"version":"a4d551dbf8746780194d550c88f26cf937caf8d56f102969a110cfaed4b06656","impliedFormat":1},{"version":"8bd86b8e8f6a6aa6c49b71e14c4ffe1211a0e97c80f08d2c8cc98838006e4b88","impliedFormat":1},{"version":"317e63deeb21ac07f3992f5b50cdca8338f10acd4fbb7257ebf56735bf52ab00","impliedFormat":1},{"version":"4732aec92b20fb28c5fe9ad99521fb59974289ed1e45aecb282616202184064f","impliedFormat":1},{"version":"2e85db9e6fd73cfa3d7f28e0ab6b55417ea18931423bd47b409a96e4a169e8e6","impliedFormat":1},{"version":"c46e079fe54c76f95c67fb89081b3e399da2c7d109e7dca8e4b58d83e332e605","impliedFormat":1},{"version":"bf67d53d168abc1298888693338cb82854bdb2e69ef83f8a0092093c2d562107","impliedFormat":1},{"version":"a4ef5ccfd69b5bc2a2c29896aa07daaff7c5924a12e70cb3d9819145c06897db","affectsGlobalScope":true,"impliedFormat":1},{"version":"a38efe83ff77c34e0f418a806a01ca3910c02ee7d64212a59d59bca6c2c38fa1","impliedFormat":1},{"version":"7394959e5a741b185456e1ef5d64599c36c60a323207450991e7a42e08911419","impliedFormat":1},{"version":"3fe4022ba1e738034e38ad9afacbf0f1f16b458ed516326f5bf9e4a31e9be1dc","impliedFormat":1},{"version":"a957197054b074bcdf5555d26286e8461680c7c878040d0f4e2d5509a7524944","affectsGlobalScope":true,"impliedFormat":1},{"version":"4314c7a11517e221f7296b46547dbc4df047115b182f544d072bdccffa57fc72","impliedFormat":1},{"version":"e9b97d69510658d2f4199b7d384326b7c4053b9e6645f5c19e1c2a54ede427fc","impliedFormat":1},{"version":"c2510f124c0293ab80b1777c44d80f812b75612f297b9857406468c0f4dafe29","affectsGlobalScope":true,"impliedFormat":1},{"version":"5524481e56c48ff486f42926778c0a3cce1cc85dc46683b92b1271865bcf015a","impliedFormat":1},{"version":"f478f6f5902dc144c0d6d7bdc919c5177cac4d17a8ca8653c2daf6d7dc94317f","affectsGlobalScope":true,"impliedFormat":1},{"version":"19d5f8d3930e9f99aa2c36258bf95abbe5adf7e889e6181872d1cdba7c9a7dd5","impliedFormat":1},{"version":"9855e02d837744303391e5623a531734443a5f8e6e8755e018c41d63ad797db2","impliedFormat":1},{"version":"a6bf63d17324010ca1fbf0389cab83f93389bb0b9a01dc8a346d092f65b3605f","impliedFormat":1},{"version":"e009777bef4b023a999b2e5b9a136ff2cde37dc3f77c744a02840f05b18be8ff","impliedFormat":1},{"version":"1e0d1f8b0adfa0b0330e028c7941b5a98c08b600efe7f14d2d2a00854fb2f393","impliedFormat":1},{"version":"71450bbc2d82821d24ca05699a533e72758964e9852062c53b30f31c36978ab8","affectsGlobalScope":true,"impliedFormat":1},{"version":"88bc59b32d0d5b4e5d9632ac38edea23454057e643684c3c0b94511296f2998c","affectsGlobalScope":true,"impliedFormat":1},{"version":"a0a1dda070290b92da5a50113b73ecc4dd6bcbffad66e3c86503d483eafbadcf","impliedFormat":1},{"version":"59dcad36c4549175a25998f6a8b33c1df8e18df9c12ebad1dfb25af13fd4b1ce","impliedFormat":1},{"version":"206a70e72af3e24688397b81304358526ce70d020e4c2606c4acfd1fa1e81fb2","impliedFormat":1},{"version":"017caf5d2a8ef581cf94f678af6ce7415e06956317946315560f1487b9a56167","impliedFormat":1},{"version":"528b62e4272e3ddfb50e8eed9e359dedea0a4d171c3eb8f337f4892aac37b24b","impliedFormat":1},{"version":"d71535813e39c23baa113bc4a29a0e187b87d1105ccc8c5a6ebaca38d9a9bff2","impliedFormat":1},{"version":"4a1c5b43d4d408cb0df0a6cc82ca7be314553d37e432fc1fd801bae1a9ab2cb8","affectsGlobalScope":true,"impliedFormat":1},{"version":"f72bc8fe16da67e4e3268599295797b202b95e54bd215a03f97e925dd1502a36","impliedFormat":1},{"version":"b1b6ee0d012aeebe11d776a155d8979730440082797695fc8e2a5c326285678f","impliedFormat":1},{"version":"45875bcae57270aeb3ebc73a5e3fb4c7b9d91d6b045f107c1d8513c28ece71c0","impliedFormat":1},{"version":"915e18c559321c0afaa8d34674d3eb77e1ded12c3e85bf2a9891ec48b07a1ca5","affectsGlobalScope":true,"impliedFormat":1},{"version":"636302a00dfd1f9fe6e8e91e4e9350c6518dcc8d51a474e4fc3a9ba07135100b","affectsGlobalScope":true,"impliedFormat":1},{"version":"3f16a7e4deafa527ed9995a772bb380eb7d3c2c0fd4ae178c5263ed18394db2c","impliedFormat":1},{"version":"933921f0bb0ec12ef45d1062a1fc0f27635318f4d294e4d99de9a5493e618ca2","impliedFormat":1},{"version":"71a0f3ad612c123b57239a7749770017ecfe6b66411488000aba83e4546fde25","impliedFormat":1},{"version":"8145e07aad6da5f23f2fcd8c8e4c5c13fb26ee986a79d03b0829b8fce152d8b2","impliedFormat":1},{"version":"e1120271ebbc9952fdc7b2dd3e145560e52e06956345e6fdf91d70ca4886464f","impliedFormat":1},{"version":"814118df420c4e38fe5ae1b9a3bafb6e9c2aa40838e528cde908381867be6466","impliedFormat":1},{"version":"e1ce1d622f1e561f6cdf246372ead3bbc07ce0342024d0e9c7caf3136f712698","impliedFormat":1},{"version":"199c8269497136f3a0f4da1d1d90ab033f899f070e0dd801946f2a241c8abba2","impliedFormat":1},{"version":"37ba7b45141a45ce6e80e66f2a96c8a5ab1bcef0fc2d0f56bb58df96ec67e972","impliedFormat":1},{"version":"125d792ec6c0c0f657d758055c494301cc5fdb327d9d9d5960b3f129aff76093","impliedFormat":1},{"version":"27e4532aaaa1665d0dd19023321e4dc12a35a741d6b8e1ca3517fcc2544e0efe","affectsGlobalScope":true,"impliedFormat":1},{"version":"2754d8221d77c7b382096651925eb476f1066b3348da4b73fe71ced7801edada","impliedFormat":1},{"version":"8c2ad42d5d1a2e8e6112625767f8794d9537f1247907378543106f7ba6c7df90","affectsGlobalScope":true,"impliedFormat":1},{"version":"f0be1b8078cd549d91f37c30c222c2a187ac1cf981d994fb476a1adc61387b14","affectsGlobalScope":true,"impliedFormat":1},{"version":"0aaed1d72199b01234152f7a60046bc947f1f37d78d182e9ae09c4289e06a592","impliedFormat":1},{"version":"98ffdf93dfdd206516971d28e3e473f417a5cfd41172e46b4ce45008f640588e","impliedFormat":1},{"version":"66ba1b2c3e3a3644a1011cd530fb444a96b1b2dfe2f5e837a002d41a1a799e60","impliedFormat":1},{"version":"7e514f5b852fdbc166b539fdd1f4e9114f29911592a5eb10a94bb3a13ccac3c4","impliedFormat":1},{"version":"7d6ff413e198d25639f9f01f16673e7df4e4bd2875a42455afd4ecc02ef156da","affectsGlobalScope":true,"impliedFormat":1},{"version":"a7692a54334fd08960cd0c610ff509c2caa93998e0dcefa54021489bcc67c22d","affectsGlobalScope":true,"impliedFormat":1},{"version":"74736930d108365d7bbe740c7154706ccfb1b2a3855a897963ab3e5c07ecbf19","impliedFormat":1},{"version":"3a051941721a7f905544732b0eb819c8d88333a96576b13af08b82c4f17581e4","impliedFormat":1},{"version":"ac5ed35e649cdd8143131964336ab9076937fa91802ec760b3ea63b59175c10a","impliedFormat":1},{"version":"c6ab0dd29bf74b71a54ff2bbce509eb8ae3c4294d57cc54940f443c01cd1baae","affectsGlobalScope":true,"impliedFormat":1},{"version":"3797dd6f4ea3dc15f356f8cdd3128bfa18122213b38a80d6c1f05d8e13cbdad8","impliedFormat":1},{"version":"ad90122e1cb599b3bc06a11710eb5489101be678f2920f2322b0ac3e195af78d","impliedFormat":1},{"version":"21ead4c9c384849887ca8cac0a2a7a683d0cf90a3b62a2a2ba8519224e16e249","affectsGlobalScope":true,"impliedFormat":1},{"version":"2329508bb462ba8f17cc60c4ed5b346618a42eefcaaddcbb0fcbf7f09cfd0a87","impliedFormat":1},{"version":"3f8cab6800b8ae88632baedb4f6c28b14227d27f21199617fc03d771c7ad3c0a","affectsGlobalScope":true,"impliedFormat":1},{"version":"556ccd493ec36c7d7cb130d51be66e147b91cc1415be383d71da0f1e49f742a9","impliedFormat":1},{"version":"b6d03c9cfe2cf0ba4c673c209fcd7c46c815b2619fd2aad59fc4229aaef2ed43","impliedFormat":1},{"version":"95aba78013d782537cc5e23868e736bec5d377b918990e28ed56110e3ae8b958","impliedFormat":1},{"version":"670a76db379b27c8ff42f1ba927828a22862e2ab0b0908e38b671f0e912cc5ed","impliedFormat":1},{"version":"81df92841a7a12d551fcbc7e4e83dbb7d54e0c73f33a82162d13e9ae89700079","impliedFormat":1},{"version":"069bebfee29864e3955378107e243508b163e77ab10de6a5ee03ae06939f0bb9","impliedFormat":1},{"version":"42baf4ca38c38deaf411ea73f37bc39ff56c6e5c761a968b64ac1b25c92b5cd8","impliedFormat":1},{"version":"d7dbe0ad36bdca8a6ecf143422a48e72cc8927bab7b23a1a2485c2f78a7022c6","impliedFormat":1},{"version":"8718fa41d7cf4aa91de4e8f164c90f88e0bf343aa92a1b9b725a9c675c64e16b","impliedFormat":1},{"version":"f992cd6cc0bcbaa4e6c810468c90f2d8595f8c6c3cf050c806397d3de8585562","impliedFormat":1},{"version":"fb893a0dfc3c9fb0f9ca93d0648694dd95f33cbad2c0f2c629f842981dfd4e2e","impliedFormat":1},{"version":"3eb11dbf3489064a47a2e1cf9d261b1f100ef0b3b50ffca6c44dd99d6dd81ac1","impliedFormat":1},{"version":"751764bb94219b4ce8f5475dc35d3de2e432fea01a0c9610cd7f69ad05e398c6","impliedFormat":1},{"version":"5d08a179b846f5ee674624b349ebebe2121c455e3a265dc93da4e8d9e89722b4","impliedFormat":1},{"version":"ed19da84b7dbf00952ad0b98ce5c194f1903bcf7c94d8103e8e0d63b271543ae","impliedFormat":1},{"version":"f3d8c757e148ad968f0d98697987db363070abada5f503da3c06aefd9d4248c1","impliedFormat":1},{"version":"fec943fdb3275eb6e006b35e04a8e2e99e9adf3f4b969ddf15315ac7575a93e4","impliedFormat":1},{"version":"a0acca63c9e39580f32a10945df231815f0fe554c074da96ba6564010ffbd2d8","impliedFormat":1},{"version":"2c3b8be03577c98530ef9cb1a76e2c812636a871f367e9edf4c5f3ce702b77f8","affectsGlobalScope":true,"impliedFormat":1},{"version":"7fa8d75d229eeaee235a801758d9c694e94405013fe77d5d1dd8e3201fc414f1","impliedFormat":1}],"root":[87,[99,104],107,[115,123],[125,132],[134,137],141,443,450,451,[453,458],461,462,466,[776,788],[790,814],[816,824],829,932,933,[943,945],947,[950,960],962,963,[965,973],996,997,[999,1017],1019,1020,[1022,1026],[1029,1031],1033,[1035,1040],1141],"options":{"composite":true,"esModuleInterop":true,"jsx":4,"module":199,"noImplicitAny":false,"noImplicitReturns":true,"noUnusedLocals":true,"noUnusedParameters":true,"skipLibCheck":true,"sourceMap":false,"strict":true,"target":99},"referencedMap":[[1144,1],[1142,2],[1140,3],[930,4],[929,5],[142,2],[144,6],[145,6],[143,2],[147,7],[148,7],[146,2],[149,2],[150,8],[151,9],[152,9],[153,2],[154,2],[155,2],[162,2],[156,2],[157,8],[158,2],[159,2],[160,10],[163,11],[167,12],[164,13],[161,2],[165,14],[166,15],[168,2],[169,8],[170,8],[171,8],[172,8],[173,8],[174,8],[175,8],[176,8],[177,8],[178,8],[179,16],[180,2],[182,17],[183,8],[203,18],[197,19],[199,19],[198,20],[195,21],[196,19],[201,2],[200,2],[202,2],[184,22],[185,2],[188,2],[191,2],[186,2],[193,2],[194,23],[190,2],[187,2],[189,2],[192,2],[181,2],[112,24],[109,2],[110,24],[113,25],[114,26],[108,2],[111,24],[464,27],[465,28],[1028,29],[946,30],[825,31],[1021,32],[1027,32],[444,33],[449,34],[446,31],[949,35],[447,31],[931,31],[948,36],[827,37],[448,31],[445,33],[459,32],[452,32],[961,38],[1032,31],[138,33],[1034,32],[460,39],[828,40],[826,2],[98,41],[97,42],[1147,43],[1143,1],[1145,44],[1146,1],[1151,45],[208,2],[210,46],[211,46],[212,2],[213,2],[215,47],[216,2],[217,2],[218,46],[219,2],[220,2],[221,48],[222,2],[223,2],[224,49],[225,2],[226,50],[227,2],[228,2],[229,2],[230,2],[233,2],[232,51],[209,2],[234,52],[235,2],[231,2],[236,2],[237,46],[238,53],[239,54],[1153,55],[1155,56],[1154,2],[1156,57],[214,2],[357,58],[1149,2],[1157,2],[1158,59],[367,58],[1152,2],[1085,60],[1086,60],[1087,61],[1046,62],[1088,63],[1089,64],[1090,65],[1041,2],[1044,66],[1042,2],[1043,2],[1091,67],[1092,68],[1093,69],[1094,70],[1095,71],[1096,72],[1097,72],[1099,2],[1098,73],[1100,74],[1101,75],[1102,76],[1084,77],[1045,2],[1103,78],[1104,79],[1105,80],[1138,81],[1106,82],[1107,83],[1108,84],[1109,85],[1110,86],[1111,87],[1112,88],[1113,89],[1114,90],[1115,91],[1116,91],[1117,92],[1118,2],[1119,2],[1120,93],[1122,94],[1121,95],[1123,96],[1124,97],[1125,98],[1126,99],[1127,100],[1128,101],[1129,102],[1130,103],[1131,104],[1132,105],[1133,106],[1134,107],[1135,108],[1136,109],[1137,110],[998,33],[1159,33],[88,2],[90,111],[91,33],[1150,112],[1160,113],[205,2],[356,2],[1161,2],[467,2],[617,114],[622,115],[624,116],[613,117],[774,118],[546,119],[625,2],[478,2],[630,120],[626,121],[627,122],[628,123],[629,124],[631,125],[632,126],[634,127],[612,128],[633,129],[588,130],[511,131],[510,132],[590,133],[480,134],[635,135],[506,136],[636,2],[601,137],[602,138],[603,139],[596,2],[637,2],[638,140],[639,2],[591,141],[640,2],[580,142],[642,143],[579,144],[647,145],[643,146],[644,147],[645,148],[646,149],[648,150],[666,151],[473,152],[614,153],[615,154],[618,155],[616,155],[649,156],[650,157],[651,158],[652,159],[509,156],[655,160],[656,161],[657,161],[653,162],[654,162],[658,163],[659,164],[660,165],[611,166],[476,166],[661,166],[581,166],[474,167],[620,168],[621,169],[662,169],[663,169],[664,169],[477,166],[475,2],[665,170],[619,171],[517,172],[594,173],[667,174],[671,175],[672,176],[674,177],[595,176],[673,178],[675,179],[676,176],[677,180],[678,181],[679,182],[508,183],[680,184],[488,185],[681,186],[766,187],[682,188],[683,184],[684,189],[686,190],[544,191],[548,192],[689,193],[537,194],[687,195],[536,196],[541,197],[539,198],[688,199],[540,200],[690,201],[695,202],[597,2],[691,203],[692,203],[599,204],[598,2],[693,205],[694,203],[700,206],[482,207],[487,208],[513,209],[494,210],[538,211],[481,2],[600,212],[699,213],[512,2],[471,214],[589,2],[486,215],[485,216],[484,217],[514,217],[501,218],[623,219],[469,220],[468,221],[515,222],[542,223],[593,224],[709,2],[503,225],[701,2],[553,221],[702,2],[604,226],[586,227],[505,228],[710,229],[607,230],[606,231],[495,2],[507,2],[470,232],[493,233],[516,2],[490,152],[703,2],[496,234],[492,221],[704,235],[609,236],[608,152],[767,237],[768,238],[769,239],[770,240],[771,241],[772,242],[550,243],[549,244],[773,245],[705,2],[696,126],[551,246],[706,2],[552,247],[670,248],[668,2],[669,249],[504,250],[707,2],[685,251],[554,252],[711,253],[547,254],[708,255],[712,256],[713,257],[714,258],[555,259],[723,260],[556,261],[573,262],[574,263],[572,264],[722,265],[575,266],[724,267],[731,268],[733,269],[725,267],[730,270],[728,271],[729,272],[732,273],[726,274],[727,275],[557,267],[566,276],[558,277],[715,278],[559,279],[716,280],[560,281],[563,280],[562,278],[561,282],[567,283],[717,280],[565,284],[568,284],[570,284],[718,280],[564,285],[569,286],[719,280],[720,278],[571,287],[721,288],[735,289],[734,290],[736,291],[737,292],[744,293],[743,294],[738,295],[745,296],[739,280],[740,297],[741,298],[742,299],[746,300],[576,301],[577,302],[697,126],[752,303],[491,304],[747,305],[748,2],[605,306],[749,307],[750,308],[587,309],[751,152],[753,2],[592,310],[545,2],[754,311],[756,312],[755,311],[578,313],[641,314],[498,315],[757,316],[499,317],[758,318],[497,319],[535,2],[759,320],[582,321],[534,322],[518,2],[519,2],[520,2],[472,2],[521,2],[522,323],[698,189],[523,2],[524,2],[525,2],[502,2],[526,2],[527,2],[483,217],[479,2],[528,2],[529,324],[489,2],[530,325],[531,2],[500,326],[532,2],[533,2],[760,327],[761,328],[762,329],[763,330],[764,331],[610,332],[583,314],[543,333],[585,334],[765,335],[584,336],[775,337],[140,338],[139,339],[105,2],[89,2],[347,340],[343,2],[344,2],[342,2],[345,2],[346,2],[348,2],[340,2],[341,341],[349,342],[206,113],[1018,2],[1139,343],[94,2],[1148,344],[133,33],[436,2],[410,345],[409,346],[408,347],[435,348],[434,349],[438,350],[437,351],[440,352],[439,353],[395,354],[369,355],[370,356],[371,356],[372,356],[373,356],[374,356],[375,356],[376,356],[377,356],[378,356],[379,356],[393,357],[380,356],[381,356],[382,356],[383,356],[384,356],[385,356],[386,356],[387,356],[389,356],[390,356],[388,356],[391,356],[392,356],[394,356],[368,358],[433,359],[413,360],[414,360],[415,360],[416,360],[417,360],[418,360],[419,361],[421,360],[420,360],[432,362],[422,360],[424,360],[423,360],[426,360],[425,360],[427,360],[428,360],[429,360],[430,360],[431,360],[412,360],[411,363],[267,364],[207,365],[270,366],[269,367],[268,366],[271,2],[352,368],[351,2],[355,369],[353,370],[204,371],[354,372],[272,373],[350,374],[339,375],[274,376],[335,376],[275,376],[276,376],[277,376],[278,376],[332,376],[336,376],[279,376],[280,376],[281,376],[282,376],[283,376],[284,376],[285,376],[337,376],[286,376],[287,376],[331,376],[288,376],[289,376],[290,376],[291,376],[292,376],[293,376],[294,376],[295,376],[296,376],[297,376],[298,376],[299,376],[334,376],[300,376],[301,376],[302,376],[303,376],[304,376],[305,376],[338,376],[306,376],[307,376],[308,376],[309,376],[310,376],[311,376],[333,376],[312,376],[313,376],[314,376],[315,376],[316,376],[317,376],[318,376],[319,376],[320,376],[321,376],[322,376],[323,376],[324,376],[325,376],[326,376],[327,376],[328,376],[329,376],[330,376],[273,377],[265,378],[266,379],[403,380],[401,381],[402,381],[406,382],[404,381],[405,381],[407,381],[400,2],[463,2],[830,2],[845,383],[846,383],[859,384],[847,385],[848,385],[849,386],[843,387],[841,388],[832,2],[836,389],[840,390],[838,391],[844,392],[833,393],[834,394],[835,395],[837,396],[839,397],[842,398],[850,385],[851,385],[852,385],[853,383],[854,385],[855,385],[831,385],[856,2],[858,399],[857,385],[399,400],[398,401],[124,402],[974,33],[976,403],[978,404],[977,405],[979,2],[980,2],[994,406],[975,2],[981,2],[982,2],[983,2],[984,2],[985,2],[986,2],[987,2],[988,2],[989,2],[990,407],[992,408],[993,408],[991,2],[995,409],[96,410],[93,2],[442,411],[441,412],[397,413],[396,414],[95,2],[92,33],[106,2],[364,415],[363,2],[264,416],[256,417],[240,2],[258,418],[257,2],[259,419],[241,2],[249,420],[244,2],[243,421],[242,2],[251,2],[262,422],[247,420],[250,2],[255,2],[248,420],[245,421],[246,2],[252,421],[253,421],[261,2],[263,2],[260,2],[254,2],[79,2],[80,2],[13,2],[14,2],[16,2],[15,2],[2,2],[17,2],[18,2],[19,2],[20,2],[21,2],[22,2],[23,2],[24,2],[3,2],[25,2],[26,2],[4,2],[27,2],[31,2],[28,2],[29,2],[30,2],[32,2],[33,2],[34,2],[5,2],[35,2],[36,2],[37,2],[38,2],[6,2],[42,2],[39,2],[40,2],[41,2],[43,2],[7,2],[44,2],[49,2],[50,2],[45,2],[46,2],[47,2],[48,2],[8,2],[54,2],[51,2],[52,2],[53,2],[55,2],[9,2],[56,2],[57,2],[58,2],[60,2],[59,2],[61,2],[62,2],[10,2],[63,2],[64,2],[65,2],[11,2],[66,2],[67,2],[68,2],[69,2],[70,2],[1,2],[71,2],[72,2],[12,2],[76,2],[74,2],[78,2],[73,2],[77,2],[75,2],[1062,423],[1072,424],[1061,423],[1082,425],[1053,426],[1052,427],[1081,428],[1075,429],[1080,430],[1055,431],[1069,432],[1054,433],[1078,434],[1050,435],[1049,428],[1079,436],[1051,437],[1056,438],[1057,2],[1060,438],[1047,2],[1083,439],[1073,440],[1064,441],[1065,442],[1067,443],[1063,444],[1066,445],[1076,428],[1058,446],[1059,447],[1068,448],[1048,449],[1071,440],[1070,438],[1074,2],[1077,450],[366,451],[362,2],[365,452],[815,2],[359,453],[358,58],[361,454],[360,455],[86,456],[82,457],[81,2],[83,458],[84,2],[85,459],[942,460],[862,461],[864,462],[871,463],[866,2],[867,2],[865,464],[868,465],[860,2],[861,2],[872,466],[863,467],[869,2],[870,468],[937,469],[940,470],[938,470],[934,469],[941,471],[939,470],[935,472],[936,473],[925,474],[877,475],[879,476],[923,2],[878,477],[924,478],[928,479],[926,2],[880,475],[881,2],[922,480],[876,481],[873,2],[927,482],[874,483],[875,2],[882,484],[883,484],[884,484],[885,484],[886,484],[887,484],[888,484],[889,484],[890,484],[891,484],[892,484],[894,484],[893,484],[895,484],[896,484],[897,484],[921,485],[898,484],[899,484],[900,484],[901,484],[902,484],[903,484],[904,484],[905,484],[906,484],[908,484],[907,484],[909,484],[910,484],[911,484],[912,484],[913,484],[914,484],[915,484],[916,484],[917,484],[918,484],[919,484],[920,484],[964,42],[1141,486],[997,487],[789,42],[1000,488],[1001,489],[1002,490],[1003,491],[1004,492],[1005,493],[1006,494],[1007,495],[1008,496],[1009,497],[1010,498],[1011,499],[1012,500],[1013,501],[1014,502],[1015,503],[1016,504],[1017,505],[786,506],[782,506],[797,507],[784,506],[779,42],[796,507],[781,506],[812,508],[785,506],[780,506],[783,509],[788,510],[798,511],[794,512],[803,513],[801,514],[805,42],[799,511],[800,511],[787,42],[792,42],[804,511],[793,42],[811,42],[813,515],[814,516],[1019,517],[818,518],[807,519],[808,520],[810,521],[802,522],[809,523],[806,524],[816,525],[817,526],[130,42],[131,527],[1020,42],[454,528],[127,529],[778,530],[462,531],[823,532],[824,533],[457,534],[945,535],[955,536],[952,537],[951,538],[954,539],[956,540],[943,541],[944,542],[957,543],[958,544],[443,545],[819,546],[795,547],[458,548],[963,549],[967,550],[973,551],[1023,552],[972,553],[822,533],[1024,554],[968,555],[970,556],[969,557],[1025,558],[971,559],[1026,560],[1029,561],[947,562],[1022,563],[965,564],[141,565],[456,564],[1030,566],[450,567],[950,568],[820,569],[933,570],[821,564],[451,564],[932,571],[1031,564],[996,572],[453,573],[962,574],[1033,575],[966,564],[1035,576],[461,577],[1036,566],[1037,578],[829,579],[137,580],[960,581],[87,582],[136,583],[135,584],[953,585],[776,586],[134,42],[777,587],[1038,588],[1040,589],[455,590],[128,591],[129,592],[104,593],[790,594],[132,595],[959,42],[791,596],[107,597],[118,598],[466,42],[116,42],[117,42],[1039,42],[999,599],[99,600],[101,601],[100,601],[125,602],[126,603],[102,601],[103,604],[123,605],[120,606],[121,606],[119,607],[122,608],[115,42]],"affectedFilesPendingEmit":[[997,17],[1000,17],[1001,17],[1002,17],[1003,17],[1004,17],[1005,17],[1006,17],[1007,17],[1008,17],[1009,17],[1010,17],[1011,17],[1012,17],[1013,17],[1014,17],[1015,17],[1016,17],[1017,17],[786,17],[782,17],[797,17],[784,17],[779,17],[796,17],[781,17],[812,17],[785,17],[780,17],[783,17],[788,17],[798,17],[794,17],[803,17],[801,17],[805,17],[799,17],[800,17],[787,17],[792,17],[804,17],[793,17],[811,17],[813,17],[814,17],[1019,17],[818,17],[807,17],[808,17],[810,17],[802,17],[809,17],[806,17],[816,17],[817,17],[130,17],[131,17],[1020,17],[454,17],[127,17],[778,17],[462,17],[823,17],[824,17],[457,17],[945,17],[955,17],[952,17],[951,17],[954,17],[956,17],[943,17],[944,17],[957,17],[958,17],[443,17],[819,17],[795,17],[458,17],[963,17],[967,17],[973,17],[1023,17],[972,17],[822,17],[1024,17],[968,17],[970,17],[969,17],[1025,17],[971,17],[1026,17],[1029,17],[947,17],[1022,17],[965,17],[141,17],[456,17],[1030,17],[450,17],[950,17],[820,17],[933,17],[821,17],[451,17],[932,17],[1031,17],[996,17],[453,17],[962,17],[1033,17],[966,17],[1035,17],[461,17],[1036,17],[1037,17],[829,17],[137,17],[960,17],[136,17],[135,17],[953,17],[776,17],[134,17],[777,17],[1038,17],[1040,17],[455,17],[128,17],[129,17],[104,17],[790,17],[132,17],[959,17],[791,17],[107,17],[118,17],[466,17],[116,17],[117,17],[1039,17],[999,17],[99,17],[101,17],[100,17],[125,17],[126,17],[102,17],[103,17],[123,17],[120,17],[121,17],[119,17],[122,17],[115,17]],"emitSignatures":[99,100,101,102,103,104,107,115,116,117,118,119,120,121,122,123,125,126,127,128,129,130,131,132,134,135,136,137,141,443,450,451,453,454,455,456,457,458,461,462,466,776,777,778,779,780,781,782,783,784,785,786,787,788,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,816,817,818,819,820,821,822,823,824,829,932,933,943,944,945,947,950,951,952,953,954,955,956,957,958,959,960,962,963,965,966,967,968,969,970,971,972,973,996,997,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1019,1020,1022,1023,1024,1025,1026,1029,1030,1031,1033,1035,1036,1037,1038,1039,1040],"version":"5.8.3"}
\ No newline at end of file