janela 0.1.0 → 0.2.1

data/docs/decisions/010-agent-guidance-ships-the-agent-waits.md

@@ -0,0 +1,130 @@
+---
+Date: 2026-09-15
+Status: Accepted
+Related: ADR 001, ADR 005, ADR 009
+Triggers:
+  - writing or changing guidance for AI agents about using Janela
+  - proposing that Janela ship an agent, a skill or an MCP surface to hosts
+  - adding generators or introspection tasks
+  - changing the public API in a way the guidance describes
+  - deciding what a host application receives on install beyond the code
+Topics: ai, agents, jan, skills, documentation, install, dx, scope
+---
+
+# ADR 010: Agent Guidance Ships, the Agent Waits
+
+## Context
+
+ADR 001 decided the reasoning behind Janela ships inside the gem, as
+ADRs, so a developer or their agent understands why a piece exists
+before changing it. That covers the *why*. Nothing covers the *how*,
+and the first real installation showed the gap has a price: three
+traps bit within an hour, each a one line fix found only by debugging.
+Ransack's allowlist is per class, so a `through:` dimension needs the
+associated model to allow the attribute. A host that bundles with
+esbuild has no importmap, so none of Janela's JavaScript loads and
+nothing cross filters while everything looks right. Janela's
+controllers are exactly as authenticated as the host's
+`ApplicationController`, which in a host that authenticates per
+controller means not at all.
+
+None of that is derivable from reading the code, which is precisely
+the test ADR 001 sets for what belongs in the repository as prose.
+
+A second, larger idea came up alongside it: that Janela ship an agent
+of its own, named Jan, so installing the gem gives a host a briefed
+colleague rather than a briefing. Open source has always shipped code
+and documentation; it could now ship the person who knows how to use
+them. It is a genuinely novel idea and nobody is doing it.
+
+The two are not the same commitment, and this ADR separates them.
+
+## Decision
+
+**A skill ships with the gem and installs into the host.**
+`docs/skills/janela/SKILL.md` lives in the gem's `docs/` tree beside
+the ADRs. `rails janela:install:skill` copies it to the host's
+`.claude/skills/janela/` and prints the one line to add to an
+`AGENTS.md` or `CLAUDE.md` for tools that read those instead. Janela
+never edits a host's instruction files itself.
+
+The skill is knowledge, not instructions to a particular agent, which
+is why it survives whatever agent formats come and go.
+
+**What the skill covers, in this order:**
+
+1. The dashboard shape that works, and why: a row of single value
+   panes, a time series, then categorical breakdowns.
+2. Choosing measures and dimensions. Name them for what they mean and
+   alias through dimensions. Keep categories low cardinality or pass
+   `limit`. Declare time dimensions with the granularity people
+   actually ask about. A dimension declaration is a promise that
+   filtering on it is allowed.
+3. The naming table from ADR 005, so an analyst's sentence becomes a
+   pane URL and back.
+4. When to take a snapshot, and that a snapshot holds results, not
+   HTML.
+5. The three traps above, each with its one line fix.
+6. What Janela deliberately does not do, so an agent does not build a
+   report designer, natural language query, row level security or a
+   scheduler into the host by accident.
+
+**The skill describes the README's API and nothing else.** One API,
+one set of names. If the skill needs to say something the README does
+not, the README is incomplete and gets fixed first. No agent only
+vocabulary.
+
+**The demo application is the worked example.** `test/dummy` shows
+every construct on realistic data, deployed and clickable. The skill
+points at specific files rather than duplicating them.
+
+**Every code sample is executable.** Each sample in the skill and in
+`docs/guides/` is lifted from a file the test suite exercises, or is
+run by a test. A sample that cannot be run is written as a sentence,
+not a code block. This is the mechanism that stops the guidance
+drifting from the code.
+
+**Jan is not shipped to hosts yet.** An agent definition is added to
+this repository only, as the project's own collaborator, and is not
+copied into host applications by any install task. Three reasons:
+
+- Its method, read the models, declare dimensions, compose in the
+  standard shape, wire the install, verify in a browser, is what a
+  capable agent with the skill loaded already does. The marginal value
+  over the skill is a name to invoke and a guarantee the skill is
+  loaded. That is convenience, not capability, and convenience is not
+  worth a public surface.
+- Agent definition formats are unsettled. The skill's content is prose
+  about dashboards and survives any format; an agent definition is the
+  part most likely to be stale in six months.
+- A gem that writes a named agent into a host arrives with opinions
+  about how that team works, not only about what its code does. That
+  cuts against the posture in ADR 001, where the invitation is to read
+  the code and fork it.
+
+**What would change this.** Ship Jan to hosts when either is true:
+
+- Jan, used on this repository, demonstrably does something a skill
+  loaded agent does not. Name the thing in the ADR that supersedes
+  this one.
+- An MCP surface exists. An agent that can query dashboards and take
+  snapshots through tools has a job no skill can do, and at that point
+  a named agent stops being a wrapper and becomes a user.
+
+## Consequences
+
+- A host that installs Janela and runs one task gets an opinionated,
+  current briefing, including the three traps that cost real debugging
+  time. That is the concrete value of this layer and it lands now.
+- `docs/guides/` becomes a real directory shipping in the gem, so a
+  forker receives reasoning, rules and how to together.
+- Jan exists but only here. The agent that helps build the gem is the
+  agent that would one day help hosts, so drift between what Jan says
+  and what the code does surfaces in this repository first. That is
+  the trial period, and it is free.
+- Saying no to shipping Jan is recorded rather than remembered, with
+  the conditions that would reverse it. A future proposal cites this
+  ADR instead of relitigating the idea.
+- Introspection (`rails janela:describe Model`), generators and MCP
+  are each one ADR away. Each must be a wrapper over the existing API,
+  for the same reason the skill must describe only one.

