Changelog

All notable changes to XOSC. Newest first. Updated automatically by just package.

Unreleased

• _nothing yet_

v0.7.19 — 2026-05-01

• Fix: enabling input "global capture" no longer blanks the screen. useGlobalHotkeys selector returned a fresh {signature, accelerator, descriptor} object per node on every snapshot. useShallow compares array elements with Object.is — always false for new object refs — so getSnapshot churned indefinitely the moment any node had globalHotkey: true, and React 18's stale-snapshot detector aborted the renderer with #185 "Maximum update depth exceeded". The selector now returns a flat signature\taccelerator string array (primitives are shallow-stable when content matches); the wire payload is derived via useMemo. Unused descriptor field on the entry shape dropped. (src/features/inputs/useGlobalHotkeys.ts)

v0.7.18 — 2026-05-01

• Fix: first-launch splash hang on multi-monitor / mixed-DPI Windows. BrowserWindow.ready-to-show silently never fires (or fires too late) on some Windows GPU configurations — typically tri-monitor setups with mixed DPI scaling. The splash stayed up forever, the main window stayed hidden, and the user concluded the app was frozen. The createMain() reveal logic is now an idempotent reveal(via, dwell) armed by three triggers: the original ready-to-show (1400 ms splash dwell preserved), did-finish-load (no dwell — the renderer is already loaded by the time it fires), and a 5 s safety timer (last resort). New phase=main-window-reveal via=... lands in lifecycle.log so the diagnostic confirms which trigger won. Also confirms the v0.7.7→v0.7.15 "close-then-reopen crash" was always the same bug — the user task-killed a stuck splash, which lifecycle.log recorded as reason=killed exitCode=1. With v0.7.18 the splash dismisses cleanly and close-then-reopen ends with === CLEAN-EXIT === every run. (electron/main.ts)

v0.7.17 — 2026-05-01

• userData directory listing on every boot. Right after main-entry, lifecycle.log gets a phase=userdata-listing entry followed by every file/folder in %APPDATA%\xosc\ (relative path, size, mtime). Capped at 200 entries / 4 levels deep. Surfaces stale .tmp.<pid>.<ts> save orphans, .corrupt.<ts> quarantines, and Chromium caches (Local Storage, IndexedDB, Cookies) so the "presets stored somewhere I didn't expect" mystery becomes a one-grep job. (electron/lifecycle-log.ts, electron/main.ts)

v0.7.16 — 2026-05-01

• v0.7.16 diagnostic battery — instrument the renderer side of the silent kill. v0.7.15 proved main-process teardown is clean (every dispose-ok, every === CLEAN-EXIT ===); the kill is renderer-side. v0.7.16 ships four pieces of instrumentation so the next reproduction lands hard evidence:

v0.7.15 — 2026-05-01

• Lifecycle log added — silent, persistent boot/teardown timeline at %APPDATA%\XOSC\lifecycle.log. Every meaningful main-process phase (single-instance lock, when-ready, splash + main window create, each handler register, before-quit, window-all-closed, each dispose call, will-quit, quit) is timestamped to disk. Each dispose is wrapped in a try/catch that records dispose-throw with the error message, so a throw in one teardown step no longer short-circuits the rest. A === CLEAN-EXIT === footer is appended on app.on("quit"); absence between two BOOT headers proves the previous run died mid-shutdown — the diagnostic the silent close-then-reopen crash needed. Top-bar ? menu adds "Open lifecycle log". Rotates to .old at 512 KB. (electron/lifecycle-log.ts, electron/main.ts, electron/preload.ts, src/components/Topbar.tsx, src/types/api.ts)
• DEBUG_BUILD disabled for ship — release.yml no longer sets DEBUG_BUILD: "1", so v0.7.15+ builds are normal production: minified, prod React, no auto-opening DevTools, ~3× lighter installer. The crash log + lifecycle log are now the diagnostic surface; the client doesn't see a debug surface anymore. (.github/workflows/release.yml)
• Easy-Next simplified to clip-only — the v0.7.14 axis toggle (advance clip vs advance layer) is gone. Every press walks the chosen layer's clips left-to-right; the layer dropdown stays so the user picks WHICH layer. Two motions on one Resolume box = two ResolumeOut nodes pinned to different layers. Saved configs with advance: "layer" are normalised back to "clip" on hydration. The phantom-extra-layer bug in layer-advance is gone with the code. (src/features/inspector/ResolumeOutInspector.tsx, src/features/mapping/useMappingRouter.ts, src/store/store.ts)
• Auto-refresh composition when Easy-Next opens — opening the Easy-Next inspector section auto-fetches Resolume's composition tree if state is idle, instead of requiring a manual click on "Refresh from Resolume" before the layer dropdown populates. Skips when already loading or in error state. (src/features/inspector/ResolumeOutInspector.tsx)

