rori 0.1.0

data/app/assets/stylesheets/rori/window.css

@@ -0,0 +1,174 @@
+@layer rori.components {
+
+  /* Author styles beat the UA's dialog rules, so restate the closed state. */
+  .rori-win {
+    --rori-bar-height: 30px;
+    position: relative;
+    isolation: isolate;
+    flex: 1;
+    min-height: 0;
+    width: auto;
+    height: auto;
+    max-width: none;
+    max-height: none;
+    margin: 0;
+    padding: 0;
+    display: flex;
+    flex-direction: column;
+    background: var(--rori-surface);
+    color: var(--rori-ink);
+    border: 1px solid var(--rori-line);
+    border-radius: var(--rori-radius);
+    overflow: hidden;
+    outline: none;
+    transition: border-color 150ms, box-shadow 150ms;
+  }
+
+  .rori-win:not([open]) {
+    display: none;
+  }
+
+  .rori-win.is-focused {
+    border-color: var(--rori-ink);
+    box-shadow: 0 0 0 1px var(--rori-ink);
+  }
+
+  .rori-win:modal {
+    position: fixed;
+    inset: 0;
+    margin: auto;
+    flex: none;
+    height: fit-content;
+    max-height: min(85vh, 48rem);
+    border-color: var(--rori-ink);
+    pointer-events: auto;
+  }
+
+  .rori-win::backdrop {
+    background: var(--rori-backdrop);
+  }
+
+  .rori-win__bar {
+    display: flex;
+    align-items: center;
+    gap: 2px;
+    flex: none;
+    height: var(--rori-bar-height);
+    padding: 0 4px;
+    border-bottom: 1px solid var(--rori-line);
+    font: 11px var(--rori-font-mono);
+    color: var(--rori-ink-muted);
+    user-select: none;
+  }
+
+  .rori-win.is-focused .rori-win__bar,
+  .rori-win:modal .rori-win__bar {
+    color: var(--rori-ink);
+  }
+
+  .rori-win__title {
+    flex: 1;
+    padding: 0 6px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .rori-win__btn {
+    width: 22px;
+    height: 22px;
+    display: grid;
+    place-items: center;
+    border-radius: 4px;
+    line-height: 1;
+    cursor: pointer;
+  }
+
+  .rori-win__btn:hover:not(:disabled) {
+    background: var(--rori-hover);
+  }
+
+  .rori-win__btn:disabled {
+    opacity: 0.3;
+    cursor: default;
+  }
+
+  /* Pages lay out against the window, not the viewport (see forms.css). */
+  /* contain: scrolling a wide table to its edge stops there instead of
+     chaining on to the page (where a sideways overscroll means "back"). */
+  .rori-win__body {
+    flex: 1;
+    min-height: 0;
+    overflow: auto;
+    overscroll-behavior: contain;
+    container-type: inline-size;
+  }
+
+  /* Inactive windows are dimmed by an overlay rather than opacity, so a single
+     field can rise above it (opacity on a parent can't be undone by a child). */
+  .rori-win::after {
+    content: "";
+    position: absolute;
+    inset: var(--rori-bar-height) 0 0;
+    z-index: 1;
+    background: color-mix(in oklch, var(--rori-surface) 45%, transparent);
+    pointer-events: none;
+    opacity: 0;
+    transition: opacity 150ms;
+  }
+
+  .rori-win:not(.is-focused, :modal)::after {
+    opacity: 1;
+  }
+
+  .is-overview .rori-win::after {
+    opacity: 0;
+  }
+
+  /* Hover keys (Rori.hover_keys) will act on this window: say so plainly. */
+  .rori-win.is-armed {
+    outline: 2px dashed var(--rori-ink);
+    outline-offset: 2px;
+  }
+
+  .rori-win.is-armed::after {
+    opacity: 0.4;
+  }
+
+  .rori-win__armed {
+    display: none;
+    padding: 0 6px;
+    border-radius: 4px;
+    background: var(--rori-primary);
+    color: var(--rori-on-primary);
+    white-space: nowrap;
+  }
+
+  .rori-win.is-armed .rori-win__armed {
+    display: block;
+  }
+
+  /* The field under the pointer in an inactive window lights up: one click
+     activates the window and focuses that field. */
+  .rori-win:not(.is-focused, :modal) :is(.simple_form .input, input, select, textarea):hover {
+    position: relative;
+    z-index: 2;
+  }
+
+  .rori-win:not(.is-focused, :modal) :is(.simple_form .input:hover :is(input, select, textarea), input:hover, select:hover, textarea:hover):not([type="hidden"], [type="checkbox"]) {
+    outline: 2px solid var(--rori-ink);
+    outline-offset: 1px;
+  }
+
+  /* --container-padding: edge-to-edge content (tables.css) bleeds by this much. */
+  .rori-win__body>turbo-frame {
+    --container-padding: 16px;
+    display: grid;
+    gap: 16px;
+    padding: 14px var(--container-padding) 16px;
+  }
+
+  .rori-win__error {
+    color: var(--rori-danger);
+  }
+}

data/app/controllers/concerns/rori/windowed.rb

@@ -0,0 +1,15 @@
+# Renders every page as a desk window. Frame requests get a layout that wraps
+# the page in whichever window frame asked for it (their ids are generated);
+# full page loads get the desk shell with the page as its first window.
+# Controllers that render the bare desk instead override `windowed?`.
+module Rori::Windowed
+  extend ActiveSupport::Concern
+
+  included do
+    layout -> { turbo_frame_request? ? "rori/window" : "rori/shell" }
+    helper_method :windowed?
+  end
+
+  private
+    def windowed? = true
+end

data/app/controllers/rori/commands/bars_controller.rb

@@ -0,0 +1,9 @@
+# "UI › Menu bar ›": top or bottom.
+class Rori::Commands::BarsController < ApplicationController
+  layout false
+
+  def index
+    @commands = Rori::Command.bars(current: helpers.rori_bars)
+    render "rori/commands/index"
+  end
+end

data/app/controllers/rori/commands/runs_controller.rb

@@ -0,0 +1,22 @@
+# Runs a server-side command (`Rori.command`) picked in ⌘K or the terminal,
+# answering with its notification as a turbo stream (rori-notifications#run).
+class Rori::Commands::RunsController < ApplicationController
+  def create
+    runnable = Rori.runnables[params.expect(:name)]
+    return head :not_found unless runnable
+
+    notification = run(runnable)
+    render turbo_stream: turbo_stream.append("rori-notifications", partial: "rori/notification", locals: { notification: }),
+      status: notification.sticky? ? :unprocessable_entity : :ok
+  end
+
+  private
+    def run(runnable)
+      result = runnable.call
+      Rori::Notification.new(title: runnable.label, body: result.is_a?(String) ? result : t(".done"), kind: :success)
+    rescue => error
+      Rails.error.report(error, handled: true)
+      # The exception's message may reveal internals; only local environments show it.
+      Rori::Notification.new(title: runnable.label, body: Rails.env.local? ? error.message : t(".failed"), kind: :error)
+    end
+end

data/app/controllers/rori/commands/themes_controller.rb

@@ -0,0 +1,9 @@
+# The palette's nested "Pick theme…" list, rendered into the same frame as the root commands.
+class Rori::Commands::ThemesController < ApplicationController
+  layout false
+
+  def index
+    @commands = Rori::Command.themes(current: helpers.current_theme)
+    render "rori/commands/index"
+  end
+end

data/app/controllers/rori/commands/ui_controller.rb

@@ -0,0 +1,9 @@
+# The "UI ›" list: appearance settings, each a nested list of its own.
+class Rori::Commands::UiController < ApplicationController
+  layout false
+
+  def show
+    @commands = Rori::Command.ui
+    render "rori/commands/index"
+  end
+end

data/app/controllers/rori/commands/wallpapers_controller.rb

@@ -0,0 +1,9 @@
+# "UI › Wallpaper ›": how (or whether) the wallpaper shows, next and pin.
+class Rori::Commands::WallpapersController < ApplicationController
+  layout false
+
+  def index
+    @commands = Rori::Command.wallpapers(current: helpers.rori_wallpaper_mode, pinned: helpers.rori_wallpaper_pinned?)
+    render "rori/commands/index"
+  end
+end

data/app/controllers/rori/commands_controller.rb

@@ -0,0 +1,7 @@
+class Rori::CommandsController < ApplicationController
+  layout false
+
+  def index
+    @commands = Rori::Command.all
+  end
+end

data/app/controllers/rori/desktops_controller.rb

@@ -0,0 +1,7 @@
+class Rori::DesktopsController < ApplicationController
+  def show
+  end
+
+  private
+    def windowed? = false
+end

data/app/helpers/rori/assets_helper.rb

@@ -0,0 +1,9 @@
+module Rori::AssetsHelper
+  # The desk's stylesheets. Propshaft's `stylesheet_link_tag :app` only globs
+  # the host's app/assets, so the shell links these right after it — after the
+  # host's tokens and `@layer` order (_init.css), which the desk's CSS relies on.
+  def rori_stylesheet_link_tags(**options)
+    paths = Rails.application.assets.load_path.asset_paths_by_glob("#{Rori::Engine.root.join("app/assets")}/**/*.css")
+    stylesheet_link_tag(*paths, **options)
+  end
+end

data/app/helpers/rori/keymap_helper.rb

@@ -0,0 +1,50 @@
+module Rori::KeymapHelper
+  KEY_SYMBOLS = {
+    "Alt" => "⌥", "Meta" => "⌘", "Control" => "⌃", "Shift" => "⇧",
+    "ArrowLeft" => "←", "ArrowRight" => "→", "ArrowUp" => "↑", "ArrowDown" => "↓",
+    "BracketLeft" => "[", "BracketRight" => "]", "Backquote" => "`", "Slash" => "/",
+    "Enter" => "↵", "Space" => "␣"
+  }.freeze
+
+  # The keyboard shortcuts modal, in reading order; keymap actions missing from
+  # Rori.keymap (an app removed them) are skipped.
+  SHORTCUT_SECTIONS = {
+    focus: %i[ focus_left focus_right focus_up focus_down ],
+    move: %i[ move_left move_right move_up move_down ],
+    workspaces: %i[ switch_to_workspace move_to_workspace ],
+    columns: %i[ consume_left consume_right cycle_width full_width center_column overview ],
+    windows: %i[ close_window reopen_window toggle_terminal shortcuts ]
+  }.freeze
+
+  # Alt in a browser, ⌘ inside the native shell (see Rori.native_user_agent).
+  def rori_modifier = Rori.modifier_for(request.user_agent)
+
+  def rori_native? = Rori.native?(request.user_agent)
+
+  # The first chord bound to a desk action, as symbols ("⌥⇧T"), or nil.
+  def rori_shortcut(action)
+    chord = Rori.resolved_keymap(rori_modifier)[action&.to_sym]&.first
+    chord && rori_chord_symbols(chord)
+  end
+
+  # "Alt+Shift+KeyT" → "⌥⇧T", "Meta+Digit*" → "⌘1–9", "Meta+Shift+Slash" → "⌘?".
+  def rori_chord_symbols(chord)
+    keys = chord.split("+")
+    keys = keys - %w[ Shift Slash ] + [ "?" ] if (keys & %w[ Shift Slash ]).size == 2
+    keys.map { |key| KEY_SYMBOLS.fetch(key) { key.sub(/\A(Key|Digit)/, "").sub("*", "1–9") } }.join
+  end
+
+  # [ [section, [ [action, ["⌥←", "⌥H"]], … ]], … ] for the shortcuts modal.
+  def rori_shortcut_sections
+    keymap = Rori.resolved_keymap(rori_modifier)
+    SHORTCUT_SECTIONS.filter_map do |section, actions|
+      rows = actions.filter_map { |action| [ action, keymap[action].map { rori_chord_symbols(it) } ] if keymap[action] }
+      [ section, rows ] if rows.any?
+    end
+  end
+
+  # Bare keys (Rori.hover_keymap) as [ [action, ["W"]], … ], empty when off.
+  def rori_hover_shortcuts
+    Rori.resolved_hover_keymap.map { |action, chords| [ action, chords.map { rori_chord_symbols(it) } ] }
+  end
+end

data/app/helpers/rori/prefs_helper.rb

@@ -0,0 +1,13 @@
+module Rori::PrefsHelper
+  BAR_POSITIONS = %w[ top bottom ].freeze
+
+  # Where the menu bar sits (UI › Menu bar): top or bottom edge.
+  def rori_bars = BAR_POSITIONS.include?(cookies[Rori.bars_cookie]) ? cookies[Rori.bars_cookie] : BAR_POSITIONS.first
+
+  # The empty-desk hint was dismissed (brought back from the shortcuts modal).
+  def rori_hint_hidden? = cookies[Rori.hint_cookie] == "hidden"
+
+  def rori_body_classes
+    class_names(rori_wallpaper_classes, "bars-bottom" => rori_bars == "bottom", "hint-hidden" => rori_hint_hidden?)
+  end
+end

data/app/helpers/rori/theme_helper.rb

@@ -0,0 +1,14 @@
+module Rori::ThemeHelper
+  # rori-theme (theme_controller.js) stores the pick in `Rori.theme_cookie` so the
+  # server can render it on <html> and pages don't flash the default theme.
+  def current_theme
+    Rori::Theme.find(cookies[Rori.theme_cookie])
+  end
+
+  # The app's own themes (Rori.themes_folder), inline: every one, so the palette
+  # can preview them. After the desk's stylesheets, so rori.themes is in order.
+  def rori_local_themes_style_tag
+    themes = Rori::Theme.local
+    tag.style(Rori::Theme.css(themes).html_safe, nonce: content_security_policy_nonce) if themes.any?
+  end
+end

data/app/helpers/rori/wallpaper_helper.rb

@@ -0,0 +1,19 @@
+module Rori::WallpaperHelper
+  # This page load's photo (the pinned one, else random), or nil when
+  # Rori.wallpapers is off.
+  def rori_wallpaper
+    return @rori_wallpaper if defined?(@rori_wallpaper)
+    @rori_wallpaper = Rori::Wallpaper.pick(cookies[Rori.wallpaper_pin_cookie])
+  end
+
+  # A pin whose photo left the pool no longer counts.
+  def rori_wallpaper_pinned? = Rori.wallpapers && Rori::Wallpaper.find(cookies[Rori.wallpaper_pin_cookie]).present?
+
+  # safe | cover | off, picked from UI › Wallpaper (rori-wallpaper stores the cookie).
+  def rori_wallpaper_mode = Rori::Wallpaper.mode(cookies[Rori.wallpaper_cookie])
+
+  def rori_wallpaper_classes
+    class_names("has-wallpaper" => rori_wallpaper && rori_wallpaper_mode != "off",
+      "wallpaper-cover" => rori_wallpaper_mode == "cover")
+  end
+end

data/app/helpers/rori/window_helper.rb

@@ -0,0 +1,36 @@
+module Rori::WindowHelper
+  # Declares how the current page wants to be shown on the desk. The window
+  # layout serializes it into a <template data-window-meta>, which the desk
+  # (rori_controller.js) reads on every frame load:
+  #
+  #   size:      column width :sm ⅓ | :md ½ | :lg ⅔ | :xl full (default :md);
+  #              for modals, the dialog width
+  #   mode:      :tile (a new column next to the focused one) | :modal |
+  #              :fullscreen (a full-width column)            (default :tile)
+  #   workspace: "name" (found or created) | :new               (first load only)
+  #   key:       windows sharing a key are reused when opened
+  #              (default controller_path, nil for modals)
+  def window(**options)
+    @window_options = options
+  end
+
+  def window_title
+    content_for(:title) || t("#{controller_path.tr("/", ".")}.#{template_action}.title")
+  end
+
+  def window_meta_tag
+    options = { size: :md, mode: :tile }.merge(@window_options || {})
+    options[:key] = options.fetch(:key) { controller_path unless options[:mode] == :modal }
+    tag.template(data: { window_meta: options.merge(title: window_title) })
+  end
+
+  # Opens the URL through the desk (a new or reused window) instead of
+  # navigating the current one. Without JavaScript it's a plain full-page link.
+  def rori_link_to(name, url, **options)
+    link_to name, url, **options, data: { **options.fetch(:data, {}), turbo_frame: "_top" }
+  end
+
+  private
+    # 422 re-renders run under create/update but show the new/edit template.
+    def template_action = { "create" => "new", "update" => "edit" }.fetch(action_name, action_name)
+end

data/app/javascript/rori/clock_controller.js

@@ -0,0 +1,18 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  connect() {
+    this.tick()
+    this.timer = setInterval(() => this.tick(), 10_000)
+  }
+
+  disconnect() {
+    clearInterval(this.timer)
+  }
+
+  tick() {
+    const now = new Date()
+    this.element.dateTime = now.toISOString()
+    this.element.textContent = now.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })
+  }
+}

