rori 0.1.0

data/app/javascript/rori/terminal_controller.js

@@ -0,0 +1,198 @@
+import { Controller } from "@hotwired/stimulus"
+import { CommandIndex, isNested } from "rori/command_index"
+
+const BUS = "rori-command"
+const HISTORY_KEY = "rori:terminal:history"
+const HISTORY_LIMIT = 100
+const SUGGESTIONS = 8
+const FIELDS = "input, textarea, select, [contenteditable]"
+const YES = /^y(es)?$/i
+
+const format = (template, values) => template.replace(/%\{(\w+)\}/g, (_, key) => values[key] ?? "")
+// "Pick theme…" → "pick-theme": one word per label, so a trail reads as words.
+const token = (label) => label.toLowerCase().replace(/[…›✓]/g, "").trim().replace(/\s+/g, "-")
+const words = (trail) => trail.map(({ label }) => token(label)).join(" ")
+
+// A drop-down command line over the same command tree as ⌘K: the same
+// server-rendered lists, client-side sources, fuzzy matcher and command bus.
+// Input matches whole paths through the tree, so `ui wallpaper cover` and
+// just `uthen` (UI › Theme › Nord) both work; a path ending on a nested item
+// lists it. Opens with Rori.terminal_key outside text fields. Commands that
+// ask first (`confirm`) wait for a `y` on the next line; anything else cancels.
+export default class extends Controller {
+  static targets = ["panel", "output", "input", "suggestions"]
+  static values = { root: String, key: String, prompt: String, messages: Object }
+
+  connect() {
+    this.history = this.#loadHistory()
+    this.cursor = this.history.length
+  }
+
+  keydown(event) {
+    if (event.code !== this.keyValue || event.metaKey || event.ctrlKey || event.altKey) return
+    const inTerminal = this.panelTarget.contains(event.target)
+    // A field in a closed dialog (see rori_controller.js `typing`) isn't being typed in.
+    if (!inTerminal && event.target.closest?.(FIELDS) && !event.target.closest("dialog:not([open])")) return
+    if (document.querySelector("dialog:modal")) return
+    event.preventDefault()
+    this.toggle()
+  }
+
+  toggle() {
+    this.panelTarget.hidden ? this.open() : this.close()
+  }
+
+  open() {
+    this.returnFocus = document.activeElement
+    this.#reindex()
+    this.panelTarget.hidden = false
+    if (!this.outputTarget.childElementCount) this.#print(this.messagesValue.welcome, "muted")
+    this.inputTarget.focus()
+    this.suggest()
+  }
+
+  close() {
+    this.confirming = null
+    this.panelTarget.hidden = true
+    this.suggestionsTarget.replaceChildren()
+    if (this.returnFocus?.isConnected) this.returnFocus.focus({ preventScroll: true })
+  }
+
+  navigate(event) {
+    if (event.key === "Escape") {
+      event.preventDefault()
+      this.close()
+    } else if (event.key === "Enter") {
+      event.preventDefault()
+      this.#submit()
+    } else if (event.key === "Tab") {
+      event.preventDefault()
+      this.#complete()
+    } else if (event.key === "ArrowUp" || event.key === "ArrowDown") {
+      event.preventDefault()
+      this.#recall(event.key === "ArrowUp" ? -1 : 1)
+    }
+  }
+
+  async suggest() {
+    const query = this.inputTarget.value.trim()
+    const ticket = (this.ticket = (this.ticket || 0) + 1)
+    const suggested = query
+      ? await this.index.search(query, { limit: SUGGESTIONS })
+      : (await this.index.list({ children: this.rootValue })).map((item) => ({ item, trail: [item] }))
+    if (ticket !== this.ticket) return
+
+    this.suggested = suggested
+    this.suggestionsTarget.replaceChildren(...suggested.slice(0, SUGGESTIONS).map(({ item, trail }, i) => {
+      const li = document.createElement("li")
+      li.className = "rori-terminal__suggestion"
+      li.toggleAttribute("aria-selected", i === 0)
+      const label = document.createElement("span")
+      label.textContent = words(trail) + (isNested(item) ? " ›" : "")
+      const group = document.createElement("span")
+      group.className = "rori-terminal__group"
+      group.textContent = (item.current ? "✓ " : "") + item.group
+      li.append(label, group)
+      return li
+    }))
+  }
+
+  // Tab: spell out the best match's whole path.
+  #complete() {
+    const best = this.suggested?.[0]
+    if (!best) return
+    this.inputTarget.value = words(best.trail) + (isNested(best.item) ? " " : "")
+    this.suggest()
+  }
+
+  async #submit() {
+    const line = this.inputTarget.value.trim()
+    this.inputTarget.value = ""
+    this.#print(`${this.promptValue} ${line}`, "echo")
+    if (this.confirming) return this.#answer(line)
+    if (!line) return this.suggest()
+    this.#remember(line)
+
+    if (line === "clear") {
+      this.outputTarget.replaceChildren()
+    } else if (line === "help") {
+      this.#printList(this.messagesValue.help, await this.index.list({ children: this.rootValue }))
+    } else {
+      await this.#run(line)
+    }
+    this.suggest()
+  }
+
+  async #run(query) {
+    const [best] = await this.index.search(query, { limit: 1 })
+    if (!best) return this.#print(format(this.messagesValue.no_match, { query }), "error")
+
+    const { item, trail } = best
+    const path = trail.map(({ label }) => label).join(" › ")
+    if (isNested(item)) return this.#printList(format(this.messagesValue.list, { path }), await this.index.list(item))
+    if (item.confirm) {
+      this.confirming = { item, path }
+      return this.#print(format(this.messagesValue.confirm, { path }), "muted")
+    }
+    this.#execute(item, path)
+  }
+
+  #answer(line) {
+    const { item, path } = this.confirming
+    this.confirming = null
+    if (YES.test(line)) this.#execute(item, path)
+    else this.#print(this.messagesValue.cancelled, "muted")
+    this.suggest()
+  }
+
+  #execute(item, path) {
+    const { url, action, param, run } = item
+    this.dispatch("run", { prefix: BUS, detail: { url, action, param, run, newWindow: false } })
+    this.#print(format(url ? this.messagesValue.opened : this.messagesValue.ran, { path }), "ok")
+    this.#reindex() // runs change state: the current theme, workspaces, records
+  }
+
+  #reindex() {
+    this.index = new CommandIndex(this.rootValue, {
+      source: (source) => this.dispatch("source", { prefix: BUS, detail: { source, items: [] } }).detail.items,
+    })
+  }
+
+  #print(text, kind) {
+    const line = document.createElement("div")
+    line.className = `rori-terminal__entry rori-terminal__entry--${kind}`
+    line.textContent = text
+    this.outputTarget.append(line)
+    this.outputTarget.scrollTop = this.outputTarget.scrollHeight
+  }
+
+  #printList(heading, items) {
+    this.#print(heading, "muted")
+    if (!items.length) return this.#print(this.messagesValue.empty, "muted")
+    for (const item of items) {
+      const nested = isNested(item) ? " ›" : ""
+      this.#print(`  ${token(item.label)}${nested}  ${item.current ? "✓ " : ""}${item.group}`, "item")
+    }
+  }
+
+  #recall(step) {
+    if (!this.history.length) return
+    this.cursor = Math.max(0, Math.min(this.history.length, this.cursor + step))
+    this.inputTarget.value = this.history[this.cursor] ?? ""
+    this.suggest()
+  }
+
+  #remember(line) {
+    this.history = [...this.history.filter((entry) => entry !== line), line].slice(-HISTORY_LIMIT)
+    this.cursor = this.history.length
+    localStorage.setItem(HISTORY_KEY, JSON.stringify(this.history))
+  }
+
+  #loadHistory() {
+    try {
+      return JSON.parse(localStorage.getItem(HISTORY_KEY)) || []
+    } catch {
+      return []
+    }
+  }
+}

