charming 0.3.0 → 0.4.0

data/lib/charming/presentation/view.rb

@@ -5,11 +5,11 @@ module Charming
   # rendering hooks, layout composition helpers (`row`, `column`, `render_component`, `yield_content`),
   # and access to controller theme, style, and focus state from within views.
   class View
-    # Initializes the view with named assigns injected as instance-local accessor methods via
-    # `define_singleton_method`. Called when a controller instantiates a view for rendering.
+    # Initializes the view with named assigns. Assign keys become private reader
+    # methods via method_missing (see below) — existing methods always win, so a
+    # `title:` assign never shadows a `def title` helper.
     def initialize(**assigns)
       @assigns = assigns
-      define_assign_readers
     end
 
     # Returns all view assigns as a hash, used by layouts to compose the full template (content + screen + controller).
@@ -28,18 +28,28 @@ module Charming
       ctrl ? ctrl.focused?(slot) : false
     end
 
+    # The RenderArtifacts from every screen_layout call in this view's render, in render
+    # order. Internal — the controller's rendering pipeline and TestHelper#render_view
+    # read them; app code should not.
+    def render_artifacts
+      @render_artifacts ||= []
+    end
+
     private
 
     attr_reader :assigns
 
-    # Returns the shared UI style configuration used by components and views for visual rendering (colors, borders).
+    # Builds a fresh Style for inline visual styling (colors, borders, alignment).
+    # Styles are constructed, not read from a shared singleton.
     def style
-      UI.style
+      UI::Style.new
     end
 
-    # Returns the active theme: uses `theme` from assigns or controller, falling back to `UI::Theme.default`.
+    # Returns the active theme as injected: the `theme` assign (the controller's
+    # rendering pipeline always passes one) or the controller's theme. Views and
+    # components take what they're given — there is no ambient fallback.
     def theme
-      assigns[:theme] || assigns[:controller]&.theme || UI::Theme.default
+      assigns[:theme] || assigns[:controller]&.theme
     end
 
     # Outputs styled text through the view's rendering pipeline. Accepts a named `style:` for inline formatting.
@@ -80,11 +90,15 @@ module Charming
     end
 
     # Builds a declarative layout tree for the current terminal screen and renders it.
+    # The layout's registration data (focusable panes, mouse targets) is stashed on the
+    # view as RenderArtifacts — the dispatch pipeline commits them when the response
+    # paints, so rendering never mutates the controller. Several screen_layout calls in
+    # one render accumulate in order.
     def screen_layout(background: nil, &)
       layout = Layout::Builder.build(screen: layout_screen, view: self, background: background, &)
-      register_layout_focus(layout)
-      register_layout_mouse_targets(layout)
-      layout.render
+      artifacts = layout.render_with_artifacts
+      render_artifacts << artifacts
+      artifacts.frame
     end
 
     # Yields the layout's `content` slot — used by view templates to inject their body into a layout wrapper (e.g., sidebar).
@@ -113,30 +127,22 @@ module Charming
       style_object ? style_object.render(value) : value
     end
 
-    # Dynamically defines read-only accessor methods for each assign key as singleton methods on self.
-    # Skips keys where the view already responds (controller methods take precedence).
-    def define_assign_readers
-      assigns.each_key do |name|
-        next if respond_to?(name, true)
+    # Resolves assign keys as zero-argument private readers. Real methods take
+    # precedence (method_missing only fires when nothing defined the message).
+    def method_missing(name, *args, &block)
+      return assigns.fetch(name) if args.empty? && block.nil? && assigns.key?(name)
 
-        define_singleton_method(name) { assigns.fetch(name) }
-      end
-    end
-
-    def layout_screen
-      assigns[:screen] || assigns[:controller]&.screen || Charming::Screen.new(width: 80, height: 24)
+      super
     end
 
-    def register_layout_focus(layout)
-      return unless assigns[:controller]
-
-      assigns[:controller].focus.define_layout(layout.focusable_names)
+    # Lets `respond_to?` answer true for assign names, matching the readers
+    # method_missing provides.
+    def respond_to_missing?(name, include_private = false)
+      assigns.key?(name) || super
     end
 
