Midwest Component Library v0.28.2

Previews

No matching results.

🗺️ Roadmap

This roadmap groups items from the Future Plans reference into versioned milestones. Each minor release targets 2–3 new components and 5–6 improvements to existing ones. Ordering reflects priority and implementation dependency, not a delivery commitment.

v0.25 — Motion, Maps, Audio & Animation

Parallax effects, maps, web audio, and motion system.

Complete. Most of this milestone landed ahead of schedule in the v0.24.x line — Motion Primitives (MotionComponent) plus the five motion-consistency improvements below shipped in v0.24.1, and Maps, Geocoding, Address Autocomplete, and Page Transitions shipped in v0.24.4. The remaining items — the get_motion_system and get_performance_characteristics MCP tools, the static AST/dependency-graph export (bin/ast), the get_bundle_analysis tool pulled forward from v0.26, and the FormComponent autosave/ajax/close-on-success behaviors — all shipped in v0.25.0. Parallax, Web Audio, and the Animation Controller/API were cut from the milestone (see below).

New Components

  • Social Preview: Threads, Bluesky ✅ — Newer text-based social platform previews extending the SocialPreview::BasePlatformComponent pattern. ThreadsComponent (wordmark header, thread-line option, reply/repost/like/send actions, optional engagement summary) and BlueskyComponent (sky-blue wordmark, inline per-action counts, link preview card, quote-post support). Both wired into the parent orchestrator (PLATFORM_MAP) and Lookbook previews
  • Parallax ❌ — Cut. Scroll-driven parallax de-scoped from the pre-1.0 roadmap
  • Map & Geocoding ✅ (v0.24.4) — Interactive maps with three interchangeable providers. MapComponent renders via Leaflet (open-source, no key), Apple MapKit JS, or Google Maps, selected once through Midwest.configure; nothing is loaded until a provider is set (privacy-first default). Four map types (:muted default, :standard, :hybrid, :satellite), auto/light/dark schemes, custom height, marker annotations (Midwest::Map::MarkerData or plain hashes), zoom/compass/user-location controls, callouts that open on load, and an accessible placeholder before init. MapKit auth via token:/token_url:; Midwest::MapKit.token(team_id:, key_id:, private_key:) generates ES256 JWTs and Midwest::MapKit::Authenticatable provides a self-refreshing endpoint. Also ships Form::AddressComponent (autocomplete with hidden lat/lng/place-id fields, optional inline map preview) and the Midwest::Geocodable model concern with Nominatim/MapKit/Google backends — the geocoder is configurable independently of the map renderer. Module-level CDN script deduplication prevents duplicate script injection when several maps mount at once
  • Web Audio ❌ — Cut. AudioContext suite de-scoped from the pre-1.0 roadmap
  • Motion Primitives ✅ — Native, zero-dependency reveal animations. MotionComponent wraps content and animates it in with one or more of five primitives (animation: takes a single value or an array — fade/slide/scale/rotate/blur, with direction: for slides); each primitive drives an independent CSS property (opacity, the individual translate/scale/rotate transform properties, and filter) so compounds like [:slide, :blur] layer cleanly; blur is a focus-in via animatable filter: blur(); a small midwest-motion Stimulus controller flips a single data-motion-visible attribute that CSS transitions animate against, driven by the shared motion tokens (duration:/easing: resolve --duration-*/--ease-*, or take raw values). trigger: :reveal (default) animates in on scroll-into-view via a midwest-motion Stimulus controller (threshold:, once: to replay on re-entry) that flips a data-motion-visible attribute; its hidden state is gated behind @media (scripting: enabled) and (prefers-reduced-motion: no-preference) so no-JS visitors see content with no flash. trigger: :load needs no controller at all — it animates in once on first render via a pure-CSS @starting-style entry (reduced-motion-gated). Both triggers share one set of --motion-from-* custom properties for the hidden state, so the reveal and load paths never drift. delay:/distance: round it out. Wired into the midwest_motion helper and Lookbook previews
  • Page Transitions ✅ — Turbo navigation transitions via the View Transitions API. PageTransitionComponent places once in the root layout body; a Stimulus controller injects the <meta name="view-transition" content="same-origin"> tag Turbo 8 requires and sets data-midwest-page-transition on <html> to scope CSS animations. Five styles: fade (default), slide (with direction: :left/:right/:up/:down), scale, and none. All respect prefers-reduced-motion. Duration and easing resolve through the motion token system. midwest_page_transition_name view helper sets view-transition-name for element-level morphing