data/app/javascript/rori/theme_controller.js

@@ -0,0 +1,35 @@
+import { Controller } from "@hotwired/stimulus"
+
+const ONE_YEAR = 60 * 60 * 24 * 365
+
+// Applies palette "theme" commands. Moving through the theme list previews
+// each one; closing the palette without picking reverts to the saved theme.
+// The pick lives in a cookie so the server renders it on <html> (no flash).
+export default class extends Controller {
+  static values = { cookie: String }
+
+  run({ detail: { action, param } }) {
+    if (action !== "theme") return
+    this.#apply(param)
+    document.cookie = `${this.cookieValue}=${encodeURIComponent(param)}; path=/; max-age=${param ? ONE_YEAR : 0}; samesite=lax`
+  }
+
+  preview({ detail: { action, param } }) {
+    action === "theme" ? this.#apply(param) : this.revert()
+  }
+
+  revert() {
+    this.#apply(this.#saved())
+  }
+
+  #apply(slug) {
+    const root = document.documentElement
+    if (slug) root.dataset.theme = slug
+    else delete root.dataset.theme
+  }
+
+  #saved() {
+    const pair = document.cookie.split("; ").find((entry) => entry.startsWith(`${this.cookieValue}=`))
+    return pair ? decodeURIComponent(pair.split("=")[1]) : ""
+  }
+}

