@mthines/reaper-mcp 0.13.0 → 0.14.1

package/main.js

@@ -1875,6 +1875,270 @@ function registerEnvelopeTools(server) {
   );
 }
 
+// apps/reaper-mcp-server/src/tools/batch.ts
+import { z as z15 } from "zod/v4";
+function registerBatchTools(server) {
+  server.tool(
+    "set_multiple_track_properties",
+    "Batch set properties (volume, pan, mute, solo, recordArm, phase, input) on multiple tracks in a single call. Much more efficient than calling set_track_property repeatedly. Pass an array of track update objects, each with trackIndex and any properties to change.",
+    {
+      tracks: z15.array(z15.object({
+        trackIndex: z15.coerce.number().int().min(0).describe("0-based track index"),
+        volume: z15.coerce.number().optional().describe("Volume in dB (0 = unity gain)"),
+        pan: z15.coerce.number().min(-1).max(1).optional().describe("Pan position -1.0 (left) to 1.0 (right)"),
+        mute: z15.coerce.number().int().min(0).max(1).optional().describe("Mute state (0=unmuted, 1=muted)"),
+        solo: z15.coerce.number().int().min(0).max(1).optional().describe("Solo state (0=unsolo, 1=solo)"),
+        recordArm: z15.coerce.number().int().min(0).max(1).optional().describe("Record arm state (0=unarmed, 1=armed)"),
+        phase: z15.coerce.number().int().min(0).max(1).optional().describe("Phase inversion (0=normal, 1=inverted)"),
+        input: z15.coerce.number().int().optional().describe("REAPER input index (-1 = no input)")
+      })).describe("Array of track property updates to apply")
+    },
+    async ({ tracks }) => {
+      const res = await sendCommand("set_multiple_track_properties", { tracks });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "setup_fx_chain",
+    "Add multiple FX plugins to a track with optional initial parameter values in a single call. Returns the FX chain indices of added plugins. More efficient than calling add_fx and set_fx_parameter repeatedly.",
+    {
+      trackIndex: z15.coerce.number().int().min(0).describe("0-based track index"),
+      plugins: z15.array(z15.object({
+        fxName: z15.string().describe('FX plugin name (partial match supported, e.g. "ReaEQ", "VST: Pro-Q 3")'),
+        enabled: z15.coerce.number().int().min(0).max(1).optional().describe("Initial enabled state (1=enabled default, 0=bypassed)"),
+        parameters: z15.array(z15.object({
+          index: z15.coerce.number().int().min(0).describe("Parameter index"),
+          value: z15.coerce.number().min(0).max(1).describe("Normalized parameter value 0.0\u20131.0")
+        })).optional().describe("Initial parameter values to set after adding the plugin")
+      })).describe("Array of FX plugins to add, in order")
+    },
+    async ({ trackIndex, plugins }) => {
+      const res = await sendCommand("setup_fx_chain", { trackIndex, plugins });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "set_multiple_fx_parameters",
+    "Batch set parameters across multiple FX plugins, potentially on different tracks, in a single call. Much faster than repeated set_fx_parameter calls. Pass an array of update objects with trackIndex, fxIndex, paramIndex, and value.",
+    {
+      updates: z15.array(z15.object({
+        trackIndex: z15.coerce.number().int().min(0).describe("0-based track index"),
+        fxIndex: z15.coerce.number().int().min(0).describe("0-based FX index in the chain"),
+        paramIndex: z15.coerce.number().int().min(0).describe("0-based parameter index"),
+        value: z15.coerce.number().min(0).max(1).describe("Normalized parameter value 0.0\u20131.0")
+      })).describe("Array of FX parameter updates to apply")
+    },
+    async ({ updates }) => {
+      const res = await sendCommand("set_multiple_fx_parameters", { updates });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+}
+
+// apps/reaper-mcp-server/src/tools/categories.ts
+import { z as z16 } from "zod/v4";
+var TOOL_CATEGORIES = {
+  project: {
+    name: "project",
+    description: "Project-level information: name, tempo, time signature, sample rate, transport state",
+    tools: ["get_project_info"]
+  },
+  tracks: {
+    name: "tracks",
+    description: "Track management: list, inspect, and set properties (volume, pan, mute, solo, record arm, phase, input). Includes batch set for multiple tracks at once.",
+    tools: ["list_tracks", "get_track_properties", "set_track_property", "set_multiple_track_properties"]
+  },
+  fx: {
+    name: "fx",
+    description: "FX chain management: add, remove, inspect, and set parameters. Includes batch setup of an entire FX chain and batch parameter updates across multiple plugins.",
+    tools: ["add_fx", "remove_fx", "get_fx_parameters", "set_fx_parameter", "set_fx_enabled", "set_fx_offline", "setup_fx_chain", "set_multiple_fx_parameters"]
+  },
+  transport: {
+    name: "transport",
+    description: "Transport control: play, stop, record, get transport state, set cursor position",
+    tools: ["play", "stop", "record", "get_transport_state", "set_cursor_position"]
+  },
+  midi: {
+    name: "midi",
+    description: "MIDI item editing: create items, insert/edit/delete notes and CC events, batch operations, analysis. Use analyze_midi first for large items; paginate with get_midi_notes offset/limit.",
+    tools: [
+      "create_midi_item",
+      "list_midi_items",
+      "get_midi_notes",
+      "analyze_midi",
+      "insert_midi_note",
+      "insert_midi_notes",
+      "edit_midi_note",
+      "edit_midi_notes",
+      "delete_midi_note",
+      "get_midi_cc",
+      "insert_midi_cc",
+      "delete_midi_cc",
+      "get_midi_item_properties",
+      "set_midi_item_properties"
+    ]
+  },
+  media: {
+    name: "media",
+    description: "Media item editing: list, inspect, set properties, split, delete, move, trim, stretch markers. Includes batch set for multiple items at once.",
+    tools: [
+      "list_media_items",
+      "get_media_item_properties",
+      "set_media_item_properties",
+      "set_media_items_properties",
+      "split_media_item",
+      "delete_media_item",
+      "move_media_item",
+      "trim_media_item",
+      "add_stretch_marker",
+      "get_stretch_markers",
+      "delete_stretch_marker"
+    ]
+  },
+  selection: {
+    name: "selection",
+    description: "Selection and navigation: get selected tracks, get/set time selection range",
+    tools: ["get_selected_tracks", "get_time_selection", "set_time_selection"]
+  },
+  markers: {
+    name: "markers",
+    description: "Markers and regions: list, add, delete markers and regions with optional names and colors",
+    tools: ["list_markers", "list_regions", "add_marker", "add_region", "delete_marker", "delete_region"]
+  },
+  tempo: {
+    name: "tempo",
+    description: "Tempo map: get all tempo and time signature changes with positions, BPM, and linear/step flags",
+    tools: ["get_tempo_map"]
+  },
+  envelopes: {
+    name: "envelopes",
+    description: "Automation envelopes: create, inspect, insert/delete points, clear, batch insert, set properties. Supports volume, pan, mute, width, trim volume, and FX parameter envelopes.",
+    tools: [
+      "create_track_envelope",
+      "get_track_envelopes",
+      "get_envelope_points",
+      "insert_envelope_point",
+      "insert_envelope_points",
+      "delete_envelope_point",
+      "clear_envelope",
+      "remove_envelope_points",
+      "set_envelope_properties"
+    ]
+  },
+  analysis: {
+    name: "analysis",
+    description: "Audio metering and analysis: peak/RMS meters, FFT spectrum, LUFS loudness, stereo correlation, crest factor",
+    tools: ["read_track_meters", "read_track_spectrum", "read_track_lufs", "read_track_correlation", "read_track_crest"]
+  },
+  discovery: {
+    name: "discovery",
+    description: "FX discovery and presets: list all installed plugins, fuzzy search by name, list and load presets",
+    tools: ["list_available_fx", "search_fx", "get_fx_preset_list", "set_fx_preset"]
+  },
+  snapshots: {
+    name: "snapshots",
+    description: "Mixer state snapshots: save, restore, and list named snapshots of volumes, pans, FX, and mutes",
+    tools: ["snapshot_save", "snapshot_restore", "snapshot_list"]
+  },
+  routing: {
+    name: "routing",
+    description: "Track routing: inspect sends, receives, parent/folder relationships for a track",
+    tools: ["get_track_routing"]
+  }
+};
+function registerCategoryTools(server) {
+  server.tool(
+    "list_tool_categories",
+    "List all available tool categories with descriptions and tool names. Use this to discover what tools are available without loading all 72+ tool schemas. Categories: project, tracks, fx, transport, midi, media, selection, markers, tempo, envelopes, analysis, discovery, snapshots, routing.",
+    {},
+    async () => {
+      const categories = Object.values(TOOL_CATEGORIES).map((cat) => ({
+        name: cat.name,
+        description: cat.description,
+        toolCount: cat.tools.length,
+        tools: cat.tools
+      }));
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ categories, totalTools: categories.reduce((sum, c) => sum + c.toolCount, 0) }, null, 2)
+        }]
+      };
+    }
+  );
+  server.tool(
+    "enable_tool_category",
+    "Signal that you intend to use tools from a specific category. All tools are already registered and available \u2014 this call returns the full list of tools in the category so you know exactly which tool names to use. Use list_tool_categories first to see all available categories.",
+    {
+      category: z16.string().describe('Category name (e.g. "tracks", "fx", "midi", "media", "transport", "markers", "envelopes", "analysis", "discovery")')
+    },
+    async ({ category }) => {
+      const cat = TOOL_CATEGORIES[category];
+      if (!cat) {
+        const available = Object.keys(TOOL_CATEGORIES).join(", ");
+        return {
+          content: [{
+            type: "text",
+            text: `Error: Unknown category "${category}". Available categories: ${available}`
+          }],
+          isError: true
+        };
+      }
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            category: cat.name,
+            description: cat.description,
+            toolCount: cat.tools.length,
+            tools: cat.tools,
+            status: "ready"
+          }, null, 2)
+        }]
+      };
+    }
+  );
+  server.tool(
+    "disable_tool_category",
+    "Signal that you are done using tools from a specific category. This is a semantic hint to help manage your context budget \u2014 the tools remain registered but you can use this to indicate you no longer need them in the current workflow.",
+    {
+      category: z16.string().describe('Category name (e.g. "tracks", "fx", "midi", "media", "transport", "markers", "envelopes", "analysis", "discovery")')
+    },
+    async ({ category }) => {
+      const cat = TOOL_CATEGORIES[category];
+      if (!cat) {
+        const available = Object.keys(TOOL_CATEGORIES).join(", ");
+        return {
+          content: [{
+            type: "text",
+            text: `Error: Unknown category "${category}". Available categories: ${available}`
+          }],
+          isError: true
+        };
+      }
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            category: cat.name,
+            status: "disabled",
+            note: "Tools remain available if needed. Use enable_tool_category to re-activate."
+          }, null, 2)
+        }]
+      };
+    }
+  );
+}
+
 // apps/reaper-mcp-server/src/server.ts
 function instrumentToolHandlers(server) {
   const originalTool = server.tool.bind(server);
@@ -1932,6 +2196,8 @@ function createServer() {
   registerMarkerTools(server);
   registerTempoTools(server);
   registerEnvelopeTools(server);
+  registerBatchTools(server);
+  registerCategoryTools(server);
   return server;
 }
 
@@ -2091,7 +2357,15 @@ var MCP_TOOL_NAMES = [
   "create_track_envelope",
   "set_envelope_properties",
   "clear_envelope",
-  "remove_envelope_points"
+  "remove_envelope_points",
+  // composite batch tools
+  "set_multiple_track_properties",
+  "setup_fx_chain",
+  "set_multiple_fx_parameters",
+  // progressive discovery
+  "list_tool_categories",
+  "enable_tool_category",
+  "disable_tool_category"
 ];
 function ensureClaudeSettings(settingsPath) {
   const allowList = MCP_TOOL_NAMES.map((t) => `mcp__reaper__${t}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mthines/reaper-mcp",
-  "version": "0.13.0",
+  "version": "0.14.1",
   "type": "module",
   "description": "MCP server for controlling REAPER DAW — real-time mixing, FX control, and frequency analysis for AI agents",
   "license": "MIT",

package/reaper/mcp_bridge.lua

@@ -1000,8 +1000,25 @@ function handlers.snapshot_restore(params)
 
   local restored = 0
 
-  if state.tracks then
-    for _, track_state in ipairs(state.tracks) do
+  -- Decode tracks array if the fallback JSON parser left it as a raw string
+  local tracks = state.tracks
+  if type(tracks) == "string" then
+    tracks = json_decode_array(tracks)
+  end
+
+  if tracks then
+    for _, track_state in ipairs(tracks) do
+      -- Decode nested arrays that may also be raw strings from fallback parser
+      if type(track_state.fx) == "string" then
+        track_state.fx = json_decode_array(track_state.fx)
+      end
+      if type(track_state.sends) == "string" then
+        track_state.sends = json_decode_array(track_state.sends)
+      end
+      if type(track_state.fxEnabled) == "string" then
+        track_state.fxEnabled = json_decode_array(track_state.fxEnabled)
+      end
+
       local track = reaper.GetTrack(0, track_state.index)
       if track then
         -- Basic mixer state (all versions)
@@ -1240,11 +1257,14 @@ function handlers.read_track_lufs(params)
   local fx_idx, err = ensure_jsfx_on_track(track, MCP_LUFS_METER_FX_NAME)
   if not fx_idx then return nil, err end
 
-  -- Set the track_slot parameter (slider2, param index 1) so this instance
-  -- writes to a unique gmem offset and doesn't collide with other tracks
-  reaper.TrackFX_SetParam(track, fx_idx, 1, idx / 127)
+  -- Set the track_slot parameter so this instance writes to a unique gmem offset
+  local desired_slot = idx / 127
+  local current_slot = reaper.TrackFX_GetParam(track, fx_idx, 1)
+  if math.abs(current_slot - desired_slot) > 0.001 then
+    reaper.TrackFX_SetParam(track, fx_idx, 1, desired_slot)
+  end
 
-  -- Attach to the LUFS meter gmem namespace and read from track-specific offset
+  -- Read from gmem (JSFX writes here from @sample)
   reaper.gmem_attach("MCPLufsMeter")
 
   local base = idx * 8
@@ -1277,6 +1297,7 @@ function handlers.read_track_correlation(params)
   local fx_idx, err = ensure_jsfx_on_track(track, MCP_CORRELATION_METER_FX_NAME)
   if not fx_idx then return nil, err end
 
+  -- Read from gmem (JSFX writes here from @sample)
   reaper.gmem_attach("MCPCorrelationMeter")
 
   local correlation  = reaper.gmem_read(0)
@@ -1303,6 +1324,7 @@ function handlers.read_track_crest(params)
   local fx_idx, err = ensure_jsfx_on_track(track, MCP_CREST_FACTOR_FX_NAME)
   if not fx_idx then return nil, err end
 
+  -- Read from gmem (JSFX writes here from @sample)
   reaper.gmem_attach("MCPCrestFactor")
 
   local crest_factor = reaper.gmem_read(0)
@@ -2352,6 +2374,196 @@ function handlers.set_fx_offline(params)
   return { trackIndex = params.trackIndex, fxIndex = params.fxIndex, offline = params.offline == 1 }
 end
 
+-- =============================================================================
+-- Composite batch tools
+-- =============================================================================
+
+function handlers.set_multiple_track_properties(params)
+  local tracks_input = params.tracks
+  if not tracks_input then return nil, "tracks array required" end
+
+  local tracks = nil
+  if type(tracks_input) == "string" then
+    tracks = json_decode(tracks_input)
+  elseif type(tracks_input) == "table" then
+    tracks = tracks_input
+  end
+  if not tracks then return nil, "Failed to parse tracks array" end
+
+  local updated = 0
+  local errors = {}
+
+  reaper.Undo_BeginBlock()
+
+  for _, t in ipairs(tracks) do
+    local track_idx = t.trackIndex
+    if track_idx == nil then
+      errors[#errors + 1] = "track entry missing trackIndex"
+    else
+      local track = reaper.GetTrack(0, track_idx)
+      if not track then
+        errors[#errors + 1] = "Track " .. track_idx .. " not found"
+      else
+        if t.volume ~= nil then
+          reaper.SetMediaTrackInfo_Value(track, "D_VOL", from_db(t.volume))
+        end
+        if t.pan ~= nil then
+          reaper.SetMediaTrackInfo_Value(track, "D_PAN", t.pan)
+        end
+        if t.mute ~= nil then
+          reaper.SetMediaTrackInfo_Value(track, "B_MUTE", t.mute)
+        end
+        if t.solo ~= nil then
+          reaper.SetMediaTrackInfo_Value(track, "I_SOLO", t.solo)
+        end
+        if t.recordArm ~= nil then
+          reaper.SetMediaTrackInfo_Value(track, "I_RECARM", t.recordArm)
+        end
+        if t.phase ~= nil then
+          reaper.SetMediaTrackInfo_Value(track, "B_PHASE", t.phase)
+        end
+        if t.input ~= nil then
+          reaper.SetMediaTrackInfo_Value(track, "I_RECINPUT", t.input)
+        end
+        updated = updated + 1
+      end
+    end
+  end
+
+  reaper.Undo_EndBlock("MCP: Batch set " .. updated .. " track properties", -1)
+
+  local result = { success = true, updated = updated, total = #tracks }
+  if #errors > 0 then result.errors = errors end
+  return result
+end
+
+function handlers.setup_fx_chain(params)
+  local track_idx = params.trackIndex
+  if track_idx == nil then return nil, "trackIndex required" end
+
+  local plugins_input = params.plugins
+  if not plugins_input then return nil, "plugins array required" end
+
+  local plugins = nil
+  if type(plugins_input) == "string" then
+    plugins = json_decode(plugins_input)
+  elseif type(plugins_input) == "table" then
+    plugins = plugins_input
+  end
+  if not plugins then return nil, "Failed to parse plugins array" end
+
+  local track = reaper.GetTrack(0, track_idx)
+  if not track then return nil, "Track " .. track_idx .. " not found" end
+
+  local added = 0
+  local errors = {}
+  local added_plugins = {}
+
+  reaper.Undo_BeginBlock()
+
+  for i, plugin in ipairs(plugins) do
+    local fx_name = plugin.fxName
+    if not fx_name or fx_name == "" then
+      errors[#errors + 1] = "plugin[" .. (i - 1) .. "] missing fxName"
+    else
+      local fx_idx = reaper.TrackFX_AddByName(track, fx_name, false, -1)
+      if fx_idx < 0 then
+        errors[#errors + 1] = "FX not found: " .. fx_name
+      else
+        -- Set enabled state if specified (default is enabled)
+        if plugin.enabled ~= nil then
+          reaper.TrackFX_SetEnabled(track, fx_idx, plugin.enabled == 1)
+        end
+
+        -- Set initial parameters if provided
+        local param_errors = {}
+        if plugin.parameters and type(plugin.parameters) == "table" then
+          for _, p in ipairs(plugin.parameters) do
+            if p.index ~= nil and p.value ~= nil then
+              local ok = reaper.TrackFX_SetParam(track, fx_idx, p.index, p.value)
+              if not ok then
+                param_errors[#param_errors + 1] = "Failed to set param " .. p.index
+              end
+            end
+          end
+        end
+
+        local _, actual_name = reaper.TrackFX_GetFXName(track, fx_idx)
+        added_plugins[#added_plugins + 1] = {
+          pluginIndex = i - 1,
+          fxName = actual_name or fx_name,
+          fxIndex = fx_idx,
+        }
+        if #param_errors > 0 then
+          for _, pe in ipairs(param_errors) do
+            errors[#errors + 1] = fx_name .. ": " .. pe
+          end
+        end
+        added = added + 1
+      end
+    end
+  end
+
+  reaper.Undo_EndBlock("MCP: Setup FX chain (" .. added .. " plugins) on track " .. track_idx, -1)
+
+  local result = {
+    success = true,
+    trackIndex = track_idx,
+    added = added,
+    total = #plugins,
+    plugins = added_plugins,
+  }
+  if #errors > 0 then result.errors = errors end
+  return result
+end
+
+function handlers.set_multiple_fx_parameters(params)
+  local updates_input = params.updates
+  if not updates_input then return nil, "updates array required" end
+
+  local updates = nil
+  if type(updates_input) == "string" then
+    updates = json_decode(updates_input)
+  elseif type(updates_input) == "table" then
+    updates = updates_input
+  end
+  if not updates then return nil, "Failed to parse updates array" end
+
+  local updated = 0
+  local errors = {}
+
+  reaper.Undo_BeginBlock()
+
+  for _, u in ipairs(updates) do
+    local track_idx = u.trackIndex
+    local fx_idx = u.fxIndex
+    local param_idx = u.paramIndex
+    local value = u.value
+
+    if track_idx == nil or fx_idx == nil or param_idx == nil or value == nil then
+      errors[#errors + 1] = "update entry missing trackIndex, fxIndex, paramIndex, or value"
+    else
+      local track = reaper.GetTrack(0, track_idx)
+      if not track then
+        errors[#errors + 1] = "Track " .. track_idx .. " not found"
+      else
+        local ok = reaper.TrackFX_SetParam(track, fx_idx, param_idx, value)
+        if not ok then
+          errors[#errors + 1] = "Failed to set track " .. track_idx .. " fx " .. fx_idx .. " param " .. param_idx
+        else
+          updated = updated + 1
+        end
+      end
+    end
+  end
+
+  reaper.Undo_EndBlock("MCP: Batch set " .. updated .. " FX parameters", -1)
+
+  local result = { success = true, updated = updated, total = #updates }
+  if #errors > 0 then result.errors = errors end
+  return result
+end
+
 -- =============================================================================
 -- Selection & Navigation
 -- =============================================================================
@@ -2671,8 +2883,9 @@ function handlers.create_track_envelope(params)
         return nil, "Unknown envelope name: " .. params.envelopeName .. ". Use Volume, Pan, Mute, Width, or Trim Volume"
       end
       -- Get track chunk, insert envelope chunk if missing
+      -- Use anchored pattern "<VOLENV\n" to avoid matching VOLENV2 (Trim Volume)
       local _, chunk = reaper.GetTrackStateChunk(track, "", false)
-      if not chunk:find(chunk_key) then
+      if not chunk:find("<" .. chunk_key .. "\n") then
         -- Insert a minimal envelope chunk before the closing >
         local env_chunk = "\n<" .. chunk_key .. "\nACT 1 -1\nVIS 1 1 1\nLANEHEIGHT 0 0\nARM 0\nDEFSHAPE 0 -1 -1\n>\n"
         -- Use position capture to find the last ">" (closing the <TRACK block).
@@ -2684,8 +2897,8 @@ function handlers.create_track_envelope(params)
         reaper.SetTrackStateChunk(track, chunk, false)
       else
         -- Envelope exists in chunk but may be hidden; make it visible
-        chunk = chunk:gsub("(" .. chunk_key .. "[^\n]*\n)ACT 0", "%1ACT 1")
-        chunk = chunk:gsub("(" .. chunk_key .. "[^\n]*\n[^\n]*\n)VIS 0", "%1VIS 1")
+        chunk = chunk:gsub("(<" .. chunk_key .. "[^\n]*\n)ACT 0", "%1ACT 1")
+        chunk = chunk:gsub("(<" .. chunk_key .. "[^\n]*\n[^\n]*\n)VIS 0", "%1VIS 1")
         reaper.SetTrackStateChunk(track, chunk, false)
       end
       env = reaper.GetTrackEnvelopeByName(track, params.envelopeName)

package/reaper/mcp_correlation_meter.jsfx

@@ -58,7 +58,6 @@ slider1:window_ms=300<50,2000,10>Window (ms)
     gmem[3] = -150;
   );
 
-  local(l, r, m, s);
   l = spl0;
   r = spl1;
 
@@ -66,7 +65,6 @@ slider1:window_ms=300<50,2000,10>Window (ms)
   m = (l + r) * 0.5;
   s = (l - r) * 0.5;
 
-  local(ll, rr, lr, mm, ss);
   ll = l * l;
   rr = r * r;
   lr = l * r;
@@ -99,8 +97,6 @@ slider1:window_ms=300<50,2000,10>Window (ms)
 
   // Update gmem every 512 samples (~86 Hz at 44.1kHz)
   (buf_pos % 512) == 0 ? (
-    local(denom, corr, mid_rms, side_rms, mid_db, side_db, width);
-
     // Correlation: sum(L*R) / sqrt(sum(L*L) * sum(R*R))
     denom = sqrt(sum_ll * sum_rr);
     denom > 0.0000001 ? (

package/reaper/mcp_crest_factor.jsfx

@@ -49,7 +49,6 @@ slider2:peak_hold_ms=1000<100,10000,100>Peak Hold (ms)
   );
 
   // Mono mix for metering
-  local(mono, sq, peak_abs);
   mono = (spl0 + spl1) * 0.5;
   sq   = mono * mono;
   peak_abs = abs(mono);
@@ -76,8 +75,6 @@ slider2:peak_hold_ms=1000<100,10000,100>Peak Hold (ms)
 
   // Update gmem every 512 samples
   (buf_pos % 512) == 0 ? (
-    local(rms_val, rms_db, peak_db, crest_db);
-
     rms_val = sqrt(sum_sq / buf_size);
 
     rms_val > 0.000001 ? (

package/reaper/mcp_lufs_meter.jsfx

@@ -21,29 +21,18 @@ slider2:track_slot=0<0,127,1>Track Slot
   // K-weighting filter state (two biquad stages per channel)
   // Stage 1: High-shelf pre-filter (+4 dB at 1681 Hz)
   // Stage 2: High-pass RLB filter (100 Hz, -12 dB/oct)
-
-  // Biquad state: [b0, b1, b2, a1, a2, x1, x2, y1, y2] per stage per channel
-  // We store state variables in flat arrays
   hs_x1l = hs_x2l = hs_y1l = hs_y2l = 0;
   hs_x1r = hs_x2r = hs_y1r = hs_y2r = 0;
   hp_x1l = hp_x2l = hp_y1l = hp_y2l = 0;
   hp_x1r = hp_x2r = hp_y1r = hp_y2r = 0;
 
-  // High-shelf filter coefficients (pre-computed for 48kHz; recomputed @slider)
-  // Using bilinear transform of analog prototype per BS.1770-4 Annex 1
+  // High-shelf filter coefficients (recomputed on init and sample rate change)
   hs_b0 = hs_b1 = hs_b2 = hs_a1 = hs_a2 = 0;
   hp_b0 = hp_b1 = hp_b2 = hp_a1 = hp_a2 = 0;
 
-  // Circular buffer for loudness blocks (sliding windows)
-  // 400ms block = momentary, 3s = short-term
-  // BS.1770 uses 100ms overlapping blocks (75% overlap)
-  // We approximate with per-sample accumulation into sliding windows
-
-  // Ring buffer for per-sample squared weighted values
-  // momentary: 400ms window
-  // short-term: 3s window
-  // We store up to 3s of samples in a circular buffer
-  buf_size = 0;           // computed at runtime from srate
+  // Ring buffer for per-sample squared weighted values (up to 3s)
+  // momentary: 400ms window, short-term: 3s window
+  buf_size = 0;
   buf_l = 65536;          // start address for left channel ring buffer
   buf_r = 131072;         // start address for right channel ring buffer
   buf_pos = 0;
@@ -63,13 +52,11 @@ slider2:track_slot=0<0,127,1>Track Slot
   // Measurement duration
   sample_count = 0;
 
-  // Flags
   needs_init = 1;
 
   function compute_kweight_filters() (
     // High-shelf pre-filter: +4 dB shelf at f0 = 1681.974 Hz
     // From BS.1770-4, Annex 1, Table 1
-    local(db, K, Vh, Vb, a0);
     db = 3.99984385397;  // ~4 dB
     K = tan($pi * 1681.974 / srate);
     Vh = exp(db / 20 * log(10));
@@ -82,7 +69,6 @@ slider2:track_slot=0<0,127,1>Track Slot
     hs_a2 = (1 - K/0.7071067811865476 + K*K) / a0;
 
     // High-pass filter: 38.13547 Hz, Q = 0.5003270373238773
-    local(K2, a0);
     K2 = tan($pi * 38.13547 / srate);
     a0 = K2*K2 + K2/0.5003270373238773 + 1;
     hp_b0 = 1 / a0;
@@ -93,7 +79,6 @@ slider2:track_slot=0<0,127,1>Track Slot
   );
 
   function reset_measurement() (
-    local(base);
     base = floor(slider2 + 0.5) * 8;
     buf_pos = 0;
     momentary_sum_l = 0;
@@ -121,7 +106,7 @@ slider2:track_slot=0<0,127,1>Track Slot
   );
 
 @slider
-  // Re-compute filter coefficients (in case sample rate has changed)
+  // Re-compute filter coefficients (handles sample rate changes)
   needs_init = 1;
 
   // Handle reset button
@@ -142,7 +127,6 @@ slider2:track_slot=0<0,127,1>Track Slot
   );
 
   // --- K-weighting: stage 1 (high-shelf) ---
-  local(wl, wr, kl, kr);
   wl = spl0;
   wr = spl1;
 
@@ -155,7 +139,6 @@ slider2:track_slot=0<0,127,1>Track Slot
   hs_x2r = hs_x1r; hs_x1r = wr; hs_y2r = hs_y1r; hs_y1r = kr;
 
   // --- K-weighting: stage 2 (high-pass) ---
-  local(fl, fr);
   fl = hp_b0 * kl + hp_b1 * hp_x1l + hp_b2 * hp_x2l - hp_a1 * hp_y1l - hp_a2 * hp_y2l;
   hp_x2l = hp_x1l; hp_x1l = kl; hp_y2l = hp_y1l; hp_y1l = fl;
 
@@ -163,13 +146,10 @@ slider2:track_slot=0<0,127,1>Track Slot
   hp_x2r = hp_x1r; hp_x1r = kr; hp_y2r = hp_y1r; hp_y1r = fr;
 
   // Squared weighted samples
-  local(sq_l, sq_r);
   sq_l = fl * fl;
   sq_r = fr * fr;
 
   // --- Ring buffer update ---
-  // Subtract outgoing samples from running sums
-  local(old_l, old_r);
   old_l = buf_l[buf_pos];
   old_r = buf_r[buf_pos];
 
@@ -177,12 +157,7 @@ slider2:track_slot=0<0,127,1>Track Slot
   shortterm_sum_l -= old_l;
   shortterm_sum_r -= old_r;
 
-  // Momentary window: 400ms = srate * 0.4 samples back
-  // We subtract from momentary only when the sample leaving is within 400ms window
-  // Simplified: maintain separate momentary accumulators via separate pointers
-  // For efficiency, use a single ring buffer and recompute momentary from partial sum
-  // Here we track momentary with a second set of pointers (400ms lag)
-  local(mom_pos);
+  // Momentary window: 400ms lag pointer
   mom_pos = buf_pos - floor(srate * 0.4);
   mom_pos < 0 ? mom_pos += buf_size;
   momentary_sum_l -= buf_l[mom_pos];
@@ -203,18 +178,12 @@ slider2:track_slot=0<0,127,1>Track Slot
   buf_pos >= buf_size ? buf_pos = 0;
 
   // --- Integrated loudness (gated per BS.1770) ---
-  // Absolute gate: only include 400ms blocks above -70 LUFS
-  // Simplified: accumulate ungated for speed, apply gate check periodically
+  // Simplified: accumulate ungated, apply gate check periodically
   integrated_sum += sq_l + sq_r;
   integrated_count += 1;
 
   // --- True peak: 4x linear interpolation oversampling ---
-  // Insert 3 interpolated samples between each real sample using linear interpolation
-  local(prev_l, prev_r, frac, tp_l, tp_r);
-
-  // We use the previous sample stored in a local state var
-  // Stored in memory block above buf_r to avoid conflict
-  // prev_l is at buf_r + buf_size, prev_r is at buf_r + buf_size + 1
+  // Previous sample stored above buf_r to avoid conflict
   prev_l = buf_r[buf_size];
   prev_r = buf_r[buf_size + 1];
 
@@ -224,7 +193,6 @@ slider2:track_slot=0<0,127,1>Track Slot
   // Check interpolated peaks at 1/4, 2/4, 3/4 offsets
   frac = 0.25;
   loop(3,
-    local(interp_l, interp_r);
     interp_l = abs(prev_l + frac * (spl0 - prev_l));
     interp_r = abs(prev_r + frac * (spl1 - prev_r));
     interp_l > tp_l ? tp_l = interp_l;
@@ -243,9 +211,6 @@ slider2:track_slot=0<0,127,1>Track Slot
 
   // --- Update gmem every 4096 samples (approx 10x/second at 44.1kHz) ---
   (sample_count % 4096) == 0 ? (
-    local(shortterm_mean, momentary_mean, integrated_lufs, shortterm_lufs, momentary_lufs);
-    local(mom_samples, base);
-
     base = floor(slider2 + 0.5) * 8;
 
     mom_samples = floor(srate * 0.4);
@@ -255,8 +220,7 @@ slider2:track_slot=0<0,127,1>Track Slot
     shortterm_mean = (shortterm_sum_l + shortterm_sum_r) / (buf_size * 2);
     momentary_mean = (momentary_sum_l + momentary_sum_r) / (mom_samples * 2);
 
-    // Integrated mean square (two channels: L + R sum, divided by count*2)
-    local(integrated_mean);
+    // Integrated mean square (two channels)
     integrated_mean = integrated_count > 0 ? (integrated_sum / (integrated_count * 2)) : 0;
 
     // LUFS = -0.691 + 10 * log10(mean_square)
@@ -274,7 +238,6 @@ slider2:track_slot=0<0,127,1>Track Slot
 
     integrated_mean > 0 ? (
       // Apply absolute gate at -70 LUFS
-      local(ungated_lufs);
       ungated_lufs = -0.691 + 10 * log10(integrated_mean);
       ungated_lufs > -70 ? (
         integrated_lufs = ungated_lufs;