MCP Server Features

  • Motion System Docs ✅ — get_motion_system MCP tool documents the motion system holistically: the standardized duration/easing scales (token-derived, with what each step is for), the slide-distance scale, the animation/direction/trigger vocabulary, the library-wide prefers-reduced-motion/no-JS contract, and how app-wide defaults are configured and resolved. Sectioned (strategy/durations/easings/distances/vocabulary/reduced_motion/configuration); complements per-component get_animation_info and raw-value get_design_tokens. MCP server now exposes 19 tools
  • Performance Characteristics ✅ — get_performance_characteristics MCP tool documents each component's rendering-cost tier (light/moderate/heavy) and dataset limits. Structural signals are derived from the code so they never drift (renders a collection via renders_many, ships a Stimulus controller, has looping keyframe motion); a curated data/performance.yml overlay adds recommended dataset sizes and scaling strategies (pagination, infinite scroll, lazy loading). Two modes: a per-component profile, or a library-wide overview ranking the dataset-sensitive components by tier. Derived cost caps at moderate — heavy is a curated judgement call, since structure alone can't tell a 4-step wizard from a 10k-row table. MCP server now exposes 20 tools
  • Static AST markdown/json files script ✅ (pulled forward from v0.26) — bin/ast generates static per-component AST files (options, slots, constants, methods, Stimulus values/targets/actions) plus a whole-library dependency graph — which components render which, from every render syntax: typed slots (renders_* :x, Midwest::YComponent), midwest_* helper calls in the ERB, direct render Midwest::YComponent.new in the ERB, and Midwest::YComponent.new constructions in the .rb definition (slot lambdas, helper methods) — with the inverse used-by. The Ruby side is parsed with Prism (a syntax-tree walk for .new on a Midwest::…Component constant, plus midwest_* helper calls — including helpers.midwest_* — "unfurled" to the component each helper renders), so it's immune to class names in comments, strings, is_a? checks, or < Superclass inheritance — no regex, no false edges. Template comments are stripped before scanning too, so a helper merely named in an ERB doc comment isn't mistaken for a render. This render graph lives in ComponentIndex (exposed as render_edges_for), so the get_component_relationships MCP tool now reports the same complete set instead of just midwest_* helpers. Each component gets a <name>.ast.json and a <name>.ast.md (the latter embeds a Mermaid graph TD visualizing its render edges, with the component itself highlighted) written into its own sidecar directory (so they travel with the component in the RubyGem via app/** and never reach the npm package, which ships only dist/** + app/assets/**); the aggregate graph.json, index.json, and DEPENDENCIES.md land in a top-level ast/ directory (shipped with the gem, not npm). Everything is derived from the same parsers the MCP server uses, so the files never drift; Tailwind @source not rules keep the JSON out of content scanning. Regenerated automatically by bin/build and staged by bin/release on every version cut. Logic lives in a testable Midwest::MCP::AstExporter; bin/ast also has summary (default) and graph commands. Backs documentation and the future bundle-analyzer / dependency-graph MCP features
  • Animation API ❌ — Cut. Documented the cancelled Animation Controller; de-scoped with it

Improvements

  • Motion System ✅ — Shipped with the v0.24.1 motion work: the standardized --duration-fast/base/slow/slower and --ease-standard/in/out/emphasized scales (tokens.css), the Midwest::Motion keyword→CSS vocabulary, the Motionable concern that gives every motion surface the same options, and app-wide defaults via Midwest.configure → --motion-default-*
  • Animation Controller ❌ — Cut. Runtime play/pause/seek transport controls de-scoped from the pre-1.0 roadmap
  • TooltipComponent — entrance driven by the shared motion system (animation:/direction:/duration:/distance:, config-aware defaults) ✅
  • DropdownComponent — desktop menu entrance driven by the shared motion system (rendered through midwest_motion, trigger: :hover); mobile keeps its bespoke bottom-sheet. Applies to every DropdownMenuComponent consumer (dropdown, breadcrumb dropdown, split button, nested submenus) ✅
  • PasswordRequirementsComponent — the anchored (popover) panel's entrance driven by the shared motion system (trigger: :hover); inline/static modes unchanged ✅
  • Form::AutocompleteComponent — desktop dropdown entrance driven by the shared motion system via an opt-in motion: flag on the shared PopoverComponent (trigger: :hover); mobile bottom-sheet unchanged. Other popover consumers (date/time pickers, confirmation) keep the flag off ✅
  • DialogComponent — the first nested element (.dialog-content) is rendered through midwest_motion (trigger: :load), so the inner content animates in on each open via the shared motion system; the native <dialog> keeps backdrop + top-layer + focus, and the panel variant keeps its right-edge slide ✅
  • FormComponent ✅ — midwest_form_with gains three opt-in behaviors driven by the midwest-form Stimulus controller: autosave: (debounced background submit on field change — true for the 600 ms default or a number of ms), ajax: (force a Turbo background submission and emit midwest-form:success/midwest-form:error events), and close_modal_on_success: (reuses the dialog controller's hide action to dismiss an enclosing midwest_dialog on a successful turbo:submit-end). See Form Behaviors

v0.26 — grab-bag of remaining pre-1.0 work

A grab-bag of remaining pre-1.0 work.

Complete. Everything in this milestone shipped in v0.26.0. The four New Components (ContextMenuComponent, MasonryComponent, SplitViewComponent, and SocialPreview::MastodonComponent) landed alongside the SocialPreview::BasePlatformComponent refactor; the three MCP-server tools (get_chart_relationships, get_chart_data_requirements, get_turbo_patterns) brought the server to 24 tools; and the improvements — the eject-component task, ChartComponent export, TableComponent column resizing / inline editing / multi-column sort, history-aware Hotwire modals, and the AssetsComponent / midwest_assets Turbo asset loader — all shipped. The Bundle Analyzer was pulled forward and shipped earlier in v0.25.0, and TableComponent's advanced filtering was cut (see below).

New Components

  • Social Preview: Mastodon ✅ — Mastodon (fediverse) post preview extending the new SocialPreview::BasePlatformComponent. MastodonComponent: white card with the purple Mastodon wordmark header, rounded-square avatar in a side-by-side layout, an optional "X boosted" attribution row, a zero-JS native content-warning disclosure (spoiler text in a <summary> with a Show more/less toggle; the post body stays hidden until expanded), and a five-button action bar (reply/boost/favourite/bookmark/share) with inline reply/boost/favourite counts. No verification badge (Mastodon has none by design); counts accept raw integers (abbreviated via format_count) or pre-formatted strings. Wired into the parent orchestrator (PLATFORM_MAP/PLATFORM_OPTIONS) and Lookbook previews
  • Context Menu ✅ — Right-click (context) menu. ContextMenuComponent wraps a trigger area; right-clicking anywhere inside it opens a floating menu at the cursor, rendered in the top layer via the native Popover API so it escapes overflow/stacking contexts. The midwest-context-menu Stimulus controller positions and clamps the menu to the viewport and dismisses it on Escape, outside click, scroll, or resize. Shares the dropdown's shell and rows — items are supplied through the items slot as DropdownItemComponents (the same link/button/header/divider/nested as: types, tooltips, confirmation dialogs, and one level of nested submenu). Entrance composed through midwest_motion (trigger: :hover, default scale primitive), so it draws on the same motion vocabulary, tokens, and app-wide Midwest.config.motion defaults as the dropdown/tooltip/popover
  • Masonry Grid ✅ — Pinterest-style layout, zero JavaScript. MasonryComponent uses the native CSS masonry syntax where supported (shortest-lane placement in true left-to-right reading order), progressively enhances two experimental syntaxes (Firefox's grid-template-rows: masonry and WebKit's display: grid-lanes), and falls back to CSS multi-column layout everywhere else. Responsive column count (columns:, clamped 1–8, stepping down to 2 then 1 on narrower viewports) and configurable gap:, driven by --masonry-* custom properties. Items supplied through the items slot
  • Split View ✅ — Two resizable panes separated by a draggable divider. SplitViewComponent exposes primary/secondary slots; the primary pane's size is adjustable by dragging or with the arrow keys when the divider is focused, and — when a storage_key: is given — persisted to localStorage so it survives reloads. Double-clicking the divider resets to the initial size. Sizes are percentages (size:/min:/max:); orientation: :horizontal (default, vertical divider) or :vertical (stacked, horizontal divider), with correct inverse ARIA aria-orientation. The midwest-split-view Stimulus controller handles dragging, clamping, keyboard resizing, and persistence

MCP Server Features

  • Chart Relationship Graph ✅ — get_chart_relationships MCP tool documents how the chart subsystem is wired: the ChartComponent facade and its chart-type → chart-class map, the BaseChart → CartesianChart → concrete-type inheritance, the Support value objects (Series, DataPoint, SeriesBuilder, Geometry, config structs), the data-flow pipeline from a raw series: array to inline SVG, and how rendering/styling work. Sectioned (overview/types/hierarchy/support/data_flow/rendering/related_tools); the chart-specific companion to get_component_relationships. A drift-guard test keeps its type map in sync with ChartComponent::CHART_CLASS_MAP
  • Data Requirement Docs ✅ — get_chart_data_requirements MCP tool documents the series: data format each chart type expects — array shape, required keys, a worked example, and the most relevant options — for pie, column/bar, line/spline/area, stackedbar/stackedarea, and bubble, plus the shared series_from: collection builder. Scope with type: or omit for all; drift-guarded against CHART_CLASS_MAP
  • Turbo Integration Patterns ✅ — get_turbo_patterns MCP tool documents how Midwest works with Hotwire Turbo: the Frame-driven pieces (remote + history-aware dialogs, the TurboTable sort/filter/paginate frame, command-palette and autocomplete frames), the Stream update patterns (the notifications container and single-row table updates via the shared TableRowComponent), how Turbo Stream broadcasts over a channel plug in (the gem ships none of its own), dynamic per-arrival asset loading (midwest_assets), and the table-specific parsing gotchas. Sectioned (overview/frames/streams/channels/assets/gotchas/related_tools). MCP server now exposes 24 tools
  • Bundle Analyzer ✅ (v0.25.0, pulled forward) — get_bundle_analysis MCP tool: the transitive set of components a given component renders (via slots, template helpers, direct renders, and Ruby constructions — from the Prism-backed render graph), the summed asset footprint of that set (co-located CSS + Stimulus controller source, with a per-component breakdown), and render-cycle detection. Built on ComponentIndex#render_targets / #source_bytes_for. MCP server now exposes 21 tools. A CI drift-guard (bin/ast build + git status check) keeps the committed AST/graph files from going stale between releases

Improvements

  • Eject Component Tool ✅ — bin/rails "midwest:eject:component[TableComponent]" copies a component's .rb + sidecar (.html.erb/.css/_controller.ts/locale .yml) out of the gem and into the consuming app's app/components/midwest/, where Rails' app-before-engine load order makes the local copy override the gem's. Accepts any name form (table, table_component, Midwest::TableComponent, social_preview/mastodon), skips generated .ast.* sidecars, refuses to clobber existing files without [name,force], and prints next-steps guidance for wiring the ejected CSS/JS. Lives under namespace :eject in lib/tasks/midwest_tasks.rake
  • SocialPreview Component ✅ — Extracted SocialPreview::BasePlatformComponent to share the common shell and header design, and migrated all ten platform previews (Facebook, Twitter/X, LinkedIn, Instagram, TikTok, YouTube, Threads, Bluesky, and the new Mastodon) onto it — not just Threads/Bluesky. Shell and header updated to match current platform branding
  • ChartComponent — export functionality ✅ — Opt-in export: toolbar (revealed on hover / keyboard focus) for downloading the chart, native and zero-dependency. export: true offers all formats; a symbol or array (%i[png csv]) narrows them. PNG and SVG rasterize the live inline <svg> client-side — the Stimulus controller clones it, inlines every node's computed presentation styles (so exports render faithfully without the component stylesheet), serializes to standalone XML, and either downloads it or paints it onto a 2× canvas for PNG. CSV serializes the new public chart.data_table (categories × series for cartesian charts, flat Label/Value for pie — both pie input shapes collapse correctly), emitted into a hidden data- element and turned into an Excel-friendly BOM-prefixed CSV. Suppressed for sparklines and empty charts; filename derives from the title
  • TableComponent — Inline editing, column resizing, multi-sort ✅ (advanced filtering cut):
    • Column resizing ✅ — resizable: true lets you drag column borders (a handle appears on each header's right edge); the controller freezes the current widths, switches the table to a fixed layout so a drag doesn't reflow the other columns, clamps to a minimum width, double-click-to-auto-size, and — with resize_storage_key: — persists widths to localStorage across reloads
    • Inline cell editing ✅ — mark a column editable: true to edit its key-based cells in place: double-click (or focus + Enter/F2) swaps the cell for an input; Enter commits, Escape cancels, blur commits. Committing dispatches a bubbling midwest-table:edit event ({ field, value, previousValue, rowId }) and, when the column supplies edit_url: (String or callable), PATCHes the value with the CSRF token (rendering any Turbo Stream response). Both covered by browser system tests
    • Multi-column sort ✅ — click a header to sort by it, Shift-click to add it as a secondary sort. The chain is URL-encoded as parallel comma-separated lists (?sort=role,name&dir=desc,asc) and drives a multi-column ORDER BY; each sorted column shows a priority badge (1, 2, 3…). Shared, security-hardened parsing lives in Midwest::TableSortable (validates every column against the safe pattern + allowed_sorts: allowlist, de-dupes, honors a bare dir) and backs both the TurboTable controller concern and TablePresenter — so midwest_table_from wires it automatically; single-column sort URLs stay backward-compatible. Sortable headers carry a data-multi-sort-url; the table controller's sortColumn follows it (frame-scoped) only on Shift-click, letting a plain click use the single-sort href. Each column cycles add → reverse → remove on repeated Shift-clicks. Covered by shared-module, presenter, controller, component, and browser (plain- vs shift-click) tests
    • Advanced filtering ❌ — Cut. Filter operators / typed filters / a filter-bar UI de-scoped; the existing param-based filter_params filtering (via TurboTable/TablePresenter + midwest_filter_form_tag) remains the supported approach
  • Hotwire Modals ✅ — Modal frame navigation with browser history, built on the existing remote (turbo-frame) DialogComponent. Opt in with remote: true, history: true (or midwest_remote_dialog(history: true)): the persistent turbo-frame gains data-turbo-action="advance", so loading content into it advances the URL and pushes a history entry (the modal URL is deep-linkable and shown in the address bar while open). The dialog controller closes the modal on Back (popstate) and, on a manual close (Escape/backdrop/close button), pops the modal's URL off the stack via history.back() so the address bar returns to the page behind it — while a form redirect still supersedes history restoration. Demonstrated by a dedicated example_history dialogable endpoint and covered by browser system tests (open advances URL, Back closes + restores, Escape closes + restores)
  • Enqueuing a component's CSS and JS via Turbo when a component is loaded ✅ — New AssetsComponent / midwest_assets helper: render it alongside markup that may be delivered dynamically (into a Turbo Frame or appended by a Turbo Stream) and its midwest-assets Stimulus controller injects Midwest's compiled stylesheet (and, opt-in, its JS bundle) into <head> on connect — once, idempotent by resolved URL — so the component styles and behaves correctly even on a page that never loaded Midwest's assets. css: true resolves the app's compiled midwest stylesheet (gracefully no-ops if the asset isn't in the pipeline); a string URL is used verbatim. Because Midwest ships a single bundled stylesheet this ensures that one file rather than per-component CSS. Covered by component tests and a browser system test asserting the <link> is injected into the head

v0.27 — Async assets & Email Sections

Per-component asset delivery, plus a mail-client-safe email component library.

Complete. Everything in this milestone shipped in v0.27.0. The async-asset work landed in full (per-component CSS/JS builds, render-time accounting, Turbo delivery, Rack serving/packaging, the @source glob fix, and cascade determinism), and the milestone also delivered a net-new Email Sections library (40+ mail-client-safe sections and six full transactional templates) that was not previously on the roadmap. The single bundle stays the default and stays supported. See Async Assets and Email Sections. The v0.27.x patch line also shipped a second net-new addition — the Form::RichTextComponent (an ActionText/Trix editor in Midwest field chrome), which replaced the long-standing rich_text_area placeholder in v0.27.3. v0.27.4 then deepened the Email Sections library's brand fit: a heading-only display font, brand type treatment (heading_transform / heading_tracking), a complement colour scale and per-role palette overrides, an opt-in permanently-dark color_scheme, and I18n-backed component copy (the few strings a section emits itself now translate through midwest.email.*, overridable per app or per call). v0.27.5 added Turbo-era refinements to two elements components: framed cards (CardComponent's frame: option wraps the card — or each face of a flippable card — in a <turbo-frame> so a response can swap its contents in place) and a max_height: cap that scrolls a card's section while pinning its header/footer, plus time-only calendar tiles (CalendarDateComponent's time_only:) and a fix so standalone form fields honour an explicit name:.

Email Sections

  • Email Sections library ✅ — A deliberately separate library under app/emails/midwest/email/ (namespace Midwest::Email::) of drop-content-in email sections that render correctly in real mail clients. Because an email cannot use Midwest's stylesheet (no cascade, no custom properties, no @layer, no Tailwind — Outlook renders through Word, Gmail strips <head>), these components take part in no CSS build, carry no .css/.ts sidecars, and emit every declaration as an inline style at render time. They share the design language only — colour scales, spacing ramp, type scale — resolved to literal values via a Midwest::Email::Palette that maps Midwest::Theme to semantic email roles, so a single config.email.theme retints a whole message. 40+ sections spanning transactional (header, hero, content, CTA, alert, verification code, details, receipt, order summary, address, status stepper, data table, stats, user, quote, attachments, social, signature) and marketing (feature grid/row, product grid, article list, testimonial, logo cloud, pricing, FAQ, survey, video, app badges, countdown) plus supplemental sections (callout, button group, bullet list, steps, coupon, event, progress, rating). Opt-in Outlook-guarded custom web fonts via config.email.web_font. Not a sending library — it renders HTML; ActionMailer sends it
  • Transactional templates ✅ — Six complete emails assembled from the sections (receipt, verification code, welcome, order shipped, alerts, monthly report), each rendered as a whole document through the real ActionMailer path
  • Email visual regression testing ✅ — bin/email-vrt --pixels (headless-Chromium screenshots diffed with ImageMagick, light + dark baselines per section), a coverage test asserting every section has a baseline, and bin/email / scripts/export_emails.rb exporting every mailer and section to self-contained .html at release time for manual Litmus / Email on Acid checks

Improvements

  • Per-component CSS build ✅ — Midwest::Assets::CssSplitter + bin/rails midwest:css:async compiles a lean core (76 KB) plus one stylesheet per component, from the same sources the bundle uses. The technique that makes it viable is source(none) with an explicitly scoped @source: without it Tailwind's automatic content detection scans to the git root and hands every component the whole library's utility set (~35 KB each — icon drops from 42.5 KB to 683 B once disabled). Two checks run on every build: each component's @layer midwest.components.* block compiled standalone must be byte-identical to what the bundle emits for it (re-verified unminified when it trips, since Lightning CSS folds shorthands contextually), and every utility rule the library emits must survive somewhere across core + components. Incremental: each output is keyed by a digest of everything feeding it, so a rebuild is ~3 s against ~55 s cold
  • Per-component JS build ✅ — Midwest::Assets::JsSplitter + midwest:js:async emits one ES module per component owning a Stimulus controller. The identifier → controller mapping is parsed out of index.ts rather than restated, so the two builds cannot disagree. Rollup's code splitting puts @hotwired/stimulus in a single shared 18 KB chunk every module imports, so a component module is only its own controller — badge is 195 bytes. A shared runtime queues registrations that arrive before the host application boots and flushes them when it appears, adopting window.Stimulus automatically
  • Render-time asset accounting ✅ — midwest_asset_tags emits exactly the components a page rendered. Rails renders the view template before the layout, so the registry populated from BaseComponent#render_in is already complete when <head> is evaluated; nested components register themselves as they render, so no dependency graph is consulted. Layout chrome rendered after <head> is named once via config.assets.always, and in development anything that renders too late warns with the exact line to add. config.assets.preload prefetches components known to arrive later over Turbo
  • Turbo delivery ✅ — Midwest::AsyncAssets appends a fragment's assets to the document head for Streams (via Turbo's targets CSS-selector form, since head has no id) and inline for Frames. AssetsComponent becomes async-aware, injecting only what the named components need; an explicit components: list is expanded through the render graph. Emitting unconditionally is safe — a duplicate <link> is a browser no-op and a duplicate module script executes once
  • Serving and packaging ✅ — artifacts are served by a Rack mount the engine installs rather than the app's asset pipeline, because Rollup emits relative imports between chunks and neither Propshaft nor Sprockets rewrites JS import specifiers. Filenames carry content hashes, so they are served immutable; config.assets.host points them at a CDN. As of v0.27.2 the ~160 hashed artifacts are committed to the repo (staged with git add -A on release) so a git-based install serves them without a build step; scripts/check_async_package.rb verifies on every build that everything the manifest names is on disk
  • @source glob fix ✅ — five of the seven globs in midwest/tailwind.css had resolved to directories that do not exist since the v4 migration (a relative @source resolves against the file declaring it, and these were written from the importing entry's perspective). Nothing broke, because automatic content detection is a superset — they were documentation of an intent the build ignored. Correcting them leaves the bundle byte-identical; scripts/check_css_sources.rb now fails on any glob matching nothing
  • Cascade determinism ✅ — three components opened a @layer no order statement declared, so they landed after every declared layer in first-seen order. Harmless in a single bundle where emission order is fixed; load-order dependent as separate <link>s. Declared explicitly, with map_component (previously unlayered) wrapped. scripts/check_css_layers.rb enforces all three leak modes

Measured

For a page rendering twelve components: 278 KB / 60 KB gzip against the bundles' 784 KB / 133 KB — 64.5% smaller raw, 54.7% gzipped, with the core cached across pages.

Post-v0.27 — unscoped polish

Releases shipped after the last milestone closed.

No open items. The v0.25–v0.27 milestones are all complete, and the v0.28.x line is net-new polish rather than milestone delivery — nothing below was a scoped roadmap item. v0.28.0 added two bare form primitives (midwest_checkbox and midwest_radio, the styled input with no label or wrapper) plus usability options on three components: avatar color: :auto (a stable per-name colour, and a single initial at xs), a collapsible split-view primary pane, and tree nodes that can be forced to render as expandable branches and forward arbitrary HTML attributes. v0.28.1 is a BadgeComponent pass — icon-only badges (an icon with no label renders round instead of a pill with an empty tail), a retuned auto-contrast threshold so light theme colours clear AA (with the icon chip resolving against its own background rather than the pill's), cap-height vertical centring via text-box: trim-both cap alphabetic (the previous text-box-trim was a silent no-op on those flex spans), a support chip that matches the icon chip's height, and a smaller 1.15em icon — alongside get_turbo_patterns guidance for opening a remote dialog from a Turbo Stream and the autoclose navigation trap underneath it.