sentiero 1.0.0.alpha1

data/lib/sentiero/web/ingest_app.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "json"
+require "rack/utils"
+require_relative "body_reader"
+require_relative "../store"
+
+module Sentiero
+  module Web
+    # Base class for the authenticated server-lane ingest apps (eg ErrorsApp, TrackApp).
+    # Subclasses implement #handle(env, project, data).
+    #
+    # Unlike EventsApp (the public browser lane), these require a per-project
+    # write-only ingest key: Authorization: Bearer <key>. Keys map to a project
+    # via Sentiero.configuration.ingest_keys ({ "<secret>" => "<project>" }).
+    class IngestApp
+      def call(env)
+        return json_response(405, {error: "method not allowed"}) unless env["REQUEST_METHOD"] == "POST"
+
+        project = authenticate(env)
+        return json_response(401, {error: "invalid or missing ingest key"}) unless project
+
+        body, error = read_body(env)
+        return error if error
+
+        begin
+          data = JSON.parse(body)
+        rescue JSON::ParserError
+          return json_response(400, {error: "invalid JSON body"})
+        end
+        return json_response(400, {error: "body must be a JSON object"}) unless data.is_a?(Hash)
+
+        handle(env, project, data)
+      end
+
+      private
+
+      # Subclass hook; returns a Rack response triple.
+      def handle(env, project, data)
+        raise NoMethodError, "#{self.class}#handle not implemented"
+      end
+
+      # Resolves the ingest key to a project name, or nil. Constant-time compare
+      # so timing can't distinguish a wrong key from a right one of equal length.
+      def authenticate(env)
+        keys = Sentiero.configuration.ingest_keys
+        return nil if keys.nil? || keys.empty?
+
+        presented = bearer_token(env)
+        return nil if presented.nil? || presented.empty?
+
+        keys.each do |key, project|
+          return project if Rack::Utils.secure_compare(key.to_s, presented)
+        end
+        nil
+      end
+
+      def bearer_token(env)
+        header = env["HTTP_AUTHORIZATION"]
+        return nil unless header
+
+        scheme, token = header.split(" ", 2)
+        return nil unless scheme&.downcase == "bearer"
+        token&.strip
+      end
+
+      def read_body(env)
+        raw, error = BodyReader.read(env)
+        return [raw, nil] unless error
+
+        status, message = BodyReader::ERRORS[error]
+        [nil, json_response(status, {error: message})]
+      end
+
+      def json_response(status, hash)
+        [status, {"content-type" => "application/json", "x-content-type-options" => "nosniff"}, [JSON.generate(hash)]]
+      end
+
+      def numeric_timestamp(raw)
+        return Time.now.to_f if raw.nil?
+        ts = raw.is_a?(Numeric) ? raw.to_f : Float(raw)
+        ts.finite? ? ts : Time.now.to_f
+      rescue ArgumentError, TypeError
+        Time.now.to_f
+      end
+
+      def valid_optional_id?(id)
+        id.is_a?(String) && id.match?(Store::VALID_ID)
+      end
+    end
+  end
+end

data/lib/sentiero/web/manifest.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Sentiero
+  module Web
+    module Manifest
+      ASSETS_DIR = File.expand_path("assets", __dir__).freeze
+
+      def self.manifest
+        if @auto_reload
+          load_manifest
+        else
+          @manifest ||= load_manifest
+        end
+      end
+
+      # Re-read manifest from disk on every access (dev, for `npm run watch`).
+      def self.auto_reload!
+        @auto_reload = true
+      end
+
+      def self.asset_path(logical_name, base_path = "")
+        filename = manifest[logical_name]
+        unless filename
+          raise Sentiero::Error, "Unknown asset: #{logical_name}. Run 'cd frontend && npm run build' first."
+        end
+        "#{base_path}/assets/#{filename}"
+      end
+
+      def self.reset!
+        @manifest = load_manifest
+        @auto_reload = false
+      end
+
+      private_class_method def self.load_manifest
+        path = File.join(ASSETS_DIR, "manifest.json")
+        return {}.freeze unless File.exist?(path)
+        JSON.parse(File.read(path)).freeze
+      end
+    end
+  end
+end

