2026-07-30 - Lane Instrument Changes Leave MIDI Patterns Portable

This supersedes the July 24 bridge rule that retargeted lane-private note/chord metadata and forked shared patterns when an Instrument changed.
Non-drum Arrangement playback already resolves every note and Chord Engine event through the owning lane's Instrument slot and Mixer route.
setArrangementLaneInstrumentSlot() and duplicate-slot repair therefore no longer clone patterns or rewrite embedded source-slot metadata.
A pattern shared by several lanes remains one shared musical pattern; each lane may perform it with a different Instrument.
SPACEAGE_ARRANGER_EDIT_CONTRACT_ONLY now proves patternPortable=1 and sharedPortable=1.
The explicit standalone Piano Roll retarget helper remains because non-Arrangement audition/edit contexts can still require a concrete source assignment.

2026-07-30 - Fresh Lane Capacity Uses Ownership

Fresh non-drum lane creation now scans for a private Instrument slot that has no lane owner, even if stale bridge-era payload remains there.
The fresh-engine initializer resets that destination before assigning it, so abandoned labels/sounds no longer create false capacity reached failures.
Copy and Variant still require a genuinely empty destination. They must never overwrite retained payload merely because no current lane owns it.
This is a bridge hardening step, not the final unbounded Instrument registry. The final registry remains the only open storage-architecture row in the lane-independence beta checklist.

2026-07-26 - Variant Means Fresh Instrument ID

COPY INSTRUMENT FROM LANE preserves the current lane's Instrument identity while copying patch settings into that lane's private slot.
VARIANT branches the current lane to a copied private Instrument slot and must receive a new Instrument ID.
Both workflows preserve the lane role and mixer channel. The difference is semantic: copy changes the sound assigned to the same Instrument owner; Variant creates a new Instrument identity for exploratory branching.

2026-07-26 - Fresh Replacement Must Refresh Live Lane Routing

When a lane receives a fresh Instrument engine, refresh the same surfaces as any other lane-owned Instrument change: selected destination lane, Piano Roll Instrument slot, armed MIDI route, lane badge, and chain/canvas state.
Preserve the lane's private Instrument slot, mixer channel, and existing clips; reset the Instrument identity because the user intentionally created a fresh sound identity for the lane.
This prevents the confusing case where the visible lane says one Instrument while live MIDI monitoring still follows stale routing.

2026-07-26 - Shared Patterns Must Fork Before Instrument Retarget

When a non-drum lane changes Instrument and one of its clips uses a pattern also referenced by another non-drum lane, do not retarget the shared pattern in place.
Copy the full pattern payload into the next unused pattern, repoint only the changed lane's clips to the copy, and retarget the copy to the lane's private Instrument.
The copied payload must include step data, Piano Roll notes, Chord Engine clips, MIDI expression/automation events, and pattern length.
This is the lane-owned equivalent of VARIANT: preserve the musical material, protect the other lane, and keep each lane's Instrument ownership coherent.

2026-07-26 - Instrument Records Should Not Teach Storage

InstrumentBayRecord text now describes private non-drum Instruments as available for Arrangement lanes or owned by a specific lane.
Avoid phrases such as stored in Instrument ## for non-drum lane records. That phrase exposes the temporary backing-slot bridge instead of the product workflow.
Lane-owned records may mention Instrument ID, mixer channel, MIDI channel, engine, and preset because those are useful routing and identity concepts.

2026-07-26 - Visible Synth Editor Headers Are Part Of The Contract

The lane-owned Synth Editor drawer must not merely route controls correctly; it must also explain itself correctly.
Closeout now checks the drawer title, selected target label, and source label for private non-drum Instruments.
Required language: INSTRUMENT, lane name, mixer channel, MIDI channel.
Forbidden language: Pad, private slot, and Instrument Bay slot.
This should be repeated for any new shared editor surface before it is treated as final.

2026-07-25 - Native Preset Cleanup Must Follow The Owner

Shared native preset loaders now use clearSampleForActiveTarget(), clearBonusShotForActiveTarget(), and clearSoundFontForActiveTarget() before applying a new synth/lab preset.
Use these helpers when code starts from getActiveSynthEditPad() and can be editing either a visible Drum Pad or a private lane Instrument.
Do not apply this rule blindly to pad-bank construction utilities; those are intentionally Pad workflows until they become shared Instrument workflows.
This keeps source/resource cleanup aligned with the same ownership model already used for labels, SoundFont readouts, and built-in synth activation.

2026-07-25 - SoundFont Source Paths Use The Same Owner Doorway

The SoundFont editor loaded-file display now routes through getSoundFontPathForSlot().
This keeps the path readout aligned with the active Pad/Instrument owner instead of leaving a Pad-named call in a shared editor page.
Future resource readouts should follow the same pattern: visible Drum Pads may use Pad paths, while private lane Instruments should go through owner-aware slot helpers.

2026-07-25 - Shared Preset/Source Loaders Use The Active Target

Added useBuiltInSynthForActiveTarget() on the editor side.
Use this helper when shared Synth Editor code is acting on getActiveSynthEditPad() and can target either a visible Pad or a lane-owned private Instrument.
Do not use this helper for clearly Pad-only batch kit setup unless the code path becomes shared later.

2026-07-25 - Shared Clear Actions Must Use The Owner Doorway

The shared Synth Editor SoundFont clear button now branches by ownership: private lane-owned Instruments use clearSoundFontForInstrumentSlot(), while visible Drum Pads use clearSoundFontForPad().
This keeps the present bridge stable while moving the UX toward the final rule: Pads are for Drum Composer/MPC interaction; non-drum Arrangement lanes own Instruments.
Future import/clear/load actions in shared editor panels should follow the same pattern rather than calling Pad-only helpers blindly.

2026-07-25 - Private Instrument Labels Do Not Read Pad Labels

getInstrumentSlotLabel() now reads only the private Instrument label store.
Custom visible Pad labels no longer leak into private lane-owned Instrument identity.
This deliberately favors the new architecture over legacy project label migration; old scratch projects are not important enough to keep the Pad-proxy bridge alive.
Verified with rebuilt MIDI_CLOSEOUT and no-build MIDI_RECORD_TIMING, MIDI_HEALTH, MIDI_READINESS, and MIDI_PROTOCOL.

Arrangement lane menus now use plain Instrument language for fresh engines, copied sounds, and available unclaimed private Instruments.
Lane Instrument remains useful as an internal architecture term, but the live menu should teach: choose an Instrument for this Lane.
Private Instrument labels now live separately from visible Pad labels, preserving lane-owned naming while leaving the Drum Composer Pad grid alone.
Future Instrument Bay work should keep this split: the Bay is the selection/browser surface; the lane owns the chosen Instrument.

2026-07-25 - Preset Names Follow The Lane Instrument Owner

Shared Synth Editor preset/application paths now route visible names through the active owner-aware label helper.
Visible Pad workflows still write Pad labels. Lane-owned/private Instrument workflows write Instrument labels.
Patch display fallback now checks private Instrument labels before Pad labels, preventing old backing-slot names from resurfacing in non-drum lane badges and Synth Editor readouts.
Verified with rebuilt MIDI_CLOSEOUT and no-build MIDI_RECORD_TIMING, MIDI_HEALTH, and MIDI_READINESS.

2026-07-25 - Saved Patch Labels Use Active Target Ownership

refreshSavedInstrumentPatchName() now uses setActiveSynthEditLabel() and syncActiveSynthEditSlot() instead of direct Pad-label mutation.
This keeps visible Pad editing unchanged while protecting lane-owned Instrument patch saves from changing selected Pad/Pad bank state.
Treat this as the save-path counterpart to target-aware patch loading.

2026-07-25 - Patch Base Names Follow Lane Ownership

activeSynthEditBaseName() now resolves private lane-owned Instrument slots through their owning Arrangement lane even when the drawer source lane is not explicitly set.
Unowned private Instrument slots use Instrument labels or engine-based Instrument fallbacks instead of default Pad labels.
This protects status messages, patch save suggestions, and copy/paste receipts from quietly reintroducing the pad-backed bridge model.