data/app/javascript/rori/command_index.js

@@ -0,0 +1,84 @@
+import { score } from "rori/fuzzy"
+
+const MAX_DEPTH = 4
+// Each level deeper costs this much, so "theme" still prefers "Pick theme…"
+// over "UI › Theme", while "uthen" (only a deep path fits) still finds Nord.
+const DEPTH_PENALTY = 1.5
+
+// A command list as the palette renders it (rori/commands/index), as data.
+export function parseList(html) {
+  const page = new DOMParser().parseFromString(html, "text/html")
+  return [...page.querySelectorAll(".rori-palette__item")].map((item) => ({
+    label: item.querySelector(".rori-palette__label").firstChild.textContent.trim(),
+    group: item.querySelector(".rori-palette__group").lastChild.textContent.trim(),
+    url: item.dataset.url,
+    action: item.dataset.roriAction,
+    param: item.dataset.param,
+    children: item.dataset.children,
+    source: item.dataset.source,
+    run: item.dataset.run,
+    confirm: "confirm" in item.dataset,
+    shortcut: item.dataset.shortcut,
+    current: "current" in item.dataset,
+  }))
+}
+
+export const isNested = (item) => Boolean(item.children || item.source)
+
+// What running an entry does; entries reachable by two paths share it.
+const target = (item) =>
+  item.url || item.children || item.source || (item.run && `run:${item.run}`) || `${item.action}:${item.param ?? ""}`
+
+// Every command reachable from the root list, flattened with its trail
+// ("UI › Theme › Nord"), so a query matches whole paths instead of one level
+// at a time. Server lists are fetched once per index; `source` answers
+// browser-only lists (workspaces) the way the command bus does.
+export class CommandIndex {
+  constructor(root, { source }) {
+    this.root = root
+    this.source = source
+    this.lists = new Map()
+  }
+
+  list({ children, source }) {
+    if (source) return Promise.resolve(this.source(source))
+    if (!this.lists.has(children)) {
+      this.lists.set(children, fetch(children, { headers: { Accept: "text/html", "Turbo-Frame": "commands" } })
+        .then((response) => response.text())
+        .then(parseList))
+    }
+    return this.lists.get(children)
+  }
+
+  entries() {
+    this.crawl ||= this.#crawl({ children: this.root }, [], new Set([this.root]))
+    return this.crawl
+  }
+
+  // Best entries for `query`, one per target, best first. `bonus(item)` adds
+  // to an entry's score (the palette's frecency).
+  async search(query, { limit = 20, bonus = () => 0 } = {}) {
+    const ranked = (await this.entries())
+      .map((entry, index) => {
+        const match = score(entry.text, query)
+        return { ...entry, index, score: match && match - (entry.trail.length - 1) * DEPTH_PENALTY + bonus(entry.item) }
+      })
+      .filter(({ score }) => score > 0)
+      .sort((a, b) => b.score - a.score || a.index - b.index)
+
+    const seen = new Set()
+    return ranked.filter(({ item }) => !seen.has(target(item)) && seen.add(target(item))).slice(0, limit)
+  }
+
+  async #crawl(node, trail, visited) {
+    const items = await this.list(node)
+    const branches = await Promise.all(items.map(async (item) => {
+      const path = [...trail, item]
+      const entry = { item, trail: path, text: path.map(({ label }) => label).join(" › ") }
+      const key = item.children || item.source
+      if (!key || path.length >= MAX_DEPTH || visited.has(key)) return [entry]
+      return [entry, ...(await this.#crawl(item, path, new Set([...visited, key])))]
+    }))
+    return branches.flat()
+  }
+}

data/app/javascript/rori/fuzzy.js

@@ -0,0 +1,50 @@
+// The one fuzzy matcher behind ⌘K and the terminal.
+//
+// Every query character must appear in order (spaces and dashes in the query
+// are ignored, so "cover-menu" and "cover menu" match "Cover menu bar"). Among all
+// ways to place them, it keeps the best-scoring one: characters at word starts
+// — including each "›" segment of a path — and consecutive runs score high,
+// gaps cost a little. That's what lets "uthen" find "UI › Theme › Nord":
+// u, the and n each start a segment.
+const SEPARATORS = " ›/-_.:…"
+const BOUNDARY = 8      // character starts a word or segment
+const FIRST = 4         // …and it's the very first character
+const CONSECUTIVE = 5   // follows the previous match directly
+const GAP_OPEN = 3      // cost of skipping ahead…
+const GAP_EXTEND = 1    // …plus this per extra skipped character
+
+export function score(text, query) {
+  query = query.toLowerCase().replace(/[\s-]+/g, "")
+  if (!query) return 1
+  text = text.toLowerCase()
+  const n = text.length
+  const m = query.length
+  if (m > n) return 0
+
+  const boundary = (i) => i === 0 || SEPARATORS.includes(text[i - 1])
+  // previous[i]: best score with query[j - 1] placed at text[i].
+  let previous = new Array(n).fill(-Infinity)
+
+  for (let j = 0; j < m; j++) {
+    const current = new Array(n).fill(-Infinity)
+    let gapped = -Infinity // best previous[k] for k <= i - 2, minus its gap cost to i
+
+    for (let i = 0; i < n; i++) {
+      if (j > 0 && i >= 2) gapped = Math.max(gapped - GAP_EXTEND, previous[i - 2] - GAP_OPEN)
+      if (text[i] !== query[j]) continue
+
+      const bonus = 1 + (boundary(i) ? BOUNDARY : 0)
+      if (j === 0) {
+        current[i] = bonus + (i === 0 ? FIRST : 0) - i * 0.05
+      } else {
+        const direct = i >= 1 ? previous[i - 1] + CONSECUTIVE : -Infinity
+        current[i] = Math.max(direct, gapped) + bonus
+      }
+    }
+    previous = current
+  }
+
+  const best = Math.max(...previous)
+  // Shorter texts win ties; a match always stays above zero.
+  return best === -Infinity ? 0 : Math.max(best - n * 0.01, 0.001)
+}

data/app/javascript/rori/index.js

@@ -0,0 +1,21 @@
+// The desk's Stimulus controllers, registered under a `desk` prefix so they
+// can't collide with the app's own (a plain `palette` or `theme`, say).
+import RoriController from "rori/rori_controller"
+import PaletteController from "rori/palette_controller"
+import ThemeController from "rori/theme_controller"
+import ClockController from "rori/clock_controller"
+import WallpaperController from "rori/wallpaper_controller"
+import TerminalController from "rori/terminal_controller"
+import PrefsController from "rori/prefs_controller"
+import NotificationsController from "rori/notifications_controller"
+
+export function registerRori(application) {
+  application.register("rori", RoriController)
+  application.register("rori-palette", PaletteController)
+  application.register("rori-theme", ThemeController)
+  application.register("rori-clock", ClockController)
+  application.register("rori-wallpaper", WallpaperController)
+  application.register("rori-terminal", TerminalController)
+  application.register("rori-prefs", PrefsController)
+  application.register("rori-notifications", NotificationsController)
+}

data/app/javascript/rori/notifications_controller.js

@@ -0,0 +1,45 @@
+import { Controller } from "@hotwired/stimulus"
+import { Turbo } from "@hotwired/turbo-rails"
+
+const STREAM = "text/vnd.turbo-stream.html"
+
+// Corner notifications (rori/_notifications). They arrive as turbo streams
+// appended to the stack: a server-side command's result (run here, from
+// `rori-command:run`) or a `Rori.notify` broadcast. The stack is a manual
+// popover, open while it holds any. Each notification fades out on its own
+// (a CSS animation, paused while the pointer is on the stack) unless sticky.
+export default class extends Controller {
+  static targets = ["stack", "notification", "failure"]
+  static values = { url: String }
+
+  async run({ detail: { run } }) {
+    if (!run) return
+    try {
+      const response = await fetch(this.urlValue, {
+        method: "POST",
+        body: new URLSearchParams({ name: run }),
+        headers: { Accept: STREAM, "X-CSRF-Token": document.querySelector("meta[name=csrf-token]")?.content },
+      })
+      if (!response.headers.get("Content-Type")?.startsWith(STREAM)) throw new Error(`${response.status}`)
+      Turbo.renderStreamMessage(await response.text())
+    } catch {
+      this.stackTarget.append(this.failureTarget.content.cloneNode(true))
+    }
+  }
+
+  notificationTargetConnected() {
+    if (!this.stackTarget.matches(":popover-open")) this.stackTarget.showPopover()
+  }
+
+  notificationTargetDisconnected() {
+    if (!this.hasNotificationTarget && this.stackTarget.matches(":popover-open")) this.stackTarget.hidePopover()
+  }
+
+  dismiss({ target }) {
+    target.closest(".rori-notification").remove()
+  }
+
+  expire({ target, animationName }) {
+    if (animationName === "rori-notification-out") target.remove()
+  }
+}