data/lib/sentiero/web/monitoring_app.rb

@@ -0,0 +1,316 @@
+# frozen_string_literal: true
+
+require_relative "base_app"
+require_relative "../analytics/browser_event_discovery"
+require_relative "../analytics/error_discovery"
+require_relative "../analytics/server_event_metrics"
+require_relative "../analytics/problem_detail"
+
+module Sentiero
+  module Web
+    # Rack app owning the error/issue tracking (/issues/*) and custom-event
+    # browsing (/custom-events/*) routes. Mounted at the same point as
+    # DashboardApp (which delegates those requests here), so PATH_INFO/SCRIPT_NAME
+    # are read from env to preserve base_path.
+    class MonitoringApp < BaseApp
+      def initialize
+        super
+        BaseApp.warn_unauthenticated_once
+      end
+
+      def call(env)
+        path = env["PATH_INFO"] || "/"
+        method = env["REQUEST_METHOD"]
+
+        return unauthorized_response unless authorized?(env)
+
+        case path
+        when "/custom-events"
+          handle_events_index(env)
+        when %r{\A/custom-events/([^/]+)\z}
+          event_id = $1
+          get_only(method) || guard(event_id) || handle_event_show(env, event_id)
+        when "/issues"
+          handle_errors_index(env)
+        when %r{\A/issues/client/([^/]+)\z}
+          # Matched BEFORE the generic /issues/:id case so "client" isn't taken as
+          # a server fingerprint. Client error ids are ErrorDiscovery group digests,
+          # not store ids, so there is no id guard here.
+          id = $1
+          get_only(method) || handle_client_error_show(env, id)
+        when %r{\A/issues/([^/]+)/status\z}
+          problem_id = $1
+          post_only(method) || guard(problem_id) || handle_error_status(env, problem_id)
+        when %r{\A/issues/([^/]+)\z}
+          problem_id = $1
+          get_only(method) || guard(problem_id) || handle_error_show(env, problem_id)
+        else
+          not_found
+        end
+      end
+
+      private
+
+      def handle_event_show(env, event_id)
+        event = Sentiero.store.get_server_event(event_id)
+        return not_found if event.nil?
+
+        audit!(env, action: :view_event)
+        render_page(env, Views::EventShowView.new(event: event), csrf: false)
+      end
+
+      def handle_events_index(env)
+        params = query_params(env)
+        return handle_browser_events(env) if params["source"] == "browser"
+
+        level = %w[debug info warn error].include?(params["level"]) ? params["level"] : nil
+        search = params["search"]
+        project_param = params["project"]
+        project_param = nil if project_param&.empty?
+        since, until_time = parse_range_params(params)
+        since_param, until_param = echo_range_params(params, since, until_time)
+
+        page, per_page, offset = paginate(params, default: 50, max: 200)
+
+        events = filtered_server_events(level: level, project: project_param, search: search, since: since, until_time: until_time)
+        page_events, has_next = take_page(events.slice(offset, per_page + 1) || [], per_page)
+
+        audit!(env, action: :list_events)
+
+        projects = (Sentiero.configuration.ingest_keys || {}).values.uniq.sort
+
+        sibling = if events.empty? && level.nil? && search.to_s.empty? && project_param.nil? && since.nil? && until_time.nil?
+          result = Sentiero::Analytics::BrowserEventDiscovery.new(Sentiero.store).recent_events
+          {count: result[:rows].size, capped: result[:was_truncated]}
+        end
+
+        # level_mix and payload metrics compute over the full pre-pagination list,
+        # so the strips describe the whole filtered range, not one page.
+        metrics = Sentiero::Analytics::ServerEventMetrics.new(events)
+        render_page(env, Views::EventsIndexView.new(
+          events: page_events,
+          level: level || "",
+          search: search || "",
+          project: project_param || "",
+          projects: projects,
+          since_param: since_param,
+          until_param: until_param,
+          level_mix: metrics.level_mix_by_day,
+          page: page,
+          per_page: per_page,
+          has_next: has_next,
+          sibling: sibling,
+          **metrics.payload_metric_locals(params["metric_key"])
+        ), csrf: false)
+      end
+
+      # Bounded server-event fetch for the events index, request filters applied.
+      # `since` rides the store's after: param (strict >, equivalent for a midnight
+      # bound); `until` and name search filter in Ruby. Newest first for display.
+      def filtered_server_events(level:, project:, search:, since:, until_time:)
+        events = Sentiero.store.list_server_events(project: project, limit: 10_000, level: level, after: since)
+        events = events.select { |e| e["timestamp"].to_f <= until_time } if until_time
+        if search && !search.empty?
+          term = search.downcase
+          events = events.select { |e| e["name"].to_s.downcase.include?(term) }
+        end
+        events.reverse
+      end
+
+      # Bound on the store-list calls behind sibling-tab counts in empty states;
+      # a count that hits the cap renders as "500+".
+      SIBLING_COUNT_LIMIT = 500
+
+      def handle_browser_events(env)
+        params = query_params(env)
+        search = params["search"]
+        since, until_time = parse_range_params(params)
+        since_param, until_param = echo_range_params(params, since, until_time)
+
+        page, per_page, offset = paginate(params, default: 50, max: 200)
+
+        result = Sentiero::Analytics::BrowserEventDiscovery.new(Sentiero.store)
+          .recent_events(since: since, until_time: until_time)
+        rows = result[:rows]
+        if search && !search.empty?
+          term = search.downcase
+          rows = rows.select { |r| r[:name].to_s.downcase.include?(term) }
+        end
+        page_rows, has_next = take_page(rows.slice(offset, per_page + 1) || [], per_page)
+
+        # Bounded count of the sibling server-events tab for the empty-state cross-link.
+        sibling = if rows.empty? && search.to_s.empty? && since.nil? && until_time.nil?
+          server_events = Sentiero.store.list_server_events(project: nil, limit: SIBLING_COUNT_LIMIT)
+          {count: server_events.size, capped: server_events.size >= SIBLING_COUNT_LIMIT}
+        end
+
+        audit!(env, action: :list_events)
+        render_page(env, Views::EventsIndexView.new(
+          source: "browser",
+          browser_rows: page_rows,
+          search: search || "",
+          since_param: since_param,
+          until_param: until_param,
+          page: page,
+          per_page: per_page,
+          has_next: has_next,
+          was_truncated: result[:was_truncated],
+          sibling: sibling,
+          **Sentiero::Analytics::ServerEventMetrics.new(
+            Sentiero::Analytics::ServerEventMetrics.adapt_browser_rows(rows)
+          ).payload_metric_locals(params["metric_key"])
+        ), csrf: false)
+      end
+
+      # Unified errors listing. `?source=client` renders aggregated client-side JS
+      # errors; otherwise the server-exception ("problems") listing. The server
+      # branch sets the CSRF cookie for inline resolve/ignore.
+      def handle_errors_index(env)
+        params = query_params(env)
+        source = (params["source"] == "client") ? "client" : "server"
+        if source == "client"
+          handle_client_errors_index(env, params)
+        else
+          handle_server_errors_index(env, params)
+        end
+      end
+
+      def handle_server_errors_index(env, params)
+        status = %w[open resolved ignored].include?(params["status"]) ? params["status"] : nil
+        search = params["search"]
+        sort_by = %w[last_seen first_seen count].include?(params["sort_by"]) ? params["sort_by"] : "last_seen"
+        since, until_time = parse_range_params(params)
+        since_param, until_param = echo_range_params(params, since, until_time)
+
+        page, per_page, offset = paginate(params, default: 50, max: 200)
+        problems = Sentiero.store.list_problems(project: nil, limit: per_page + 1, offset: offset,
+          status: status, sort_by: sort_by, search: search, since: since, until_time: until_time)
+        problems, has_next = take_page(problems, per_page)
+
+        audit!(env, action: :list_problems)
+
+        sibling = if problems.empty? && page == 1 && status.nil? && search.to_s.empty? && since.nil? && until_time.nil?
+          result = Sentiero::Analytics::ErrorDiscovery.new(Sentiero.store).grouped_errors
+          {count: result[:groups].size, capped: result[:was_truncated]}
+        end
+
+        render_page(env, Views::ErrorsIndexView.new(
+          source: "server",
+          problems: problems,
+          sibling: sibling,
+          status: status || "",
+          search: search || "",
+          sort_by: sort_by,
+          since_param: since_param,
+          until_param: until_param,
+          new_since: since,
+          page: page,
+          per_page: per_page,
+          has_next: has_next
+        ))
+      end
+
+      def handle_client_errors_index(env, params)
+        sort_by = %w[count recency].include?(params["sort_by"]) ? params["sort_by"] : "count"
+        search = params["search"]
+        since, until_time = parse_range_params(params)
+        since_param, until_param = echo_range_params(params, since, until_time)
+
+        page, per_page, offset = paginate(params, default: 50, max: 200)
+
+        result = Sentiero::Analytics::ErrorDiscovery.new(Sentiero.store)
+          .grouped_errors(sort_by: sort_by, since: since, until_time: until_time)
+        groups = result[:groups]
+        if search && !search.empty?
+          term = search.downcase
+          groups = groups.select { |g| g[:message].to_s.downcase.include?(term) }
+        end
+        page_groups, has_next = take_page(groups.slice(offset, per_page + 1) || [], per_page)
+
+        audit!(env, action: :list_problems)
+
+        # Bounded count of the sibling server-exceptions tab for the empty-state cross-link.
+        sibling = if groups.empty? && search.to_s.empty? && since.nil? && until_time.nil?
+          problems = Sentiero.store.list_problems(project: nil, limit: SIBLING_COUNT_LIMIT)
+          {count: problems.size, capped: problems.size >= SIBLING_COUNT_LIMIT}
+        end
+
+        render_page(env, Views::ErrorsIndexView.new(
+          source: "client",
+          groups: page_groups,
+          sibling: sibling,
+          sort_by: sort_by,
+          search: search || "",
+          since_param: since_param,
+          until_param: until_param,
+          page: page,
+          per_page: per_page,
+          has_next: has_next,
+          was_truncated: result[:was_truncated]
+        ))
+      end
+
+      # Client-side JS error detail page. Re-runs ErrorDiscovery and finds the
+      # group whose stable :id matches.
+      def handle_client_error_show(env, id)
+        result = Sentiero::Analytics::ErrorDiscovery.new(Sentiero.store).grouped_errors
+        group = result[:groups].find { |g| g[:id] == id }
+        return not_found if group.nil?
+
+        audit!(env, action: :view_client_error)
+
+        render_page(env, Views::ClientErrorShowView.new(group: group, was_truncated: result[:was_truncated]), csrf: false)
+      end
+
+      def handle_error_show(env, problem_id)
+        problem = Sentiero.store.get_problem(problem_id)
+        return not_found if problem.nil?
+
+        occurrences = Sentiero.store.get_occurrences(problem_id, limit: 50).reverse # newest first
+        session_ids = Sentiero.store.session_ids_for_problem(problem_id, limit: 50)
+
+        session_summaries = session_ids.map do |sid|
+          session = Sentiero.store.get_session(sid)
+          if session
+            first_window = (session[:windows] || []).first
+            ua = session.dig(:metadata, "userAgent")
+            {
+              session_id: sid,
+              first_event_at: session[:first_event_at],
+              last_event_at: session[:last_event_at],
+              browser: ua ? parse_browser(ua) : nil,
+              window_id: first_window ? first_window[:window_id] : nil
+            }
+          else
+            {session_id: sid, first_event_at: nil, last_event_at: nil, browser: nil, window_id: nil}
+          end
+        end
+
+        audit!(env, action: :view_problem, problem_id: problem_id)
+
+        detail = Sentiero::Analytics::ProblemDetail.new(Sentiero.store)
+        render_page(env, Views::ProblemShowView.new(
+          problem: problem,
+          occurrences: occurrences,
+          session_ids: session_ids,
+          session_summaries: session_summaries,
+          facets: detail.facets(occurrences, session_summaries),
+          trend: detail.trend(problem_id, occurrences)
+        ))
+      end
+
+      def handle_error_status(env, problem_id)
+        request = Rack::Request.new(env)
+        return forbidden_csrf unless valid_csrf_token?(env, request.POST["csrf_token"])
+
+        status = request.POST["status"]
+        return [400, {"content-type" => "text/plain"}, ["bad status"]] unless %w[open resolved ignored].include?(status)
+
+        Sentiero.store.update_problem_status(problem_id, status)
+        audit!(env, action: :update_problem_status, problem_id: problem_id)
+
+        redirect("#{base_path(env)}/issues/#{problem_id}", status: 303)
+      end
+    end
+  end
+end