2026-07-25 - Drawer Copy/Paste Language Is Part Of The Migration

Lane-owned Synth Editor drawers now preserve shorter Instrument wording after copy actions.
COPY INSTRUMENT and PASTE INSTRUMENT are intentional in this context; they distinguish lane Instrument editing from visible Drum Pad settings without exposing private slot mechanics.
Any future shared editor command should refresh context text after changing copy/paste state.

2026-07-25 - Variant Means New Instrument Identity, Same Lane Role

The lane VARIANT workflow now has closeout coverage.
A variant copies the lane's current Instrument settings into a new private slot, but the lane role, mixer channel, clips, notes, and chords stay put. Arrangement playback supplies the lane-owned Instrument without rewriting the score.
Mixer-owned values such as gain and effect sends must remain mixer decisions. They should not ride along when the user is only creating an alternate patch/instrument identity for the same musical lane.

2026-07-25 - Fresh Replacement Preserves Lane-Owned Identity

The NEW INSTRUMENT action for an existing non-drum lane is now guarded by MIDI closeout.
Replacing the engine on a lane preserves the lane's private Instrument slot and mixer channel; it should not allocate a new visible Pad, jump to another lane, or create an extra starter clip when the lane already contains real material.
This is the intended bridge behavior until the final Instrument Bay registry removes pad-indexed storage from non-drum lanes entirely: user-facing identity belongs to the lane, not to a Pad.

2026-07-25 - Editor Actions Must Reject Visible Pads

Add Instrument Lane and lane reassignment now reject visible Pad slots before clamping to the private lane-Instrument range.
This matters because clamping a visible Pad into a private slot looks harmless in code but preserves exactly the workflow confusion we are removing: a non-drum lane should never feel as though it was secretly created from Pad 5.
Processor restore/normalization may still clamp historical or defensive state, but user-triggered editor actions should fail clearly when they are pointed at Drum Pad space.

2026-07-25 - Lane-Owned Drawer Titles Are Explicit Instruments

The Synth Editor side label now reports the actual lane Instrument label for lane-owned targets instead of the generic [Instrument].
The closeout test now asserts that lane-owned Synth Editor titles start as Instruments, include the source lane name and mixer context, and do not contain Pad .
This keeps the bridge architecture honest until non-drum instruments are fully removed from pad-indexed internals.

2026-07-25 - Target-Aware Synth Editor Labels

Added setActiveSynthEditLabel() as the bridge helper for active Synth Editor targets.
Redshift/native patch loading, SoundFont loading, MIDI Patch Mapper SoundFont assignment, and Quasar build/load now use the helper where the same UI can target either a visible Pad or a private lane Instrument.
This should be the default label route for any future shared Synth Editor loader until the Instrument Bay registry is fully independent.

2026-07-25 - Quasar Loader Target-Aware Labeling

The Quasar loader is now named around active Instruments rather than active Pads.
Loading Quasar into a private lane Instrument updates setInstrumentSlotLabel(), while visible Pad targets still use the Pad label path.
This is a useful model for every shared engine: a source may be common, but identity must follow the target workflow.

2026-07-25 - Piano Roll Source Reads

Piano Roll readiness now uses getInstrumentSlotSourceName() instead of the Pad-facing getSampleName() call.
This is not just cosmetic: read paths influence future write paths, so non-drum lane workflows should remain on the InstrumentSlot surface whenever they inspect source identity.
The closeout gate now proves visible Pad sources stay hidden through that wrapper while private lane-Instrument sources remain readable.

2026-07-25 - Fresh Lane Creation Boundary

initialiseFreshLaneInstrument() now clears sample, SoundFont, and Quasar payloads through guarded InstrumentSlot APIs.
This keeps Add Instrument Lane aligned with Option B even while the transitional engine still stores many parameters in pad-indexed arrays.
Treat this as the creation-path counterpart to the Piano Roll preset wrapper work: both paths must talk in lane-Instrument terms at the source/identity boundary.

2026-07-25 - Piano Roll Preset Paths Use Slot Wrappers

Piano Roll preset application now uses private InstrumentSlot wrappers for sample clearing, SoundFont clearing, built-in synth activation, and private slot labels.
The lower-level synth parameters still live in the transitional pad-indexed parameter bank, but the editor no longer calls Pad-facing source/label APIs for the selected Piano Roll Instrument.
This makes the eventual registry migration smaller: preset code already speaks in lane-Instrument terms at the source/identity boundary.

The COPY INSTRUMENT SETTINGS FROM LANE submenu now uses source-lane Instrument naming internally.
This is intentionally not a behavior change. The menu still copies another lane's Instrument into the selected lane's own Instrument slot.
Keeping the internal names aligned with the workflow reduces the chance that future Instrument Bay work accidentally reintroduces shared hidden-slot assignment.

2026-07-25 - Processor-Owned Availability Check

isArrangementInstrumentSlotAvailableForNewLane() is now the public model API for deciding whether a private backing slot can be assigned to a newly created Instrument lane.
The editor no longer owns a separate copy of the private-slot availability rules.
This keeps the bridge-phase 64-slot store boxed in: visible Pad slots remain protected, lane-owned slots cannot be reused, and empty internal slots can still be allocated until the final Instrument Bay registry replaces the bridge.

2026-07-25 - MIDI Import Candidate Wording

Melodic MIDI import candidates now say Choose a lane Instrument preset or SoundFont patch.
The wizard still points the user toward useful sound choices, but the wording makes the Arrangement result clear: imported melodic data becomes a lane-owned Instrument workflow.
Protocol coverage prevents this from reverting to Instrument Bay preset.

2026-07-25 - Lane Instrument Choice Formatter

The shared editor formatter for non-drum lane instrument choices is now named formatLaneInstrumentChoiceLabel().
It still formats lane-ready instrument choices the same way, but the source name now matches the Option B migration target.
Avoid bringing back formatInstrumentBayLabel() or similar names for lane UI. Instrument Bay is the browser/place where instruments are chosen; a lane owns an Instrument.

2026-07-25 - Available Instrument Wording

Unowned private lane-instrument candidates now display as AVAILABLE INSTRUMENT ##.
Add Instrument Lane exhaustion now reports NO EMPTY INSTRUMENTS AVAILABLE, avoiding the developer-ish idea of an instrument pool.
MIDI closeout now proves the label avoids Pad, Instrument Bay slot, and private-slot language.

2026-07-25 - SoundFont Preset Access Uses Lane Instrument Wrappers

Added instrument-slot SoundFont wrappers for preset lists, counts, selected index, selected name, and selected index mutation.
Arrangement lane labels now use those wrappers when displaying SoundFont engine/preset information.
The editor now has a slot-aware SoundFont helper layer for mixed contexts such as Piano Roll presets and the SoundFont tab, where the active slot may be a visible Drum Pad or a private lane Instrument.
Visible Pad indices are rejected by the wrapper guard, preserving the split between Drum Pads and private non-drum lane instruments.

2026-07-25 - Copy Settings From Lane Workflow Contract

Added editor-level regression coverage for copying one lane's instrument settings into another lane.
The destination lane keeps its private instrument slot while receiving the copied patch label and instrument parameter value.
The workflow also preserves the selected Drum Pad/Pad bank, reinforcing that lane instrument editing and drum pad selection are separate mental models.

2026-07-25 - Lane Backing Slot Collision Repair

Non-drum lanes now defend against hidden backing-slot sharing.
setArrangementLaneInstrumentSlot() treats an already-owned target slot as a sound source to copy from, then writes the copy into the destination lane's own slot.
Project restore now runs a duplicate-slot sweep after pad/instrument payloads are loaded, so damaged state can be repaired without losing the source patch data.
MIDI closeout now reports instrumentSlotsUnique=1 when this contract holds.

2026-07-25 - Lane Instrument Identity Duplicate Repair

setArrangementLane() now repairs duplicate non-drum instrumentId values the same way it already protects duplicate lane IDs.
MIDI closeout coverage now creates duplicate instrument IDs through direct lane setting and through serialized project state, then proves SpaceAge restores each non-drum lane with a unique positive instrument ID.
This does not remove hidden backing slots yet, but it prevents the transitional model from letting two lane-owned instruments collapse into one identity.