data/app/javascript/rori/wallpaper_controller.js

@@ -0,0 +1,67 @@
+import { Controller } from "@hotwired/stimulus"
+
+const ONE_YEAR = 60 * 60 * 24 * 365
+
+// Applies the UI › Wallpaper commands:
+//   wallpaper (safe | cover | off) — classes on <body>: the photo inside the
+//     desk, behind the menu bar too, or none. Previews as you move through the
+//     list and reverts if you don't pick, like rori-theme.
+//   wallpaper_next — the next photo in the pool, swapped in place.
+//   wallpaper_pin  — keep the current photo across launches (toggles).
+// Mode and pin live in cookies so the server renders them on load.
+export default class extends Controller {
+  static targets = ["credit"]
+  static values = { cookie: String, mode: String, pinCookie: String, pool: Array, current: String, pinned: Boolean }
+
+  run({ detail: { action, param } }) {
+    if (action === "wallpaper") {
+      this.modeValue = param
+      this.#setCookie(this.cookieValue, param)
+    } else if (action === "wallpaper_next") {
+      this.#next()
+    } else if (action === "wallpaper_pin") {
+      this.pinnedValue = !this.pinnedValue
+      this.#setCookie(this.pinCookieValue, this.pinnedValue ? this.currentValue : "")
+    }
+  }
+
+  preview({ detail: { action, param } }) {
+    action === "wallpaper" ? this.#apply(param) : this.revert()
+  }
+
+  revert() {
+    this.#apply(this.modeValue)
+  }
+
+  modeValueChanged(mode) {
+    this.#apply(mode)
+  }
+
+  #next() {
+    const pool = this.poolValue
+    if (pool.length < 2) return
+    const index = pool.findIndex(({ id }) => id === this.currentValue)
+    const wallpaper = pool[(index + 1) % pool.length]
+
+    this.element.style.setProperty("--rori-wallpaper", wallpaper.image)
+    this.currentValue = wallpaper.id
+    if (this.pinnedValue) this.#setCookie(this.pinCookieValue, wallpaper.id)
+    if (this.hasCreditTarget) {
+      this.creditTarget.hidden = !wallpaper.credit
+      if (wallpaper.credit) this.creditTarget.href = wallpaper.credit
+    }
+    this.#apply(this.modeValue)
+  }
+
+  #apply(mode) {
+    // Without a photo on the page (Rori.wallpapers off) there's nothing to show.
+    const photo = this.element.style.getPropertyValue("--rori-wallpaper") !== ""
+    this.element.classList.toggle("has-wallpaper", photo && mode !== "off")
+    this.element.classList.toggle("wallpaper-cover", mode === "cover")
+  }
+
+  // An empty value removes the cookie.
+  #setCookie(name, value) {
+    document.cookie = `${name}=${encodeURIComponent(value)}; path=/; max-age=${value ? ONE_YEAR : 0}; samesite=lax`
+  }
+}

data/app/models/rori/command.rb