data/docs/decisions/011-panes-do-not-render-in-the-host-layout.md

@@ -0,0 +1,81 @@
+---
+Date: 2026-09-15
+Status: Accepted
+Related: ADR 003, ADR 005
+Triggers:
+  - changing which layout a pane renders in
+  - a host reporting NameError from its own layout when a pane loads
+  - adding anything to the engine's own layout
+  - making the dummy application unrepresentative of a real host
+Topics: layouts, engines, panes, urls, install
+---
+
+# ADR 011: Panes Do Not Render in the Host Layout
+
+## Context
+
+ADR 005 promised that a pane opened directly "gets that pane alone
+inside the host's layout". Dogfooding 0.2.0 in a second application
+showed that promise is a bug. `Janela::ApplicationController` inherits
+the host's `ApplicationController` and therefore the host's layout,
+but the engine is `isolate_namespace`d, so a route helper written in
+that layout resolves against Janela's routes and raises `NameError`.
+Almost every real application layout has a nav, so almost every host
+is broken on install, and a whole dashboard of frames goes blank.
+
+The gem's own dummy application has no route helper in its layout,
+which is exactly why the suite, the demo and the first host install
+never saw it. The first host squeaked through because its only layout
+helpers were an Active Storage URL and a PWA manifest path rather
+than nav links.
+
+## Decision
+
+**A pane requested inside a Turbo Frame renders with no layout.**
+Turbo extracts the matching frame from the response and discards
+everything around it, so a layout was never doing any work there. This
+alone fixes every dashboard, which is how panes are almost always
+requested.
+
+**A pane requested directly renders in Janela's own layout.** A
+minimal layout in the engine, carrying only a charset, a viewport, the
+CSRF and CSP tags and a `yield`. It keeps ADR 005's shareable pane
+alive and cannot depend on anything the host has not got.
+
+```ruby
+layout -> { turbo_frame_request? ? false : "janela/application" }
+```
+
+**A directly opened pane is therefore unstyled, and that is
+documented.** Janela ships no CSS (issue #15), and the engine layout
+deliberately loads none of the host's assets, because it cannot know
+their names or whether the host bundles or uses importmap. A host that
+wants its own styling on direct pane URLs sets
+`Janela::ApplicationController.layout "application"` in an
+initializer, and is told the condition: that layout must not call a
+bare host route helper, since inside an engine those need a
+`main_app.` prefix.
+
+**The dummy application's layout gains a route helper.** The dummy is
+the gem's stand in for a real host, and a stand in that omits the most
+common thing a layout contains is not doing its job. A `link_to` to
+the dashboard makes the suite fail if a pane ever renders in the host
+layout again.
+
+## Consequences
+
+- ADR 005's sentence about the host layout is superseded by this ADR.
+  The rest of ADR 005, the URL grammar and the naming table, stands.
+- Direct pane URLs render a table but not a chart, because no
+  JavaScript is loaded. Shareable pane links are therefore honest for
+  data and plain for visuals until a host opts its own layout in.
+  Acceptable: the pane URL's job is to show a number to someone, and
+  the dashboard is where charts live.
+- The engine now owns a view that a host might want to override.
+  `app/views/layouts/janela/application.html.erb` is overridable by
+  the usual Rails precedence, which is the Rails answer and needs no
+  configuration of Janela's own.
+- The lesson generalises beyond layouts: the dummy application should
+  resemble a real host in the ways hosts actually vary. Each time a
+  host finds something the dummy could not, the dummy gains that
+  characteristic rather than the fix being verified only by hand.

data/docs/decisions/INDEX.md

@@ -20,13 +20,18 @@ them when in doubt: `grep -l "Triggers:.*fork" docs/decisions/*.md`.
 
 | Topic | ADRs |
 |-------|------|
-| **Vision, scope, forkability** | 001 |
+| **Vision, scope, forkability** | 001, 010 |
 | **Open-source & host-decoupling** | 001 |
-| **DSL & query layer** | 002 |
-| **Dependencies** | 002, 003, 004 |
-| **Authorisation** | 002, 003, 004 |
-| **Cross-filtering & Hotwire** | 003, 004 |
-| **JavaScript delivery & charts** | 004 |
+| **DSL & query layer** | 002, 006, 007 |
+| **Dependencies** | 002, 003, 004, 006 |
+| **Authorisation** | 002, 003, 004, 009 |
+| **Cross-filtering & Hotwire** | 003, 004, 005, 008 |
+| **Layouts & views** | 011 |
+| **JavaScript delivery & charts** | 004, 006 |
+| **Time dimensions** | 006 |
+| **Routes, URLs & naming** | 005, 007, 008, 009, 011 |
+| **Snapshots & publishing** | 009 |
+| **AI agents & guidance** | 010 |
 | **Security** | 003 |
 | **Testing** | 003 |
 
@@ -38,7 +43,14 @@ them when in doubt: `grep -l "Triggers:.*fork" docs/decisions/*.md`.
 | 002 | Measures and Dimensions over Ransack | 2026-09-13 | Accepted |
 | 003 | Cross-filtering with Turbo Frames | 2026-09-13 | Accepted |
 | 004 | Charts and JavaScript Delivery | 2026-09-15 | Accepted |
+| 005 | Pane URLs and the Mount Path | 2026-09-15 | Accepted |
+| 006 | Time Dimensions with Groupdate | 2026-09-15 | Accepted |
+| 007 | Ordering and Limits | 2026-09-15 | Accepted |
+| 008 | Dashboard Filters in the Page URL | 2026-09-15 | Accepted |
+| 009 | Snapshots | 2026-09-15 | Accepted |
+| 010 | Agent Guidance Ships, the Agent Waits | 2026-09-15 | Accepted |
+| 011 | Panes Do Not Render in the Host Layout | 2026-09-15 | Accepted |
 
 ## Next number
 
-Next ADR: 005
+Next ADR: 012

data/lib/janela/definition.rb

@@ -9,34 +9,63 @@ module Janela
     end
 
     def measure(name, **aggregate)
-      measures[name] = Measure.build(name, **aggregate)
+      measures[name] = Measure.build(name, **aggregate).tap { |measure| reject_boolean_column!(measure) }
     end
 
-    def dimension(name, through: nil)
-      dimensions[name] = Dimension.new(name, model: model, through: through)
+    def dimension(name, through: nil, column: nil, granularity: nil)
+      dimensions[name] = Dimension.new(name, model: model, through: through, column: column, granularity: granularity)
     end
 
     # Filters are Ransack params, so a host can pass params[:q] straight
     # through from a search_form_for slicer. Scope with on: to respect the
-    # host's authorisation, e.g. on: policy_scope(Order).
-    def query(measure_name, by: nil, where: {}, on: nil)
+    # host's authorisation, e.g. on: policy_scope(Order). A time dimension
+    # buckets by its declared granularity unless one is given.
+    def query(measure_name, by: nil, where: {}, on: nil, granularity: nil, limit: nil)
+      measure = measure!(measure_name)
       relation = filter(on || model.all, where)
+      return measure.apply(relation) if by.nil?
 
-      if by
-        dimension = dimension!(by)
-        relation = relation.left_joins(dimension.through) if dimension.through
-        relation = relation.group(dimension.attribute)
-      end
+      dimension = dimension!(by)
+      relation = relation.left_joins(dimension.through) if dimension.through
 
-      measure!(measure_name).apply(relation)
+      if dimension.time?
+        granularity = Dimension.granularity!(granularity || dimension.granularity)
+        options = granularity == "week" ? { week_start: Date.beginning_of_week } : {}
+        buckets = relation.group_by_period(granularity, dimension.qualified_column, **options)
+        measure.apply(buckets).transform_keys { |bucket| dimension.label(bucket, granularity) }
+      else
+        grouped = relation.group(dimension.attribute).order(Arel.sql("#{measure.sql_alias} DESC"))
+        grouped = grouped.limit(limit!(limit)) if limit
+        measure.apply(grouped).transform_keys { |value| value.nil? ? Dimension::NONE : value }
+      end
     end
 
     def dimension!(name)
-      dimensions.fetch(name) { raise Error, "#{model} has no janela dimension #{name.inspect}" }
+      dimensions.fetch(name) { raise NotFound, "#{model} has no janela dimension #{name.inspect}" }
+    end
+
+    # ActiveRecord casts an aggregate back through the column's own type, so
+    # AVG over a boolean returns true rather than a ratio. Say so at
+    # declaration rather than rendering a meaningless pane.
+    def reject_boolean_column!(measure)
+      return unless measure.column && Measure::NUMERIC.include?(measure.aggregate)
+      return unless model.type_for_attribute(measure.column).type == :boolean
+
+      raise Error, "measure #{measure.name.inspect} takes #{measure.aggregate} of the boolean " \
+                   "#{model}##{measure.column}, which ActiveRecord casts back to true or false. " \
+                   "Declare dimension #{measure.column.inspect} instead and read the split."
+    rescue ActiveRecord::ActiveRecordError
+      nil # no database to ask yet; a query will raise on its own if it cannot run
+    end
+
+    def limit!(value)
+      limit = Integer(value, exception: false)
+      raise BadRequest, "limit must be a whole number from 1 to 1000, got #{value.inspect}" unless limit&.between?(1, 1000)
+      limit
     end
 
     def ransackable_attributes
-      dimensions.values.reject(&:through).map { |dimension| dimension.name.to_s }
+      dimensions.values.reject(&:through).map { |dimension| dimension.column.to_s }
     end
 
     def ransackable_associations
@@ -59,12 +88,12 @@ module Janela
         dropped = params.keys.reject { |key| applied.any? { |name| key.to_s.start_with?(name) } }
         return if dropped.empty?
 
-        raise Error, "#{model} does not allow filtering on #{dropped.join(', ')}. " \
+        raise BadRequest, "#{model} does not allow filtering on #{dropped.join(', ')}. " \
                      "Declare a janela dimension, or add it to ransackable_attributes."
       end
 
       def measure!(name)
-        measures.fetch(name) { raise Error, "#{model} has no janela measure #{name.inspect}" }
+        measures.fetch(name) { raise NotFound, "#{model} has no janela measure #{name.inspect}" }
       end
   end
 end

data/lib/janela/dimension.rb

@@ -1,21 +1,60 @@
 module Janela
   class Dimension
-    attr_reader :name, :model, :through
+    GRANULARITIES = %w[hour day week month quarter year].freeze
 
-    def initialize(name, model:, through: nil)
+    # A group of rows whose dimension is null. Labelled rather than blank, and
+    # filtered with Ransack's null predicate rather than an empty string.
+    NONE = "(none)".freeze
+
+    LABELS = {
+      "hour" => ->(t) { t.strftime("%Y-%m-%d %H:00") },
+      "day" => ->(t) { t.strftime("%Y-%m-%d") },
+      "week" => ->(t) { t.strftime("%Y-%m-%d") },
+      "month" => ->(t) { t.strftime("%b %Y") },
+      "quarter" => ->(t) { "Q#{(t.month - 1) / 3 + 1} #{t.year}" },
+      "year" => ->(t) { t.strftime("%Y") }
+    }.freeze
+
+    attr_reader :name, :model, :through, :column, :granularity
+
+    # A dimension is named for what it means on the dashboard and reads a
+    # column that may be called something else, usually on an association:
+    # dimension :customer, through: :customer, column: :name.
+    def initialize(name, model:, through: nil, column: nil, granularity: nil)
       @name = name
       @model = model
       @through = through
+      @column = (column || name).to_sym
+      @granularity = granularity&.to_s
 
       raise Error, "#{model} has no association #{through.inspect}" if through && reflection.nil?
+      self.class.granularity!(@granularity) if @granularity
+    end
+
+    def self.granularity!(value)
+      value = value.to_s
+      raise BadRequest, "unknown granularity #{value.inspect}, use one of #{GRANULARITIES.join(', ')}" unless GRANULARITIES.include?(value)
+      value
+    end
+
+    def time?
+      !granularity.nil?
     end
 
     def attribute
-      klass.arel_table[name]
+      klass.arel_table[column]
+    end
+
+    def qualified_column
+      "#{klass.table_name}.#{column}"
     end
 
     def ransack_name
-      through ? "#{through}_#{name}" : name.to_s
+      through ? "#{through}_#{column}" : column.to_s
+    end
+
+    def label(bucket, granularity = self.granularity)
+      LABELS.fetch(granularity).call(bucket)
     end
 
     private

data/lib/janela/measure.rb

@@ -1,6 +1,9 @@
 module Janela
   class Measure
     AGGREGATES = %i[sum count average minimum maximum].freeze
+    # Aggregates whose answer is a number, so a boolean column would have its
+    # result cast back to true or false by ActiveRecord.
+    NUMERIC = %i[sum average].freeze
 
     attr_reader :name, :aggregate, :column
 
@@ -22,5 +25,11 @@ module Janela
     def apply(relation)
       column ? relation.public_send(aggregate, column) : relation.public_send(aggregate)
     end
+
+    # The column alias ActiveRecord gives a grouped calculation, so a
+    # relation can be ordered by the measure before it is calculated.
+    def sql_alias
+      "#{aggregate}_#{column || 'all'}"
+    end
   end
 end

data/lib/janela/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Janela
-  VERSION = "0.1.0"
+  VERSION = "0.2.1"
 end

data/lib/janela.rb

@@ -1,4 +1,5 @@
 require "ransack"
+require "groupdate"
 require "turbo-rails"
 require "stimulus-rails"
 
@@ -11,29 +12,34 @@ require "janela/dimension"
 
 module Janela
   class Error < StandardError; end
+  # Something the request named does not exist: a model, measure, dimension
+  # or a pane a snapshot did not freeze. Rendered as 404.
+  class NotFound < Error; end
+  # Something the request asked for is not allowed here: a renderer, a
+  # granularity, a limit or a filter. Rendered as 400.
+  class BadRequest < Error; end
 
   # Janela's controllers inherit from the host's, so the host's authentication
   # and authorisation apply to dashboards with no configuration.
   mattr_accessor :parent_controller, default: "ApplicationController"
 
-  # Only models that declare a janela block are addressable over HTTP, so a
-  # request parameter can never name an arbitrary class. Names are stored
-  # rather than definitions so a reloaded model does not leave a stale class
-  # behind in development.
+  # Only models that declare a janela block are addressable over HTTP, keyed by
+  # the route key that appears in pane URLs (orders, sales_orders). Names are
+  # stored rather than classes so a reloaded model leaves nothing stale behind.
   def self.registry
-    @registry ||= Set.new
+    @registry ||= {}
   end
 
   def self.register(model)
-    registry << model.name
+    registry[model.model_name.route_key] = model.name
   end
 
-  def self.definition!(name)
+  def self.definition!(route_key)
     # In development a model is only registered once autoloaded, so a cold
     # lookup loads the app rather than constantizing an unvetted parameter.
-    Rails.application.eager_load! unless registry.include?(name)
-    raise Error, "#{name.inspect} is not a janela model" unless registry.include?(name)
+    Rails.application.eager_load! unless registry.key?(route_key)
+    class_name = registry.fetch(route_key) { raise NotFound, "#{route_key.inspect} is not a janela model" }
 
-    name.constantize.janela
+    class_name.constantize.janela
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: janela
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Jay Killeen
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: groupdate
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: turbo-rails
   requirement: !ruby/object:Gem::Requirement
@@ -81,21 +95,32 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
-- Rakefile
 - app/assets/javascripts/janela/chart_controller.js
 - app/assets/javascripts/janela/dashboard_controller.js
 - app/assets/javascripts/janela/vendor/chart.js
 - app/controllers/janela/application_controller.rb
-- app/controllers/janela/visuals_controller.rb
+- app/controllers/janela/panes_controller.rb
+- app/controllers/janela/snapshot_panes_controller.rb
 - app/helpers/janela/dashboard_helper.rb
-- app/models/janela/visual.rb
-- app/views/janela/visuals/show.html.erb
+- app/jobs/janela/snapshot_job.rb
+- app/models/janela/pane.rb
+- app/models/janela/snapshot.rb
+- app/views/janela/panes/show.html.erb
+- app/views/layouts/janela/application.html.erb
 - config/importmap.rb
 - config/routes.rb
+- db/migrate/20260915000001_create_janela_snapshots.rb
 - docs/decisions/001-built-to-be-forked.md
 - docs/decisions/002-measures-and-dimensions-over-ransack.md
 - docs/decisions/003-cross-filtering-with-turbo-frames.md
 - docs/decisions/004-charts-and-javascript-delivery.md
+- docs/decisions/005-pane-urls-and-mount-path.md
+- docs/decisions/006-time-dimensions-with-groupdate.md
+- docs/decisions/007-ordering-and-limits.md
+- docs/decisions/008-dashboard-filters-in-the-page-url.md
+- docs/decisions/009-snapshots.md
+- docs/decisions/010-agent-guidance-ships-the-agent-waits.md
+- docs/decisions/011-panes-do-not-render-in-the-host-layout.md
 - docs/decisions/INDEX.md
 - lib/janela.rb
 - lib/janela/definition.rb
@@ -112,6 +137,7 @@ metadata:
   source_code_uri: https://github.com/retail-tasker/janela
   changelog_uri: https://github.com/retail-tasker/janela/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/retail-tasker/janela/issues
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib

data/Rakefile

@@ -1,23 +0,0 @@
-require "bundler/setup"
-
-APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
-load "rails/tasks/engine.rake"
-
-require "bundler/gem_tasks"
-
-require "minitest/test_task"
-
-Minitest::TestTask.create do |t|
-  t.test_globs = Dir["test/**/*_test.rb"] - Dir["test/system/**/*_test.rb"]
-  t.warning = false
-end
-
-Minitest::TestTask.create(:system) do |t|
-  t.test_globs = [ "test/system/**/*_test.rb" ]
-  t.warning = false
-end
-
-require "rubocop/rake_task"
-RuboCop::RakeTask.new
-
-task default: %i[test rubocop]

data/app/models/janela/visual.rb

@@ -1,65 +0,0 @@
-module Janela
-  # One measure grouped by one dimension, rendered as a table or a chart. A
-  # visual ignores filters on its own dimension: clicking a value in a visual
-  # should re-scope the others, not collapse itself to the value clicked.
-  class Visual
-    RENDERERS = %w[table bar].freeze
-
-    attr_reader :definition, :measure, :dimension, :renderer, :filters
-
-    # The helper renders the frame and the controller renders its replacement,
-    # so both derive the id the same way from the same parameters.
-    def self.frame_id(model:, measure:, by:, as: :table)
-      "janela_#{model.to_s.underscore}_#{measure}_by_#{by}_#{as}"
-    end
-
-    def initialize(definition:, measure:, dimension:, renderer: "table", filters: {})
-      @definition = definition
-      @measure = measure
-      @dimension = dimension
-      @renderer = renderer.to_s
-      @filters = filters
-
-      raise Error, "unknown visual renderer #{renderer.inspect}" unless RENDERERS.include?(@renderer)
-    end
-
-    def model
-      definition.model
-    end
-
-    def chart?
-      renderer != "table"
-    end
-
-    def frame_id
-      self.class.frame_id(model: model.name, measure: measure, by: dimension, as: renderer)
-    end
-
-    def title
-      "#{measure.to_s.humanize} by #{dimension.to_s.humanize}"
-    end
-
-    def result(on: nil)
-      definition.query(measure, by: dimension, where: applicable_filters, on: on)
-    end
-
-    def filter_key
-      "#{ransack_name}_eq"
-    end
-
-    # The filter on this visual's own dimension is not applied to its query,
-    # but it is what the user clicked here, so the view highlights it.
-    def selected_value
-      filters[filter_key] || filters[filter_key.to_sym]
-    end
-
-    private
-      def ransack_name
-        definition.dimension!(dimension).ransack_name
-      end
-
-      def applicable_filters
-        filters.reject { |key, _| key.to_s.start_with?(ransack_name) }
-      end
-  end
-end