2026-07-25 - Instrument Lane Creation Regression

A focused editor regression now protects the Add Instrument Lane workflow.
The protected behavior: new Instrument lanes insert at the top, get a 16-step starter non-drum clip, use a 16-step pattern, and do not change the selected Pad/Pad bank.
This keeps Option B visible in the main Arrangement workflow while hidden pad-backed storage is still being replaced.

2026-07-25 - Lane Synth Editor Selection Contract

Opening the Synth Editor from a non-drum Arrangement lane now has focused editor coverage.
The contract is explicit: the drawer edits the lane's private instrument slot, the drawer title says INSTRUMENT, and the currently selected Pad/Pad bank stays unchanged.
This prevents a subtle workflow regression where lane-owned editing could appear to work while quietly dragging the old Pad workflow back into the user's mental model.

2026-07-25 - New Instrument Lanes Claim An Available MIDI Channel

Instrument lane creation now asks for the first unused MIDI channel instead of deriving the channel from lane count.
This better supports external hardware, stem export, and future Instrument Bay routing because lane position no longer quietly determines MIDI identity.
Drum lanes continue to default to MIDI channel 10.

2026-07-25 - Private Instrument Slots Are Never Pads In The UI

Synth Editor context now treats every private lane-instrument slot as an Instrument, even if that slot is temporarily unowned or reached through a non-lane doorway.
Free/private instrument labels now use MIXER CHANNEL ## language to match lane badges and routing reports.
This prevents old internal pad storage numbers like Pad 57 from leaking into lane-owned instrument presentation.

2026-07-25 - Add Instrument Lane Exhaustion Uses Instrument Language

The Add Instrument Lane failure status now says NO EMPTY INSTRUMENTS AVAILABLE instead of exposing Instrument Bay/Drum Pad storage details.
This is still a bridge-phase limit, but the user-facing copy now reinforces that non-drum lanes request lane instruments while Drum lanes remain the only pad-bank workflow.

2026-07-25 - Lane Mixer Route Refresh

setArrangementLaneMixerChannel() now refreshes external MIDI input route demand and republishes the sequencer playback snapshot immediately after normalizing the lane route.
The regression suite now checks that a lane mixer route survives an instrument-slot reassignment, project restore, and live playback snapshot publication.
This keeps Option B honest during the transitional hidden-slot phase: the user-facing lane mixer assignment remains independent from the hidden instrument slot.

2026-07-24 - MIDI Split Import Defaults Allocate Lane Instruments

Channel-split MIDI import now assigns default melodic destinations through available lane-instrument allocation rather than a fixed MIDI-channel-to-backing-slot formula.
The review panel stores the chosen destination on each row, and both the preview text and commit request read the same value.
This keeps import behavior aligned with Option B: imported melodic channels become lane-instrument material, while drum channels remain Drum Composer/drum-lane material.

The lane instrument chooser now labels the copy path as COPY INSTRUMENT SETTINGS FROM LANE.
Its status and confirmation text explicitly state that the target lane receives an independent lane instrument copy, while the source lane remains unchanged.
This keeps Option B readable during the transitional hidden-slot phase: users choose instruments from lanes; they do not manage hidden pad-backed storage or accidentally create shared melodic instruments.
The MIDI import drum-row tooltip also avoids Instrument Bay slot wording and now describes the result as long-form drum notes rather than a lane instrument.
The automatic lane-instrument allocation comment now calls the result lane-owned instruments, not Instrument Bay slots, preserving the Option B language in source guidance.

2026-07-24 - Synth Drawer Context Text Follows Lane Ownership

The Synth Editor drawer now refreshes its title and copy/paste action labels through one context-aware helper.
Lane-owned instruments say LANE INSTRUMENT and use lane/instrument language; pad contexts keep normal Synth Engine / pad-oriented language.
The drawer engine dropdown now refreshes from the active edit slot instead of stale selectedPad, preventing lane-owned editors from reporting the wrong engine after lane-focused edits.

2026-07-24 - Mixer Route Persistence Is Now Tested

Added regression coverage proving that a lane can be assigned to a user-chosen mixer channel, then reassigned to a different private instrument slot, without snapping its mixer route back to the hidden slot number.
This protects the Option B workflow: lane instrument identity and lane mixer routing are separate user-facing decisions.

2026-07-24 - Active Synth Edit Label Uses Lane Identity

The Synth Engine side label now reports the lane-owned instrument identity when the editor is attached to a non-drum Arrangement lane.
Pads remain pad-labeled in Drum Composer/Pads contexts, but melodic/harmonic/bass lane editing should not teach the user to think in hidden backing pad numbers.
This is another temporary UI shield while the underlying Instrument Bay storage moves away from pad-index backing slots.

2026-07-24 - Lane Synth Drawer Uses Lane-Owned Route Label

Synth Editor drawer titles opened from non-drum Arrangement lanes now reuse the lane instrument formatter, including MIXER CHANNEL xx / MIDI CHANNEL yy and the patch display name.
This keeps the editor title aligned with the lane badge and avoids a shorter legacy label path that could drift back toward pad-slot thinking.
Drum/Pads editing remains allowed to use pad language because Drum Composer still intentionally uses pad-bank routing.

2026-07-24 - Private Instrument Slot Allocation Protects Melodic Payloads

New Instrument lanes now treat private backing slots as unavailable when any Piano Roll note or Chord Engine marker still references that slot.
This closes a transitional Instrument Bay hazard: a slot could look empty because it had no sample, SoundFont, Quasar package, or Drum Composer steps, while still owning melodic/chord material from a prior clip workflow.
The implementation is still 64-slot backed, but the allocator is now more honest while the true unbounded Instrument Bay registry is being built.

Lane-Owned Instrument Migration

Last updated: 2026-07-08

Goal

Non-drum Arranger lanes should behave as lane-owned instrument instances. The user chooses an instrument for a lane from the Instrument Bay; clips on that lane are MIDI clips for that lane. They are not conceptually assigned to Drum Pads.

Drum Composer lanes remain intentionally different: they use MPC-style pad mapping and pad mixer channels because the note-input paradigm is pad-bank based.

Option B

Option B is the chosen direction:

Non-drum lanes own instrument identity.
Non-drum lanes own mixer/channel routing.
Clips created in those lanes inherit the lane instrument.
The UI should not teach users that melodic/harmonic/bass lanes are Pad 57 or similar.
The old pad-backed storage can remain as a temporary implementation detail only while the engine is being migrated.

Current Implementation Boundary

The app still uses backing pad slots for some non-drum instrument state and mixer state. This pass hides that concept from the user-facing lane and synth-editor surfaces where possible, but deeper backend migration remains.

Migration Checklist

Add a true lane/instrument store that can hold engine type, preset state, and patch parameters without requiring a pad index.
Move non-drum mixer routing away from instrumentPad + 1.
Keep Drum Composer pad routing intact.
Update project serialization to store lane-owned instruments directly.
Update render, live MIDI, piano roll, chord engine, automation, ghost notes, and mixer routing to use lane instrument IDs instead of pad backing slots.
Remove any remaining user-facing Pad XX wording for non-drum lane instruments.
Remove dormant APVTS compatibility parameters after the lane-owned store is stable.

2026-07-22 Update

- ADD LANE now asks for Drum Lane or Instrument Lane instead of guessing.
Drum lanes remain attached to Drum Composer/pad-bank behavior by design.
Instrument lanes now present lane-owned wording in the Arrangement menu and Synth Engine drawer, with instrumentSlot serialized as the forward-facing state name.
Regression coverage now protects lane insertion reindexing and instrument-slot project restore.

Remaining Backend Split

Rename the internal instrumentPad field after the model is stable enough to avoid high-risk churn.
Move non-drum parameter storage and mixer routing to true lane-owned instrument records instead of hidden pad slots.
Keep Pad-grid workflows available for drums and deliberate MPC-style instrument triggering only.

2026-07-22 Accessor Bridge