@@ -0,0 +1,105 @@
+# A command-palette entry. Running it either opens `url` in a desk window,
+# fires a client-side `action` (with an optional `param`) that the desk or
+# theme controller picks up, runs a server-side command (`run`, see
+# `Rori.command`; `confirm` asks first), or drills into a nested list: served
+# at the `children` URL, or built in the browser from a named `source` for
+# state the server can't see (see rori-palette's `source` event).
+class Rori::Command < Data.define(:label, :group, :url, :action, :param, :children, :source, :current, :run, :confirm)
+  ACTIONS = %w[ overview new_workspace cycle_width full_width center_column close_window reopen_window toggle_terminal shortcuts ].freeze
+
+  class << self
+    def all = routes + records + actions + [ workspace_mover, theme_picker, ui_menu ] + runs + app_commands
+
+    # Every parameterless GET route becomes a command once it has a label under
+    # `desk.commands.routes.<controller>.<action>` — adding the locale key opts it in.
+    def routes
+      Rails.application.routes.routes.filter_map do |route|
+        controller, action = route.defaults.values_at(:controller, :action)
+        next unless controller && route.verb == "GET" && route.required_parts.empty?
+
+        key = "rori.commands.routes.#{controller.tr("/", ".")}.#{action}"
+        new(label: I18n.t(key), group: group(:open), url: route.format({})) if I18n.exists?(key)
+      end.uniq(&:url)
+    end
+
+    # The most recently updated records of every model in `Rori.records`.
+    def records
+      Rori.records.map(&:constantize).flat_map do |model|
+        model.order(updated_at: :desc).limit(Rori.record_limit).map do |record|
+          new(label: record.to_s, group: model.model_name.human, url: url_helpers.polymorphic_path(record))
+        end
+      end
+    end
+
+    def actions
+      ACTIONS.map { new(label: I18n.t(it, scope: "rori.commands.actions"), group: group(:rori), action: it) }
+    end
+
+    # The app's server-side commands (`Rori.command`).
+    def runs
+      Rori.runnables.values.map { new(label: it.label, group: group(:run), run: it.name, confirm: it.confirm) }
+    end
+
+    def workspace_mover
+      new(label: I18n.t("rori.commands.workspaces.move"), group: group(:rori), source: "workspaces")
+    end
+
+    def theme_picker
+      new(label: I18n.t("rori.commands.themes.pick"), group: group(:rori), children: url_helpers.rori_commands_themes_path)
+    end
+
+    def ui_menu
+      new(label: I18n.t("rori.commands.ui.label"), group: group(:rori), children: url_helpers.rori_commands_ui_path)
+    end
+
+    # "UI ›": one nested list per appearance setting.
+    def ui
+      theme = new(label: I18n.t("rori.commands.ui.theme"), group: group(:ui), children: url_helpers.rori_commands_themes_path)
+      wallpaper = new(label: I18n.t("rori.commands.ui.wallpaper"), group: group(:ui), children: url_helpers.rori_commands_wallpapers_path)
+      bars = new(label: I18n.t("rori.commands.ui.bars"), group: group(:ui), children: url_helpers.rori_commands_bars_path)
+      Rori.wallpapers ? [ theme, wallpaper, bars ] : [ theme, bars ]
+    end
+
+    # "UI › Menu bar ›": top or bottom.
+    def bars(current:)
+      Rori::PrefsHelper::BAR_POSITIONS.map do |position|
+        new(label: I18n.t(position, scope: "rori.commands.bars"), group: I18n.t("rori.commands.ui.bars"),
+          action: "bars", param: position, current: position == current)
+      end
+    end
+
+    # The modes, then Next (swap the photo now) and Pin (keep it across launches).
+    def wallpapers(current:, pinned: false)
+      group = I18n.t("rori.commands.ui.wallpaper")
+      modes = Rori::Wallpaper::MODES.map do |mode|
+        new(label: I18n.t(mode, scope: "rori.commands.wallpapers"), group:, action: "wallpaper", param: mode, current: mode == current)
+      end
+      modes + [
+        new(label: I18n.t("rori.commands.wallpapers.next"), group:, action: "wallpaper_next"),
+        new(label: I18n.t("rori.commands.wallpapers.pin"), group:, action: "wallpaper_pin", current: pinned)
+      ]
+    end
+
+    # `param: ""` is the built-in theme (no data-theme attribute).
+    def themes(current:)
+      default = new(label: I18n.t("rori.commands.themes.default"), group: I18n.t("rori.commands.themes.auto"),
+        action: "theme", param: "", current: current.nil?)
+
+      [ default ] + Rori::Theme.all.map do |theme|
+        new(label: theme.name, group: I18n.t(theme.dark? ? "dark" : "light", scope: "rori.commands.themes"),
+          action: "theme", param: theme.slug, current: theme.slug == current&.slug)
+      end
+    end
+
+    private
+      def app_commands = Rori.commands.flat_map { Array(it.call) }
+
+      def group(name) = I18n.t(name, scope: "rori.commands.groups")
+
+      def url_helpers = Rails.application.routes.url_helpers
+  end
+
+  def initialize(label:, group:, url: nil, action: nil, param: nil, children: nil, source: nil, current: false, run: nil, confirm: false) = super
+
+  def to_partial_path = "rori/commands/command"
+end

