senren-ui 0.1.6 → 0.3.0

data/docs/hot_reload.md

@@ -0,0 +1,103 @@
+# Hot reload
+
+What reloads automatically, what does not, and why — for both people working
+on the gem and people using it in an app.
+
+## Working on the gem
+
+`templates/` is the source of truth, and the preview app under `.local/preview`
+holds *copies* made by `bin/seed_preview`. Editing a template therefore has no
+effect on the running preview until the copy is refreshed. `bin/watch` closes
+that gap.
+
+```bash
+bin/seed_preview                       # once
+cd .local/preview && bin/rails server  # terminal 1
+bin/watch                              # terminal 2, from the gem root
+```
+
+With both running, editing `templates/components/button/button_component.html.erb`
+copies that one file into the preview app and the browser reloads within about
+a second.
+
+What each kind of edit does:
+
+| You edit | `bin/watch` does | Result |
+|---|---|---|
+| `templates/components/<name>/*` | copies the one file | page reloads |
+| `templates/controllers/*.js` | copies the one controller | page reloads |
+| `registry/*.yml` | full reinstall of every component | page reloads |
+| `lib/generators/senren/install/templates/*.tt` | copies to its host path | page reloads |
+| `lib/**/*.rb` | nothing | restart `bin/watch` and the server |
+
+`lib/` is deliberately not watched: changing gem internals requires restarting
+the Ruby process, which a file copy cannot do.
+
+`installed_components.yml.tt` is never synced. That file is a *template* for a
+ledger, and the ledger in the preview app is state — copying over it would
+erase the install history.
+
+Options:
+
+- `SENREN_PREVIEW_ROOT` — watch a preview app somewhere else. Matches
+  `bin/seed_preview`.
+- `SENREN_WATCH_INTERVAL` — poll interval in seconds, default `0.5`.
+
+### How the browser reload works
+
+`bin/watch` writes a timestamp to `tmp/senren-reload.txt` after every sync. The
+preview layout polls `/senren/reload_token` twice a second and calls
+`location.reload()` when the value changes.
+
+This exists because Rails only reloads *Ruby and ERB*. A Stimulus controller is
+JavaScript already delivered to the browser: syncing the file changes nothing
+until the page is reloaded and the module is fetched again. The token is what
+makes controller edits feel hot.
+
+There is no websocket, no ActionCable, and no extra gem — deliberately, since
+the whole plumbing exists only in the gitignored `.local/preview` app and must
+never reach a published gem or a host app.
+
+### Manual check
+
+Automated tests cover the path-mapping logic (`test/template_sync_test.rb`).
+The polling loop itself is verified by hand:
+
+1. Start the server and `bin/watch`.
+2. Change a colour class in a component template — the page reloads with the
+   new style.
+3. Add a `console.log` to a controller — the page reloads and the log appears.
+4. Add a component to `registry/components.yml` — the watcher reports a full
+   reinstall and the new component renders.
+
+## Using the gem in your app
+
+After `bin/rails senren:add`, the components are yours. Rails handles most of
+the reloading, so there is little for Senren to add:
+
+| You edit | Reloads? |
+|---|---|
+| `app/components/senren/*.rb` | Yes — Rails reloads on the next request |
+| `app/components/senren/*.html.erb` | Yes — same |
+| `app/assets/stylesheets/senren.css` | Yes, once Tailwind rebuilds |
+| `app/javascript/controllers/senren/*.js` | **No** — needs a page reload |
+
+The Stimulus row is the one to know about. With importmap the controller is a
+module the browser has already fetched, so editing it does nothing until you
+reload the page. In development Propshaft serves the new file immediately, so
+an ordinary refresh is enough — you do not need to restart the server or clear
+a cache.
+
+If you want that refresh automated, the usual choice is the `hotwire-livereload`
+gem in your own `Gemfile`. Senren does not ship one, because doing so would put
+a development dependency and a websocket into every app that installs a
+component library.
+
+### Turbo morphing
+
+If your app uses Turbo 8 page morphing, a morph can move or replace the element
+a controller is attached to, which triggers `disconnect()` and `connect()`.
+Senren controllers clean up their document-level listeners in `disconnect()`,
+so they survive repeated morphs. If you write your own controller, do the same:
+anything you add to `document` or `window` in `connect()` or on open must be
+removed in `disconnect()`, or it will accumulate on every navigation.