New code should use getArrangementLaneInstrumentSlot() when referring to a non-drum lane's hidden transitional instrument slot.
getArrangementLaneInstrumentPad() remains only as a compatibility wrapper until the true lane-owned instrument store replaces hidden pad slots.
The editor now uses slot terminology for lane-owned instrument routing and editing paths.

2026-07-22 10:14 - Processor Slot Call Site Cleanup

Playback, chord triggering, melodic note triggering, recording target selection, and mixer-channel reporting now use the lane instrument slot accessor rather than the legacy pad accessor.
ArrangementLane::instrumentPad remains as a transitional backing-slot field until audio routing and mixer ownership are fully lane-native.

2026-07-22 10:25 - Lane-Aware Synth Drawer Context

Added synthDrawerSourceLane so the editor no longer has to guess which lane owns a backing instrument slot.
This reduces customer-facing pad/proxy leakage while preserving the transitional slot-backed audio path.

Arrangement lane instrument selection now presents NEW INSTRUMENT before COPY INSTRUMENT SETTINGS FROM LANE, so the customer-facing workflow teaches lane-owned instruments instead of Pad assignment.
Existing pad/backing-slot material remains available as an import/copy source during the migration, but it is no longer the primary menu story.

2026-07-23 - Fresh Lane Identity Bridge

New instrument lanes created from the Instrument Bay now enter the processor with no pre-existing lane instrument id, so the processor assigns a fresh lane-owned identity.
Copying or changing a sound inside an existing non-drum lane keeps that lane identity intact. This is the desired behavior: auditioning or replacing a patch must not destroy the lane's mixer, MIDI, automation, or future scene identity.
Drum lanes remain intentionally different: they are still tied to the Drum Composer and pad-bank model.

2026-07-23 - Drawer Language Cleanup

Lane-owned instrument editing still uses hidden backing slots internally, but the synth drawer title now treats the lane as the visible source of truth.
This keeps the migration direction intact: pads remain for drum/MPC work, while Arrangement instrument lanes teach lane-owned instruments.

2026-07-23 - Lane Naming Extended To Save/Render Defaults

Patch save, render-to-sample, and Quasar capture defaults now follow the visible lane-owned instrument identity when the synth drawer is opened from an Arrangement lane.
This removes another customer-facing trace of the transitional backing pad model without changing the audio routing contract yet.

2026-07-23 - Piano Roll Lane Lock Language

When a Piano Roll clip is opened from an Arrangement lane, the hidden/disabled instrument selector now contains a single LANE INSTRUMENT entry rather than the full Pad-backed source list.
This removes another user-facing Pad smell from non-drum lanes while preserving the internal slot bridge until the full Instrument Bay storage split is complete.

2026-07-23 - Copy Existing Instrument Wording

The lane instrument chooser still uses the transitional backing-slot bridge internally, but the copy workflow now presents candidates as instruments rather than Pad sources.
This is a bridge-state UI cleanup while the larger registry split continues: behavior is preserved, but visible language is closer to the final Instrument Bay model.

2026-07-23 - Copy/Paste Uses Active Drawer Target

Synth Drawer copy/paste now resolves through the active drawer target, which is the lane-owned instrument while editing from an Arrangement lane.
This is another guardrail around the transitional backing-slot system: internally it still stores parameters in a slot, but user actions now follow the visible editing context.

2026-07-23 - Lane Instrument Duplication Narrows Copy Scope

Lane instrument duplicate/variant actions now use copyPadInstrumentSettings() instead of full Pad copy.
The bridge still stores instruments in backing slots, but duplication now copies the instrument sound and source state without importing mixer-strip ownership values.

2026-07-23 - Synth Editor Overlay Decoupled From Pads Page

The Synth Editor drawer is now owned by the editor root rather than padsPage.
Lane-owned instruments can be edited from the Arrangement Canvas without visually routing the user through Pad-land.
This is still a transitional bridge internally because instruments are backed by slots, but the customer-facing workflow now treats the lane as the source of truth.

2026-07-23 - Current-page Editing Guard

Root-level Synth Editor overlays now close on page navigation. This keeps lane-owned editing contextual without letting the editor become an accidental global panel.

The copy-from-existing menu now resolves the owner lane for each non-drum instrument slot and presents that lane as the visible source of truth.
Hidden slot numbers remain only as fallback labels for unassigned instruments until the backing store is replaced by the final Instrument Bay registry.

2026-07-23 - User-Facing Labels Prefer Lanes Over Slots

formatInstrumentBayLabel() now checks whether an instrument slot is owned by a non-drum Arrangement lane. If so, it reports the lane name, mixer channel, and instrument display name.
Unowned entries now explicitly say UNASSIGNED INSTRUMENT ##, which is clearer than implying a pad workflow for melodic/harmonic lanes.
This is still a bridge: code paths may continue storing a backing slot internally until the true Instrument Bay registry fully replaces pad-index-backed instrument storage.

2026-07-23 - Legacy Wrapper Deleted

Deleted getArrangementLaneInstrumentPad() from the processor API. The single supported reader is now getArrangementLaneInstrumentSlot() while the deeper Instrument Bay registry continues to mature.
The remaining instrumentPad storage field is explicitly transitional backing storage, not a user-facing workflow concept.

2026-07-23 - InstrumentBayRecord::laneOwned

InstrumentBayRecord now exposes laneOwned. This gives UI and future registry code a clean boolean instead of asking whether owningLane >= 0 or reverse-engineering ownership from a backing slot.
This is a bridge affordance for the eventual true Instrument Bay: lane-owned records can be handled as musical instruments, while unowned records remain pool candidates.

2026-07-23 13:21 - Shared Ownership Lookup

Added findArrangementLaneOwningInstrumentSlot() in the editor and routed the Instrument Bay label/menu code through it. This keeps the temporary pad-backed storage bridge easier to retire when the full lane-owned instrument registry lands.

2026-07-23 13:25 - Lane-Owned Synth Drawer Titles

Synth Editor drawer titles now treat any non-drum Arrangement-owned instrument slot as LANE INSTRUMENT, even when opened through an indirect path. This avoids teaching the deprecated pad-proxy mental model for lane instruments while preserving normal pad/drum behavior.

2026-07-23 - Editor Helper Terminology

Replaced editor helper names createArrangementLaneFromBay/findNextUnusedArrangementInstrumentPad/isPadAvailableForNewArrangementInstrument with instrument-slot terminology.
The deeper processor storage still uses the transitional instrumentPad field, but user-facing lane code should continue to route through getArrangementLaneInstrumentSlot() and getInstrumentBayRecordForLane().
Drum lanes intentionally retain pad-bank language because their instrument model is still MPC-style pad mapping.

The lane instrument menu now copies from other lane-owned instruments only. This avoids asking users to reason about hidden backing slots while the true Instrument Bay registry is still being finished.
The old unassigned-slot list is intentionally not shown from the lane badge workflow. The remaining unassigned-label formatter is a fallback for non-lane contexts until the standalone Instrument Bay browser exists.

2026-07-23 - Engine-Aware Lane Creation and Replacement

Add Lane now asks for Drum Lane vs Instrument Lane, and Instrument Lane opens an engine-specific submenu instead of creating a hard-coded Redshift lane.
New instrument lanes initialize the chosen native engine in the same undo checkpoint as lane creation, then create the starter clip in that lane.
The lane badge's NEW INSTRUMENT menu now uses the same fresh-engine initializer, so replacing a lane sound source no longer goes through a stale "Create Fresh Redshift" action.
Drum lanes remain intentionally pad-bank based; non-drum lanes are lane-owned instrument instances backed by transitional internal slots until Instrument Bay is fully surfaced.

2026-07-23 - Lane-Owned Mixer Channel State

Arrangement lanes now carry an explicit mixerChannel field in the processor model and project serialization.
getArrangementLaneMixerChannel() now reads that lane-owned value when present, falling back to the transitional instrument slot only for older/empty lane state.
This is the backend foundation for user-reassignable lane mixer destinations: changing an Instrument and choosing a Mixer channel can become separate decisions instead of being fused by hidden pad-slot plumbing.
Remaining work: expose the customer-facing mixer-channel picker from the lane badge, then route audio/meter ownership through that explicit mixer destination wherever hidden pad-slot assumptions still remain.