v0.7.14 — 2026-05-01 (diagnostic build, persistent crash log + Easy-Next redesigned around Resolume's grid)

Added — persistent crash log so we can finally see what's actually failing

• %APPDATA%\XOSC\crash.log captures every uncaught exception, unhandled rejection, render-process-gone event, and renderer-side error/unhandledrejection. Wired before any other module load in both main and renderer (electron/crash-log.ts setup runs at the top of electron/main.ts; src/crash-handler.ts is the very first import in src/main.tsx). Synchronous appendFileSync so entries land even when the process is dying. The last six releases all rolled back blind because we had no diagnostic surface for "won't launch on Windows" failures — DevTools doesn't open if the renderer crashes before mount, and the app shows no on-screen feedback. This file is now the authoritative source.
• "Open crash log" + "Show crash log folder" in the topbar ? menu. One click puts the file in front of the user. (src/components/Topbar.tsx)
• window.xosc.app.reportCrash / openCrashLog / showCrashLogFolder IPC wired through preload + types. Renderer's window.error and unhandledrejection listeners forward to main; React mount throws are caught explicitly in src/main.tsx and forwarded too. Buffered when the preload bridge isn't ready yet, flushed on next animation frame.

Changed — Easy-Next redesigned around Resolume's actual grid model

User insight: Resolume's coordinate system is ALWAYS (layer × column). There's no useful "advance column" without picking a layer first — server-side column-fan-out connects every layer's clip in that column simultaneously, which is rarely what you want. The actually-useful primitive is "I picked a layer, the button walks that layer's clips left to right". The complementary primitive is "stay on the same column, advance the layer dropdown" — useful for comparing the same beat across layers. Plus: Resolume renders layer N on top of layer N-1, so the array-order layer dropdown was visually inverted from what the user sees on stage.

• Mode selector (auto / columns / layer-clips) deleted. Always layer-clips. Saved configs from v0.7.7-v0.7.13 with mode: "auto" or "columns" are normalised to "layer-clips" during hydration. (src/store/store.ts, src/features/inspector/ResolumeOutInspector.tsx)
• New "Axis" toggle: clip-advance vs layer-advance. Clip-advance (default) walks columns within the chosen layer — same press, same layer, different clip. Layer-advance walks the layer dropdown while keeping the column position fixed — same press, next layer down/up, same beat. Both wrap. Implemented in the router as a new advance field on ResolumeEasyNextSpec; the fire path branches on the axis and patches either currentIndex (clip mode) or layerIndex (layer mode). (src/store/store.ts, src/features/mapping/useMappingRouter.ts, src/features/inspector/ResolumeOutInspector.tsx)
• Layer dropdown reversed. Resolume renders layer N on top of layer N-1, so array index 0 is the bottom of the visible stack. The dropdown now shows the visually top-most layer at the top of the list. Values stay 1-based to match Resolume's REST URLs. (src/features/inspector/ResolumeOutInspector.tsx)
• Layer-advance auto-skips empty layers. When the next layer in the cycle has no populated clips at all (or zero after skipEmpty), the router skips it and tries the one after — caps at one full trip around so a totally-empty composition can't loop forever. (src/features/mapping/useMappingRouter.ts)

Notes for the next session

• v0.7.13 still crashed on close-then-reopen with a Resolume Out node configured, even after four-layer defence on webContents.send. The crash log will surface the actual root cause on the next reproduction. Until that file shows real data, do not ship more behavioural changes — the fixes have to be evidence-driven now.
• Still on DEBUG_BUILD=1. Production cutover happens once the crash log shows a clean close-then-reopen cycle with a Resolume Out node.

v0.7.13 — 2026-05-01 (diagnostic build, Easy-Next regression revert + close-crash defence-in-depth)

Fixed (THIS is the "press goes down the wire but Resolume doesn't advance" regression I introduced in v0.7.11)

• Easy-Next router reverted to "next to fire" semantics. v0.7.11 changed currentIndex to mean "currently playing" and made the router fire (connectedIdx + 1) % total. That works only if Resolume's connected.value parses correctly. On the user's Resolume build it doesn't (clip likely in Previewing state, or shape mismatch), so connectedIdx === -1, the router fell back to currentIndex for fire BUT then set currentIndex = fireIdx (not + 1). Result: every press fired the same slot. Resolume kept connecting the same clip. Visually dead. Restored v0.7.10's algorithm: always fire currentIndex, always advance to (fireIdx + 1) % total after a successful send. The press now produces a different connect every time regardless of connected parsing. (src/features/mapping/useMappingRouter.ts)
• Inspector + node body now display nextIdx (always known) as the primary indicator. The dashed-border "next press fires" row is the source of truth. Resolume's connected state is shown as a secondary (now: name) annotation when detectable, never as the primary highlight — guessing at the playhead when connected was unreadable was the v0.7.11 bug. (src/features/inspector/ResolumeOutInspector.tsx, src/features/mapping/ResolumeOutNode.tsx)
• "Copy composition JSON" button added to the Easy-Next inspector. The user couldn't paste from DevTools (the composition is a few hundred KB) and a console fetch() from the renderer hits CORS against Resolume's webserver. The button serializes the in-memory composition cache and writes it to the system clipboard via navigator.clipboard, giving a one-click way to capture diagnostic data when something looks wrong. Removed once Easy-Next is stable. (src/features/inspector/ResolumeOutInspector.tsx)

Fixed (close-crash defence in depth — v0.7.12 fixed two sites; this catches the rest of the class)

• Logger.push now wraps each listener in try/catch. v0.7.12 fixed two webContents.send call sites (main.ts:194, serial-bridge.ts:54) that were re-throwing on shutdown. But the general problem is that Logger.push.listeners.forEach(fn) had no per-listener insulation: a single listener throwing took out the rest of the dispose chain because the throw bubbled through log.emit → bridge close handler → disposeResolumeBridges → app.on("window-all-closed"). Per-listener try/catch means a future listener regression can't ever soft-brick shutdown again. (electron/logger.ts)
• logger.beginShutdown() flag suppresses listener notifications after app.before-quit. Earliest signal that everything is tearing down. The logger still records entries in its in-memory buffer (useful if next-launch logs surface them), it just stops fanning them out to listeners that may have stale window references. (electron/logger.ts, electron/main.ts)
• resolume-bridge.ts pushStatus now checks wc.isDestroyed() and try/catches the send. v0.7.12 audited this site and thought it was already guarded — it checks win.isDestroyed() but not win.webContents.isDestroyed(). Same race as the two sites fixed in v0.7.12. The above three changes mean each of the four "WS close fires during dispose" code paths is now triple-protected (per-listener try/catch in Logger + shuttingDown flag + per-call site isDestroyed() checks + try/catch on send). (electron/resolume-bridge.ts)

Notes

• The user reported v0.7.12 still crashed on close (silently — no more error modal because the per-listener throw in v0.7.12's main.ts logger fix was working, but a different listener was throwing instead). v0.7.13's per-listener try/catch in Logger itself catches every shutdown listener regardless of which file it lives in.
• Still on diagnostic harness — production cutover happens once you confirm v0.7.13 (a) closes cleanly with a Resolume Out node, (b) advances Resolume on each press of an Easy-Next-enabled output, AND (c) the next launch boots without needing to delete %APPDATA%\XOSC.

v0.7.12 — 2026-05-01 (diagnostic build, shutdown-crash root cause)

Fixed (THIS is the v0.7.7+ "won't open / crashes on close" root cause)

• Main process no longer throws "Object has been destroyed" during shutdown. The user's stack trace finally pinned it: when the window closes with a live Resolume WebSocket, disposeResolumeBridges() runs in the window-all-closed handler, the WS close event fires, the bridge calls pushStatus → log.emit, the logger fans out to its onChange subscribers, and one of those subscribers (electron/main.ts:194) called mainWin?.webContents.send("log:stream", …). The ?. only guarded against null — mainWin itself was still a valid reference, but its webContents had already been torn down by Electron, so the send threw. Electron then surfaced the throw as the "A JavaScript error occurred in the main process" modal. Same race in electron/serial-bridge.ts:54 (parser data event firing after the window starts tearing down). Both sites now check win.isDestroyed() AND win.webContents.isDestroyed(), plus a try/catch swallows any remaining race, because log streaming + serial data are best-effort and re-throwing during graceful shutdown helps no one. (electron/main.ts, electron/serial-bridge.ts)
• The "saved-config soft-brick" was a downstream symptom of the same crash. When the renderer threw the "Object has been destroyed" exception during shutdown, the useConfigSync debounced save was sometimes mid-flight. With v0.7.11's atomic-rename writeSnapshot this is now harmless even if it does happen, but with v0.7.10's direct fs.writeFile the file landed truncated, then the next launch hit JSON.parse → uncaught exception → frozen splash. v0.7.11 already shipped the atomic write + corrupt-file quarantine + try/catch hydration; v0.7.12 takes out the upstream cause. Both fixes stand: v0.7.11's hardening means a config-write crash from any future cause still recovers cleanly, and v0.7.12's IPC guard means the crash that triggered this whole investigation can't happen anymore.

Notes

• The bug class — webContents.send without isDestroyed check — predates v0.7.6/v0.7.7. The reason it surfaced now: v0.7.7 added a readCachedComposition codepath that opens / refreshes Resolume WS connections more aggressively, and the user added a Resolume Out node to test Easy-Next, which is what made the WS close path hot during shutdown. v0.7.5 and earlier rarely triggered it because most users never had a connected WS at close time. Audited all other webContents.send sites (dmx/engine.ts, osc-listener.ts, dmx/artnetIn.ts, peer-discovery.ts, global-hotkeys.ts, resolume-bridge.ts) — they already guard with isDestroyed() correctly.
• Still on the diagnostic harness — production-mode build is one revert away once you confirm v0.7.12 launches AND closes cleanly with a Resolume Out node configured.

v0.7.11 — 2026-05-01 (diagnostic build, Easy-Next correctness fixes + soft-brick recovery)

Fixed (soft-brick recovery — root cause of v0.7.10 "won't reopen after JS error on close")

• xosc.config.json is now written atomically. writeSnapshot previously called fs.writeFile directly, so a renderer JS error mid-shutdown could leave a truncated JSON file on disk; the next launch's JSON.parse then threw and useConfigSync could not recover, soft-bricking the app until the user manually deleted %APPDATA%\XOSC. Switched to write-to-tmp + atomic-rename: a crash mid-write leaves either the previous good file or an orphaned .tmp.<pid>.<ts>, never a half-written real path. (electron/config-store.ts)
• Corrupt config files self-quarantine on read instead of crashing the app. If readSnapshot hits an invalid-JSON or invalid-shape error, the bad file is renamed with a .corrupt.<ts> suffix and the app boots with the same empty snapshot it would on first launch — saved graph is preserved on disk for manual recovery, but the user gets a working app immediately. (electron/config-store.ts)
• hydrateFromSnapshot now wrapped in try/catch with per-node sanitisation. Any unexpected throw inside hydration logs to console and falls through to defaults instead of bubbling out and stranding the renderer. Easy-Next blocks on saved nodes are normalised: invalid mode strings collapse to "auto", NaN/negative/Infinity currentIndex collapses to 0, sub-1 layerIndex is dropped. (src/store/store.ts)

Fixed

• Easy-Next playlist highlight now tracks Resolume's actual playhead, not the local pointer. Previously the highlighted item was always one ahead of what Resolume was playing because currentIndex stored "next to fire" but the UI displayed it as "now playing". Each PlaylistItem now carries a connected boolean derived from Resolume's per-clip connected.value (mapped from both numeric and string-enum forms — Empty/Disconnected/Previewing/Connected/Connected & previewing → 0..4, threshold >= 3); the inspector + node body highlight whatever Resolume reports as connected. Manual triggers in Resolume now sync the UI without requiring a button press in XOSC. (src/features/inspector/resolumePlaylist.ts, src/features/inspector/ResolumeOutInspector.tsx, src/features/mapping/ResolumeOutNode.tsx)
• *Easy-Next router fires the item after whatever Resolume is currently playing, not the next item after our stored pointer. resolveEasyNextFire reads connected across the resolved playlist; if any item is connected, the press fires (connectedIdx + 1) % total. Falls back to currentIndex only when nothing is connected (Resolume just opened, blackout, etc.) so first-press behaviour stays predictable. The persisted currentIndex semantics changed from "next to fire" to "currently playing" — the index advances after a successful fire instead of pointing at the upcoming target. (src/features/mapping/useMappingRouter.ts)
• Column mode now shows names + thumbnails. Resolume's REST API has no native column thumbnail endpoint — column tiles carry only name + connected status. Built a representative-clip lookup: for each column slot, walk every layer's clip at that index and synthesize a thumbnailPath against the first populated clip found (/api/v1/composition/layers/{repLayerIndex}/clips/{slot}/thumbnail). The same clip's name fills in when the column itself has no user-set name (Resolume defaults like Column 1 are unhelpful). Resolume's # placeholder in column names (their own rest-example convention for "insert column number here") is now substituted with the 1-based slot. Both the inspector preview list and the node-body thumbnail work for columns now. (src/features/inspector/resolumePlaylist.ts)
• Inspector counter relabeled "now playing" with both the connected item's name and the next-up item's name shown after an arrow. The "Will fire on next press →" path stays in sync with the router so the displayed REST URL is the one that actually fires. PreviewRow gets a new dashed-border state to mark the next-to-fire row distinctly from the connected (highlighted) row. (src/features/inspector/ResolumeOutInspector.tsx, src/features/inspector/resolume-easy-next.css)

• PadEditorModal crashed with React #310 ("rendered more hooks than during the previous render") on the pencil-edit click. Two useMemo calls sat after the if (!draft) return null early return, so the hook count shrank from 4 to 2 between mount (pad set) and re-mount (pad null). Moved both above the early return.

• Adding a Resolume In node crashed the renderer (React #185). useResolumeThumbnail paired useSyncExternalStore with a getSnapshot that returned a freshly-allocated { fetchedAt: 0, url: "", state: "idle" } object on every call when the cache had no entry yet (or when the supplied path was null — which is the default case for a freshly-added Resolume In node, because its starting parameter is /composition/layers/1/video/opacity, not a clip path, so thumbnailPathForClip returns null). React 18 compares snapshots by reference; a new object every call meant the snapshot was always "different" and the renderer entered an unbounded re-render loop the moment the node mounted. Worse, the loop was sticky across relaunches because the broken node was now in the saved graph: every subsequent app start re-mounted it and re-crashed before the user could remove it. Same family of bug as the v0.6.6 useGlobalHotkeys fix and the v0.6.2 EMPTY_PADS fix — third instance of "snapshot reference must be stable" biting in the same release line. Fix: hoist a single shared idleThumbEntry constant at module scope (mirroring how useResolumeComposition already handles its idleEntry) so the empty-cache return is reference-stable.
• Zoom controls were white on every dark theme. The --xy-controls-button-background-color-default we set in src/styles/app.css (line 164, mapped to var(--surface)) was being clobbered by xyflow's own .react-flow { ... --xy-controls-button-background-color-default: #fefefe; } rule because the bundler emitted xyflow's stylesheet after app.css. xyflow's dark-mode swap selector (.react-flow.dark) never matches because we theme via CSS custom properties on :root and a data-mode attribute, not via that class. Fix: hoist import "@xyflow/react/dist/style.css" in src/main.tsx to before the import App line, so app.css now lands later in the bundle and our overrides actually win cascade order.

• v0.6.1's launch crash didn't actually fix v0.6.0's launch crash. With sourcemaps enabled in v0.6.1, the renderer console finally pointed at the real culprit: the defensive ?? [] selector pattern I added in v0.6.1 returned a fresh empty array on every Zustand selector call, breaking Object.is equality and causing every component reading settings.dmx. to re-render on every store change. Combined with the ClockBar BPM writeback effect, that produced the React #185 "max update depth exceeded" loop.
• Stable singleton fallbacks. New EMPTY_PADS / EMPTY_CLOCKS / EMPTY_TRANSMITTERS exported from the store. Selectors fall back to these instead of [], so the result is reference-stable when the underlying slice is missing — Zustand bails on Object.is and skips the re-render.
• Removed ClockBar's BPM writeback effect. It tried to keep the persisted BPM in sync with the runtime tap-tempo state via a useEffect that ran on every clocks change. Even with the v0.6.1 mismatch guard it remained the most plausible loop trigger. Tap onClick already writes BPM directly through setClockBpm; future external clock sources (MIDI Clock, OSC /clock/bpm) will use the same explicit-write path. Net behaviour: identical for tap-tempo users; one fewer render-loop trap door.

v0.6.1 — 2026-04-29

Fixed

• Renderer infinite-update loop on launch. The Topbar ClockBar widget had a feedback chain (setClocks → emit → subscriber → force re-render → effect re-runs) that, under certain hydration timings, hit React's "max update depth" guard and unmounted the entire React tree — leaving the user staring at the gradient background with no visible UI. The chain has been rewritten to skip emits when nothing changed, separate read-only display refreshes from store-write paths, and avoid setState inside the listeners-iteration scope.
• Defensive hydration of settings.dmx. Older configs (v0.5.x had no dmx block at all; early v0.6 builds had only {transmitters, userProfiles}) now backfill cleanly with current defaults via a new ensureDmx() helper instead of producing a partial shape that crashed the first selector reading dmx.pads / dmx.clocks. All renderer selectors that read settings.dmx. are now nullish-safe.
• Visible crash screen. New <ErrorBoundary> wraps the app — uncaught render errors now show the message + stack + a hint about renaming the config file, instead of failing silently to a blank background. The crash also pushes a system-source log entry so the debug log captures it.

• Custom theme editor. Settings now ships an in-app editor below the built-in theme grid: pick six seed colors (background, surface, accent, accent-2, text, border) with a clickable swatch (OS color picker) and a hex field. Surface 2/3, border-strong, text-dim/mute, and accent glows are derived automatically via chroma-js so the result stays internally consistent. Light/dark mode auto-detects from the background luminance. Every change live-applies; Reset clears the custom theme and returns to whichever built-in is active. Seeds persist with customTheme in xosc.config.json so the editor reopens preloaded.
• mDNS auto-discovery for hosts. Resolume Out / Resolume In / OSC Out inspectors get a host picker dropdown of LAN-discovered peers — no more hunting for IP addresses. The main process runs bonjour-service browsers for _resolume._tcp, _osc._udp, and _companion._tcp; each picker is filtered by service kind so the Resolume inspector doesn't show Companion controllers. Selecting a peer fills both host and port. mDNS is broadcast-only on 224.0.0.251:5353 — XOSC does not advertise itself. On a hardened venue with multicast blocked, the picker stays empty and manual entry still works as before.

v0.5.2 — 2026-04-29

Added

• Cycle-warning UI. Edges that participate in a logical feedback loop now render with an amber stroke and a ⟳ loop pill at the midpoint. Detection includes static graph cycles AND virtual loops that close through Resolume parameter equality (a resolume-out writing parameter P is treated as feeding any resolume-in reading P on the same host:port). Non-blocking — the depth cap and echo guard still terminate the loop at runtime; this is a static design-time hint so you can spot the wiring at a glance.
• Per-sink event-rate gauge. OSC-out and Resolume-out nodes show a tiny events/sec pill while traffic is live. The pill turns amber above 60 events/s, red above 200 — useful for spotting an over-wired continuous source from across the canvas. Side-channel ring buffer (out of Zustand) so 60 Hz axis traffic doesn't trigger React re-renders across the app.
• Resolume swagger autocomplete. The Resolume parameter picker now fetches /api/v1/docs/swagger.json alongside the composition tree and unions paths in. Effect / dynamic params that don't appear in the composition (because they haven't been added yet) are still pickable as long as Resolume's swagger lists them.
• Global keyboard hotkeys. New per-input toggle in the keyboard input inspector. When on, XOSC registers an Electron globalShortcut for that key so it's captured even when the window isn't focused. globalShortcut fires once per press; XOSC synthesizes a release ~120 ms later so toggle / hold downstream stays predictable. Modifier combinations and most non-symbol keys are supported; the failure-to-register reason is logged.

v0.5.1 — 2026-04-29

Added

• Per-edge throttle override. MappingEdge.throttleMs? overrides the engine's default 25 ms continuous-burst throttle on a per-wire basis. Edge inspector exposes a Toggle + Slider — useful when one source feeds many sinks and only some need calming.
• Save debug log to file. DebugPanel gets a Save button alongside Copy / Clear. Writes the filtered buffer as JSONL via a new log:save IPC + dialog.showSaveDialog. Default filename is xosc-log-<timestamp>.jsonl.
• OSC Monitor node. New sink-only node kind that visualises traffic on its left handle: live-scaling sparkline of the last 120 numeric values + the last 6 raw timestamped samples. Doesn't fire any side effects; great for stage debugging without opening the debug panel. Topbar Monitor button.

Fixed

• Toggle state survives rebind. When a sink's incoming edges or triggerMode change, its per-sink toggleState entry is now cleared so the next press starts from a known state instead of mid-flip. Stale entries for deleted sinks are also dropped.

v0.5.0 — 2026-04-29

Added

• Loop protection: dispatch lineage + depth cap. InputFiredEvent now carries an optional causedBy: { nodeId, depth }. The mapping router drops any event whose depth > 8 and emits a warn-level log entry. Foundation for safe multi-hop chains.
• Resolume echo-suppression on resolume-in. When a resolume-out writes parameter P, the dispatch tracker remembers the write for ~200 ms. The next parameter_update for P is dropped (default) — kills the resolume-in → resolume-out → Resolume → resolume-in loop without throttling user-driven motion. New per-node "Echo guard" toggle in the resolume-in inspector lets the round-trip through when you actually want it; depth cap still terminates at 8 hops.
• Inbound OSC listener (osc-in node). New source node kind that opens a UDP listener on a configurable (bindHost, port) and emits matching packets onto the input bus, ready to be wired to any sink. Address patterns support (any non-slash chars) and ? (one char). Single listener per (bindHost, port), refcounted across nodes — many nodes can listen on different addresses on the same port. Default bind is 127.0.0.1 (loopback only); 0.0.0.0 is opt-in with a clear "LAN visible" warning in the inspector. Topbar button + node body shows live-hit indicator and last numeric value.
• Math / logic transform nodes. New mid-graph node kind that's both a sink and a source. Initial set: clamp, scale (range remap), invert, curve (gamma), hold-timer (separate tap / hold outputs), double-tap, threshold (hysteresis with high / low outputs), latch (toggle on press), edge (rise / fall / both). Stateful ops keep state per (transformNodeId, sourceId) and reset on app reload. Multi-output ops expose multiple right-side handles; edges remember sourceHandle / targetHandle.
• Dispatch mode per edge. Edges now carry an optional dispatch: { mode, order, delayMs?, requirePrevOk? }. Modes: parallel (default; current behaviour), sequential (await each previous edge before firing), after-prev (sequential + skip on previous error). Edges from the same source group sort by order ascending. New EdgeInspector exposes the controls; click an edge to select it. ColorMixEdge renders dashed strokes + an order/mode badge for non-default edges.

• CI: typecheck-web added @types/node to web/package.json so astro check resolves node:fs/promises / node:path / process.cwd() references in build-time loaders. Was passing locally because of a hoisted dep at the repo root; failed in CI because the verify job only installs web/'s deps.
• CI: deploy-site / release workflows no longer fail at workflow-validation time when SITE_DEPLOY_SSH_KEY isn't configured. The optional rsync / scp upload is gated behind a step output instead of ${{ env. }} in if.

v0.2.0 — 2026-04-29

Added

• OSC throttle for continuous bursts. electron/osc-engine.ts coalesces continuous values per host:port:address (leading + trailing flush, default 25 ms). Discrete pulses still pass through synchronously. OscSendRequest gained continuous?: boolean + throttleMs?: number.
• Continuous values from MIDI CC, pitch bend, and gamepad axes. Descriptors carry continuous: true; inputBus events carry a normalized value: number ∈ [0,1]. Gamepad axis polling joined the existing button polling loop.
• Mapping router routes continuous values to the first numeric arg of every downstream sink (f arg gets the float verbatim; i arg gets round(v127)).
• Resolume modifier-prefix preset in OutputInspector: prepends "a" / "+" / "-" / "" / "?" as the first string arg for Resolume-style relative parameter sets.
• Resolume WebSocket output node. New resolume-out graph node speaks the Resolume WS API (action: trigger, set, subscribe, unsubscribe). One socket per host:port, exponential-backoff reconnect (cap 30 s), bounded send queue while connecting, per-parameter throttling for set, live status pill on the node, and a Reconnect button in the inspector.
• Topbar "Resolume" button spawns the new node at viewport center.
• Real logo + favicon set. Brand SVG retired in favor of the actual XOSC mark; filter: invert(1) for dark themes; light themes (bone, newsprint) keep it black. Site header, footer, splash, Electron Topbar, and full favicon/manifest set all share one webp.

Changed

• CSP locked down for offline / air-gapped venues. No remote font/connect/object/frame loads in index.html or splash.html. Renderer never makes outbound HTTP at runtime — only local WS to the Resolume host the user picks (default 127.0.0.1).
• External navigation blocked. setWindowOpenHandler denies popups; will-navigate rejects any non-file/non-dev URL.
• Font fallback chain prefers Windows 11 system fonts (Segoe UI Variable Display, Cascadia Mono) so the UI renders correctly on a venue laptop without the design fonts installed.
• Debug log polish. Continuous OSC + WS sends log at debug level (info filter shows discrete fires only). Resolume bridge logs every send / receive / queue / state-change main-side; renderer pipes resolume:onMessage + resolume:onStatus into the same buffer. DebugPanel gained source filter, level filter, free-text search across data payloads, tail toggle, and per-row inline data summary.

Fixed

• Gamepad axis prevAxis bug — first deliberate move post-bind now reliably trips the delta gate.
• Hydration robustness — hydrateFromSnapshot filters unknown node kinds and drops dangling edges whose endpoints don't exist (forward-compat for older saves).

Audit

• Confirmed no autoUpdater, Sentry, Bugsnag, or crashReporter calls anywhere. electron-builder --publish never keeps the build pipeline offline-only.

v0.1.0 — 2026-04-26

• Initial XOSC release. Electron app + Astro site + CI.