data/app/models/rori/notification.rb

@@ -0,0 +1,20 @@
+# A notification in the desk's corner (rori/_notification): the result of a
+# server-side command, or anything the app sends with `Rori.notify`.
+# Errors stay until dismissed; the rest fade out on their own.
+class Rori::Notification < Data.define(:title, :body, :kind)
+  KINDS = %i[ info success error ].freeze
+
+  def initialize(title:, body: nil, kind: :info)
+    kind = kind.to_sym
+    raise ArgumentError, "notification kind must be one of #{KINDS.join(", ")}" unless KINDS.include?(kind)
+
+    super
+  end
+
+  def sticky? = kind == :error
+
+  def broadcast
+    Turbo::StreamsChannel.broadcast_append_to Rori.notifications_stream,
+      target: "rori-notifications", partial: "rori/notification", locals: { notification: self }
+  end
+end

data/app/models/rori/theme/color.rb

@@ -0,0 +1,30 @@
+# An OKLCH color. Theme files are sRGB hex; the app's CSS speaks oklch().
+class Rori::Theme::Color < Data.define(:lightness, :chroma, :hue)
+  class << self
+    # sRGB hex → linear RGB → OKLab → OKLCH (https://bottosson.github.io/posts/oklab/).
+    def from_hex(hex)
+      r, g, b = hex.delete_prefix("#").scan(/../).map { linear(it.to_i(16) / 255.0) }
+
+      l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b)
+      m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b)
+      s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b)
+
+      lab_l = 0.2104542553 * l + 0.7936177850 * m - 0.0040720468 * s
+      lab_a = 1.9779984951 * l - 2.4285922050 * m + 0.4505937099 * s
+      lab_b = 0.0259040371 * l + 0.7827717662 * m - 0.8086757660 * s
+
+      new(lightness: lab_l, chroma: Math.hypot(lab_a, lab_b), hue: Math.atan2(lab_b, lab_a) * 180 / Math::PI % 360)
+    end
+
+    private
+      def linear(channel) = channel <= 0.04045 ? channel / 12.92 : ((channel + 0.055) / 1.055)**2.4
+  end
+
+  def darken(amount) = with(lightness: (lightness - amount).clamp(0, 1))
+
+  # Near-greys have no meaningful hue; pin it so rounding noise doesn't churn the stylesheet.
+  def to_s
+    hue = chroma < 0.002 ? 0 : self.hue
+    format("oklch(%.4f %.4f %.2f)", lightness, chroma, hue)
+  end
+end

data/app/models/rori/theme.rb

@@ -0,0 +1,87 @@
+# A terminal colour scheme in Ghostty's format, vendored from
+# iTerm2-Color-Schemes into `Rori.themes_directory`. Each theme overrides the
+# host's semantic color tokens (--color-*), so it re-colours the whole app; the
+# desk's own --rori-* tokens derive from them (rori/_init.css); `bin/rails rori:themes:build` compiles them all into
+# `Rori.themes_stylesheet`. Drop in another file and rebuild to add one.
+class Rori::Theme
+  # Window gutters sit this much darker than windows, like the default theme.
+  CANVAS_DARKEN = 0.04
+
+  attr_reader :name, :colors
+
+  class << self
+    # Bundled themes plus the app's `Rori.themes_folder`; an app theme with a
+    # bundled theme's name replaces it.
+    def all = (bundled + local).index_by(&:slug).values.sort_by(&:name)
+
+    def bundled = load(Rori.themes_directory)
+
+    def local = Rori.themes_folder ? load(Rails.root.join(Rori.themes_folder)) : []
+
+    def find(slug) = slug.presence && all.find { it.slug == slug }
+
+    def from_file(path)
+      colors = path.readlines.each_with_object({}) do |line, colors|
+        key, value = line.split("=", 2).map(&:strip)
+        next if value.blank?
+
+        if key == "palette"
+          index, hex = value.split("=", 2)
+          colors[index.to_i] = hex.strip
+        else
+          colors[key] = value
+        end
+      end
+      new(path.basename.to_s, colors)
+    end
+
+    # The compiled file holds the bundled themes; app themes are rendered into
+    # the shell instead (Rori::ThemeHelper), so apps never write into the gem.
+    def stylesheet
+      <<~CSS
+        /* Generated by `bin/rails rori:themes:build` from vendor/themes/ghostty — do not edit. */
+        #{css(bundled)}
+      CSS
+    end
+
+    def css(themes) = "@layer rori.themes {\n#{themes.map(&:to_css).join("\n")}}"
+
+    private
+      def load(directory) = Pathname(directory).glob("*").select(&:file?).sort.map { from_file(it) }
+  end
+
+  def initialize(name, colors)
+    @name = name
+    @colors = colors
+  end
+
+  def slug = name.parameterize
+
+  def dark? = background.lightness < 0.6
+
+  def tokens
+    {
+      "--color-canvas" => background.darken(CANVAS_DARKEN),
+      "--color-surface" => background,
+      "--color-ink" => color("foreground"),
+      "--color-danger" => color(1),
+      "--color-success" => color(2),
+      "--color-warning" => color(3),
+      "--color-info" => color(4)
+    }
+  end
+
+  def to_css
+    declarations = [ "color-scheme: #{dark? ? "dark" : "light"}", *tokens.map { |token, value| "#{token}: #{value}" } ]
+    <<~CSS.indent(2)
+      :root[data-theme="#{slug}"] {
+      #{declarations.map { "  #{it};" }.join("\n")}
+      }
+    CSS
+  end
+
+  private
+    def background = color("background")
+
+    def color(key) = Color.from_hex(colors.fetch(key))
+end

