janela 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1dbbea1c971d06f91daeb2e1bbd3ecc0a9d056363efd0e61664bf9cac51da9b
-  data.tar.gz: 50e76f042113f5e5e071f20d242c62176672aba367ab676448f6e722f1df9f2d
+  metadata.gz: eac851a1f9a4eda7cac89f9ceced6664b28b26a5c889b1939147a0f5a4ed5688
+  data.tar.gz: 5425fbb11f1585892bbc4cff9b87ddbf9f6c08a2398ec87d5cd9402e8d624d51
 SHA512:
-  metadata.gz: 2a96c9be9933a2c7f4e33109bd5bd63f8fe6a0003047e66a3ab28f306bf33aa5d8be3f8be860ce306d4a994775749dcd410ca64998d8c856916caa048e3ab1c2
-  data.tar.gz: b9d548a0042e569e3cd9ceaae714af366b852a1a81ec95966bbd0a1b7b21f1978d352f560192fad01b87acc14d65d0dddb652ec443702eda5ffabeb61507d32f
+  metadata.gz: 3d8563226d41987ac12140bc9af25a6492f1784937d02796c077e1282d999c132e0e19285d9f938a78b4d20e98958f28e2bd1bb55a14a6bad23e8267b5bf9a9b
+  data.tar.gz: 0a836386550bc34bcb4e16d284592f7a8473accdbf073385eadc88e3f6b2e1da9eb14ea61394a0d0b79baa59f3f9c6e540b7f3423d6064b23da21b24f4bdc6c7

data/CHANGELOG.md

@@ -5,6 +5,16 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.10.0] - 2026-09-28
+
+### Added
+
+- `Janela::Frame` gains `default_model` and `default_where`, a permanent filter that is data rather than code: `frame.update!(default_model: "orders", default_where: { status_in: %w[paid pending] })`. Until now the only filter a frame could carry was `where:` (ADR 040), a host's own code, per record, typed into every view that rendered the frame; something true on every render, such as a queue never counting an archived row, had nowhere on the data side to live. `default_model` names the one model the condition is about, so a frame holding panes from more than one model is never narrowed by a condition that was never about the pane reading it: a pane over a different model simply does not receive it, no error. It composes ahead of `where:` and the reader's `q[...]`, applies even on a pane's own dimension, and is validated the moment you save it, against that model's declared dimensions and ADR 025's existing predicate bounds, rather than only discovered wrong at render. Set both columns together; either alone is a validation error. Needs a migration; see `UPGRADING.md` (ADR 043, #63).
+
+### Fixed
+
+- A bar or line pane's colour now comes from `--janela-accent`, not a literal `rgba(54, 162, 235, ...)`. Three hardcoded copies of Chart.js's own default blue meant a chart disagreed with the very theme installed alongside it, vitral included: a selected table value read the theme's accent, the equivalent bar stayed Chart.js blue. Nothing to configure and nothing new in the theming contract; the property was already public (ADR 016), the chart just never read it (#62).
+
 ## [0.9.0] - 2026-09-28
 
 ### Added
@@ -205,6 +215,7 @@ First alpha, installed from GitHub for testing in a single host application.
 - Only models that declare a `janela` block are addressable over HTTP.
 - ADRs 001 to 004 in `docs/decisions/`, shipped inside the gem.
 
+[0.10.0]: https://github.com/retail-tasker/janela/releases/tag/v0.10.0
 [0.9.0]: https://github.com/retail-tasker/janela/releases/tag/v0.9.0
 [0.8.0]: https://github.com/retail-tasker/janela/releases/tag/v0.8.0
 [0.7.0]: https://github.com/retail-tasker/janela/releases/tag/v0.7.0

data/README.md

