@pired/lightroom-mcp 3.1.0

package/dist/LightroomMCP.lrplugin/HandlerPreview.lua

@@ -0,0 +1,189 @@
+local LrApplication = import 'LrApplication'
+local LrTasks = import 'LrTasks'
+local LrPathUtils = import 'LrPathUtils'
+local LrFileUtils = import 'LrFileUtils'
+
+local PhotoLookup = require 'PhotoLookup'
+local Log = require 'Log'
+
+local PreviewHandler = {}
+
+-- =====================================================================
+-- get_photo_preview — let the AI actually SEE the photo
+-- =====================================================================
+--
+-- The Lightroom SDK can render a JPEG of any catalog photo through
+-- photo:requestJpegThumbnail(width, height, callback). The callback runs
+-- asynchronously on a background render task, so we poll a completion
+-- flag with LrTasks.sleep() instead of blocking.
+--
+-- The JPEG bytes are written to a file next to the MCP token
+-- (<home>/.config/lightroom-mcp/previews/) so the MCP server can read
+-- them back and attach the image inline to the tool response (Claude
+-- Desktop renders image content blocks in the conversation). Writing to
+-- disk keeps the large binary out of the line-delimited JSON socket
+-- protocol entirely.
+--
+-- Old previews are pruned to bound disk usage: the folder keeps the
+-- newest MAX_FILES_KEPT files (filenames embed a unix timestamp, so a
+-- lexicographic sort on the timestamp field approximates mtime order
+-- without a stat() API, which LrFileUtils does not expose).
+
+local NAMED_SIZES = {
+    small = 240,
+    medium = 640,
+    large = 1024,
+}
+
+local MIN_PIXELS = 32
+local MAX_PIXELS = 2048
+local RENDER_TIMEOUT_S = 60
+local POLL_INTERVAL_S = 0.1
+local MAX_FILES_KEPT = 60
+local FILE_PREFIX = "preview_"
+
+local function previewsDir()
+    local config = LrPathUtils.child(
+        LrPathUtils.getStandardFilePath("home"), ".config")
+    local base = LrPathUtils.child(
+        LrPathUtils.child(config, "lightroom-mcp"), "previews")
+    LrFileUtils.createAllDirectories(base)
+    return base
+end
+
+-- "DSC_0123 (cópia).NEF" -> "dsc_0123_cpa" : Windows-safe, ascii-ish.
+local function sanitizeBase(filename)
+    local base = filename or "photo"
+    base = base:gsub("%.[^%.]*$", "") -- drop extension
+    base = base:lower():gsub("[^%w%-_]", "")
+    if #base > 40 then base = base:sub(1, 40) end
+    if base == "" then base = "photo" end
+    return base
+end
+
+-- Delete oldest generated previews past MAX_FILES_KEPT. Filenames are
+-- preview_<id>_<size>px_<timestamp>.jpg; extracting the timestamp keeps
+-- the sort stable across ids/sizes. Best-effort, never fatal.
+local function pruneOldPreviews(dir)
+    local entries = LrFileUtils.directoryContents(dir) or {}
+    local stamped = {}
+    for _, name in ipairs(entries) do
+        local ts = name:match("^" .. FILE_PREFIX .. ".-(%d+)%.jpg$")
+        if ts then table.insert(stamped, { name = name, ts = ts }) end
+    end
+    if #stamped <= MAX_FILES_KEPT then return end
+    table.sort(stamped, function(a, b) return a.ts < b.ts end)
+    for i = 1, #stamped - MAX_FILES_KEPT do
+        pcall(function() LrFileUtils.delete(LrPathUtils.child(dir, stamped[i].name)) end)
+    end
+end
+
+function PreviewHandler.getPhotoPreview(args)
+    args = args or {}
+    if not args.photo_id then
+        error("photo_id is required")
+    end
+
+    local requested = args.size or "medium"
+    local pixelSize
+    if type(requested) == "string" then
+        pixelSize = NAMED_SIZES[requested]
+        if not pixelSize then
+            error("size must be 'small', 'medium', 'large' or a number of pixels")
+        end
+    elseif type(requested) == "number" then
+        pixelSize = math.floor(requested)
+        if pixelSize < MIN_PIXELS or pixelSize > MAX_PIXELS then
+            error(string.format("size must be between %d and %d pixels", MIN_PIXELS, MAX_PIXELS))
+        end
+    else
+        error("size must be 'small', 'medium', 'large' or a number of pixels")
+    end
+
+    local catalog = LrApplication.activeCatalog()
+
+    local photo, filename, dimensions
+    catalog:withReadAccessDo(function()
+        photo = PhotoLookup.resolveOne(catalog, args.photo_id)
+        if photo then
+            filename = photo:getFormattedMetadata('fileName')
+            dimensions = photo:getRawMetadata('dimensions')
+        end
+    end)
+
+    if not photo then
+        error("No photo matched photo_id")
+    end
+
+    -- requestJpegThumbnail renders asynchronously and invokes its callback
+    -- from a background task; both the render and the poll sleep yield, so
+    -- they stay OUTSIDE any catalog access gate (issues #134/#124).
+    local jpegData, renderError, done = nil, nil, false
+    photo:requestJpegThumbnail(pixelSize, pixelSize, function(jpg, err)
+        if err then
+            renderError = tostring(err)
+        else
+            jpegData = jpg
+        end
+        done = true
+    end)
+
+    local waited = 0
+    while not done and waited < RENDER_TIMEOUT_S do
+        LrTasks.sleep(POLL_INTERVAL_S)
+        waited = waited + POLL_INTERVAL_S
+    end
+
+    if renderError then
+        error("Lightroom failed to render the preview: " .. renderError)
+    end
+    if not done then
+        error(string.format(
+            "Timed out after %ds waiting for Lightroom to render the preview "
+            .. "(a photo still pending standard previews can do this; retry "
+            .. "after Lightroom finishes building previews)", RENDER_TIMEOUT_S))
+    end
+    if not jpegData or #jpegData == 0 then
+        error("Lightroom returned no image data for this photo")
+    end
+
+    local dir = previewsDir()
+    local outName = string.format("%sp%d_%dpx_%d.jpg",
+        FILE_PREFIX, photo.localIdentifier or 0, pixelSize, os.time())
+    local outPath = LrPathUtils.child(dir, outName)
+
+    local fh, openErr = io.open(outPath, "wb")
+    if not fh then
+        error("failed to write preview file: " .. tostring(openErr))
+    end
+    fh:write(jpegData)
+    fh:close()
+
+    pruneOldPreviews(dir)
+
+    Log.info(string.format("getPhotoPreview: wrote %s (%d bytes, %dpx)",
+        outPath, #jpegData, pixelSize))
+
+    return {
+        success = true,
+        file_path = outPath,
+        size_bytes = #jpegData,
+        mime_type = "image/jpeg",
+        size_px = pixelSize,
+        photo = {
+            id = photo.localIdentifier,
+            path = photo:getRawMetadata('path'),
+            filename = filename,
+            width = dimensions and dimensions.width or nil,
+            height = dimensions and dimensions.height or nil,
+        },
+        -- Marker consumed by the MCP server (tool-handler.ts): the JPEG is
+        -- on disk and small enough to inline as an MCP image content block.
+        image_attached_by_server = true,
+        message = string.format(
+            "Preview written to %s and attached as an image (%d bytes, %dpx)",
+            outPath, #jpegData, pixelSize),
+    }
+end
+
+return PreviewHandler

package/dist/LightroomMCP.lrplugin/HandlerSearch.lua

@@ -0,0 +1,185 @@
+local LrApplication = import 'LrApplication'
+
+local Log = require 'Log'
+
+local SearchHandler = {}
+
+local function parseDate(value, name)
+    if type(value) ~= "string" then
+        error(name .. " must be a string in YYYY-MM-DD format", 0)
+    end
+
+    local year, month, day = value:match("^(%d%d%d%d)%-(%d%d)%-(%d%d)$")
+    if not year then
+        error(name .. " must use YYYY-MM-DD format", 0)
+    end
+
+    year = tonumber(year)
+    month = tonumber(month)
+    day = tonumber(day)
+
+    if month < 1 or month > 12 then
+        error(name .. " must use a valid calendar date", 0)
+    end
+
+    local timestamp = os.time({ year = year, month = month, day = day, hour = 12 })
+    local normalized = os.date("*t", timestamp)
+    if normalized.year ~= year or normalized.month ~= month or normalized.day ~= day then
+        error(name .. " must use a valid calendar date", 0)
+    end
+
+    return value, timestamp
+end
+
+local function addDays(timestamp, days)
+    return os.date("%Y-%m-%d", timestamp + (days * 86400))
+end
+
+local MAX_SEARCH_RULES = 20
+
+-- Advanced criteria rules, the same { criteria, operation, value, value2? }
+-- shape create_smart_collection feeds into its searchDesc. Lets a caller
+-- use any findPhotos criterion (cameraModel, lens, isoSpeedRating,
+-- copyName, hasAdjustments, ...) beyond the simplified filename/keywords/
+-- rating/date shortcuts above. Rules intersect with those shortcuts.
+local function appendRules(desc, rules)
+    if rules == nil then return end
+    if type(rules) ~= "table" then
+        error("rules must be an array", 0)
+    end
+    if #rules == 0 then
+        error("rules must contain at least one entry when provided", 0)
+    end
+    if #rules > MAX_SEARCH_RULES then
+        error("rules must contain at most " .. MAX_SEARCH_RULES .. " entries", 0)
+    end
+    for i, rule in ipairs(rules) do
+        if type(rule) ~= "table" then
+            error("rules[" .. i .. "] must be an object", 0)
+        end
+        if type(rule.criteria) ~= "string" or rule.criteria == "" then
+            error("rules[" .. i .. "].criteria is required (e.g. 'cameraModel', 'lens', 'isoSpeedRating', 'copyName', 'hasAdjustments')", 0)
+        end
+        if type(rule.operation) ~= "string" or rule.operation == "" then
+            error("rules[" .. i .. "].operation is required (e.g. 'all', 'any', '==', '>=', 'in', 'startsWith')", 0)
+        end
+        if rule.value == nil then
+            error("rules[" .. i .. "].value is required", 0)
+        end
+        local r = {
+            criteria = rule.criteria,
+            operation = rule.operation,
+            value = tostring(rule.value),
+        }
+        if rule.value2 ~= nil then r.value2 = tostring(rule.value2) end
+        table.insert(desc, r)
+    end
+end
+
+local function buildSearchDesc(args)
+    local desc = { combine = args.combine == "union" and "union" or "intersect" }
+
+    if args.filename then
+        table.insert(desc, { criteria = "filename", operation = "any", value = args.filename })
+    end
+
+    if args.rating then
+        table.insert(desc, { criteria = "rating", operation = "==", value = args.rating })
+    end
+
+    if args.keywords and #args.keywords > 0 then
+        for _, kw in ipairs(args.keywords) do
+            table.insert(desc, { criteria = "keywords", operation = "all", value = kw })
+        end
+    end
+
+    if args.start_date and args.end_date then
+        local startDate, startTimestamp = parseDate(args.start_date, "start_date")
+        local endDate, endTimestamp = parseDate(args.end_date, "end_date")
+        if startTimestamp > endTimestamp then
+            error("start_date must be on or before end_date", 0)
+        end
+        table.insert(desc, {
+            criteria = "captureTime",
+            operation = "in",
+            value = startDate,
+            value2 = endDate,
+        })
+    elseif args.start_date then
+        local _, startTimestamp = parseDate(args.start_date, "start_date")
+        table.insert(desc, { criteria = "captureTime", operation = ">", value = addDays(startTimestamp, -1) })
+    elseif args.end_date then
+        local _, endTimestamp = parseDate(args.end_date, "end_date")
+        table.insert(desc, { criteria = "captureTime", operation = "<", value = addDays(endTimestamp, 1) })
+    end
+
+    appendRules(desc, args.rules)
+
+    return desc
+end
+
+local function buildResult(photo)
+    return {
+        id = photo.localIdentifier,
+        path = photo:getRawMetadata('path'),
+        filename = photo:getFormattedMetadata('fileName'),
+        rating = photo:getRawMetadata('rating'),
+        dateTimeOriginal = photo:getFormattedMetadata('dateTimeOriginal'),
+    }
+end
+
+function SearchHandler.searchPhotos(args)
+    local catalog = LrApplication.activeCatalog()
+    local results = {}
+    local searchDesc = buildSearchDesc(args)
+    local hasFilters = #searchDesc > 0
+
+    -- floor: the tool schema permits any number, and a fractional offset would
+    -- make the page loop index matches[i] with a non-integer key (always nil)
+    -- and crash buildResult(nil).
+    local limit = math.floor(tonumber(args.limit) or 100)
+    if limit < 0 then limit = 0 end
+    local offset = math.floor(tonumber(args.offset) or 0)
+    if offset < 0 then offset = 0 end
+
+    -- Run the catalog query OUTSIDE withReadAccessDo. findPhotos() runs an
+    -- async catalog search that yields; called from inside the read gate on
+    -- Windows it deadlocks -- the task never returns and never releases the
+    -- gate, wedging the whole bridge until the 30s server timeout (issue #124,
+    -- same root cause as #134's getTargetPhotos). Only the per-photo metadata
+    -- reads need the gate. getAllPhotos() (no-filter path) is a non-yielding
+    -- enumeration, but is hoisted out too for a single, consistent structure.
+    Log.info(string.format("searchPhotos: querying (hasFilters=%s)", tostring(hasFilters)))
+    -- Unrated photos have nil rating; rating>=0 excludes them, so getAllPhotos()
+    -- must be used when no filters are specified.
+    local matches = (hasFilters
+        and catalog:findPhotos{ searchDesc = searchDesc }
+        or catalog:getAllPhotos()) or {}
+
+    local total = #matches
+    Log.info(string.format("searchPhotos: query returned %d", total))
+
+    local last = math.min(offset + limit, total)
+    catalog:withReadAccessDo(function()
+        for i = offset + 1, last do
+            table.insert(results, buildResult(matches[i]))
+        end
+    end)
+
+    Log.info(string.format("Search matched %d photos, returning %d (offset=%d, limit=%d)",
+        total, #results, offset, limit))
+
+    local response = {
+        count = total,
+        photos = results,
+        has_more = (offset + #results) < total,
+    }
+
+    if not hasFilters then
+        response.warning = "No filters applied — scanned full catalog. Provide filename, keywords, rating, or date filters to narrow results and improve performance."
+    end
+
+    return response
+end
+
+return SearchHandler

package/dist/LightroomMCP.lrplugin/HandlerSelection.lua

@@ -0,0 +1,302 @@
+local LrApplication = import 'LrApplication'
+local LrSelection = import 'LrSelection'
+
+local PhotoLookup = require 'PhotoLookup'
+local Log = require 'Log'
+
+local SelectionHandler = {}
+
+local function buildResult(photo)
+    return {
+        id = photo.localIdentifier,
+        path = photo:getRawMetadata('path'),
+        filename = photo:getFormattedMetadata('fileName'),
+        rating = photo:getRawMetadata('rating'),
+        dateTimeOriginal = photo:getFormattedMetadata('dateTimeOriginal'),
+    }
+end
+
+function SelectionHandler.getSelectedPhotos(args)
+    args = args or {}
+    local catalog = LrApplication.activeCatalog()
+
+    -- floor: the tool schema permits any number, and a fractional offset would
+    -- make the page loop index matches[i] with a non-integer key (always nil)
+    -- and crash buildResult(nil).
+    local limit = math.floor(tonumber(args.limit) or 100)
+    if limit < 0 then limit = 0 end
+    local offset = math.floor(tonumber(args.offset) or 0)
+    if offset < 0 then offset = 0 end
+
+    -- Acquire the target set OUTSIDE withReadAccessDo. getTargetPhotos() reads
+    -- the live view selection, which yields to the UI thread; called from
+    -- inside the read gate on Windows it deadlocks -- the task never returns
+    -- and never releases the gate, so the whole bridge wedges until the 30s
+    -- server timeout (issues #134, #124). Only the per-photo metadata reads
+    -- need the gate; getTargetPhotos() does not. This mirrors get_photo_metadata,
+    -- which works because it only does a non-yielding getAllPhotos() pass.
+    Log.info("getSelectedPhotos: requesting target photos")
+    local matches = catalog:getTargetPhotos() or {}
+    local total = #matches
+    Log.info(string.format("getSelectedPhotos: getTargetPhotos returned %d", total))
+
+    local last = math.min(offset + limit, total)
+    local results = {}
+    catalog:withReadAccessDo(function()
+        for i = offset + 1, last do
+            table.insert(results, buildResult(matches[i]))
+        end
+    end)
+
+    Log.info(string.format("getSelectedPhotos: returning %d (offset=%d, limit=%d)",
+        #results, offset, limit))
+
+    return {
+        count = total,
+        photos = results,
+        has_more = (offset + #results) < total,
+    }
+end
+
+-- Test-only: kept out of server/src/tool-contracts.ts so it is reachable from
+-- the raw TCP probe but never from an MCP client, which must not be able to
+-- reorder the user's filmstrip. Lets the e2e playbook stage the selection that
+-- get_selected_photos reads back, instead of a human clicking in Lightroom.
+function SelectionHandler.setSelection(args)
+    args = args or {}
+    local ids = args.photo_ids
+    if type(ids) ~= "table" or ids[1] == nil then
+        error("photo_ids is required")
+    end
+
+    local catalog = LrApplication.activeCatalog()
+    local resolved = PhotoLookup.resolveMany(catalog, ids)
+
+    local photos = {}
+    local missing = {}
+    local seen = {}
+    local selectedCount = 0
+    local missingCount = 0
+    for _, entry in ipairs(resolved) do
+        if entry.photo then
+            if not seen[entry.photo] then
+                seen[entry.photo] = true
+                selectedCount = selectedCount + 1
+                photos[selectedCount] = entry.photo
+            end
+        else
+            missingCount = missingCount + 1
+            missing[missingCount] = tostring(entry.id)
+        end
+    end
+
+    if selectedCount == 0 then
+        error("No photos matched photo_ids")
+    end
+
+    -- Yields to the UI thread, so it must stay OUTSIDE withReadAccessDo for the
+    -- same reason getTargetPhotos does (#134/#124). First arg becomes active.
+    Log.info(string.format("setSelection: selecting %d (missing %d)", selectedCount, missingCount))
+    catalog:setSelectedPhotos(photos[1], photos)
+
+    -- Lightroom ignores photos outside the current view source and leaves the
+    -- old selection in place, reporting nothing. Read the selection back so a
+    -- caller is never told a selection happened that did not.
+    local requested = {}
+    for _, photo in ipairs(photos) do
+        requested[photo] = true
+    end
+    local actualCount = 0
+    for _, photo in ipairs(catalog:getTargetPhotos() or {}) do
+        if requested[photo] then
+            actualCount = actualCount + 1
+        end
+    end
+
+    local result = {
+        selected = actualCount,
+        requested = selectedCount,
+        active = photos[1].localIdentifier,
+        missing = missing,
+    }
+    if actualCount < selectedCount then
+        result.warning = string.format(
+            "Lightroom selected %d of %d photos: the rest are not in the current view source. "
+            .. "Switch Lightroom to a source that contains them, such as All Photographs.",
+            actualCount, selectedCount)
+    end
+    return result
+end
+
+-- =====================================================================
+-- select_photos — set the Lightroom UI selection by photo ids or mode
+-- =====================================================================
+--
+-- Ported from znznzna/lightroom-cli (MIT) setSelectedPhotos/SelectionModule
+-- and exposed as a first-class tool: selecting photos drives every
+-- LrSelection-based command (flags, rating, labels) and stages the photo
+-- the Develop module loads. catalog:setSelectedPhotos yields to the UI
+-- thread, so it runs OUTSIDE any catalog gate (#134/#124), like the
+-- test-only setSelection above; the two share the read-back verification.
+
+function SelectionHandler.selectPhotos(args)
+    args = args or {}
+    local ids = args.photo_ids
+    local mode = args.mode
+
+    if ids == nil and mode == nil then
+        error("photo_ids or mode is required")
+    end
+    if ids ~= nil and mode ~= nil then
+        error("pass either photo_ids or mode, not both")
+    end
+
+    local catalog = LrApplication.activeCatalog()
+
+    if mode ~= nil then
+        local MODE_COMMANDS = {
+            all = LrSelection.selectAll,
+            none = LrSelection.selectNone,
+            inverse = LrSelection.selectInverse,
+            deselect_others = LrSelection.deselectOthers,
+        }
+        local command = MODE_COMMANDS[mode]
+        if not command then
+            error("mode must be one of: all, none, inverse, deselect_others")
+        end
+
+        -- LrSelection commands act on the UI selection directly (no catalog
+        -- gate involved — same family as the flag commands in set_flags).
+        local ok, err = pcall(command)
+        if not ok then
+            error("LrSelection command for mode '" .. mode .. "' failed: " .. tostring(err))
+        end
+
+        Log.info("selectPhotos: mode=" .. mode)
+
+        return {
+            success = true,
+            mode = mode,
+            message = "Selection mode applied: " .. mode,
+        }
+    end
+
+    if type(ids) ~= "table" or ids[1] == nil then
+        error("photo_ids must be a non-empty array")
+    end
+
+    local resolved = PhotoLookup.resolveMany(catalog, ids)
+
+    local photos = {}
+    local missing = {}
+    local seen = {}
+    local selectedCount = 0
+    local missingCount = 0
+    for _, entry in ipairs(resolved) do
+        if entry.photo then
+            if not seen[entry.photo] then
+                seen[entry.photo] = true
+                selectedCount = selectedCount + 1
+                photos[selectedCount] = entry.photo
+            end
+        else
+            missingCount = missingCount + 1
+            missing[missingCount] = tostring(entry.id)
+        end
+    end
+
+    if selectedCount == 0 then
+        error("No photos matched photo_ids")
+    end
+
+    -- Yields to the UI thread, so it must stay OUTSIDE withReadAccessDo for
+    -- the same reason getTargetPhotos does (#134/#124). First arg becomes active.
+    Log.info(string.format("selectPhotos: selecting %d (missing %d)", selectedCount, missingCount))
+    catalog:setSelectedPhotos(photos[1], photos)
+
+    -- Lightroom ignores photos outside the current view source and leaves the
+    -- old selection in place, reporting nothing. Read the selection back so a
+    -- caller is never told a selection happened that did not.
+    local requested = {}
+    for _, photo in ipairs(photos) do
+        requested[photo] = true
+    end
+    local actualCount = 0
+    for _, photo in ipairs(catalog:getTargetPhotos() or {}) do
+        if requested[photo] then
+            actualCount = actualCount + 1
+        end
+    end
+
+    Log.info(string.format("selectPhotos: Lightroom reports %d of %d", actualCount, selectedCount))
+
+    local result = {
+        success = actualCount > 0,
+        selected = actualCount,
+        requested = selectedCount,
+        active = photos[1].localIdentifier,
+        missing = missing,
+        message = string.format("Selected %d of %d photo(s)", actualCount, selectedCount),
+    }
+    if actualCount < selectedCount then
+        result.warning = string.format(
+            "Lightroom selected %d of %d photos: the rest are not in the current view source. "
+            .. "Switch Lightroom to a source that contains them, such as All Photographs.",
+            actualCount, selectedCount)
+    end
+    return result
+end
+
+-- =====================================================================
+-- navigate_photo — filmstrip navigation (next / previous)
+-- =====================================================================
+--
+-- LrSelection.nextPhoto()/previousPhoto() move the filmstrip the way the
+-- arrow keys do; the loupe view follows. Outside any gate (LrSelection
+-- family, cf. set_flags). Ported from lightroom-cli SelectionModule.
+
+function SelectionHandler.navigatePhoto(args)
+    args = args or {}
+    local direction = args.direction or "next"
+    if direction ~= "next" and direction ~= "previous" then
+        error("direction must be 'next' or 'previous'")
+    end
+
+    local command = (direction == "next") and LrSelection.nextPhoto
+        or LrSelection.previousPhoto
+    if type(command) ~= "function" then
+        error("LrSelection navigation is not available")
+    end
+
+    local ok, err = pcall(command)
+    if not ok then
+        error("could not navigate to " .. direction .. " photo: " .. tostring(err))
+    end
+
+    -- Report which photo is active after the move, so the caller can chain
+    -- get_photo_preview / develop work without a second round-trip.
+    local catalog = LrApplication.activeCatalog()
+    local activeId, activePath = nil, nil
+    pcall(function()
+        local targets = catalog:getTargetPhotos() or {}
+        local active = targets[1]
+        if active then
+            activeId = active.localIdentifier
+            activePath = active:getRawMetadata('path')
+        end
+    end)
+
+    Log.info("navigatePhoto: " .. direction)
+
+    local result = {
+        success = true,
+        direction = direction,
+        message = "Moved to " .. direction .. " photo",
+    }
+    if activeId ~= nil then
+        result.active = { id = activeId, path = activePath }
+    end
+    return result
+end
+
+return SelectionHandler