data/docs/performance_testing.md

@@ -16,9 +16,13 @@ bin/ci
 `bin/performance` reads `config/performance_budgets.yml`.
 `bin/system` runs headless browser tests against `test/dummy`.
 
-`bin/system` uses Selenium with local Chromium/ChromeDriver by default.
-Override paths with `SENREN_CHROME_BIN` and `SENREN_CHROMEDRIVER` if your
-machine installs them somewhere else.
+`bin/system` runs Selenium against headless Chrome. It uses a system
+Chrome/Chromium and `/usr/bin/chromedriver` when they are present (the Linux CI
+image), and otherwise lets Selenium Manager resolve and download a matching
+driver — so macOS and other local machines need no setup.
+
+Set `SENREN_CHROME_BIN` or `SENREN_CHROMEDRIVER` only to force a specific
+binary; leaving them unset is the supported path.
 
 ## Benchmark Model
 

data/docs/visual_style.md

@@ -37,6 +37,86 @@ tokens are available for documentation, examples, and branded surfaces.
 | `--senren-palette-iris` | secondary visual accent |
 | `--senren-palette-paper` | warm neutral surface |
 
+## Palette Presets
+
+`senren.css` declares Spring Garden in `:root`. That is the default and needs no
+attribute. `senren_themes.css` adds five alternates, each one a re-declaration
+of the same token table:
+
+| `data-senren-theme` | Reads as |
+| --- | --- |
+| *(omitted)* | Spring Garden — warm paper, pine ink, garden green |
+| `rose` | warm pink, low contrast |
+| `slate` | neutral grey, high contrast |
+| `indigo` | cool blue-violet |
+| `emerald` | cool green |
+| `amber` | warm gold |
+
+```erb
+<%= stylesheet_link_tag "senren" %>
+<%= stylesheet_link_tag "senren_themes" %>
+```
+
+```erb
+<html data-senren-theme="rose">
+```
+
+**Load `senren_themes.css` after `senren.css`.** `:root` and
+`[data-senren-theme="rose"]` are equal specificity, so the later rule wins and
+source order is the whole mechanism. Reversed, both files load, the attribute is
+on `<html>`, nothing errors, and the page renders in the default palette — the
+one failure mode of this feature, and it looks like the theme file was never
+installed.
+
+The attribute goes on `<html>`, not on `<body>` or a wrapper, so it composes
+with the existing `.dark` class instead of replacing it. Light/dark stays
+orthogonal to palette: each preset ships both blocks.
+
+No component knows themes exist. They read `hsl(var(--senren-*))` and inherit
+whatever is in scope, which is why a sixth palette is a copied CSS block and
+nothing else — no component to touch, no build step, no configuration.
+
+Switching at runtime is one attribute write:
+
+```js
+document.documentElement.dataset.senrenTheme = "slate"
+```
+
+## Overriding a Component's Classes
+
+`class_name:` and `class:` are both merged into the element the component
+styles. Merged, not resolved — the component's own class stays in the list:
+
+```erb
+<%= render Senren::DialogComponent.new(class_name: "max-w-sm") %>
+<!-- panel renders class="… max-w-lg max-w-sm …" -->
+```
+
+Two `max-w-*` declarations with identical specificity, so the winner is whichever
+Tailwind emits later in the stylesheet. The order of the HTML attribute is not an
+input to that. Tailwind emits the named scale alphabetically, which measured
+against a real build means:
+
+| You pass | Against dialog's `max-w-lg` | Result |
+| --- | --- | --- |
+| `max-w-sm` | `sm` emitted after `lg` | applies |
+| `max-w-2xl` | `2xl` emitted before `lg` | **silently ignored** |
+
+Nothing about either class tells you which you are getting. For an override that
+does not depend on emit order, use Tailwind's important modifier:
+
+```erb
+<%= render Senren::DialogComponent.new(class_name: "max-w-2xl!") %>
+```
+
+This applies to any pair from one utility family — `w-`, `h-`, `p-`, `z-`,
+`text-`, `bg-`. It is not specific to widths. Senren does not ship a
+class-conflict resolver; adding one means a `tailwind_merge` dependency, which
+the library has so far chosen not to take.
+
+Classes from families the component does not use need no modifier — there is
+nothing to conflict with.
+
 ## Component Rules
 
 - Prefer semantic tokens over raw color utilities.

