stimulus_plumbers 0.4.14 → 0.4.16

data/lib/stimulus_plumbers/plumber/config.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Plumber
+    # Sibling of Slots for block DSLs whose payload is configuration, not content.
+    # Slots captures blocks through the view; Config only stores values, and holds
+    # the template to pass on to renderers.
+    #
+    # The store is private. Slots publishes `resolve` because its payload is uniform
+    # content a renderer reads generically; a Config's settings are typed, so each
+    # subclass exposes its own named readers instead.
+    class Config
+      attr_reader :template
+
+      def initialize(template = nil)
+        @template = template
+        @config = {}
+      end
+
+      private
+
+      # Returns nil so a subclass's DSL method reads as a command, not a value.
+      def configure(name, value)
+        @config[name] = value
+        nil
+      end
+
+      def config(name)
+        @config[name]
+      end
+
+      def configured?(name)
+        @config.key?(name)
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/plumber/dispatcher/callable_inspector.rb

@@ -13,6 +13,10 @@ module StimulusPlumbers
         def accepts_kwargs?(callable)
           callable.parameters.any? { |type, _| %i[key keyreq keyrest].include?(type) }
         end
+
+        def accepts_block?(callable)
+          callable.parameters.any? { |type, _| type == :block }
+        end
       end
     end
   end

data/lib/stimulus_plumbers/plumber/slots.rb

@@ -37,8 +37,10 @@ module StimulusPlumbers
         @template ? @template.capture(&block) : block.call
       end
 
+      # Returns nil so a subclass's `with_*` method reads as a command, not a value.
       def set_slot(name, value, options = {})
         @slots[name] = { value: value, options: options }
+        nil
       end
 
       class << self
@@ -55,7 +57,6 @@ module StimulusPlumbers
         def define_flat_slot(name)
           define_method(:"with_#{name}") do |value = nil, **opts, &block|
             set_slot(name, block || value, opts)
-            nil
           end
         end
 
@@ -64,7 +65,6 @@ module StimulusPlumbers
             sub = by.new(@template)
             block&.call(sub)
             set_slot(name, sub)
-            nil
           end
         end
 

data/lib/stimulus_plumbers/themes/schema/progress/ranges.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Themes
+    module Schema
+      module Progress
+        module Ranges
+          PLACEMENT = %i[inside outside].freeze
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/themes/schema.rb

@@ -11,6 +11,7 @@ require_relative "schema/form/ranges"
 require_relative "schema/form/checkbox/ranges"
 require_relative "schema/form/floating/ranges"
 require_relative "schema/form/radio/ranges"
+require_relative "schema/progress/ranges"
 require_relative "schema/icon"
 
 module StimulusPlumbers
@@ -159,6 +160,12 @@ module StimulusPlumbers
           error:    { default: false, validate: Ranges::BOOL },
           floating: { default: nil,   validate: [nil, *Form::Floating::Ranges::TYPE] }
         }.freeze,
+        password_strength_wrapper:              {}.freeze,
+        password_strength_rules_heading:        {}.freeze,
+        password_strength_rules:                {}.freeze,
+        password_strength_rule:                 {}.freeze,
+        password_strength_rule_icon:            {}.freeze,
+        password_strength_level:                {}.freeze,
         form_field_input_select:                {
           error:    { default: false, validate: Ranges::BOOL },
           floating: { default: nil,   validate: [nil, *Form::Floating::Ranges::TYPE] }
@@ -173,6 +180,10 @@ module StimulusPlumbers
           type:    { default: :default,  validate: Form::Radio::Ranges::TYPE },
           variant: { default: :tertiary, validate: Form::Radio::Ranges::VARIANT }
         }.freeze,
+        form_field_input_progress:              {}.freeze,
+        form_field_input_range:                 {}.freeze,
+        form_field_input_range_group:           {}.freeze,
+        form_field_input_range_value:           {}.freeze,
         form_field_input_combobox:              {
           error:    { default: false, validate: Ranges::BOOL },
           floating: { default: nil,   validate: [nil, *Form::Floating::Ranges::TYPE] }
@@ -249,11 +260,19 @@ module StimulusPlumbers
         popover:           {}.freeze
       }.freeze
 