-    def register_layout_mouse_targets(layout)
-      return unless assigns[:controller]
-
-      assigns[:controller].register_mouse_targets(layout.mouse_targets)
+    def layout_screen
+      assigns[:screen] || assigns[:controller]&.screen || Charming::Screen.new(width: 80, height: 24)
     end
   end
 end

data/lib/charming/render_artifacts.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Charming
+  # RenderArtifacts is what a pure view render produces: the painted *frame* string plus
+  # the registration data the frame implies — *focus_slots* (focusable layout pane
+  # names) and *mouse_targets* (named pane hit areas). Views stash them instead of
+  # mutating the controller mid-render; the dispatch pipeline commits them when the
+  # response actually paints.
+  RenderArtifacts = Data.define(:frame, :focus_slots, :mouse_targets) do
+    def initialize(frame: "", focus_slots: [], mouse_targets: [])
+      super
+    end
+
+    # Merges several layouts' artifacts from one render: the last-rendered layout wins
+    # for focus, and mouse targets concatenate in render order (overlays hit-test
+    # last-wins via rfind).
+    def self.merge(artifacts)
+      new(
+        focus_slots: artifacts.last&.focus_slots || [],
+        mouse_targets: artifacts.flat_map(&:mouse_targets)
+      )
+    end
+  end
+end

data/lib/charming/response.rb

@@ -1,31 +1,42 @@
 # frozen_string_literal: true
 
 module Charming
-  # Response encapsulates a controller's dispatch outcome — one of render text, navigate to another route, or quit.
+  # Response encapsulates a controller's dispatch outcome — one of render text, navigate to another screen, or quit.
   # Rails-style factories (`render`, `navigate`, `quit`) serve as the public API and map to :kind values
   # that the Runtime interprets at the end of each event loop iteration.
   #
   # *escapes* carries any out-of-band terminal sequences (image transmissions, clipboard writes,
   # notifications, window-title changes) gathered during the dispatch. The Runtime flushes them straight
   # to the backend, bypassing the line-based frame pipeline. It is empty for ordinary responses.
-  Response = Data.define(:kind, :body, :path, :escapes) do
+  #
+  # *artifacts* carries the merged RenderArtifacts (focus slots, mouse targets) from the views
+  # rendered during the dispatch, attached when the response is assigned. The dispatch pipeline
+  # commits them at dispatch exit; nil for navigate/quit responses and renders with no layout.
+  Response = Data.define(:kind, :body, :name, :params, :escapes, :artifacts) do
     # Factory constructing a Render response for displaying *body* text on the current screen. *escapes*
     # is the list of out-of-band sequences gathered during the dispatch (defaults to none).
     def self.render(body, escapes: [])
-      new(kind: :render, body: body, path: nil, escapes: escapes)
+      new(kind: :render, body: body, name: nil, params: {}, escapes: escapes, artifacts: nil)
     end
 
-    # Factory constructing a NavigateResponse routing to the named *path* (string).
-    def self.navigate(path)
-      new(kind: :navigate, body: "", path: path, escapes: [])
+    # Factory constructing a NavigateResponse routing to the screen registered under *name*
+    # (a Symbol from config/routes.rb), passing *params* through to the controller.
+    def self.navigate(name, **params)
+      if name.is_a?(String) && name.start_with?("/")
+        suggestion = name.split("/")[1].to_s.delete_prefix(":")
+        raise ArgumentError,
+          "String URL paths were removed. Use `navigate :#{suggestion}` with a screen name from config/routes.rb. See UPGRADING.md."
+      end
+
+      new(kind: :navigate, body: "", name: name.to_sym, params: params, escapes: [], artifacts: nil)
     end
 
     # Factory constructing a QuitResponse signalling termination of the top-level event loop.
     def self.quit
-      new(kind: :quit, body: "", path: nil, escapes: [])
+      new(kind: :quit, body: "", name: nil, params: {}, escapes: [], artifacts: nil)
     end
 
-    # Returns `true` when this response is navigating to another screen or route.
+    # Returns `true` when this response is navigating to another screen.
     def navigate?
       kind == :navigate
     end

data/lib/charming/router.rb

@@ -1,16 +1,17 @@
 # frozen_string_literal: true
 
-require "uri"
-
 module Charming