data/app/models/rori/wallpaper.rb

@@ -0,0 +1,54 @@
+# An optional background photo behind the strips (Rori.wallpapers). One is
+# picked at random per full page load — the desk's "launch" — unless one is
+# pinned; window frames never re-render the shell, so it stays put while you
+# work. UI › Wallpaper › Next swaps it in place (rori-wallpaper).
+#
+# The pool is the bundled Unsplash photos (hotlinked, resized by their CDN), or
+# the images in the app's own `Rori.wallpapers_folder` asset folder.
+class Rori::Wallpaper < Data.define(:id, :local)
+  CDN = "https://images.unsplash.com"
+  IMAGE = /\.(jpe?g|png|webp|avif)\z/i
+
+  # safe: inside the desk only; cover: behind the menu bar too.
+  MODES = %w[ safe cover off ].freeze
+
+  class << self
+    def all = Rori.wallpapers_folder ? local : unsplash
+
+    def unsplash = YAML.load_file(Rori.wallpapers_file).map { new(id: it.to_s) }
+
+    # Images under the folder, as asset logical paths (`paths` for tests).
+    def local(paths = asset_paths)
+      prefix = "#{Rori.wallpapers_folder.to_s.delete_suffix("/")}/"
+      paths.select { it.start_with?(prefix) && it.match?(IMAGE) }.sort.map { new(id: it, local: true) }
+    end
+
+    def find(id) = id.presence && all.find { it.id == id }
+
+    # The pinned one if it's still in the pool, a random one otherwise.
+    def pick(pinned = nil)
+      (find(pinned) || all.sample) if Rori.wallpapers
+    end
+
+    def mode(value) = MODES.include?(value) ? value : MODES.first
+
+    private
+      def asset_paths = Rails.application.assets.load_path.assets.map { it.logical_path.to_s }
+  end
+
+  def initialize(id:, local: false) = super
+
+  # imgix resizes on the fly; image-set lets hi-dpi screens take the sharper one.
+  def url(width) = "#{CDN}/photo-#{id}?auto=format&fit=crop&w=#{width}&q=75"
+
+  def css_image
+    local ? %(url("#{ActionController::Base.helpers.asset_path(id)}")) : %(image-set(url("#{url(1920)}") 1x, url("#{url(3200)}") 2x))
+  end
+
+  # Where the status-bar credit links: the full photo on Unsplash; local
+  # wallpapers are the app's own and get no credit.
+  def credit_url = (url(3200) unless local)
+
+  # What rori-wallpaper needs to swap it in without a reload.
+  def as_json(*) = { id:, image: css_image, credit: credit_url }
+end

data/app/views/layouts/rori/_head.html.haml

@@ -0,0 +1,2 @@
+-# App-wide <head> tags for the desk shell (favicons, meta). Override by
+-# adding app/views/layouts/rori/_head.html.haml to the host app.