data/lib/sentiero/web/script_tag.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "escaping"
+
+module Sentiero
+  module Web
+    module ScriptTag
+      extend Escaping
+
+      def self.render(events_url:, recorder_url: nil)
+        config = Sentiero.configuration
+
+        recorder_url ||= default_recorder_url(events_url)
+
+        json_data = {
+          eventsUrl: events_url,
+          flushIntervalMs: config.flush_interval_ms,
+          flushEventThreshold: config.flush_event_threshold,
+          recorderOptions: config.effective_recorder_options,
+          crossTabSessions: config.cross_tab_sessions,
+          redaction: config.redaction.to_client_hash,
+          # Seconds on the Ruby side (matches retention_period's unit); ms on
+          # the wire so the client can compare directly against Date.now().
+          sessionIdleTimeoutMs: config.session_idle_timeout * 1000,
+          sessionMaxAgeMs: config.session_max_age * 1000
+        }
+        json_data[:captureMetadata] = true if config.capture_metadata
+        json_data[:captureErrors] = true if config.capture_errors
+        json_data[:trackNavigation] = true if config.track_navigation
+        json_data[:trackCustomEvents] = true if config.track_custom_events
+        json_data[:captureWebVitals] = true if config.capture_web_vitals
+        json_data[:captureClicks] = true if config.capture_clicks
+        json_data[:trackForms] = true if config.track_forms
+        json_data[:optOutCookieName] = config.opt_out_cookie_name if config.user_opt_out
+        json_data[:respectGpc] = true if config.respect_gpc
+
+        config_json = JSON.generate(json_data)
+
+        safe_json = escape_json(config_json)
+        escaped_recorder_url = escape_html(recorder_url.to_s)
+
+        <<~HTML
+          <script type="application/json" id="sentiero-config">#{safe_json}</script>
+          <script src="#{escaped_recorder_url}"></script>
+        HTML
+      end
+
+      def self.default_recorder_url(events_url)
+        base = events_url.sub(%r{/events\z}, "")
+        Sentiero::Web::Manifest.asset_path("recorder", base)
+      end
+
+      private_class_method :default_recorder_url
+    end
+  end
+end