-  # Router manages an application's route table and provides a Rails-inspired DSL for defining routes.
-  # Each route maps a URL path to a controller, action (implicitly :show), and title (for sidebar display).
+  # Router manages an application's screen table and provides a Rails-inspired DSL for
+  # defining screens. Each screen maps a symbolic name to a controller, an action
+  # (implicitly :show), and a title (for sidebar display). Navigation passes params
+  # directly — there are no URL path templates.
   class Router
-    # Route is a Data object holding a route's path template, target controller/action, title, and resolved params.
-    Route = Data.define(:path, :controller_class, :action, :title, :params) do
+    # Route is a Data object holding a screen's name, target controller/action, title,
+    # and resolved params.
+    Route = Data.define(:name, :controller_class, :action, :title, :params) do
       def with_params(params)
         self.class.new(
-          path: path,
+          name: name,
           controller_class: controller_class,
           action: action,
           title: title,
@@ -19,48 +20,48 @@ module Charming
       end
     end
 
-    DynamicRoute = Data.define(:route, :pattern, :param_names)
-
     # Initializes a new router with an optional namespace prefix for controller constant lookups.
     def initialize(namespace: nil)
       @namespace = namespace
       @routes = {}
-      @dynamic_routes = []
     end
 
-    # Evaluates a block in the context of this Router instance using instance_eval, allowing DSL calls like screen and root to register routes.
-    # This is how `routes.draw { screen "/", to: "HomeController", title: "Home" }` works.
+    # Evaluates a block in the context of this Router instance using instance_eval, allowing DSL
+    # calls like screen and root to register routes.
+    # This is how `routes.draw { root "home#show" }` works.
     def draw(&)
       instance_eval(&)
     end
 
-    # Registers the home screen at "/" with a given title. Shorthand for `screen path, to: target`.
-    # Example: `root "HomeController"` maps `/` → HomeController#show with title "Home".
+    # Registers the home screen under the reserved name :root.
+    # Example: `root "home#show"` maps :root → HomeController#show with title "Home".
     def root(target, title: "Home")
-      screen("/", to: target, title: title)
+      screen(:root, target, title: title)
     end
 
-    # Maps a URL path to a controller and action (e.g. "HomeController" for HomeController#show).
-    # Builds a Route object from the path, resolved controller constant, parsed action, and an optional or derived title.
-    def screen(path, to:, title: nil)
-      controller_name, action = to.split("#", 2)
-      route = Route.new(
-        path: path,
+    # Maps a symbolic *name* to a controller and action (e.g. "home#show" for
+    # HomeController#show; the action defaults to :show). *title* defaults to a
+    # humanized form of the name.
+    def screen(name, target = nil, title: nil, to: nil)
+      name = screen_name(name)
+      target ||= to or raise ArgumentError, "screen :#{name} needs a target like \"home#show\""
+      controller_name, action = target.split("#", 2)
+      @routes[name] = Route.new(
+        name: name,
         controller_class: constantize(controller_constant_name(controller_name)),
         action: (action || "show").to_sym,
-        title: title || derive_title(path),
+        title: title || derive_title(name),
         params: {}
       )
-      @routes[path] = route
-      @dynamic_routes.reject! { |dynamic_route| dynamic_route.route.path == path }
-      @dynamic_routes << compile_dynamic_route(route) if dynamic_path?(path)
     end
 
-    # Resolves a route by path from the router's table. Exact routes win over dynamic routes.
-    # Raises KeyError if no route matches.
-    # Used at runtime to look up the controller class and action for incoming requests.
-    def resolve(path = "/")
-      @routes[path] || resolve_dynamic(path) || raise(KeyError, "key not found: #{path.inspect}")
+    # Resolves a screen by name, returning the route with *params* attached. Raises
+    # KeyError listing the registered names when no screen matches. Used at runtime to
+    # look up the controller class and action for navigation.
+    def resolve(name = :root, params = {})
+      @routes.fetch(name.to_sym) do
+        raise KeyError, "unknown screen #{name.inspect} (registered screens: #{@routes.keys.map(&:inspect).join(", ")})"
+      end.with_params(params)
     end
 
     # Returns all registered routes as Route objects, ordered by insertion.
@@ -75,58 +76,39 @@ module Charming
     # For example, namespace "Admin" means HomeController resolves as Admin::HomeController.
     attr_reader :namespace
 
-    def dynamic_path?(path)
-      path.split("/").any? { |segment| segment.start_with?(":") && segment.length > 1 }
-    end
+    # Normalizes a screen name to a Symbol, rejecting legacy string URL paths with a
+    # migration hint.
+    def screen_name(name)
+      return name if name.is_a?(Symbol)
+      raise ArgumentError, string_path_hint(name, "screen") if name.is_a?(String) && name.start_with?("/")
 
-    def compile_dynamic_route(route)
-      param_names = []
-      segments = route.path.split("/", -1).map do |segment|
-        if segment.start_with?(":") && segment.length > 1
-          param_names << segment.delete_prefix(":").to_sym
-          "([^/]+)"
-        else
-          Regexp.escape(segment)
-        end
-      end
-
-      DynamicRoute.new(route: route, pattern: /\A#{segments.join("/")}\z/, param_names: param_names)
-    end
-
-    def resolve_dynamic(path)
-      @dynamic_routes.each do |dynamic_route|
-        match = dynamic_route.pattern.match(path)
-        return dynamic_route.route.with_params(extract_params(dynamic_route.param_names, match.captures)) if match
-      end
-
-      nil
-    end
-
-    def extract_params(names, values)
-      names.zip(values).to_h do |name, value|
-        [name, URI.decode_www_form_component(value)]
-      end
+      name.to_sym
     end
 
     # Looks up a constant by name in Object. Used to resolve controller strings from route definitions.
     def constantize(name)
-      ActiveSupport::Inflector.constantize(name)
+      Internal::Inflections.constantize(name)
     end
 
     # Builds the full controller constant name, prepending the namespace if present.
     # For example: "home" with namespace "Admin" → "Admin::HomeController".
     def controller_constant_name(controller_name)
-      name = "#{ActiveSupport::Inflector.camelize(controller_name)}Controller"
+      name = "#{Internal::Inflections.camelize(controller_name)}Controller"
       @namespace.to_s.empty? ? name : "#{@namespace}::#{name}"
     end
 
-    # Derives a human-readable title from a URL path by stripping the leading slash,
-    # splitting on underscores/hyphens/slashes, capitalizing each segment, and joining with spaces.
-    # Examples: "/projects" → "Projects", "/projects/list" → "Projects List".
-    def derive_title(path)
-      return "Home" if path == "/"
+    # Derives a human-readable title from a screen name by splitting on underscores and
+    # hyphens, capitalizing each segment, and joining with spaces.
+    # Example: :project_list → "Project List".
+    def derive_title(name)
+      name.to_s.split(/[_-]/).map(&:capitalize).join(" ")
+    end
 
-      path.delete_prefix("/").split(%r{[_\-/]}).map(&:capitalize).join(" ")
+    # The error message for callers still passing string URL paths.
+    def string_path_hint(path, dsl)
+      suggestion = path.split("/")[1].to_s.delete_prefix(":")
+      "String URL paths were removed. Register screens by name — `#{dsl} :#{suggestion}, ...` — " \
+        "and navigate with `navigate :#{suggestion}`. See UPGRADING.md."
     end
   end
 end

data/lib/charming/runtime.rb

@@ -16,7 +16,7 @@ module Charming
       @task_queue = Thread::Queue.new
       @task_executor = build_task_executor(task_executor)
       @application.task_executor = @task_executor
-      @route = resolve_route("/")
+      @route = resolve_route(:root)
       @screen = backend_screen
       @coalesce_input = @application.respond_to?(:coalesce_input?) && @application.coalesce_input?
       @event_loop = build_event_loop
@@ -24,6 +24,7 @@ module Charming
         event_loop: @event_loop,
         bindings: -> { @route.controller_class.timer_bindings }
       )
+      enter_controller
     end
 
     # Runs the event loop: enters alt-screen, dispatches incoming events
@@ -34,10 +35,12 @@ module Charming
       setup_terminal
       install_signal_handlers
       install_exit_hook
+      @controller.capture_loop_thread!
       with_raw_input do
         render(initial_response)
         @event_loop.run { |event, more_ready| process(event, flush: !more_ready) }
       ensure
+        exit_controller
         restore_signal_handlers
         @task_executor&.shutdown(timeout: 2.0)
         @application.save_session if @application.respond_to?(:save_session)
@@ -213,38 +216,48 @@ module Charming
     # Dispatches an action on the current route's controller with an optional event.
     # Entry point from the event loop into controllers.
     def dispatch(action, event: nil)
-      controller(event: event).dispatch(action)
+      @controller.dispatch(action, event: event)
     end
 
     # Dispatches a key press to the current route's controller.
     def dispatch_key(event)
-      controller(event: event).dispatch_key
+      @controller.dispatch_key(event)
     end
 
     # Dispatches a timer tick to the current route's controller.
     def dispatch_timer(event)
-      controller(event: event).dispatch_timer
+      @controller.dispatch_timer(event)
     end
 
     # Dispatches an async task result to the current route's controller.
     def dispatch_task(event)
-      controller(event: event).dispatch_task
+      @controller.dispatch_task(event)
     end
 
     # Dispatches a task progress report to the current route's controller.
     def dispatch_task_progress(event)
-      controller(event: event).dispatch_task_progress
+      @controller.dispatch_task_progress(event)
     end
 
     # Dispatches a mouse action (click, drag, scroll) to the current route's controller.
     def dispatch_mouse(event)
-      controller(event: event).dispatch_mouse
+      @controller.dispatch_mouse(event)
     end
 
-    # Instantiates a fresh controller for the active route, passing the application, current *event*,
-    # route params, screen dimensions, and route object. Called by every dispatch path.
-    def controller(event: nil)
-      @route.controller_class.new(application: @application, event: event, params: @route.params, screen: screen, route: @route)
+    # Constructs the controller for the current route and runs its screen_entered hook.
+    # The instance lives until the next navigation (or quit), so controller ivars hold
+    # screen-lifetime state.
+    def enter_controller
+      @controller = @route.controller_class.new(
+        application: @application, params: @route.params, screen: screen, route: @route
+      )
+      @controller.screen_entered
+    end
+
+    # Runs the current controller's screen_exited hook and releases it.
+    def exit_controller
+      @controller&.screen_exited
+      @controller = nil
     end
 
     # Type-based dispatcher: routes resize, task, progress, timer, mouse, paste, and key
@@ -264,47 +277,50 @@ module Charming
     # Dispatches a terminal focus change to the controller's optional `focus_changed`
     # action. Ignored when the controller doesn't define one.
     def dispatch_focus_change(event)
-      ctrl = controller(event: event)
-      return nil unless ctrl.respond_to?(:focus_changed)
+      return nil unless @controller.respond_to?(:focus_changed)
 
-      ctrl.dispatch(:focus_changed)
+      @controller.dispatch(:focus_changed, event: event)
     end
 
     # Dispatches pasted text to the current route's controller.
     def dispatch_paste(event)
-      controller(event: event).dispatch_paste
+      @controller.dispatch_paste(event)
     end
 
-    # Dispatches a resize event: updates screen dimensions and re-renders the current action.
+    # Dispatches a resize event: updates screen dimensions on the live controller and
+    # re-renders the current action.
     # The renderer's cached previous frame is invalidated and the backend is cleared so the
     # new-dimension frame paints onto a clean alt-screen instead of overlaying stale rows.
     def dispatch_resize(event)
       @screen = Screen.new(width: event.width, height: event.height)
       @renderer.invalidate if @renderer.respond_to?(:invalidate)
       @backend.clear if @backend.respond_to?(:clear)
+      @controller.update_screen(@screen)
       dispatch(@route.action, event: event)
     end
 
-    # Follows navigation responses: resolves the new route from the router,
-    # reschedules the event loop's timers for the new controller, and
+    # Follows navigation responses: discards the current controller, resolves and enters
+    # the new route, reschedules the event loop's timers for the new controller, and
     # dispatches that route's action.
     def resolve_response(response)
       return response unless response.navigate?
 
-      @route = resolve_route(response.path)
+      exit_controller
+      @route = resolve_route(response.name, response.params)
       @event_loop.reset_timers(autostart_timer_bindings)
+      enter_controller
       dispatch(@route.action)
     end
 
-    # Resolves *path* from the app's router. An unrouted "/" falls back to the app's
-    # first route, or to the built-in welcome screen when no routes are defined yet
-    # (like Rails' welcome page); other unrouted paths still raise.
-    def resolve_route(path)
-      @application.routes.resolve(path)
+    # Resolves *name* from the app's router, attaching *params*. An unrouted :root falls
+    # back to the app's first route, or to the built-in welcome screen when no screens
+    # are defined yet (like Rails' welcome page); other unrouted names still raise.
+    def resolve_route(name, params = {})
+      @application.routes.resolve(name, params)
     rescue KeyError
-      raise unless path == "/"
+      raise unless name.to_sym == :root
 
-      @application.routes.all.first || Welcome.route
+      (@application.routes.all.first || Welcome.route).with_params(params)
     end
 
     # Derives Screen dimensions (width, height) from the terminal backend.

data/lib/charming/{controller/command_palette.rb → shell/palette.rb}

@@ -1,12 +1,35 @@
 # frozen_string_literal: true
 
 module Charming
-  class Controller
-    # Command palette helpers mixed into Controller. Opens/closes the palette, builds the
-    # palette from registered command bindings or theme list, and routes key/mouse events
-    # through it. Supports both the standard command palette (:commands) and the theme picker
-    # (:themes) via a discriminated `session[:command_palette]` state hash.
-    module CommandPalette
+  # Shell::Palette is the opt-in app-shell command palette: the `command` class DSL,
+  # open/close helpers, the theme picker, and key/mouse routing while the palette is
+  # open. Generated apps include it in ApplicationController when generated with the
+  # sidebar layout (`include Charming::Shell::Palette`).
+  #
+  # Palette state lives in the session, not on the controller: the palette is app-global —
+  # a command can navigate to another screen, and the open/closed state must survive the
+  # controller swap that navigation causes.
+  module Shell
+    module Palette
+      # Wires the class-level `command` DSL into the including controller.
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # Class-level palette DSL: `command` entries and their inherited registry.
+      module ClassMethods
+        # Adds a CommandPalette entry with the given *label*. *action* is a method name to send on
+        # the controller, or a block to instance_exec when selected.
+        def command(label, action = nil, &block)
+          command_bindings << Components::CommandPalette::Command.new(label: label, value: block || action)
+        end
+
+        # Array of registered command palette entries, inherited from superclass when undefined.
+        def command_bindings
+          @command_bindings ||= superclass.respond_to?(:command_bindings) ? superclass.command_bindings.dup : []
+        end
+      end
+
       # Opens the command palette populated with the controller's `command_bindings`. Pushes
       # a focus scope so subsequent keys are routed to the palette.
       def open_command_palette
@@ -32,6 +55,13 @@ module Charming
         build_command_palette_from_state(session[:command_palette]) if command_palette_open?
       end
 
+      # Opens the theme picker (a CommandPalette populated with the registered themes) and renders.
+      def open_theme_palette
+        session[:command_palette] = command_palette_state(:themes)
+        focus.push_scope([:command_palette], origin: :command_palette)
+        render_default_action
+      end
+
       private
 
       # Routes the current key event to the open palette. Cancels on Escape, performs the
@@ -40,10 +70,10 @@ module Charming
         palette = command_palette
         result = palette.handle_key(event)
 
-        if result == :cancelled
+        if result&.cancelled?
           close_command_palette
         elsif selected_command?(result)
-          perform_command(result.last)
+          perform_command(result.value)
         else
           save_command_palette_state(palette)
           render_default_action unless response
@@ -92,13 +122,15 @@ module Charming
         session[:command_palette] = session.fetch(:command_palette).merge(palette.state)
       end
 
-      # True when a component result is the `[:selected, command]` array shape.
+      # True when a component result carries a selected command (Result.selected).
       def selected_command?(result)
-        result.is_a?(Array) && result.first == :selected
+        result.respond_to?(:selected?) && result.selected?
       end
 
       # Invokes the value (proc, lambda, or method symbol) of the selected *command*, then
       # closes the palette unless the command was :quit or the user has re-opened it.
+      # A command that set a response keeps it; only a command that produced no response
+      # falls back to the default render.
       def perform_command(command)
         current_palette_state = session[:command_palette]
         pop_command_palette_scope
@@ -106,7 +138,7 @@ module Charming
         if command.value != :quit && session[:command_palette].equal?(current_palette_state)
           session.delete(:command_palette)
         end
-        render_default_action unless response&.navigate? || response&.quit?
+        render_default_action unless response
       end
 
       # Returns the theme-switching commands used by the theme picker palette.