2026-07-24 - Lane Mixer Destination Enters The Audio Path

Voice now carries both a source slot (pad) and a mixerChannel, so non-drum lane instruments can keep using transitional internal source storage while sending audio to the lane's chosen mixer strip.
Arrangement clip playback, Chord Engine playback, and armed MIDI monitoring now pass the lane-owned mixer destination into melodic voices.
The final mix stage now uses the voice mixer destination for gain, mute/solo, pan, channel-strip processing, meters, output bus routing, and shared effect sends.
Drum lanes intentionally remain pad-routed for MPC-style behavior. The split is specifically for non-drum Arrangement lanes.
The lane badge instrument menu now exposes a MIXER CHANNEL submenu for non-drum lanes, allowing the user to reassign the lane's mixer destination without changing the instrument.
Remaining work: audit remaining source-vs-mixer assumptions, especially any synth-page EQ/effect code that still reads from the source slot, and continue deleting user-facing pad language from non-drum workflows.

2026-07-24 - Piano Roll Live Input And EQ Follow Lane Mixer Destination

Added an explicit Piano Roll live-input mixer-channel bridge so monitoring an Arrangement-owned lane previews through that lane's selected mixer strip instead of falling back to the hidden source slot.
Parametric/channel EQ processing now reads mixer-destination parameters for lane-owned voices. The source slot still owns synthesis parameters; the mixer channel owns mix treatment.
This keeps the split clear: internal source storage makes the sound, lane mixer destination shapes and routes the sound.

2026-07-24 - New Instrument Lanes Use Free Mixer Channels

New instrument lanes now choose the first unused mixer channel instead of inheriting the hidden backing instrument slot number. Changing or copying a lane-owned instrument preserves the lane's mixer destination, so instrument identity and mixer routing are now separate user concepts. Drum lanes remain pad-bank/pad-mixer based by design.

2026-07-24 - Editor Current Instrument Terminology Cleanup

Renamed the editor-side current Piano Roll instrument variable from selectedPianoInstrumentPad to selectedPianoInstrumentSlot. This is intentionally a narrow cleanup: the storage bridge still uses pad-backed slots internally, but new editor code should describe non-drum instruments as instrument slots or lane-owned instruments rather than pads.

Remaining extraction target: selectPad() is still a heavy Pad-page selection path used by Synth Drawer entry, because layer and one-shot editor controls still assume selectedPad. Do not remove that call casually. The right next step is an explicit active instrument edit context so lane-owned instrument editing can target layers, one-shots, presets, and engine parameters without changing Pad-page selection state.

2026-07-24 - Synth Drawer active edit target cleanup

Layer editor refresh/actions, one-shot refresh/actions, and mod-route refresh/actions now resolve the active synth edit slot through getActiveSynthEditPad() instead of assuming selectedPad.
This is an incremental Instrument Bay migration step: the drawer can now display/edit the lane-owned instrument target more reliably while Pad/sample-layer workflows remain intact.
Intentionally kept openSynthDrawer() calling selectPad() for now because parameter attachments and several legacy engine panels still bind through selectedPad. Next split should isolate parameter attachment target selection without dragging the Pads page state along with it.

2026-07-24 - Synth Drawer attachment target cleanup

attachSynthDrawer() now computes editSlot from getActiveSynthEditPad() and binds synth/lab/EQ/SoundFont/TG-55 parameter attachments to that active drawer target.
This removes another major selectedPad dependency from lane-owned instrument editing while preserving Pads-page behavior because selected Pad remains one valid edit context.
Remaining known Pad-proxy areas include pad text refresh, several preset workflow helpers, and legacy Pad-page actions that still intentionally operate on selectedPad.

2026-07-24 - Lane-Owned Synth Drawer Stops Selecting Pads

Added isSynthDrawerEditingLaneOwnedInstrument() and syncActiveSynthEditSlot() so synth-editor code can distinguish lane-owned instruments from true Pad-page editing.
openSynthDrawer() no longer calls selectPad() when the editor is opened for a non-drum Arrangement lane. It updates the active Piano Roll instrument slot instead.
Redshift/native patch loading, SoundFont loading, Quasar loading/build loading, and saved-patch name refresh now sync the active edit slot without forcing global Pad selection during lane-owned editing.
Lunacy/Liftoff source import callbacks now guard selected-pad updates the same way.
Release standalone compile passed through the Visual Studio developer environment after this pass.

2026-07-24 - Lane Instrument Editor Entry Points Stop Forcing Pad Selection

Synth Drawer engine changes now call syncActiveSynthEditSlot() instead of assigning selectedPad directly.
The Piano Roll synth-icon path now opens the lane-owned instrument target without preselecting a Pad when the clip belongs to a non-drum Arrangement lane.
The Arranger lane instrument editor opener no longer calls selectPad() for non-drum lane instruments.
This keeps true Pad workflows available on the Pads/Drum Composer side, while non-drum lane editing presents as lane/instrument work.
Verification: Release standalone compile passed after this cleanup.

2026-07-24 - Lane Badge SoundFont/Fresh Engine Actions Decoupled From Pad Selection

The lane badge's NEW INSTRUMENT and LOAD SOUNDFONT INTO INSTRUMENT actions now retarget the lane's active instrument slot without assigning selectedPad.
Synth Editor SoundFont load/clear buttons now call syncActiveSynthEditSlot() so lane-owned SoundFont edits do not force Pad-page selection.
PASTE INSTRUMENT SETTINGS now opens through the active synth edit target; it only calls selectPad() for true Pad-context editing.
Remaining intentional selectedPad assignments are Pad-page workflows and standalone Piano Roll legacy paths. The next deeper architectural cleanup is renaming/removing processor-level instrumentPad terminology once lane-owned instrument slots are stable.
Verification: Release standalone compile passed.

2026-07-24 - Processor slot boundary cleanup

Renamed the ArrangementLane backing field from instrumentPad to instrumentSlot so non-drum lanes no longer describe their owned generator as a pad internally.
Added CinematicDrumsAudioProcessor::setArrangementLaneInstrumentSlot() so editor code no longer mutates the lane-owned instrument slot directly.
Updated lane instrument reassignment and MIDI import lane creation to use instrumentSlot storage/accessors.
New project state now writes instrumentSlot for Arrangement lanes; legacy instrumentPad reads remain only as a quiet fallback for old test state.
Release standalone compile passed after the change.

2026-07-23 - Instrument Slot Naming Is Now Source-Level

Arrangement lanes now store their non-drum generator reference as instrumentSlot in source, not instrumentPad.
Added getInstrumentBayRecordForInstrumentSlot() so lane-owned code can ask for an Instrument Bay record without speaking in Pad-page terms.
Lane creation, lane labels, MIDI import lane creation, save-state writing, and processor lane records now use the slot-oriented path.
The remaining getInstrumentBayRecordForPad() calls are intentional Pad-page or compatibility storage calls. They are not the desired Arrangement-lane user workflow.
Compile check: Release standalone target builds successfully after the cleanup.

2026-07-23 - Legacy Lane Pad Restore Removed

Removed the old Arrangement-lane instrumentPad restore fallback. New lane state restores from instrumentSlot only.
Remaining instrumentPad identifiers in source are real pad/note capture contexts, not Arrangement lane ownership.
Compile check: Release standalone target builds successfully after removing the fallback.

2026-07-23 - Piano Roll Target Slot API

Added primary Piano Roll instrument-slot accessors: setPianoRollInstrumentSlot(), getPianoRollInstrumentSlot(), setPianoRollLiveInputInstrumentSlot(), and getPianoRollLiveInputInstrumentSlot().
Moved processor/editor call sites to the slot-named accessors so lane/Piano Roll routing no longer has to call Pad-named target APIs.
Renamed the Piano Roll target backing atomics from pianoRollInstrumentPad and pianoRollLiveInputPad to pianoRollInstrumentSlot and pianoRollLiveInputInstrumentSlot.
Kept Pad-named accessors only as compatibility wrappers. The slot API is now the primary path.
Compile check: Release standalone target builds successfully after this cleanup.