data/lib/generators/senren/component/templates/controller.js.tt

@@ -3,11 +3,14 @@ import { Controller } from "@hotwired/stimulus"
 // Stimulus controller for Senren <%= class_name %>.
 // Identifier: <%= stimulus_identifier %>
 //
-// Responsibilities (local UI only):
+// Scope — local UI only:
 // - Manage open/close, focus, or keyboard behavior for this component.
-// Forbidden:
-// - fetch / XHR (Turbo handles server state)
-// - importing React, Vue, Alpine, lit, or any other framework
+//
+// Out of scope:
+// - fetch / XHR. Turbo owns server state; a controller that fetches ends up
+//   holding a second copy of it.
+// - Importing a client-side rendering framework. This component's markup comes
+//   from the server, so a second renderer would be fighting it for the DOM.
 export default class extends Controller {
   static targets = []
   static values  = {}

data/lib/generators/senren/install/install_generator.rb

@@ -30,6 +30,9 @@ module Senren
       def copy_base_files
         template 'base_component.rb.tt', 'app/components/senren/base_component.rb'
         template 'senren.css.tt',                'app/assets/stylesheets/senren.css'
+        # Optional: link it only if you want the palette presets. senren.css
+        # alone gives you the default, so this file costs nothing until used.
+        template 'senren_themes.css.tt',         'app/assets/stylesheets/senren_themes.css'
         template 'conventions.md.tt',            '.senren/conventions.md'
         template 'installed_components.yml.tt',  '.senren/installed_components.yml'
       end
@@ -38,6 +41,27 @@ module Senren
         copy_file Senren::Rails.registry_path, '.senren/registry.yml'
       end
 
+      # Switches Stimulus to on-demand loading instead of documenting it.
+      #
+      # Rails' default is `eagerLoadControllersFrom("controllers", application)`,
+      # which imports every controller in the importmap on every page. Because
+      # `pin_all_from "app/javascript/controllers"` is recursive it also covers
+      # app/javascript/controllers/senren, so a static page paid for every
+      # interactive component the app had installed.
+      #
+      # This was a README instruction the developer had to follow by hand, and a
+      # "PASS" in bin/performance that only grepped that README. An instruction
+      # nobody runs is not a feature.
+      #
+      # It uses the official stimulus-loading helper rather than a Senren-specific
+      # loader, and therefore changes loading for the app's own controllers too.
+      # That is the trade the README already asked for; the generator only acts
+      # when the file still carries the untouched Rails default, and says so.
+      def configure_stimulus_loading
+        enable_lazy_controller_loading
+        disable_controller_preloading
+      end
+
       def write_skill_file
         say_status :senren, 'writing .senren/skill.md'
         Senren::Rails::SkillWriter.new(paths: host_paths).sync!
@@ -56,6 +80,59 @@ module Senren
 
       private
 
+      def enable_lazy_controller_loading
+        index = 'app/javascript/controllers/index.js'
+        unless host_file?(index)
+          return say_status(:skip,
+                            "#{index} not found; switch to lazyLoadControllersFrom by hand")
+        end
+
+        source = File.read(File.join(destination_root, index))
+        if source.include?('lazyLoadControllersFrom')
+          return say_status(:senren,
+                            'controllers already load on demand')
+        end
+
+        unless source.include?('eagerLoadControllersFrom')
+          return say_status(:skip, "#{index} has a custom loader; left alone")
+        end
+
+        gsub_file index, 'eagerLoadControllersFrom', 'lazyLoadControllersFrom'
+        say_status :senren, 'Stimulus controllers now load when their data-controller appears'
+      end
+
+      # Only strips the modulepreload tags. On its own it does not stop eager
+      # importing, which is why it is paired with the change above.
+      def disable_controller_preloading
+        importmap = 'config/importmap.rb'
+        unless host_file?(importmap)
+          return say_status(:skip,
+                            "#{importmap} not found; add preload: false by hand")
+        end
+
+        source = File.read(File.join(destination_root, importmap))
+        if source.match?(/under:\s*["']controllers["'].*preload:\s*false/)
+          return say_status(:senren,
+                            'controller preloading already disabled')
+        end
+
+        if source.match?(%r{pin_all_from\s+["']app/javascript/controllers["']})
+          # A backreference rather than a block: Thor forwards the block to
+          # String#gsub across several frames, where $~ is no longer the match.
+          # The lookahead makes a second run a no-op.
+          gsub_file importmap,
+                    %r{(pin_all_from\s+["']app/javascript/controllers["'](?![^\n]*preload:)[^\n]*)},
+                    '\1, preload: false'
+        else
+          append_to_file importmap,
+                         %(\npin_all_from "app/javascript/controllers", under: "controllers", preload: false\n)
+        end
+      end
+
+      def host_file?(relative)
+        File.exist?(File.join(destination_root, relative))
+      end
+
       def host_paths
         @host_paths ||= Senren::Rails::HostPaths.new(destination_root)
       end

data/lib/generators/senren/install/templates/base_component.rb.tt

@@ -27,28 +27,139 @@ module Senren
 
     # Compose final root attributes; subclasses pass their base classes.
     def root_attrs(*classes, **extra)
-      data = (extra.delete(:data) || {}).merge(senren_component: senren_component_name)
+      # `data` arrives from two places: the caller's own attributes (html_attrs)
+      # and whatever the template passes here. Both are merged, and the
+      # component marker is applied last so it always survives.
+      #
+      # Splatting html_attrs after a computed `data:` used to overwrite it
+      # wholesale, so any component given a `data:` hash silently lost its
+      # data-senren-component marker. MaskedInput hit this on every render.
+      data = merge_data(caller_data, extra.delete(:data), { senren_component: senren_component_name })
+
+      # `class` had exactly the same defect and it was never fixed alongside
+      # `data`. Every Rails tag helper accepts `class:`, so it is the first
+      # thing anyone types — and splatting html_attrs replaced the computed
+      # value outright, erasing the component's variant and size styling with
+      # no warning. It is merged like any other caller-supplied class instead.
+      #
+      # Merged, not resolved, and the distinction matters. See merge_classes.
       tag_class = merge_classes(
         classes,
         self.class::VARIANTS[@variant],
         self.class::SIZES[@size],
         @class_name,
-        extra.delete(:class)
+        extra.delete(:class),
+        caller_class
       )
-      { class: tag_class, data: data, **html_attrs, **extra }
+      { class: tag_class, data: data, **html_attrs_without_class_and_data, **extra }
+    end
+
+    # For components whose root is a wrapper and whose styling lives on an inner
+    # element -- every overlay: the panel is what gets positioned, the root just
+    # hosts the controller.
+    #
+    # Same merging as root_attrs, minus VARIANTS and SIZES. Passing those to the
+    # root of a sheet applied `translate-x-full` there, and a transformed
+    # ancestor becomes the containing block for its `position: fixed`
+    # descendants -- so the panel was positioned against the shifted root and
+    # rendered off-screen. It opened; you just could not see it.
+    def wrapper_attrs(*classes, **extra)
+      data = merge_data(caller_data, extra.delete(:data), { senren_component: senren_component_name })
+      tag_class = merge_classes(classes, extra.delete(:class))
+
+      { class: tag_class.presence, data: data, **html_attrs_without_class_and_data, **extra }.compact
+    end
+
+    # The class list for the element a wrapper component actually styles.
+    #
+    # For an overlay the caller means the panel: `class_name: "max-w-2xl"` on a
+    # dialog is a request to widen the dialog, not to widen an invisible
+    # wrapper. Putting it on the root left it in the DOM doing nothing, which is
+    # harder to debug than dropping it -- the class is right there and the panel
+    # is still max-w-lg.
+    def panel_class(*classes)
+      merge_classes(classes, @class_name, caller_class)
     end
 
     def senren_component_name
       self.class.name.to_s.sub(/^Senren::/, '').sub(/Component$/, '').gsub(/([a-z])([A-Z])/, '\1_\2').downcase
     end
 
+    # Builds a DOM id from the arguments that identify this component, so the
+    # same inputs always produce the same id.
+    #
+    # Components used to append `SecureRandom.hex`, which made every render emit
+    # different HTML. That single fact disabled Turbo morph (it pairs nodes by
+    # id), HTTP ETags (the body never matched), fragment caching (cached and
+    # fresh fragments referenced different ids), and snapshot testing.
+    #
+    # Two components with identical identifying inputs on one page now produce
+    # the same id and the accessibility test fails. That is deliberate: the
+    # caller should pass an explicit `id:`. A random suffix hid the collision
+    # instead of resolving it.
+    def senren_dom_id(*parts)
+      seed = parts.flatten.map(&:to_s).reject(&:empty?).join('-')
+      base = "senren-#{senren_component_name.tr('_', '-')}"
+      return base if seed.empty?
+
+      "#{base}-#{seed.parameterize}"
+    end
+
     private
 
+    # Callers write `data: { controller: "x" }` and `data: { "controller" => "x" }`
+    # interchangeably, and Rails renders both the same, so the merge has to see
+    # both the same. Reading with dig(:symbol) missed the String form entirely:
+    # the append never ran and the tag builder kept the caller's value alone,
+    # which for data-action removed the component's own close-on-click and
+    # arrow-key handling.
+    #
+    # `controller` and `action` are space-separated lists in Stimulus, so a
+    # caller's value is appended rather than substituted -- attaching your own
+    # controller to a Senren component must not unbind the component's.
+    APPENDABLE_DATA = %i[controller action].freeze
+
+    def merge_data(*sources)
+      sources.compact.map { |h| h.transform_keys(&:to_sym) }.reduce({}) do |acc, incoming|
+        acc.merge(incoming) do |key, old, new|
+          # Split before uniq. Deduplicating the two whole strings only catches an
+        # exact repeat: `data: { controller: "a senren--popover" }` on a popover
+        # produced "a senren--popover senren--popover", and Stimulus reads that
+        # list literally -- same controller connected twice on one element, every
+        # action firing twice, so a toggle opens and immediately closes.
+        APPENDABLE_DATA.include?(key) ? [old, new].map(&:to_s).join(' ').split.uniq.join(' ') : new
+        end
+      end
+    end
+
+    def caller_class
+      html_attrs[:class] || html_attrs['class']
+    end
+
+    def caller_data
+      html_attrs[:data] || html_attrs['data']
+    end
+
+    def html_attrs_without_class_and_data
+      html_attrs.reject { |k, _| %w[class data].include?(k.to_s) }
+    end
+
     def safe_url(value, fallback: '#', protocols: SAFE_URL_PROTOCOLS)
       url = value.to_s.strip
       return fallback if url.empty?
+      # Browsers treat "\" as "/" for special schemes and strip TAB/CR/LF
+      # before parsing, so "/\evil.example" and "/<TAB>/evil.example" would
+      # both slip past a plain "//" check and resolve off-origin.
+      return fallback if url.include?('\\')
+      return fallback if url.match?(/[[:cntrl:]]/)
       return url if url.start_with?('#')
-      return url if url.start_with?('/') && !url.start_with?('//')
+      # Any leading "//" is protocol-relative regardless of how many slashes
+      # follow. Rejecting here rather than relying on URI.parse matters:
+      # URI.parse("///evil.example") reports no scheme and no host, so the
+      # scheme-less fallback below would otherwise hand back a URL the browser
+      # resolves to https://evil.example/.
+      return fallback if url.start_with?('//')
+      return url if url.start_with?('/')
 
       uri = URI.parse(url)
       return url if uri.scheme && Array(protocols).map(&:to_s).include?(uri.scheme.downcase)
@@ -71,6 +182,33 @@ module Senren
       raise ArgumentError, "Unknown #{label}: #{value.inspect}. Allowed: #{table.keys.join(', ')}"
     end
 
+    # Concatenation, not conflict resolution — and the caller's class going last
+    # in the attribute does not make it win.
+    #
+    # `class="max-w-lg max-w-2xl"` leaves both declarations live. Which applies
+    # is decided by the order the two rules appear in the stylesheet, because
+    # their specificity is identical; the order of the attribute is not an input
+    # to that at all. Tailwind emits the named scale alphabetically, so measured
+    # against a real build:
+    #
+    #   dialog base max-w-lg + class_name: "max-w-sm"  -> sm wins   (works)
+    #   dialog base max-w-lg + class_name: "max-w-2xl" -> lg wins   (silent no-op)
+    #
+    # Narrowing happens to work and widening happens not to, and nothing about
+    # either class says which you are getting. Any pair drawn from one utility
+    # family has this property.
+    #
+    # Resolving it properly means knowing which Tailwind utilities conflict,
+    # which is irregular enough (`text-sm` and `text-red-500` share a prefix and
+    # are different families) that a partial implementation would silently drop
+    # a component's own styling — a worse failure than the one it replaces. That
+    # is what tailwind_merge is for, and taking the dependency is a decision
+    # this library has not made.
+    #
+    # Until it does, the deterministic override is Tailwind's own important
+    # modifier, which beats source order rather than depending on it:
+    #
+    #   render Senren::DialogComponent.new(class_name: "max-w-2xl!")
     def merge_classes(*sources)
       sources.flatten.map { |s| s.to_s.strip }.reject(&:empty?).join(' ')
     end

data/lib/generators/senren/install/templates/conventions.md.tt

@@ -8,7 +8,9 @@ and obey it strictly.
 1. Use Senren components before writing custom HTML for the same purpose.
 2. Server-render via ViewComponent. Stimulus only for **local** behavior.
 3. Turbo handles server state. Controllers do not fetch/XHR from JS.
-4. No React, Vue, Alpine, lit, or external state framework. Ever.
+4. Interactivity stays in Stimulus. These components render on the server, so
+   introducing a client-side framework alongside them puts two systems in
+   charge of the same state.
 5. Tailwind classes must use **semantic tokens** (`bg-background`,
    `text-foreground`, `bg-primary`, `text-muted-foreground`,
    `border-border`, `bg-destructive`). Do not hard-code `gray-*`,
@@ -27,6 +29,60 @@ and obey it strictly.
    <%% end %>
    ```
 
+8. **Never put `app/components` on the asset load path.** With Propshaft this
+   publishes the directory: `assets:precompile` copies every component `.rb`
+   and `.html.erb` into `public/assets`, `.manifest.json` maps each logical
+   name to its digested filename, and the web server serves the source with
+   `HTTP 200` without Rails involved. Senren raises at boot in production if it
+   finds this, and warns elsewhere. Sidecar assets belong in their own
+   directory:
+   ```ruby
+   # config/initializers/assets.rb
+   Rails.application.config.assets.paths << Rails.root.join("app/components/assets")
+   # NOT app/components
+   ```
+
+9. **Do not pass `type:` to a button inside a form.** `ButtonComponent`
+   omits the attribute, so the browser's own rule applies and the button
+   submits, exactly as plain HTML does. Pass `type: :button` only for a
+   control that must *not* submit — a dialog, sheet, or menu trigger.
+   ```erb
+   <%%= form_with url: sessions_path do %>
+     <%%= render(Senren::ButtonComponent.new(variant: :primary)) { "Sign in" } %>
+   <%% end %>
+
+   <%%= render(Senren::ButtonComponent.new(type: :button)) { "Open dialog" } %>
+   ```
+
+10. **Load `senren_themes.css` after `senren.css`.** The install writes both.
+    `senren.css` declares the token set in `:root`; `senren_themes.css`
+    redeclares it under `[data-senren-theme="..."]` for the `rose`, `slate`,
+    `indigo`, `emerald`, and `amber` presets. The two selectors have equal
+    specificity, so source order decides which wins. In the wrong order every
+    file still loads, the attribute is still on `<html>`, nothing errors — and
+    the page renders in the default palette.
+    ```erb
+    <%%= stylesheet_link_tag "senren" %>
+    <%%= stylesheet_link_tag "senren_themes" %>
+
+    <html data-senren-theme="rose">   <%%# omit for the default palette %>
+    ```
+    The attribute belongs on `<html>` so it composes with `.dark` rather than
+    replacing it. Add a palette by copying a block and changing values; no
+    component reads the theme, so none needs editing.
+
+11. **`class:` is merged, not resolved.** Passing `class_name: "max-w-sm"` to a
+    dialog produces `class="… max-w-lg max-w-sm …"` — the component's own class
+    is still there. Both have the same specificity, so the winner is decided by
+    which one Tailwind emits later in the stylesheet, **not** by the order in
+    the attribute. Narrowing a dialog works; widening it silently does not.
+    When overriding a utility the component already uses, add Tailwind's
+    important modifier:
+    ```erb
+    <%%= render Senren::DialogComponent.new(class_name: "max-w-2xl!") %>
+    ```
+    Classes from families the component does not use need no modifier.
+
 ## File ownership
 
 | Path                                | Owned by         |