data/lib/sentiero/web/shareable_replay.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "base_app"
+require_relative "manifest"
+
+module Sentiero
+  module Web
+    # Builds a single self-contained HTML document for a whole session, inlining
+    # the rrweb-player JS/CSS and the session's events so it replays offline with
+    # no server. #html returns the document, or nil when there's nothing to replay.
+    #
+    # Events are inlined as a <script type="application/json"> blob escaped via
+    # escape_json so a </script> in the data cannot break out of the script context.
+    class ShareableReplay
+      include Escaping
+
+      def initialize(store, session_id)
+        @store = store
+        @session_id = session_id
+      end
+
+      def html
+        session = @store.get_session(@session_id)
+        return nil if session.nil?
+
+        windows = session[:windows] || []
+        return nil if windows.empty?
+
+        events = collect_events(windows)
+        return nil if events.empty?
+
+        build_html(events)
+      end
+
+      private
+
+      # rrweb replays a flat, time-ordered stream, so all windows are merged
+      # and sorted by timestamp into one timeline.
+      def collect_events(windows)
+        windows
+          .flat_map { |window| @store.get_events(Sentiero::WindowRef.new(@session_id, window[:window_id])) }
+          .sort_by { |event| event["timestamp"] || 0 }
+      end
+
+      def build_html(events)
+        <<~HTML
+          <!DOCTYPE html>
+          <html lang="en">
+          <head>
+          <meta charset="utf-8">
+          <meta name="viewport" content="width=device-width, initial-scale=1">
+          <title>Sentiero session #{escape_html(@session_id)}</title>
+          <style>#{read_asset("rrweb-player-css")}</style>
+          <style>body{margin:0;background:#1a1a1a}#sentiero-player{display:flex;justify-content:center;padding:16px}</style>
+          </head>
+          <body>
+          <div id="sentiero-player"></div>
+          <script type="application/json" id="sentiero-events">#{escape_json(JSON.generate(events))}</script>
+          <script>#{read_asset("rrweb-player")}</script>
+          <script>#{bootloader}</script>
+          </body>
+          </html>
+        HTML
+      end
+
+      # JSON.parse safely round-trips the escape_json transform, which only
+      # touched <, >, & and the JS line separators (all valid in JSON strings).
+      def bootloader
+        <<~JS
+          (function () {
+            var events = JSON.parse(document.getElementById("sentiero-events").textContent);
+            var Player = rrwebPlayer.default || rrwebPlayer;
+            new Player({
+              target: document.getElementById("sentiero-player"),
+              props: { events: events, autoPlay: false }
+            });
+          })();
+        JS
+      end
+
+      def read_asset(logical_name)
+        filename = Manifest.manifest.fetch(logical_name)
+        File.read(File.join(BaseApp::ASSETS_DIR, filename))
+      end
+    end
+  end
+end

data/lib/sentiero/web/templates/_analytics_nav.html.erb

@@ -0,0 +1,22 @@
+<%
+  range_pairs = {}
+  range_pairs["since"] = since if since && !since.to_s.empty?
+  range_pairs["until"] = until_str if until_str && !until_str.to_s.empty?
+  range_qs = range_pairs.empty? ? "" : "?" + Rack::Utils.build_query(range_pairs)
+
+  nav_tabs = [
+    {label: "Overview", href: "#{view.base_path}/analytics#{range_qs}", active: active == :overview},
+    {label: "Heatmap", href: "#{view.base_path}/analytics/heatmap#{range_qs}", active: active == :heatmap},
+    {label: "Scroll", href: "#{view.base_path}/analytics/scroll#{range_qs}", active: active == :scroll},
+    {label: "Forms", href: "#{view.base_path}/analytics/forms#{range_qs}", active: active == :forms},
+    {label: "Pages", href: "#{view.base_path}/analytics/page#{range_qs}", active: active == :pages},
+    {label: "Segments", href: "#{view.base_path}/analytics/segments#{range_qs}", active: active == :segments},
+    {label: "Web Vitals", href: "#{view.base_path}/analytics/vitals#{range_qs}", active: active == :vitals},
+    {label: "Frustration", href: "#{view.base_path}/analytics/frustration#{range_qs}", active: active == :frustration},
+    {label: "Funnel", href: "#{view.base_path}/analytics/funnel#{range_qs}", active: active == :funnel},
+    {label: "Engagement", href: "#{view.base_path}/analytics/engagement#{range_qs}", active: active == :engagement},
+    {label: "Conversions", href: "#{view.base_path}/analytics/conversions#{range_qs}", active: active == :conversions},
+    {label: "Export", href: "#{view.base_path}/analytics/export#{range_qs}", active: active == :export}
+  ]
+-%>
+<%= view.render_partial("_tabs.html.erb", tabs: nav_tabs) %>

data/lib/sentiero/web/templates/_brand.html.erb

@@ -0,0 +1,18 @@
+<a class="s-sidebar-brand" href="<%= view.h(view.base_path) %>/">
+  <svg class="s-sidebar-brand-logo" xmlns="http://www.w3.org/2000/svg" width="28" height="28" viewBox="0 0 100 100" fill="none" role="img" aria-label="Sentiero">
+    <rect width="100" height="100" rx="22" fill="#ff6b5a"/>
+    <path d="M28 76 C42 76, 68 68, 68 56 C68 44, 30 42, 30 32 C30 24, 44 18, 58 18" stroke="white" stroke-width="3.8" stroke-linecap="round" fill="none"/>
+    <path d="M66 60 C70 64, 74 68, 76 72" stroke="white" stroke-width="1.5" stroke-linecap="round" fill="none" opacity="0.28" stroke-dasharray="4 3.5"/>
+    <circle cx="76" cy="72" r="3" fill="white" opacity="0.18"/>
+    <path d="M32 36 C26 32, 22 28, 20 24" stroke="white" stroke-width="1.5" stroke-linecap="round" fill="none" opacity="0.24" stroke-dasharray="4 3.5"/>
+    <circle cx="20" cy="24" r="3" fill="white" opacity="0.16"/>
+    <path d="M48 48 C40 52, 30 56, 22 56" stroke="white" stroke-width="1.5" stroke-linecap="round" fill="none" opacity="0.22" stroke-dasharray="4 3.5"/>
+    <circle cx="22" cy="56" r="2.5" fill="white" opacity="0.15"/>
+    <path d="M52 44 C58 42, 66 40, 74 42" stroke="white" stroke-width="1.5" stroke-linecap="round" fill="none" opacity="0.25" stroke-dasharray="4 3.5"/>
+    <circle cx="74" cy="42" r="2.5" fill="white" opacity="0.16"/>
+    <line x1="62" y1="13" x2="70" y2="21" stroke="white" stroke-width="3" stroke-linecap="round"/>
+    <line x1="70" y1="13" x2="62" y2="21" stroke="white" stroke-width="3" stroke-linecap="round"/>
+    <circle cx="28" cy="76" r="3" fill="white" opacity="0.35"/>
+  </svg>
+  Sentiero
+</a>

data/lib/sentiero/web/templates/_date_range.html.erb

@@ -0,0 +1,18 @@
+<%#
+  Shared From/To date-input pair for the standard `since`/`until` range
+  params (parsed UTC; the To-day is inclusive). Embed inside a GET form that
+  supplies the action and any other filter fields.
+
+  Locals: since (string), until_str (string); optional from_label / to_label
+  when the filtered column needs calling out (e.g. "Last seen from").
+-%>
+<% from_label = (defined?(from_label) && from_label) ? from_label : "From" -%>
+<% to_label = (defined?(to_label) && to_label) ? to_label : "To" -%>
+<div class="shrink-0">
+  <label for="since" class="label"><%= view.h(from_label) %></label>
+  <input type="date" name="since" id="since" class="input" style="width:8.5rem" value="<%= view.h(since) %>">
+</div>
+<div class="shrink-0">
+  <label for="until" class="label"><%= view.h(to_label) %></label>
+  <input type="date" name="until" id="until" class="input" style="width:8.5rem" value="<%= view.h(until_str) %>">
+</div>