2026-07-23 22:23 - Instrument Slot Wrapper Slice

Added processor-level instrument-slot wrapper APIs for lane-owned instruments: labels, SoundFont/Quasar presence and clearing, built-in synth activation, source-name reporting, and instrument-slot copying.
Updated Arrangement lane-owned code paths to call the slot-named APIs instead of directly using Pad-named calls for lane instrument initialization, reassignment, duplication, and availability checks.
Kept the existing Pad APIs intact for Drum Composer, MPC-style Pads, and legacy internal storage while the Instrument Bay extraction continues.
Verified Release Standalone compile. Remaining architectural dependency: true unbounded Instrument Registry / Instrument Bay object storage is still not complete; instrument slots remain backed by the current 64-bank engine.

2026-07-23 22:32 - Private Lane Instrument Slot Policy

New non-drum Arrangement lanes now allocate from private upper instrument slots only (16-63), preserving visible Pads 1-16 for Drum Composer / MPC-style pad workflows.
If no private slot is available, lane creation now fails instead of silently borrowing a visible drum pad slot. This is a transitional safeguard until the real unlimited Instrument Bay registry replaces the 64-slot backing store.
Drum lane customer-facing text now says Drum Mixer / Drum Mapping rather than Pad Mixer / Drum Pad Mapping where the context is the Arrangement lane system.

2026-07-24 - Private Instrument Slot Policy Centralized

Added CinematicDrumsAudioProcessor::firstPrivateArrangementInstrumentSlot = 16 so the first visible 16 MPC-style pads stay reserved for drum-pad workflow.
New non-drum Arrangement lanes now search private instrument slots 64 down to 17 and fail cleanly if that pool is full, instead of silently borrowing visible drum pads.
This is still a transitional 64-slot-backed implementation; the final Instrument Bay should replace the pad-backed slot pool with true lane-owned instrument records.

2026-07-23 23:32 - Private Slot Guard and Mixer Stability

Non-drum lanes are now guarded away from visible drum pad slots when set through processor lane APIs.
Valid lane mixer-channel assignments are preserved when the lane instrument changes; choosing an instrument must not silently reroute the lane to a different mixer strip.
This is still the transitional 64-slot-backed implementation, not the final unbounded Instrument Bay registry.

2026-07-24 - MIDI Split Import Uses Lane-Owned Destination Language

The MIDI split-import dialog no longer exposes non-drum destinations as raw 1-64 instrument slots. Drum material still imports as a long-form Drum Lane, while melodic/harmonic channels are presented as private lane-owned instruments. Existing lane-owned instruments include their lane name in the destination picker so the user sees a musical lane target instead of a pad/proxy assignment.

Regression coverage touched this same pass: SPACEAGE_ARRANGER_EDIT_CONTRACT_ONLY, MIDI_RECORD_TIMING, MIDI_HEALTH, and MIDI_READINESS all pass after the UI wording and destination filtering change.

2026-07-24 - Split Import Clamps Melodic Destinations To Private Lane Instruments

The processor MIDI split-import path now explicitly clamps non-drum imported lanes to private Arrangement instrument slots. This closes a stale edge where an old/custom request could still name a visible drum-pad-range slot for melodic material. The UI already presents these destinations as lane instruments; now the backend contract enforces the same model.

Regression added: the MIDI protocol gate deliberately requests a stale visible-slot melodic destination during split import and requires the resulting non-drum lane to land in the private lane-instrument range. MIDI_PROTOCOL passes with this regression in place.

2026-07-24 - setArrangementLane Clamps Stale Visible Pad Slots

Added a closeout regression proving that if stale code attempts to assign a non-drum Arrangement lane to a visible drum-pad slot, the central lane setter clamps it back into the private lane-instrument slot range. Drum lanes remain the only lanes allowed to resolve to visible pad slot 0 during this bridge phase.

2026-07-24 - Split Import UI Also Clamps Melodic Destinations

The MIDI split-import dialog now clamps non-drum destination selections to the private lane-instrument slot range before building the commit request. This matches the backend guardrail and keeps the UI from handing melodic/harmonic lanes visible drum-pad slot IDs during import.

2026-07-24 - Standalone Piano Roll Selector Avoids Visible Drum Pads

The standalone Piano Roll instrument selector now lists private lane-instrument slots instead of the visible first 16 drum-pad slots, and maps selections by ComboBox item ID rather than visible row index. The selector no longer changes global Pad selection as a side effect. Arrangement lane clips remain lane-locked and continue to display their owning lane instrument only.

2026-07-24 - Piano Roll And Chord Helpers Clamp To Lane-Instrument Space

Piano Roll and Chord Engine helper paths that retarget notes/chords or infer the active standalone instrument now clamp selected tonal instruments into the private lane-instrument range. This keeps helper code aligned with the visible selector and prevents melodic/chord workflows from drifting back into Pads 1-16 during the bridge phase.

2026-07-24 - Removed Piano Roll Pad-Named Compatibility Wrappers

Removed the processor's pad-named Piano Roll instrument/live-input wrappers and renamed MIDI step-input storage from pad terminology to instrument-slot terminology. Step input now clamps its target into the private lane-instrument slot range. The voice engine still uses pad-backed slots internally during the bridge phase, but the public Piano Roll/MIDI API no longer teaches Pad identity for tonal step input.

2026-07-24 - Synth/Lab Presets Use Active Edit Slot

Converted synth and Drum Lab preset application paths from selectedPad to getActiveSynthEditPad(). This preserves normal Pad-page editing while preventing lane-owned Synth Drawer edits from writing a preset into whichever visible pad happened to be selected before the drawer opened.

2026-07-24 - Playback Snapshot Private-Slot Guard

Arrangement playback now clamps non-drum clip lane instrument slots to the private lane-instrument range when resolving snapshot playback. This is a defensive guardrail: normal lane setters already normalize the value, but playback should not be able to revive visible drum-pad slot identity if stale data ever reaches a snapshot.

2026-07-24 - Playback Guard Has A Regression

Added a self-test-only playback snapshot hook that can intentionally inject a stale visible Pad-slot value into a non-drum Arrangement lane after normal lane validation has already clamped it.
The regression confirms playback still resolves that stale value back to the private Arrangement instrument pool, so non-drum lanes cannot accidentally revive Pads 1-16 through a stale snapshot path.
Verification: MIDI_CLOSEOUT passes with playbackSlotGuard=1; MIDI_RECORD_TIMING and MIDI_PROTOCOL also passed after the guard work.

2026-07-24 - Lane Instrument Copies Undo As One Gesture

Duplicating a lane instrument into a new lane now wraps the hidden instrument copy and the visible lane/clip creation in one checkpoint. Copying an Instrument Bay choice into an existing lane-owned instrument also checkpoints before the hidden slot changes, so Undo matches the user gesture instead of leaving private instrument residue behind.

2026-07-24 - SoundFont And Source Editors Follow Lane-Owned Instruments

SoundFont preset/filter controls, Liftoff source clearing, Lunacy source clearing, P-key preview, sample-layer loading, and one-shot loading now resolve through the active synth edit slot when the drawer is editing a lane-owned Instrument. This removes another set of selected-pad leaks from non-drum Arrangement lane editing.

2026-07-24 - Flux Nodes And Tab Indicators Use Active Edit Slot

Flux Nodes and the Synth Engine tab-used highlighter now resolve through getActiveSynthEditPad() instead of reading selectedPad. This keeps lane-owned instruments honest: opening a lane's synth editor, Flux Nodes panel, or tab state no longer silently inspects the currently selected drum pad.

2026-07-24 - Instrument Bay Wording No Longer Exposes Pad Slots

Cleaned customer-facing Instrument Bay labels so unassigned private lane instruments appear as AVAILABLE INSTRUMENT ## and MIDI import destinations appear as INSTRUMENT ##, not pad-backed slot names. The backend still uses private slots 16-63 as an interim storage layer, but the visible workflow now reinforces that melodic/harmonic lanes own instruments directly while Drum Composer owns the MPC-style pad bank.

2026-07-24 - Lane Instrument Changes Normalize Lane-Private Patterns (Superseded 2026-07-30)