@@ -27,7 +27,7 @@ Janela is an alpha on [rubygems.org](https://rubygems.org/gems/janela). It has t
 
 ```ruby
 # Gemfile
-gem "janela", "~> 0.9"
+gem "janela", "~> 0.10"
 ```
 
 ```ruby
@@ -286,6 +286,14 @@ What an analyst writes is escaped, never rendered as markup, and a `link` must b
 
 It travels in each pane's URL as `where[...]`, apart from the reader's `q[...]`, so Clear filters, Escape and a click on the same dimension cannot take it off, and the reader's selection can only narrow inside it. It is bounded like any filter: declared dimensions only, and the predicates ADR 025 allows. It is a view filter, not a permission: it is visible in the pane URL, and a reader who edits it out sees only what your `policy_scope` already allows them to. Keep a record out of reach in the scope, not here. Putting the same filter in the page URL's `q[...]` instead does not hold, because `q[...]` is the reader's to clear (ADR 040).
 
+**A frame's own permanent filter**, for something that is true on every render, not one record: "this queue never counts an archived row." Where `where:` is code, per request, this is data, so an analyst changes it without a deploy (ADR 043):
+
+```ruby
+frame.update!(default_model: "orders", default_where: { status_in: %w[paid pending] })
+```
+
+`default_model` names the one model it narrows; a pane over any other model in the same frame is untouched by it, so a frame is free to hold panes from more than one model without the two ever fighting over what the default means. It composes ahead of `where:` and the reader's `q[...]`, applies even on a pane's own dimension, and is validated the moment you save it, against that model's declared dimensions and ADR 025's predicate bounds, the same sentence a bad request would raise, read at the point you can still fix it. Set both columns together, or neither; either alone is a validation error.
+
 ### Janela's own pages
 
 The engine serves an index and a page per frame at the mount root, so you can install the gem and navigate the same day:
@@ -534,7 +542,7 @@ Deliberately out of scope: natural-language query, a separate data warehouse, a
 
 ## Status
 
-**v0.9.0 alpha.** The measures/dimensions DSL, time dimensions, cross-filtering with multi-selection, bar and line charts, pane URLs, shareable dashboard URLs, snapshots, database-backed frames found by owner and key, panes that hold words or a host partial as well as a query, a host-fixed frame filter no click can remove, STI subclasses, the engine's own pages for reading and editing them and the optional vitral theme work and are covered by unit and real-browser tests, with the classes a theme may target documented in [Theming Janela](docs/theming.md). Not yet built: a visual editor, drill-down on time panes, other chart types. [Vista](docs/roadmap.md), the roadmap, says what 1.0 means and which of these are in it; open work is in [GitHub Issues](https://github.com/retail-tasker/janela/issues).
+**v0.10.0 alpha.** The measures/dimensions DSL, time dimensions, cross-filtering with multi-selection, bar and line charts, pane URLs, shareable dashboard URLs, snapshots, database-backed frames found by owner and key, panes that hold words or a host partial as well as a query, a host-fixed filter no click can remove and a frame's own permanent one beside it, STI subclasses, the engine's own pages for reading and editing them and the optional vitral theme work and are covered by unit and real-browser tests, with the classes a theme may target documented in [Theming Janela](docs/theming.md). Not yet built: a visual editor, drill-down on time panes, other chart types. [Vista](docs/roadmap.md), the roadmap, says what 1.0 means and which of these are in it; open work is in [GitHub Issues](https://github.com/retail-tasker/janela/issues).
 
 ## Development
 

data/UPGRADING.md

@@ -12,6 +12,33 @@ bin/rails janela:doctor
 
 It reads your application and lists what still needs changing.
 
+## 0.9.0 to 0.10.0
+
+One migration, if you use stored frames.
+
+**Take the frame default filter migration.**
+
+A frame can now carry a permanent filter as data (ADR 043).
+`janela_frames` gains `default_model` and `default_where`:
+
+```bash
+bin/rails janela:install:migrations
+bin/rails db:migrate
+```
+
+Every existing frame keeps both columns nil and is unaffected. Nothing
+changes unless you set them:
+
+```ruby
+frame.update!(default_model: "orders", default_where: { status_in: %w[paid pending] })
+```
+
+Only a pane over `default_model` takes the filter; every other pane in
+the frame is untouched by it. Set both columns together, or neither:
+either alone is a validation error, and so is a condition your model
+does not declare or a predicate ADR 025 does not allow for that kind of
+dimension.
+
 ## 0.8.0 to 0.9.0
 
 Two migrations, if you use stored frames. Both are taken by the same

data/app/assets/javascripts/janela/chart_controller.js

@@ -20,7 +20,7 @@ export default class extends Controller {
           label: this.titleValue,
           data: this.valuesValue,
           backgroundColor: this.colours(),
-          borderColor: "rgba(54, 162, 235, 0.9)"
+          borderColor: this.accentColour(0.9)
         }]
       },
       options: {
@@ -52,11 +52,37 @@ export default class extends Controller {
     const selected = this.selectedValue.map(String)
     return this.labelsValue.map((label) =>
       selected.length === 0 || selected.includes(String(label))
-        ? "rgba(54, 162, 235, 0.9)"
-        : "rgba(54, 162, 235, 0.25)"
+        ? this.accentColour(0.9)
+        : this.accentColour(0.25)
     )
   }
 
+  // #62: this used to be a literal rgba(54, 162, 235, ...), Chart.js's own
+  // default, so a bar disagreed with --janela-accent (ADR 016) and with
+  // every other selected thing on the page. Read off this element rather
+  // than the document root, so whatever ancestor sets the property is the
+  // one honoured, the way it already inherits for everything else.
+  accentColour(alpha) {
+    const [ r, g, b ] = this.resolvedAccent().match(/\d+/g)
+    return `rgba(${r}, ${g}, ${b}, ${alpha})`
+  }
+
+  // A custom property's computed value is returned exactly as authored,
+  // "rgb(...)", "#7c3aed", a name, never resolved the way an ordinary
+  // colour property is. Setting it as one and reading that back resolves
+  // any of them the same way, rather than parsing each form by hand.
+  resolvedAccent() {
+    if (this.resolvedAccentValue) return this.resolvedAccentValue
+
+    const accent = getComputedStyle(this.element).getPropertyValue("--janela-accent").trim()
+    const probe = document.createElement("span")
+    probe.style.color = accent
+    document.body.appendChild(probe)
+    this.resolvedAccentValue = getComputedStyle(probe).color
+    probe.remove()
+    return this.resolvedAccentValue
+  }
+
   disconnect() {
     this.chart?.destroy()
     this.chart = null

data/app/models/janela/frame.rb

@@ -18,6 +18,9 @@ module Janela
     # The shape of the symbol a host passes, so nothing that reads like a
     # name or a path gets in (ADR 041).
     validates :key, format: { with: /\A[a-z0-9_]+\z/ }, uniqueness: { scope: %i[owner_type owner_id] }, allow_nil: true
+    # Present or absent together, and default_where is only ever as valid as
+    # default_model says it can be (ADR 043).
+    validate :default_where_matches_default_model
 
     # The host's frame for this owner and key, created on first use (ADR 041).
     # The block runs only when the frame is created, to set what a new frame
@@ -44,5 +47,31 @@ module Janela
         pane.update_columns(position: index + 1) unless pane.position == index + 1
       end
     end
+
+    # This frame's permanent filter, if the pane asking is over the model it
+    # names; empty for any other model, because the condition was never
+    # claimed to be about it (ADR 043).
+    def default_for(model)
+      return {} if default_model.blank? || default_model != model.model_name.route_key
+
+      default_where.to_h
+    end
+
+    private
+      def default_where_matches_default_model
+        return if default_model.blank? && default_where.blank?
+        return errors.add(:default_where, "cannot be set without default_model") if default_model.blank?
+        return errors.add(:default_model, "cannot be set without default_where") if default_where.blank?
+
+        definition = Janela.definition!(default_model)
+        # A no-op relation: this checks the condition's shape against the
+        # model's declared dimensions (ADR 025), and never has to touch a row
+        # to do it.
+        definition.narrow(definition.model.none, default_where)
+      rescue Janela::NotFound
+        errors.add(:default_model, "must be a model with a janela block")
+      rescue Janela::BadRequest => e
+        errors.add(:default_where, e.message)
+      end
   end
 end

data/app/models/janela/pane.rb

@@ -73,7 +73,7 @@ module Janela
     def query(filters: {}, fixed: {}, renderer: self.renderer)
       Query.new(definition: definition, measure: measure.to_sym, dimension: dimension.presence&.to_sym,
                 renderer: renderer, granularity: granularity, limit: limit, filters: filters, fixed: fixed,
-                title: title)
+                default: frame.default_for(definition.model), title: title)
     end
 
     # The row's own words, for a list or a heading. Built from the columns

data/app/models/janela/query.rb

@@ -7,7 +7,7 @@ module Janela
   class Query
     RENDERERS = %w[table bar line].freeze
 
-    attr_reader :definition, :measure, :dimension, :renderer, :limit, :filters, :fixed, :snapshot
+    attr_reader :definition, :measure, :dimension, :renderer, :limit, :filters, :fixed, :default, :snapshot
 
     # The helper renders the turbo frame and the controller renders its
     # replacement, so both derive the id the same way from the same parameters.
@@ -17,7 +17,7 @@ module Janela
       parts.compact.join("_")
     end
 
-    def initialize(definition:, measure:, dimension: nil, renderer: "table", granularity: nil, limit: nil, filters: {}, fixed: {}, snapshot: nil, title: nil)
+    def initialize(definition:, measure:, dimension: nil, renderer: "table", granularity: nil, limit: nil, filters: {}, fixed: {}, default: {}, snapshot: nil, title: nil)
       @definition = definition
       @title = title
       @measure = measure
@@ -25,6 +25,7 @@ module Janela
       @renderer = renderer.to_s
       @filters = filters
       @fixed = fixed
+      @default = default
       @snapshot = snapshot
 
       raise BadRequest, "unknown pane renderer #{renderer.inspect}" unless RENDERERS.include?(@renderer)
@@ -98,9 +99,11 @@ module Janela
     def result(on: nil)
       return snapshot.stored_result(self) if frozen?
 
-      # The fixed filter applies even on this pane's own dimension, unlike the
-      # reader's: it is the host saying which rows the frame is about, not a
-      # selection this pane should show the alternatives to (ADR 040).
+      # Default, then fixed, then the reader's: a frame's own permanent
+      # filter narrows first, a host's per-record filter narrows again, and
+      # both apply even on this pane's own dimension, unlike the reader's
+      # selection, which this pane shows the alternatives to (ADR 040, 043).
+      on = definition.narrow(on || model.all, default) if default.present?
       on = definition.narrow(on || model.all, fixed) if fixed.present?
       definition.query(measure, by: dimension, where: applicable_filters, on: on, granularity: granularity, limit: limit)
     end

data/db/migrate/20260928000001_add_default_filter_to_janela_frames.rb

@@ -0,0 +1,10 @@
+class AddDefaultFilterToJanelaFrames < ActiveRecord::Migration[8.0]
+  def change
+    # A frame's own permanent filter (ADR 043): only a pane over
+    # default_model takes it, so a frame that holds panes from more than one
+    # model is never narrowed by a condition that is not about it. Present
+    # or absent together; every existing frame has neither.
+    add_column :janela_frames, :default_model, :string
+    add_column :janela_frames, :default_where, :json
+  end
+end

data/docs/composing.md

@@ -93,6 +93,25 @@ pane the reader can click: any value but the fixed one returns nothing.
 A figure you compute yourself for the same page, such as the progress
 bar below, takes the same condition in its own `where:`.
 
+## A frame's own permanent filter
+
+Some conditions are not about which record's page this is, they are
+true every time: "this queue never counts an archived row." `where:` is
+code, written into a view, run again on every render. A frame's own
+default filter is data instead, so an analyst changes it without a
+deploy (ADR 043):
+
+```ruby
+frame.update!(default_model: "orders", default_where: { status_in: %w[paid pending] })
+```
+
+`default_model` says which model the condition is about, so a frame
+holding panes from more than one model is never narrowed by a condition
+that was never about the pane reading it. It is validated when you save
+it, against that model's declared dimensions, rather than only
+discovered wrong the next time a pane renders. Set both columns
+together; either alone is a validation error.
+
 ## Components
 
 Each of these is plain HTML. The class names that start `janela-` are

data/docs/decisions/043-a-frames-default-filter-names-the-model-it-narrows.md

@@ -0,0 +1,163 @@
+---
+Date: 2026-09-28
+Status: Accepted
+Related: ADR 012, ADR 014, ADR 020, ADR 025, ADR 040
+Triggers:
+  - a frame that should always exclude some rows, regardless of who renders it
+  - adding a column to Janela::Frame or Janela::Pane
+  - a host copying the same where: condition into every view that renders one frame
+  - validating a stored Ransack condition at save time rather than at render
+Topics: frames, filters, cross-filtering, persistence, ransack
+---
+
+# ADR 043: A Frame's Default Filter Names the Model It Narrows
+
+## Context
+
+#63, found while dogfooding: ADR 040 gives a host a way to narrow a
+frame to the current record, `where: { project_id_eq: @project.id }`,
+code, per request, correctly not data because the value is inherently
+per-record. It does not give a frame a way to say something that is
+true on every render, forever: "this queue never counts an archived
+row." That is not per-record narrowing, it is a permanent property of
+what the dashboard means, and today it can only be expressed by typing
+the same Ransack condition into every view that renders the frame.
+
+ADR 012's own argument is that composition moved out of ERB because
+the analyst, not the developer, owns a dashboard, and a decision typed
+into a view is "a file held by the wrong owner." A permanent filter is
+exactly that file, with nowhere on the data side to move to: `Frame`
+and `Pane` have no column that could hold one.
+
+### What breaks the obvious shape
+
+The obvious answer, a `default_where` column on `Frame` applied to
+every pane in it, runs into a fact ADR 020 already used to reject the
+frame as the layer for a different per-pane setting: a frame can hold
+panes from more than one model. Measured against the demo, reusing the
+existing bound check rather than assuming it:
+
+```ruby
+Order.janela.narrow(Order.all, "expedited_eq" => "false")
+# => Janela::BadRequest: Order does not allow filtering on expedited_eq.
+#    Declare a janela dimension, or add it to ransackable_attributes.
+```
+
+`expedited` is a real column on `Order`, not a declared dimension. A
+condition applied uniformly to every pane in a frame raises for any
+pane whose model, or whose declared dimension set, does not carry the
+attribute the condition names. ADR 020's own case was a format string
+being "right for the currency and wrong for the count sitting next to
+it"; a stored Ransack condition is at least as specific to one model.
+
+### What was considered for where the mismatch goes
+
+**Raise for every pane whose model does not match.** Rejected: the
+frame breaks the moment an analyst adds a pane over a second model, or
+the moment a declared dimension is removed from the first, and the
+failure is frame-wide rather than local to the pane that changed.
+
+**Skip the condition quietly for a pane it does not apply to.** Rejected
+outright. ADR 024, ADR 032 and ADR 034 all refuse the same shape of
+quiet: a filter that means one thing for one pane and nothing for
+another, on the same frame, with nothing on the page saying so.
+
+**Restrict a frame with a default to panes over one model.** Considered
+and rejected as an unnecessary restriction on `Pane`, which already
+allows any model with a `janela` block. The mismatch is the default's
+problem to solve, not a new constraint on what a frame may hold.
+
+## Decision
+
+**A frame's default filter names the one model it narrows, and only a
+pane over that model takes it.** `Janela::Frame` gains two columns,
+`default_model` and `default_where`, both nullable and present or
+absent together:
+
+```ruby
+frame.update!(default_model: "orders", default_where: { "status_not_eq" => "archived" })
+```
+
+**`default_model` is validated the same way `Pane#model` already is**:
+blank, or a route key naming a model with a `janela` block, checked
+through `Janela.definition!` and rescued the same way
+`declared_by_a_janela_block` does. It does not have to match any pane
+the frame currently holds. A frame can carry a default before its first
+matching pane exists, and a pane over a different model is simply never
+narrowed by it, no error, because the condition was never claimed to be
+about it.
+
+**`default_where` is validated against that one model's `Definition` at
+save time**, not only discovered wrong at render. `Definition#narrow`
+already runs `Ransack#ransack` and the three checks ADR 025 built
+(dropped filters, disallowed predicates, oversized value lists); a new
+validation calls it against `default_model`'s definition and turns a
+raised `Janela::BadRequest` into a validation error on `default_where`,
+the same sentence a request would have raised, read at the point an
+analyst can still fix it. This is new ground: nothing today validates a
+persisted, arbitrary Ransack condition at save time, only `fixed` and
+the reader's `q[...]`, which are validated fresh on every render because
+neither is ever stored.
+
+**It composes as a third layer, ahead of the two ADR 040 already
+built.** `Pane#query` asks its frame for the default that applies to its
+own model and passes it to `Query`, which narrows with it before `fixed`
+narrows again, before the reader's own filters:
+
+```ruby
+# Janela::Frame
+def default_for(model)
+  default_model == model.model_name.route_key ? default_where.to_h : {}
+end
+
+# Janela::Query#result
+on = definition.narrow(on || model.all, default) if default.present?  # frame, permanent
+on = definition.narrow(on, fixed) if fixed.present?                   # host, per-record (ADR 040)
+definition.query(measure, by: dimension, where: applicable_filters, on: on, ...) # reader
+```
+
+Applied even on a pane's own dimension, the same as `fixed`: the point
+of "this queue never counts an archived row" is that no pane on it ever
+shows archived as one of its own bars either. Nothing the reader does
+in `q[...]` can remove it, for the same reason nothing the reader does
+can remove a host's fixed filter.
+
+**Only a stored frame can have one.** A hand composed `janela_frame do
+... end` block has no `Frame` row for a default to live on; a host
+composing a page in ERB already writes its own permanent conditions in
+its own code, in one place, which is what ADR 012 left unchanged for
+that path. This is additive to the data-driven half only.
+
+**Vocabulary, so the three layers stay distinct.** *Default* is the
+frame's own, permanent, data. *Fixed* stays ADR 040's word for the
+host's own, per-record, code. *Filters*, or `q[...]`, stays the
+reader's. Three words, three owners, and none of them is allowed to
+mean another.
+
+## Consequences
+
+- An analyst declares "this queue never counts an archived row" once,
+  as a row, and it holds across every page that ever renders the frame,
+  including one that does not exist yet.
+- **A stale default is a frame-wide failure, not a pane-wide one.**
+  If `default_model`'s `janela` block later drops the dimension
+  `default_where` names, every pane over that model in the frame raises
+  at render, the same "missing pane" treatment `declared_by_a_janela_block`
+  already gives a stale measure or dimension, just wider: one condition
+  now speaks for every pane that shares its model rather than for one
+  row. Worth a line in the engine's own edit form once built.
+- `janela_frames` gains `default_model` and `default_where`, both
+  nullable. Existing frames are unaffected either way; needs a migration
+  and an `UPGRADING.md` entry (ADR 015).
+- **Not decided here: a frame with panes over two models, each wanting
+  its own permanent default.** One `(model, where)` pair per frame is
+  what is built. A second model needing one of its own is the trigger to
+  revisit this as a has-many rather than a second pair of columns, the
+  same way ADR 040 left a signed filter for the day a host's need for
+  one is real rather than guessed at.
+- The engine's own frame form needs a way to set both columns together,
+  and to clear both together; not built here.
+- What would change this decision: a host needing a permanent filter
+  that is not one model's own condition, such as one spanning an
+  association two different pane models both reach through. Nothing
+  proposes that today.

data/docs/decisions/INDEX.md

@@ -27,10 +27,10 @@ them when in doubt: `grep -l "Triggers:.*fork" docs/decisions/*.md`.
 | **Authorisation** | 002, 003, 004, 009, 017, 019, 022, 032, 033, 034, 035, 039, 040 |
 | **Performance & storage** | 007, 017, 025 |
 | **Ordering & formatting** | 007, 020, 038 |
-| **Cross-filtering & Hotwire** | 003, 004, 005, 008, 024, 025, 040 |
+| **Cross-filtering & Hotwire** | 003, 004, 005, 008, 024, 025, 040, 043 |
 | **Layouts & views** | 011, 012, 016, 018, 020, 027, 039 |
 | **CSS & styling** | 016, 018, 023, 026, 027, 036, 042 |
-| **Frames, panes & persistence** | 012, 013, 014, 019, 029, 030, 033, 039, 040, 041 |
+| **Frames, panes & persistence** | 012, 013, 014, 019, 029, 030, 033, 039, 040, 041, 043 |
 | **Naming rule** | 014, 023, 036 |
 | **JavaScript delivery & charts** | 004, 006, 026, 042 |
 | **Time dimensions** | 006, 025 |
@@ -90,7 +90,8 @@ them when in doubt: `grep -l "Triggers:.*fork" docs/decisions/*.md`.
 | 040 | A Host Can Fix a Frame's Filter, and No Click Removes It | 2026-09-24 | Accepted |
 | 041 | A Host Finds Its Frame by Owner and Key | 2026-09-24 | Accepted |
 | 042 | A Chart's Title Is a Figcaption, and the Canvas Points to It | 2026-09-28 | Accepted |
+| 043 | A Frame's Default Filter Names the Model It Narrows | 2026-09-28 | Accepted |
 
 ## Next number
 
-Next ADR: 043
+Next ADR: 044

data/docs/theming.md

@@ -31,7 +31,7 @@ Three, and setting them moves everything that depends on them.
 | --- | --- | --- |
 | `--janela-space` | `0.25rem` | The base unit of the whole spacing scale. Every gap and padding is a multiple of it. |
 | `--janela-line` | `rgba(128, 128, 128, 0.3)` | Rules between rows, borders on cards and fields. |
-| `--janela-accent` | `rgb(54, 162, 235)` | A selected value, a hovered card. |
+| `--janela-accent` | `rgb(54, 162, 235)` | A selected value, a hovered card, a chart's bars (#62). |
 
 ```css
 :root {

data/lib/janela/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: janela
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Jay Killeen
@@ -141,6 +141,7 @@ files:
 - db/migrate/20260921000001_add_owner_to_janela_snapshots.rb
 - db/migrate/20260924000001_add_content_to_janela_panes.rb
 - db/migrate/20260924000002_add_key_to_janela_frames.rb
+- db/migrate/20260928000001_add_default_filter_to_janela_frames.rb
 - docs/composing.md
 - docs/decisions/001-built-to-be-forked.md
 - docs/decisions/002-measures-and-dimensions-over-ransack.md
@@ -184,6 +185,7 @@ files:
 - docs/decisions/040-a-host-can-fix-a-frames-filter.md
 - docs/decisions/041-a-host-finds-its-frame-by-owner-and-key.md
 - docs/decisions/042-a-charts-title-is-a-figcaption.md
+- docs/decisions/043-a-frames-default-filter-names-the-model-it-narrows.md
 - docs/decisions/INDEX.md
 - docs/multi-tenancy.md
 - docs/naming.md
@@ -209,22 +211,14 @@ metadata:
   bug_tracker_uri: https://github.com/retail-tasker/janela/issues
   rubygems_mfa_required: 'true'
 post_install_message: |
-  Janela 0.9.0: a migration if you use stored frames, and a markup
-  check if you wrote CSS or JavaScript against a chart pane.
+  Janela 0.10.0: a migration if you use stored frames. Nobody else
+  has anything to do.
 
-  1. If you use stored frames, take two migrations together:
-     bin/rails janela:install:migrations && bin/rails db:migrate
-     A pane can now hold words or a host partial instead of a query
-     (ADR 039), and Janela::Frame.for(owner, key) finds a frame kept
-     for one of your pages without a column of your own (ADR 041).
-     Existing frames and panes are unaffected either way.
-
-  2. A chart pane's title is now a visible <figcaption> inside a
-     <figure> wrapping the canvas, not only the canvas's aria-label
-     (ADR 042). janela-pane moved from the <canvas> to the <figure>;
-     janela-chart stayed on the canvas. If you selected
-     .janela-pane.janela-chart as one element, or read a chart's
-     title from aria-label, both need updating.
+  A frame can now carry its own permanent filter as data, not only
+  the per-record one you pass in code (ADR 043):
+    bin/rails janela:install:migrations && bin/rails db:migrate
+  janela_frames gains default_model and default_where, both nil on
+  every existing frame. Nothing changes unless you set them.
 
   Steps: UPGRADING.md in this gem, or
   https://github.com/retail-tasker/janela/blob/main/UPGRADING.md