v0.1.2

Added

• Complete public API rustdoc for the application, core, and format crates, including units,
  input limits, errors, and links to the integration guide.
• HostedPlugin::poll_timing offers an opportunistic owning-thread timing read. Its default
  returns None, preserving existing trait implementations; timing remains the fresh read.
• The main crate re-exports ParameterFlags, Sample, the render Process trait, and public
  audio, text, preset and event/diagnostic buffer limits, avoiding a separate core dependency.
• Debug for chains, scanners, helper monitors, scan controls, render sessions and native
  plugins, modules and processors. Formatting does not invoke plugin code or acquire an
  engine lock, and render sessions do not require the caller's processor to implement Debug.
• render::Process::validate_events lets processors reject unavailable event ports across the
  whole render before processing begins; its default preserves existing implementations.
• InputError::PathEncoding identifies bundle and preset paths that the helper's Unicode path
  protocol cannot represent. Chain loading and preset requests reject them before sending them to
  a helper; scans report them individually without caching them or interrupting other bundles.

Changed

• Idle timing polls skip a busy processing engine and send only changed observations to the
  worker. CLAP reads tail after change notifications; VST3 and AU poll at a 100 ms cadence,
  retrying skipped reads. Explicit timing reads, control edits and render startup stay fresh.
• Native automation resolves and validates block edits once. CLAP and AU reuse prepared native
  point storage; VST3 resolves parameter queue indices once per assembly and holds queue locks
  while filling the block, releasing them before plugin callbacks. Control-only flushes and
  invalid-input rejection preserve pending edits, queue ordering and exact sample output.
• Unchanged scan cache entries are reused before reading executable headers. Parallel native
  scans query the Audio Unit registry within the same worker limit, alongside bundles; cache
  write failures also terminate an active registry helper.
• Render preflight sends each distinct automation target to the helper once, without fetching
  every slot's parameter list. The helper indexes metadata for both preflight and block checks;
  invalid targets anywhere in the render still fail before its first DSP call.
• Scan helpers initialize AppKit only when needed, and helper startup waits on socket/pipe
  readiness instead of sleeping between connection attempts. Interactive retries still
  initialize and activate the application before loading the plugin.
• Parameter edits, text edits and reset return the updated chain timing in their own reply,
  removing the follow-up timing request while preserving native parameter notifications.
• State and preset requests borrow the caller's payload until encoding, avoiding a full input
  copy. Encoding reserves each frame's exact size, so a large payload is held once. Completed or
  rejected writes retain at most 64 KiB of serialization scratch; closing the transport releases
  it after any pending Windows write has been cancelled and completed.
• IPC readers reuse initialized receive storage and retain bytes from subsequent frames. Large
  payloads accumulate received slices without zero-filling the unread body. Partial frames and
  deadlines remain resumable; MessageReader must be kept for the whole connection.
• AU completion and notification waits sleep when a non-main thread's run loop has no sources,
  instead of spinning. Completion callbacks still wake the wait and run-loop callbacks run.
• AU creation looks up its component description directly, avoiding enumeration and name
  queries for every unrelated registered component.
• VST3 converts each block's input events once into prepared scratch storage and skips copying
  held notes for empty input, preserving pre-DSP event expansion checks and automation order.
• CLAP output note-offs with an ID remove their matching note directly, preserving explicit
  address constraints. CLAP and VST3 skip wildcard note-off scans when no notes are tracked.
• Helper channel views are allocated for the negotiated channel counts during preparation
  and reused for processing and publication, avoiding repeated 512-channel stack arrays.
• Sidechain latency alignment uses bulk ring-buffer transfers while retaining lazy history
  initialization, exact samples and existing preparation memory limits.
• Offline ramp scheduling visits active ramps and indexes interval validation, preserving
  every per-sample point and equal-offset input order while avoiding scans of all ramps.
• Error and PresetSearchError display their context while source() retains the cause,
  avoiding duplicate messages when formatting an error chain. Format the source chain to
  include the full diagnostic; portable scan failures still retain it.
• The internal helper protocol is now 27. Applications and helpers with different protocol
  versions fail the handshake; rebuild and distribute the helper with the application.

Fixed

• A finished scan or retry releases the scan cache lock even while a process being started on
  another thread still shares the lock file, so the next scan or retry no longer fails with
  WouldBlock.
• Malformed Unicode in an AU binary preset name returns a state error instead of aborting
  during conversion from Foundation strings.
• Excessively nested VST3 moduleinfo.json metadata is ignored before recursive parsing can
  exhaust the application stack during discovery.
• AU parameters marked NonRealTime remain editable but reject block automation.
• AU input rejects a system exclusive message longer than the 65,535 bytes an AU MIDI event
  holds with InputError::EventCapacity before scheduling the block, instead of truncating its
  length.
• Helper OS event processing and editor updates run on a 10 ms deadline even while control
  requests keep arriving, so a busy caller does not starve native timers and UI events.
• AU Cocoa editor metadata with a null bundle or no non-null class name is treated like other
  incomplete Cocoa view metadata, without constructing an invalid retained pointer or indexing an
  empty class list.
• AU preparation preserves parameter, editor and bypass edits made after an unprepared state
  restore or factory preset selection when the unit took that state, and reads timing after
  restoring it. A unit whose state did not change still receives the restored state again after
  allocation.
• Scan caches survive library upgrades when their schema and architecture are unchanged.
  Helper startup, handshake and pre-request failures preserve cached plugin failure counts.
• Plugin discovery follows each directory only once, preventing repeated scans through
  directory aliases or cyclic symlinks while retaining the caller's directory priority.
• VST3 inactive parameter flushes receive the same initialized process context as prepared
  flushes, and their output parameter changes reach the controller.
• VST3 MIDI assignment queries run outside the engine lock, allowing processing to continue
  while the controller responds.
• The VST3 host attribute list accepts empty binary values with null data and rejects null
  IDs, strings, nonempty binary data and output pointers without dereferencing them.
• Timing queries deliver pending CLAP and VST3 host edits before reading the tail, so
  Chain::tail() and reported-tail renders use parameter edits immediately.
• Failed CLAP processing starts preserve queued host edits for retry. MPE-only note ports
  advertise note input and output support consistently with their event ports.
• A CLAP block consumes its pending flush request, avoiding an extra audio-thread flush on
  the next idle tick.
• Event routes that exceed the first slot's input budget are rejected with
  InputError::EventCapacity before processing, allowing a retry without reset.
• Helper output events are validated for frame offsets, ordering, ports, note values and total
  SysEx bytes before caller audio or events change. Invalid slot reports and loaded plugin
  counts also terminate the helper as protocol errors; later requests report Crashed.
• Every unexpected control response terminates the helper. Losing it during any request
  invalidates shared processing state, so later processing and rendering report NotPrepared.
• Repreparation uses the load timeout for reloading plugins; reset uses the control timeout.
  The timeout documentation now includes editor opening and distinguishes initial preparation.
• Chain is Send + Sync on Windows as on macOS, including while a timed-out overlapped
  pipe write is pending.
• A disconnected helper socket does not raise SIGPIPE in a C or Swift embedding process
  that retains the signal's default action.
• Rendering an unprepared chain reports NotPrepared before checking its input buffers, for
  both sample precisions and continuous render sessions.
• Invalid event ports anywhere in a render are rejected before DSP state advances, including
  segments submitted through RenderSession.
• Automation ramps reach their exact endpoints and stay within their endpoint range despite
  floating-point rounding, so fades to zero or one do not fail during rendering.