When a non-drum Arrangement lane changes instruments, SpaceAge now retargets note and Chord Engine metadata for patterns used only by that lane. Shared patterns are deliberately skipped so one lane's instrument change cannot silently rewrite another lane's clip data. Playback already resolves notes/chords through the lane-owned instrument slot; this pass improves editor/export/readback consistency for lane-private material.

2026-07-24 - Lane Instrument Changes Normalize Lane-Private Patterns (Superseded 2026-07-30)

Instrument-lane reassignment now retargets MIDI notes and Chord Engine markers inside lane-private pattern payloads to the lane's newly chosen Instrument Bay slot. Shared pattern payloads are deliberately skipped so changing one lane cannot silently rewrite another lane's musical material.

Regression coverage: SPACEAGE_ARRANGER_EDIT_CONTRACT_ONLY now reports privateRetarget=1 and sharedSkip=1.

2026-07-24 - Central Setter Owns Lane Retargeting (Superseded 2026-07-30)

setArrangementLaneInstrumentSlot() now performs the lane-private note/chord retarget internally. This prevents future UI, import, duplicate, or setup paths from changing the lane-owned instrument slot while leaving stale note/chord metadata behind.

2026-07-24 - Piano Roll Setters Enforce Private Instrument Range

The Piano Roll and live-input instrument setters now enforce the same private lane-instrument boundary as the selector UI. This prevents future MIDI recording or preview code from accidentally assigning melodic input to Pads 1-16 during the transitional slot-backed phase.

Visible Pad Slot Ownership Guard

Editor helpers that create, initialize, or reassign instrument lanes now clamp to the private lane-instrument range. Ownership lookup treats slots below firstPrivateArrangementInstrumentSlot as drum pads and returns no lane owner, preserving the Drum Composer/Instrument Lane split.

Pad Presets No Longer Hijack Piano Roll Focus

Preset application and sample import now treat visible pads as drum-pad edits and private slots as lane-instrument edits. This keeps Pad workflow useful without resurrecting the deprecated pad-proxy model for instrument lanes.

Private Instrument Labels Stop Saying Pad

getInstrumentBayRecordForInstrumentSlot() now sanitizes default Pad XX labels for private slots, while getInstrumentBayRecordForPad() remains truthful for the Drum Composer and pad workflows. The public lane story stays instrument-first even while the backend still uses pad-indexed parameters.

Instrument Slot Copy Guard

copyInstrumentSlotSettings() now requires both source and destination to be private lane-owned instrument slots. This keeps hidden lane-copy and Instrument Bay workflows from treating the visible Drum Composer pad bank as generic storage in either direction. If SpaceAge later adds an explicit Import From Pad command, it should be a separate named workflow with confirmation, not a generic InstrumentSlot copy.

InstrumentSlot Wrappers Reject Visible Pads

The InstrumentSlot compatibility wrappers now enforce the private lane-owned instrument boundary. This is a bridge-phase guardrail: the backing store is still pad-indexed internally, but APIs that describe lane instruments should not read or write visible Drum Composer pads.

Non-Lane Pad Selection Page Sync

The remaining legitimate Pad-selection paths now keep selectedPadPage synchronized with selectedPad. This does not change the lane-owned Instrument model; it only keeps legacy Pad-page state coherent while the Instrument Bay bridge still exists.

2026-07-24 - Edit Target / Pad Selection Boundary

Private Arrangement instrument slots can be the Synth Drawer target and Piano Roll instrument target, but they no longer drive selectedPad or selectedPadPage.
The remaining visible-pad selection writes are intended for true Pad workflows: Pad page buttons, Drum Composer lane buttons, pad vault actions, and bank loading.
This preserves the product rule: instrument lanes own instruments; Pads remain the drum/MPC surface.

2026-07-24 - Drawer Target Boundary

The Synth Drawer now resolves an owning Arrangement lane from the target instrument slot before deciding whether to behave as a Pad editor or a lane-owned Instrument editor.
This is a transitional guard while private instruments still use pad-indexed storage internally: the storage may be pad-shaped, but the user-facing edit target must stay lane/instrument-shaped.

Audited the Arrangement lane instrument menu after the drawer owner-inference fix. The active architecture remains: non-drum lanes own private instrument slots; copying another lane's instrument copies settings into the current lane's private slot rather than making the lane share a visible Pad.
Updated user-facing SoundFont status text to describe lane instrument loading instead of implying Pad-badge loading for instrument lanes.

2026-07-24 07:58 - Visible Pads No Longer Masquerade As Lane Instruments

The Synth Drawer/lane lookup helper now rejects visible Pad slots before checking Arrangement lane ownership. This prevents Pad 01-16 from being misidentified as whatever private instrument slot they would have clamped to.
Fallback record info now presents untouched private backing storage as a Lane Instrument, not an Instrument Bay slot.

2026-07-24 08:06 - Direct Private Records Use Lane Instrument Language

Even direct private backing-slot records now describe themselves as Lane Instruments. This keeps the visible Pad grid reserved for Drum Composer/MPC behavior while the transitional backing store remains hidden from user-facing labels.

The lane instrument menu now shows the current lane instrument/mixer/MIDI identity before offering NEW INSTRUMENT, COPY INSTRUMENT SETTINGS FROM LANE, or SEND TO MIXER CHANNEL actions. This reinforces the final model: non-drum lanes own instruments and can route to user-chosen mixer channels; pads remain the drum/MPC surface.

2026-07-24 09:14 - Piano Roll Preset Categories Stop Saying Pad

Piano Roll preset category labels that previously said Pad | ... now say Atmosphere | .... This is not an engine change; it is a workflow-language cleanup so tonal lane work does not imply hidden ownership by the Pad grid. The Pad page remains the MPC/drum/performance surface; instrument lanes remain lane-owned.

2026-07-24 09:18 - Redshift Starting Points Stop Using Pad As Category

Redshift starting-point preset categories now use Atmosphere | ... for pad-like sounds instead of Pad | .... Patch names may still include the word Pad when that is the musical name of the sound, but the category no longer implies Pad-grid ownership for non-drum lanes.

2026-07-24 10:52 - Split MIDI Import Private-Slot Guard

Split-channel MIDI imports now avoid reusing the same private arrangement instrument slot across melodic lanes. Imported drum material remains intentionally pad-backed, but imported melodic lanes become lane-owned instrument clients by default. Private default names are normalized to Init labels to keep the lane-first Instrument Bay model clear.

2026-07-24 11:08 - Explicit Split-Import Slot De-Dupe

Split MIDI import no longer trusts duplicate explicit private instrument-slot requests as shared ownership. The first requested slot may be used, but later melodic lanes reserve a unique private fallback. This protects the migration rule: one non-drum lane owns one instrument instance unless the user deliberately invokes a future shared-instrument workflow.

2026-07-24 11:16 - InstrumentSlot Label Sanitizing

getInstrumentSlotLabel() now returns an empty label for private slots still carrying default Pad XX names, while preserving custom private labels. This keeps availability checks useful and prevents low-level helper callers from reintroducing pad-proxy wording into non-drum lane workflows.

2026-07-26 00:18 - Shared Asset Loads Use InstrumentSlot Wrappers

The shared Synth Editor now routes SoundFont and one-shot loads through active-target helpers. If the active target is a private Arrangement Instrument slot, the processor receives an InstrumentSlot load; if the active target is a visible Pad, the processor receives the Pad load. SoundFont path reads also have an InstrumentSlot wrapper. This keeps the UI workflow lane-owned without disrupting true Pad-bank loading, bulk pad loading, or Drum Composer behavior.

2026-07-26 00:44 - Sample Layer Controls Respect The Same Boundary

The layer editor, velocity-layer helpers, and Liftoff/Lunacy source selectors now use the same active-target rule as SoundFont and one-shot loading. Private Arrangement Instrument slots route through InstrumentSlot sample-layer wrappers; visible Pads still route through the existing Pad APIs. Clear All Pads remains explicitly Pad-based because it is a Pad-bank housekeeping command, not a lane-owned Instrument operation.

2026-07-26 01:05 - Boundary Covered By Closeout