+      # The outside readout gets its own keys, not parameters on existing ones — a theme method
+      # written before them has no keyword to accept.
       PROGRESS = {
-        progress_bar:      {}.freeze,
-        progress_bar_fill: {}.freeze,
-        progress_ring:     {}.freeze,
-        progress_meter:    {}.freeze
+        progress_bar:               { labelled: { default: false, validate: Ranges::BOOL } }.freeze,
+        progress_bar_group:         {}.freeze,
+        progress_bar_fill:          {}.freeze,
+        progress_bar_value:         {}.freeze,
+        progress_bar_value_outside: {}.freeze,
+        progress_segment_group:     {}.freeze,
+        progress_segment:           {}.freeze,
+        progress_segment_fill:      {}.freeze,
+        progress_ring:              { size: { default: nil, validate: %i[sm md lg] } }.freeze,
+        progress_meter:             {}.freeze
       }.freeze
 
       TIMELINE = {

data/lib/stimulus_plumbers/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StimulusPlumbers
-  VERSION = "0.4.14"
+  VERSION = "0.4.16"
 end

data/lib/stimulus_plumbers.rb

@@ -13,8 +13,11 @@ require_relative "stimulus_plumbers/logger"
 # -- Plumber base --
 require_relative "stimulus_plumbers/plumber/dispatcher"
 require_relative "stimulus_plumbers/plumber/slots"
+require_relative "stimulus_plumbers/plumber/config"
 require_relative "stimulus_plumbers/plumber/base"
 
+require_relative "stimulus_plumbers/password/requirements"
+
 # -- UI components --
 require_relative "stimulus_plumbers/components/icon"
 require_relative "stimulus_plumbers/components/indicator"
@@ -46,9 +49,11 @@ require_relative "stimulus_plumbers/components/input_group"
 require_relative "stimulus_plumbers/components/popover"
 require_relative "stimulus_plumbers/components/popover/trigger"
 require_relative "stimulus_plumbers/components/popover/panel"
+require_relative "stimulus_plumbers/components/progress/shared"
 require_relative "stimulus_plumbers/components/progress_bar"
 require_relative "stimulus_plumbers/components/progress_ring"
 require_relative "stimulus_plumbers/components/progress_meter"
+require_relative "stimulus_plumbers/components/password_strength"
 
 # -- Calendar --
 require_relative "stimulus_plumbers/components/calendar"
@@ -70,7 +75,7 @@ require_relative "stimulus_plumbers/components/combobox/date/navigation"
 require_relative "stimulus_plumbers/components/combobox/dropdown"
 require_relative "stimulus_plumbers/components/combobox/typeahead"
 require_relative "stimulus_plumbers/components/combobox/time"
-require_relative "stimulus_plumbers/components/combobox/builder"
+require_relative "stimulus_plumbers/components/combobox/config"
 
 # -- Form --
 require_relative "stimulus_plumbers/form/field"
@@ -94,3 +99,4 @@ module StimulusPlumbers
 end
 
 require_relative "stimulus_plumbers/engine" if defined?(Rails::Engine)
+require_relative "stimulus_plumbers/password_strength_validator" if defined?(ActiveModel::EachValidator)

data/vendor/ARIA.md

@@ -97,6 +97,16 @@ Two helper classes handle keyboard navigation in controllers — see [`stimulus-
 - Accepted tradeoff: because `indeterminate` has no HTML attribute, the server can only render the master's initial `checked` state for the all-true case; every other case (including mixed) renders unchecked and is corrected to `indeterminate` once the `checklist` controller connects — a brief, accepted flash for the mixed case only.
 - Disabled (readonly) items are excluded from the master's aggregate and from bulk toggling — the `checklist` controller filters them out via their own `.disabled` property, mirroring their exclusion from tab order and AT interaction.
 
+#### Progress (`progress_controller`, `sp_progress_*`)
+- `role="progressbar"` is read-only and never focusable — it reports a value, it does not accept one. An interactive equivalent is a native `<input type="range">` (or `role="slider"`), not a progressbar with `tabindex`
+- Value: `aria-valuemin`/`aria-valuemax` always; `aria-valuenow` omitted while indeterminate (an omitted `valuenow` is what signals "unknown progress" to AT)
+- `aria-valuetext` only when the readout text is not derivable from `aria-valuenow` — set for the `value`/`value_max` formats, deliberately **not** for `percent`, where AT already computes the percentage and a duplicate would be announced twice
+- On-screen readout is `aria-hidden="true"` — the value reaches AT through `aria-valuenow`/`aria-valuetext`, so exposing the span too would double-announce it
+- Name: `aria-label` standalone, or `aria-labelledby` → a visible caption. `<label for>` cannot name a progressbar — `for=` is only valid against a labelable element (`button`, `input`, `meter`, `output`, `progress`, `select`, `textarea`), so a `<div role="progressbar">` targeted by one is silently left unnamed (WCAG 4.1.2). Form fields rendering a progressbar therefore emit a `<span>` caption, not a `<label>`
+- No `aria-invalid`/`aria-required` on a progressbar — neither is supported on the role, and it submits nothing that could be invalid. Errors still attach via `aria-describedby`
+- Segment slots are decorative (`aria-hidden="true"`) — the value is announced once, by the container
+- The `range` variant drives a native `<input type="range">` and writes **no** ARIA: the native control already exposes slider role, value, and keyboard operation, and duplicating them announces worse than leaving them alone. It keeps an ordinary `<label for>` because an `input` is labelable
+
 #### Avatar / Card / Icon
 - Decorative images/icons: `aria-hidden="true"` or `alt=""`
 - Meaningful images: descriptive `alt` text

data/vendor/component/manifest.json

@@ -155,6 +155,14 @@
     "targets": [],
     "values": []
   },
+  "password-strength": {
+    "actions": [
+      "score"
+    ],
+    "listens": [],
+    "targets": [],
+    "values": []
+  },
   "popover": {
     "actions": [
       "close",
@@ -166,20 +174,26 @@
     "values": []
   },
   "progress": {
-    "actions": [],
+    "actions": [
+      "refresh"
+    ],
     "listens": [],
     "targets": [
       "fill",
-      "meter"
+      "input",
+      "meter",
+      "value"
     ],
     "values": [
       "current",
+      "format",
       "high",
       "indeterminate",
       "low",
       "max",
       "min",
       "optimum",
+      "segmentMode",
       "variant"
     ]
   },

data/vendor/controller/docs/password-strength.md

@@ -0,0 +1,38 @@
+# password-strength
+
+Live password meter and requirements checklist. Scoring is provided by the [password strength plumber](../plumber/password_strength.md).
+
+## Targets
+
+| Target                    | Element   | Description                                             |
+| ------------------------- | --------- | ------------------------------------------------------- |
+| `input`                   | `<input>` | Password input to score                                 |
+| `rule`                    | `<li>`    | Requirement row with `data-rule` and `data-satisfied`   |
+| `level`                   | Element   | Visible, polite live strength label                     |
+| `checkIcon` / `closeIcon` | `<svg>`   | Paired rule-state icons; both are required for swapping |
+
+## Values and outlet
+
+| Name              | Type       | Default   |
+| ----------------- | ---------- | --------- |
+| `scorer`          | String     | `'rules'` |
+| `rules`           | Array      | `[]`      |
+| `options`         | Object     | `{}`      |
+| `labels`          | Object     | `{}`      |
+| `announceDelay`   | Number     | `700`     |
+| `progress` outlet | Controller | —         |
+
+`score()` is wired to the input event. It updates the progress outlet immediately and debounces level-label changes.
+
+## Rule descriptors
+
+The controller holds no built-in rule table — the server (or a standalone caller) supplies every rule as data via the `rules` value. Each descriptor is `{ key, label?, pattern?, min?, max? }` and passes when `min ≤ n ≤ max`, where `n` is:
+
+- **length** (no `pattern`) — the password length.
+- **count** (with `pattern`) — non-overlapping occurrences of `pattern`: `(pw.match(new RegExp(pattern, "g")) || []).length`.
+
+Defaults: `min` `0`, `max` `Infinity`. So `{ pattern: "\\d", min: 2 }` requires ≥2 digits, and `{ pattern: "\\s", min: 0, max: 0 }` forbids whitespace.
+
+**Portability constraint:** patterns must be single-char-consuming character classes — no anchors (`^`/`$`), lookbehind, or unicode-property escapes — so non-overlapping counts agree across the Ruby and JS regex engines.
+
+The strength `level` is `strong` when every rule passes; otherwise the score (`satisfied / total × 100`) splits `weak` from `fine` at `options.low` (default `34`). `options` carries only these non-rule knobs.

data/vendor/controller/docs/progress.md

@@ -1,6 +1,6 @@
 # Progress
 
-Value-driven progress indicator supporting three render variants: a linear bar, an SVG ring, and a native `<meter>`.
+Value-driven progress indicator supporting five render variants: a linear bar, a segmented bar, an SVG ring, a native `<meter>`, and a native `<input type="range">`.
 
 ## Stimulus Identifier
 
@@ -8,37 +8,58 @@ Value-driven progress indicator supporting three render variants: a linear bar,
 
 ## Targets
 
-| Name    | Element                           | Purpose                                                                             |
-| ------- | --------------------------------- | ----------------------------------------------------------------------------------- |
-| `fill`  | `<div>` (bar) / `<circle>` (ring) | Element whose `width` (bar) or `stroke-dasharray`/`stroke-dashoffset` (ring) is set |
-| `meter` | `<meter>`                         | Present only for `variant: "meter"` — native element, attributes synced directly    |
+| Name    | Element                           | Purpose                                                                                                                                                                             |
+| ------- | --------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `fill`  | `<div>` (bar) / `<circle>` (ring) | Element whose `width` (bar) or `stroke-dasharray`/`stroke-dashoffset` (ring) is set. Segmented renders **one `fill` per segment**; the controller distributes the value across them |
+| `meter` | `<meter>`                         | Present only for `variant: "meter"` — native element, attributes synced directly                                                                                                    |
+| `value` | `<span>`                          | Optional on-screen readout; its `textContent` is set from `format`. Bar and range variants                                                                                          |
+| `input` | `<input type="range">`            | Range-only, and only when a readout is present — the controller then sits on a wrapper containing both                                                                              |
 
 ## Values
 
-| Name                    | Type    | Default | Purpose                                                                   |
-| ----------------------- | ------- | ------- | ------------------------------------------------------------------------- |
-| `variant`               | String  | `"bar"` | `"bar"` \| `"ring"` \| `"meter"`                                          |
-| `current`               | Number  | `0`     | Current value                                                             |
-| `min`                   | Number  | `0`     | Range minimum                                                             |
-| `max`                   | Number  | `100`   | Range maximum                                                             |
-| `optimum`               | Number  | —       | Meter-only; maps to native `<meter optimum>`                              |
-| `low`                   | Number  | —       | Meter-only; maps to native `<meter low>`                                  |
-| `high`                  | Number  | —       | Meter-only; maps to native `<meter high>`                                 |
-| `indeterminate`         | Boolean | `false` | Suppresses `aria-valuenow`; toggles the `sp-progress-indeterminate` class |
-| `indeterminateFraction` | Number  | `0.25`  | Static bar width / ring arc fraction rendered while indeterminate         |
+| Name                    | Type    | Default      | Purpose                                                                                                                                |
+| ----------------------- | ------- | ------------ | -------------------------------------------------------------------------------------------------------------------------------------- |
+| `variant`               | String  | `"bar"`      | `"bar"` \| `"segmented"` \| `"ring"` \| `"meter"` \| `"range"`                                                                         |
+| `current`               | Number  | `0`          | Current value                                                                                                                          |
+| `min`                   | Number  | `0`          | Range minimum                                                                                                                          |
+| `max`                   | Number  | `100`        | Range maximum                                                                                                                          |
+| `optimum`               | Number  | —            | Meter-only; maps to native `<meter optimum>`                                                                                           |
+| `low`                   | Number  | —            | Meter-only; maps to native `<meter low>`                                                                                               |
+| `high`                  | Number  | —            | Meter-only; maps to native `<meter high>`                                                                                              |
+| `indeterminate`         | Boolean | `false`      | Suppresses `aria-valuenow`; toggles the `sp-progress-indeterminate` class                                                              |
+| `indeterminateFraction` | Number  | `0.25`       | Bar width / ring arc / segment chunk-width fraction rendered while indeterminate                                                       |
+| `segmentMode`           | String  | `"discrete"` | Segmented-only. `"discrete"` lights a whole segment once progress reaches into it; `"continuous"` partially fills the boundary segment |
+| `format`                | String  | `""`         | Readout text for the `value` target: `"percent"` \| `"value"` \| `"value_max"`. Empty or unrecognized renders nothing                  |
+
+### Readout formats
+
+| `format`      | Renders   | `aria-valuetext` |
+| ------------- | --------- | ---------------- |
+| `"percent"`   | `45%`     | not set          |
+| `"value"`     | `45`      | `45`             |
+| `"value_max"` | `45 / 60` | `45 / 60`        |
+
+`percent` omits `aria-valuetext` — assistive technology derives the percentage from `aria-valuenow` itself, so setting it would only duplicate what AT already announces. The readout element is decorative (`aria-hidden`); the value reaches AT through `aria-valuenow`/`aria-valuetext`.
+
+The `range` variant writes no `aria-value*` at all — a native `<input type="range">` already exposes its own slider semantics — and sets `--sp-progress-percent` on the input so a theme can paint the filled portion of the track.
+
+The `bar` variant sets `--sp-progress-percent` too, on the controller element, alongside the fill target's width. A theme can use it to split the readout's color at the fill edge. It is unset until the controller connects, so read it as `var(--sp-progress-percent, 0)` to match the server-rendered (empty) fill.
+
+The rendered number is the value clamped to `[min, max]`, so an out-of-range `current` reads as the nearest bound rather than an impossible percentage. An empty or inverted range (`max <= min`) renders `0%`. While `indeterminate`, the readout is blank and `aria-valuetext` is removed.
 
 ## Methods
 
-| Method                       | Wired via               | Purpose                                                                                                   |
-| ---------------------------- | ----------------------- | --------------------------------------------------------------------------------------------------------- |
-| `setValue(value)`            | —                       | Programmatic API — clamps to `[min, max]`, updates `currentValue`, dispatches `progress:changed`          |
-| `currentValueChanged(value)` | Stimulus value callback | Recalculates fill/meter attrs whenever `current` changes (covers `setValue()` and direct attribute edits) |
+| Method                       | Wired via                 | Purpose                                                                                                   |
+| ---------------------------- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
+| `setValue(value)`            | —                         | Programmatic API — clamps to `[min, max]`, updates `currentValue`, dispatches `progress:changed`          |
+| `currentValueChanged(value)` | Stimulus value callback   | Recalculates fill/meter attrs whenever `current` changes (covers `setValue()` and direct attribute edits) |
+| `refresh()`                  | `input->progress#refresh` | Range-only. Reads the native input's value and passes it to `setValue()`                                  |
 
 ## Dispatches
 
-| Event              | Detail                | When                                 |
-| ------------------ | --------------------- | ------------------------------------ |
-| `progress:changed` | `{ value, min, max }` | After `setValue()` updates the value |
+| Event              | Detail                | When                                                                                   |
+| ------------------ | --------------------- | -------------------------------------------------------------------------------------- |
+| `progress:changed` | `{ value, min, max }` | After `setValue()` updates the value — including a range drag, which routes through it |
 
 ## Example HTML
 
@@ -54,6 +75,34 @@ Value-driven progress indicator supporting three render variants: a linear bar,
   <div data-progress-target="fill"></div>
 </div>
 
+<!-- Bar with an on-screen readout -->
+<div
+  role="progressbar"
+  data-controller="progress"
+  data-progress-current-value="45"
+  data-progress-max-value="100"
+  data-progress-format-value="percent"
+>
+  <div data-progress-target="fill"></div>
+  <span data-progress-target="value" aria-hidden="true">45%</span>
+</div>
+
+<!-- Segmented — one fill per segment; number of segments = number of fill targets -->
+<div
+  role="progressbar"
+  data-controller="progress"
+  data-progress-variant-value="segmented"
+  data-progress-current-value="6"
+  data-progress-max-value="10"
+>
+  <!-- ×5 slots → segment size 2 -->
+  <div aria-hidden="true"><div data-progress-target="fill"></div></div>
+  <div aria-hidden="true"><div data-progress-target="fill"></div></div>
+  <div aria-hidden="true"><div data-progress-target="fill"></div></div>
+  <div aria-hidden="true"><div data-progress-target="fill"></div></div>
+  <div aria-hidden="true"><div data-progress-target="fill"></div></div>
+</div>
+
 <!-- Ring -->
 <svg
   role="progressbar"
@@ -75,6 +124,34 @@ Value-driven progress indicator supporting three render variants: a linear bar,
   data-progress-max-value="100"
 ></meter>
 
+<!-- Range — no readout, so the controller sits on the input itself -->
+<input
+  type="range"
+  min="0"
+  max="100"
+  value="45"
+  style="--sp-progress-percent: 45"
+  data-controller="progress"
+  data-progress-variant-value="range"
+  data-progress-current-value="45"
+  data-progress-min-value="0"
+  data-progress-max-value="100"
+  data-action="input->progress#refresh"
+/>
+
+<!-- Range with a readout — a target must be a descendant, so a wrapper hosts the controller -->
+<div
+  data-controller="progress"
+  data-progress-variant-value="range"
+  data-progress-current-value="45"
+  data-progress-max-value="100"
+  data-progress-format-value="percent"
+  data-action="input->progress#refresh"
+>
+  <input type="range" min="0" max="100" value="45" style="--sp-progress-percent: 45" data-progress-target="input" />
+  <span data-progress-target="value" aria-hidden="true">45%</span>
+</div>
+
 <!-- Indeterminate -->
 <div role="progressbar" data-controller="progress" data-progress-indeterminate-value="true">
   <div data-progress-target="fill"></div>

data/vendor/controller/guide.md

@@ -3,14 +3,68 @@
 For a non-Rails / plain JS consumer of `@stimulus-plumbers/controllers`. Rails apps get this wired
 automatically via the `stimulus_plumbers` gem's `sp_*` helpers — skip this guide for Rails.
 
+## Install
+
 ```bash
-npm install @stimulus-plumbers/controllers
+npm install @hotwired/stimulus @stimulus-plumbers/controllers
+```
+
+## Register
+
+Every controller is a named export. Import the ones you use and register each under its identifier:
+
+```javascript
+import { Application } from '@hotwired/stimulus';
+import { PopoverController, ProgressController, ComboboxDateController } from '@stimulus-plumbers/controllers';
+
+const application = Application.start();
+
+application.register('popover', PopoverController);
+application.register('progress', ProgressController);
+application.register('combobox-date', ComboboxDateController);
+```
+
+The export name is the identifier in PascalCase plus `Controller` — `combobox-date` →
+`ComboboxDateController`. For the full identifier list ask `list_controllers` / read
+`controller://index`; each one's targets, values, classes, outlets, and events are in
+`get_controller_schema(name: identifier)` — `name:` is the identifier (`combobox-date`), not the
+export name. Narrative docs come from `get_controller_docs(name: family)`, which takes the family
+(`combobox`) rather than the identifier; `list_controller_docs` lists the families. Outside MCP, the
+[Controllers table](https://github.com/ryancyq/stimulus-plumbers/blob/main/stimulus-plumbers/README.md#controllers)
+lists the same identifiers.
+
+Registering a controller the page never uses is harmless — Stimulus only instantiates on a matching
+`data-controller`.
+
+## Wire the markup
+
+Interactive components (combobox, popover, calendar) expect their `data-controller`, target, and
+value attributes to already be present in the rendered HTML. Rails apps get these from `sp_*`
+helpers; a plain-JS setup writes them by hand, following the HTML structure in each controller's
+doc:
+
+```html
+<div
+  role="progressbar"
+  data-controller="progress"
+  data-progress-current-value="30"
+  data-progress-min-value="0"
+  data-progress-max-value="100"
+>
+  <div data-progress-target="fill"></div>
+</div>
 ```
 
-Import and register each controller you use with your Stimulus application — see
-[README.md](../README.md#setup) for the full import + `application.register(...)` list and the
-[Controllers table](../README.md#controllers) for identifiers and their docs.
+Markup shape is per-controller — take the authoritative structure from `get_controller_docs(name:)`
+rather than adapting this example.
+
+## Styling
+
+Controllers ship no CSS; they toggle classes and attributes only. Bring your own styles, or use the
+`stimulus_plumbers_tailwind` gem's token set (`guide://tailwind`).
+
+## Accessibility
 
-Interactive components (combobox, popover, calendar) expect their `data-controller` attributes to
-already be present in the rendered HTML — Rails apps get these from `sp_*` helpers; a plain-JS setup
-must add them manually per each controller's doc.
+Keyboard, focus, and ARIA behaviour per component is in `aria://reference` — read it before
+hand-writing markup, since the controllers assume the documented roles and relationships are
+present.

data/vendor/controller/manifest.json

@@ -558,6 +558,53 @@
     "actions": [],
     "dispatches": []
   },
+  "password-strength": {
+    "identifier": "password-strength",
+    "targets": [
+      "input",
+      "rule",
+      "level",
+      "checkIcon",
+      "closeIcon"
+    ],
+    "values": {
+      "scorer": {
+        "type": "String",
+        "default": "rules"
+      },
+      "rules": {
+        "type": "Array",
+        "default": []
+      },
+      "options": {
+        "type": "Object",
+        "default": {}
+      },
+      "labels": {
+        "type": "Object",
+        "default": {}
+      },
+      "announceDelay": {
+        "type": "Number",
+        "default": 700
+      }
+    },
+    "outlets": [
+      "progress"
+    ],
+    "classes": [],
+    "actions": [
+      "announce",
+      "constructor",
+      "drawIcons",
+      "drawRules",
+      "enhance",
+      "if",
+      "readValue",
+      "score"
+    ],
+    "dispatches": []
+  },
   "popover": {
     "identifier": "popover",
     "targets": [
@@ -616,7 +663,9 @@
     "identifier": "progress",
     "targets": [
       "fill",
-      "meter"
+      "input",
+      "meter",
+      "value"
     ],
     "values": {
       "variant": {
@@ -643,6 +692,14 @@
         "type": "Number",
         "default": 0.25
       },
+      "segmentMode": {
+        "type": "String",
+        "default": "discrete"
+      },
+      "format": {
+        "type": "String",
+        "default": ""
+      },
       "optimum": {
         "type": "Number"
       },
@@ -657,11 +714,16 @@
     "classes": [],
     "actions": [
       "clamp",
+      "formattedValue",
       "percent",
+      "refresh",
       "render",
       "renderBar",
       "renderMeter",
+      "renderRange",
       "renderRing",
+      "renderSegmented",
+      "renderValueText",
       "setCircumference",
       "setValue"
     ],