Sample-layer wrapper behavior is now covered by MIDI_CLOSEOUT. The test proves visible Pad layer state cannot be mutated through InstrumentSlot wrappers, while private lane-owned Instrument layer state can be loaded, activated, cleared, expanded, and spread through those wrappers.

2026-07-26 01:24 - Quasar Joins The Active-Target Rule

Quasar package load/reveal/readout paths now use active-target helpers from the shared Synth Editor. This keeps lane-owned Quasar Instruments independent from visible Pads even while the internal storage arrays are still pad-shaped during the migration.

2026-07-26 02:42 - Effects And Mixer Labels Respect Lane-Owned Instruments

The Effects source chooser now labels drum targets as Drum Pads and lane-owned targets with their Instrument/Mixer/MIDI identity instead of generic source numbers or Pad wording. Mixer strip headers now say MIXER ## when a non-drum lane owns that destination, while true drum-only destinations can still say PAD ##. Mixer strip tooltips include lane name, patch label, and MIDI channel, keeping the temporary private-slot backing store hidden while the signal-flow UI teaches the final model: Lane -> Instrument -> Mixer Channel.

2026-07-26 03:10 - Piano Roll Clip Context Names The Owning Lane

When the Piano Roll is opened from an Arrangement clip, its Instrument selector now behaves as a disabled receipt that names the owning lane before the Instrument/Mixer/MIDI details. This blocks the old top-inspector confusion: the lane badge remains the place to change the Instrument, while the Piano Roll only reports the lane-owned target during clip editing.

2026-07-29 - Beta Gate Lane-Independence Checklist

The beta readiness health model now exposes instrumentLaneIndependenceChecklist. It turns the Instrument Bay / lane-independence blocker into inspectable rows covering creation, visible-Pad rejection, unique Instrument IDs/backing slots, copy/variant semantics, fresh Instrument replacement, portable shared patterns, owner-aware shared editor loaders, lane-facing language, Arrangement recording targets, and the remaining final Instrument registry work.

The honest state is bridge-phase, not final architecture. Most lane-facing contracts have automated closeout proof, but the final row remains open until non-drum Instrument parameter/preset/resource storage is moved out of hidden pad-indexed backing arrays and into the unbounded Instrument registry.

2026-07-30 - Non-Overlapping Source Backing Implemented

The bridge store no longer overlaps the 64 Drum Pads. Current cardinalities are explicit:

64 Drum source slots: 0-63.
16 private Arrangement Instrument source slots: 64-79.
64 Mixer channels: 1-64, stored internally as 0-63.
16 maximum Arrangement lanes.

Mixer-owned parameter arrays are now sized to numMixerChannels, while synthesis/sample/source arrays are sized to numSourceSlots. Drum pattern arrays are sized to numDrumPads. The transitional numPads alias remains only as the total source-slot count while remaining pad-shaped source APIs are renamed incrementally.

Lane-Instrument assignment uses a compact Instrument-slot Undo record. The record contains source parameters and source assets, but no Mixer processing. Undo and Redo capture the inverse Instrument snapshot in place, preserving the normal clipboard and the destination Mixer channel.

Automated boundary proof covers constants, Drum row 64 rejection, private parameter isolation, Mixer preservation, Undo/Redo, and private Redshift playback. The full native synth smoke matrix also passes after the split.

Remaining migration work:

Replace the transitional numPads source alias with numSourceSlots throughout internal source-only code.
Replace pad-shaped naming on shared source APIs with explicit DrumPad or InstrumentSource terminology.
Decide whether public beta remains at 16 Arrangement lanes or moves to a dynamically allocated Instrument registry before beta.
Perform human lane creation, replacement, save/load, routing, and Mixer QA with new projects.

2026-07-30 - Follow-Up Implementation

Explicit validators now distinguish Drum Pad, total source-slot, Mixer-index, and customer-facing Mixer-channel domains.
Default BASS, HARMONY, and MELODY lanes use private slots 64-66 rather than obsolete Pad-range slots.
Instrument Bay lookup resolves private source routing through lane ownership.
Generic live MIDI, channel-10 playback, and recording proof cannot address private sources as Drum Pads.
Compact Instrument snapshots include Flux Nodes, and project-load duplicate repair is intentionally non-undoable.
State roundtrip proof covers lane type, source slot, Mixer channel, MIDI channel, names, source label, drive, and independent Mixer gain.

The next migration slice is to make fresh Instrument replacement reset every source-only subsystem consistently, update old tests to allocate private slots from 64 upward, and exercise Arrangement playback through a lane-routed private source while hostile source-index Mixer values are present.

2026-07-30 - Fresh Replacement And Explicit Routing Completed

Fresh lane-Instrument replacement now calls resetInstrumentSlotSourceState() in the processor. The processor owns the complete definition of a clean Instrument source, so editor code no longer carries an incomplete list of parameters or assets to clear. The reset excludes all Mixer-owned state and supports compact source-only Undo/Redo.

The old private-slot test fixtures have been migrated to offsets from firstPrivateArrangementInstrumentSlot. A hostile-routing audio regression now proves that a private source routed to Mixer Channel 17 ignores contradictory mute, gain, and pan values on the numerically source-derived channel. That remains true after save/load and targeted Instrument Undo/Redo.

The migration's remaining bridge work is primarily terminology and capacity: retire the transitional numPads alias from source-only internals, continue renaming shared pad-shaped APIs, and decide whether beta intentionally ships with 16 Arrangement lanes or first receives dynamically allocated Instrument records.

2026-07-30 - Audition And Effects Obey Lane Routing

Direct synth/Piano Roll/chord audition requests now carry a resolved Mixer channel into the audio thread. They no longer clamp a private source number into Mixer Channel 64. The Effects page uses the same resolver when attaching sends and EchoRay sync controls, so selecting a lane Instrument edits the processing on that lane's assigned channel.

Processor source loops and arrays have been migrated from the transitional numPads spelling to numSourceSlots. The compatibility alias remains temporarily at the public boundary while editor-facing Pad and Instrument APIs are separated deliberately.

2026-07-30 - Patches Preserve The Lane's Mix

Factory preset selection, SoundFont preset selection, and initial Piano Roll Instrument setup now modify source-owned sound parameters only. They do not unmute a channel, move its fader or pan, change its output, or disable its EQ. Drum Lab presets obey the same rule even when their source engine lives in the shared source implementation.

MIDI file channel-split review also uses the lane-owned boundary. Each selected melodic channel must have a unique reviewed private Instrument destination; the backend honors that exact destination or rejects the row with a warning. It no longer substitutes an unreviewed slot after the musician commits.

2026-07-30 - Common Synth EQ Surface Removed

The shared EQ tab has been removed from the Synth Engine drawer. Its controls, attachments, layout, active-tab highlighting, and unused graph component are gone. Instrument patches continue to own engine-native tone controls such as filters, drive, resonance, transient shape, and bit reduction; channel EQ remains exclusively owned by the lane's assigned Mixer channel.

Tab highlighting now resolves through synthTabIndexForEngine() rather than a second hard-coded engine-to-tab table. This prevents SoundFont, TG-55, and later engines from highlighting the wrong tab when the drawer order changes.

Automated proof now rejects any Synth Engine tab named EQ, in addition to rejecting Mixer gain, pan, mute, output, EQ, and send IDs from native patch allowlists. The focused Instrument-UI slice and complete AudioSelfTest suite pass after the removal.

2026-07-31 - Beta Capacity Decision

SpaceAge beta intentionally supports a maximum of 16 Arrangement lanes. The current private Instrument-source pool also contains 16 non-overlapping sources, one for every possible Arrangement lane, while the 64 Drum Pads remain in their own disjoint source range. Therefore, the bridge does not impose a lower practical Instrument limit than the Arrangement itself and is not a beta blocker.

The future dynamic Instrument registry remains valid product architecture, especially if SpaceAge later removes the 16-lane ceiling, introduces reusable Instrument instances, or hosts plug-ins. It is now classified as post-beta architecture rather than an incomplete beta promise. Beta proof must still show that all 16 lanes can own unique Instruments, survive save/load, route independently, and never mutate visible Drum Pads.