themelia-ui 3.0.0 → 3.2.0

package/docs/learn/composition.md

@@ -20,6 +20,10 @@ ready-made surface does not express the job.
 compose both; neither may import a block. The complete generated graph is in
 [Profiles](../generated/profiles.md).
 
+For structural blocks, spacing roles and responsive widths, use
+[Structure and spacing](./structure-and-spacing.md). For ready analytics, onboarding,
+timeline and admin presentations, use [Choosing blocks](./blocks.md).
+
 ## The composition ladder
 
 Use the lowest rung that solves the real requirement:
@@ -68,11 +72,8 @@ generic metadata, and an action without teaching the package what an invoice is:
 
 ```tsx compile
 import { Button } from "themelia-ui/base/buttons"
-import "themelia-ui/base/buttons.css"
 import { MetadataList } from "themelia-ui/base/display"
-import "themelia-ui/base/display.css"
 import { Page } from "themelia-ui/layout/page"
-import "themelia-ui/layout/page.css"
 
 type Invoice = { id: string; number: string; customerName: string; status: string; dueLabel: string }
 export function InvoiceDetail({ invoice, onCollectPayment }: {
@@ -111,10 +112,8 @@ callbacks, then open each linked module reference for the complete prop contract
 ### Dashboard
 
 ```tsx fragment — dashboard data and chart series come from the consuming application
-import { MetricGrid } from "themelia-ui/patterns/analytics"
-import "themelia-ui/patterns/analytics.css"
+import { MetricGrid } from "themelia-ui/blocks/analytics"
 import { Page } from "themelia-ui/layout/page"
-import "themelia-ui/layout/page.css"
 
 <Page header={{ title: "Overview", description: periodLabel }}>
   <MetricGrid metrics={metrics} variant="card" />
@@ -128,7 +127,6 @@ window, permission-filtered figures, and what clicking a metric means.
 
 ```tsx fragment — columns, filters, records, paging, and mutations are consumer-owned
 import { DataView, DataViewPagination } from "themelia-ui/features/data-view"
-import "themelia-ui/features/data-view.css"
 
 <DataView
   data={records}
@@ -148,13 +146,18 @@ The invoice example above is the canonical shape: `Page` for route geometry,
 `MetadataList` and primitives for facts, then domain callbacks on package actions. Keep the
 record type out of the package.
 
+When the task also fits the standard loading, empty, error and retry presentation, use
+`ResourceShowShell` or `ResourceIndexShell` from `features/resource`. Those shells already
+own a header, body and state replacement; do not duplicate that route header by wrapping
+them in another Page. Page remains appropriate for a custom record arrangement where the
+application already owns lifecycle feedback. Read the
+[resource API](../generated/components/features--resource.md) for state and slot contracts.
+
 ### Form
 
 ```tsx fragment — validation, field values, submit mutation, and product copy remain in the app
 import { FormActionsBar, FormField, FormSection, SubmitStateButton } from "themelia-ui/base/forms"
-import "themelia-ui/base/forms.css"
 import { Input } from "themelia-ui/base/text-inputs"
-import "themelia-ui/base/text-inputs.css"
 
 <FormSection title="Billing" description="Where invoices go.">
   <FormField label="Company" error={errors.company}>
@@ -171,7 +174,6 @@ adapter when React Hook Form already owns the state.
 
 ```tsx fragment — route matching and the router link renderer belong to the application
 import { AsideNavShell } from "themelia-ui/layout/settings"
-import "themelia-ui/layout/settings.css"
 
 <AsideNavShell
   title="Settings"
@@ -200,7 +202,7 @@ documentation tree whose vocabulary is not settings.
 
 Look up a specific task with the offline finder. Exact symbols take priority; `--explain`
 shows matched components, selection reasons and direct API anchors. `--json` exposes the
-same records for tools. Guidance marked `family` is a fallback, not a component-specific
+same records for tools. Guidance marked `module` is a fallback, not a component-specific
 recommendation. An empty result means refine the query or inspect the catalogue, not invent
 an export.
 
@@ -218,15 +220,10 @@ the entered value; pending state prevents a second submission.
 ```tsx compile
 import { useState } from "react"
 import { Card, CardHeader, CardContent } from "themelia-ui/base/cards"
-import "themelia-ui/base/cards.css"
 import { FormField } from "themelia-ui/base/forms"
-import "themelia-ui/base/forms.css"
 import { Input } from "themelia-ui/base/text-inputs"
-import "themelia-ui/base/text-inputs.css"
 import { Button } from "themelia-ui/base/buttons"
-import "themelia-ui/base/buttons.css"
 import { Stack } from "themelia-ui/base/structure"
-import "themelia-ui/base/structure.css"
 
 export function RenameRecord({ initialName, save }: {
   initialName: string
@@ -248,7 +245,7 @@ export function RenameRecord({ initialName, save }: {
         catch { setError("Could not save. Your changes are still here; try again.") }
         finally { setPending(false) }
       }}>
-        <Stack gap="md">
+        <Stack gap="sm">
           <FormField label="Name" error={error}>
             <Input value={name} disabled={pending} onChange={(event) => setName(event.target.value)} />
           </FormField>
@@ -270,7 +267,6 @@ filtering contract to your query layer instead of filtering an already paged sub
 ```tsx compile
 import { useState } from "react"
 import { DataView, type DataViewProps } from "themelia-ui/features/data-view"
-import "themelia-ui/features/data-view.css"
 import { FilterType, FilterOperator, type ActiveFilter, type FilterConfig } from "themelia-ui/features/filters"
 
 type RecordRow = { id: string; name: string; status: string }
@@ -298,7 +294,6 @@ edge fade through the public prop instead of adding a local mask or a second scr
 
 ```tsx compile
 import { Tabs, TabList, Tab, TabPanel } from "themelia-ui/base/navigation"
-import "themelia-ui/base/navigation.css"
 
 export function SettingsTabs() {
   return <Tabs defaultValue="general">
@@ -330,6 +325,92 @@ Only use states the selected module exposes; the API reference is authoritative.
 complete examples above type-check against the built package, but their application
 callbacks are illustrative: verify persistence and browser behaviour in your app.
 
+## Decide the owners before JSX
+
+| Owner | Insets and type | Name and command scope | Parent responsibility |
+| --- | --- | --- | --- |
+| `Page` | Route geometry; header owns heading type | One route heading; route commands | Data, routing and independent subjects |
+| `Card` / parts | Surface and content inset; header owns title/description | A bounded subject; commands for that subject | Arrange sibling subjects, choose heading level |
+| `ContentBlock` | Title/content gap; `plain` has no inset, decorated surfaces add one | Supporting content within a subject | Decide whether another independent surface is warranted |
+| `MetadataList` / values | Fact layout; labels and semantic value formatting | Read-only facts, not editable labels | Permission-filtered records and value descriptors |
+| Analytics blocks | Quantity hierarchy and responsive metric arrangement | Measures and their period; metric actions | Query, unknown quantities and interpretation |
+| `FormSection` | Section inset and heading; `flat` retains its padding | Editable region title; section-specific actions | Form, values, validation and completion |
+| `FieldGroup` | Related control arrangement and support line | Fieldset/legend for a group; children retain distinct labels | Group disabled state and validation policy |
+| `FormField` / binding | Label and support typography, control association | One editable field | Value, mutation and explicit name/ARIA overrides |
+| `Stack` / `Grid` | Shared gaps; no new typography owner | Passive arrangement | Choose whether child insets already supply separation |
+| `DataView` | Filter/table shell and responsive filter presentation | Resource-browser commands | Transport, page totals and selection lifetime |
+| `DataTable` | Tabular interaction and table geometry | Column/row names and row commands | Filters, surrounding surface and server transport |
+| `FilterLayout` / slots | Responsive controls and sheet | Filter controls only | Shared filter state; put export/create in action slots |
+
+`surface="flat"` changes decoration, not the inset contract. Several flat FormSections
+inside CardContent accumulate the card content inset and each section's inset. Use the
+ready Card body when that separation is useful; use parts when you need a different region
+arrangement. `Stack gap="none"` is appropriate when adjacent sections already own their
+vertical separation. Do not compensate by assigning private padding variables or local type.
+
+These are fragments; the [complete workflows](./reference-workflows.md) include state,
+helpers and submission behavior.
+
+```tsx fragment — fields and subject data come from the application
+<Card title="Account details">
+  <Stack gap="none">
+    <FormSection surface="flat" title="Contact">{contactFields}</FormSection>
+    <FormSection surface="flat" title="Billing">{billingFields}</FormSection>
+  </Stack>
+</Card>
+```
+
+```tsx fragment — parts expose the same owners; table rows and columns are application data
+<Card>
+  <CardHeader title="Related records" titleLevel={2} />
+  <CardContent><DataTable data={rows} columns={columns} /></CardContent>
+</Card>
+```
+
+Use sibling Cards for independent subjects. Use ContentBlock inside a Card for supporting
+prose. Repeating the route heading as each Card title adds no new subject. Repeating a
+FormField label in a nested DisplayLabel creates competing names; supply the field label
+once and let FormField associate it. A FieldGroup legend names the group, so its children's
+labels should identify their distinct values. Labels on different records may repeat.
+
+```tsx fragment — each subject supplies its own application-owned facts
+<Grid columns={{ base: 1, md: 2 }}>
+  <Card title="Contact"><MetadataList items={contactFacts} /></Card>
+  <Card title="Billing"><MetadataList items={billingFacts} /></Card>
+</Grid>
+```
+
+Grid owns separation between the sibling subjects and their responsive columns. Each Card
+owns its header and body inset. For a resource browser, DataView already owns the filter/table
+frame: put a Heading and supporting Text beside that frame instead of wrapping it in another
+Card. The [resource workflow](./reference-workflows.md) demonstrates a constrained parent;
+the detail workflow demonstrates a secondary table within an independent titled subject.
+
+Keep a record's command beside that record, a page command in the page header, and a
+selected-row command in the table's bulk-action seam. Filter toolbars communicate query
+state; export and create belong in the action slots. Applications decide destructive policy,
+field-per-row arrangements and permission boundaries.
+
+For server filtering, use `filtering.filterRows: ({ data }) => [...data]` when the server
+already matched the page. DataView's default filtering is local and can remove valid server
+matches whose search fields are absent from the visible columns. Use an app-owned cursor
+footer when totals are unknown; never invent a page count. Drop to DataTable when the app
+already owns the browser shell, filters and command placement.
+
+Selector variants serve different lifecycles: SuggestionsCombobox uses the generic lookup
+hook; AsyncCombobox accepts application-owned results; ResourceCombobox owns the ready
+single-resource fetching presentation. Use `scopeKey` on SuggestionsCombobox or ResourceCombobox when workspace or permission context changes without a
+query change. It invalidates lookup results, not the controlled selection. The application
+clears a value that is invalid in the new context.
+
+```bash
+node node_modules/themelia-ui/scripts/consumer/find-component.mjs "editable section" --context=existing-surface --context=editable --explain
+node node_modules/themelia-ui/scripts/consumer/find-component.mjs "resource selector" --context=changing-scope --json
+```
+
+Context matches are positive evidence. Uncurated exports remain visible with unknown
+context coverage; they do not become recommendations by omission.
+
 ## When to wrap, compose, or contribute
 
 - **Wrap** when the product needs a stable local name or defaults around one module.

package/docs/learn/forms.md

@@ -69,9 +69,10 @@ consumer on plain state never resolves react-hook-form.
 
 ## Field chrome
 
-`FormField` renders exactly **one** supporting line, resolved as `error || helperText ||
-hint`. They replace each other rather than stacking, so a field never grows or shifts as
-validation state changes. It also owns the wiring: it associates the label, points
+`FormField` renders at most **one** supporting message, resolved as `error || helperText ||
+hint`. They replace each other rather than stacking. A message can wrap, and adding or
+changing it can change field height; check long translated errors at narrow widths.
+It also owns the wiring: it associates the label, points
 `aria-describedby` at the supporting line, and sets `aria-invalid` on the control when there
 is an error, without overriding any of these that the caller set explicitly. Errors are
 announced politely (`role="status"`), so validation firing on each keystroke does not
@@ -80,6 +81,25 @@ interrupt typing.
 `FieldGroup` covers several controls sharing one label and one supporting line — a date
 range, a name split in two.
 
+## Sections and completion
+
+Use FormSection for an editable region inside a form, Card for an independent subject,
+and ContentBlock for supporting read-only prose. Flat FormSections retain region padding;
+an enclosing Stack can use `gap="none"` when that padding supplies the desired separation.
+FieldGroup supplies fieldset/legend semantics. Each child FormField still needs a distinct
+label. A section heading is not a field label.
+
+A resolved promise is not evidence that validation succeeded. ActionDialog normally closes
+after its confirmation callback resolves. Set `closeOnAsyncComplete={false}` when the app
+resolves with errors, and close controlled `open` only after explicit success. For a native
+form, use `formId` to associate the dialog's submit action with that form; avoid also invoking
+the mutation in `onConfirm`. Native constraint validation, the submit handler and domain
+validation then each have one owner. Prevent duplicate submissions while pending, retain
+drafts after rejection and associate errors with the relevant field or root region.
+
+See the complete [multi-section form and nested action](./reference-workflows.md) sources.
+For the inset and gap contract, see [Structure and spacing](./structure-and-spacing.md#use-the-two-spacing-roles).
+
 ## Generated forms
 
 When the fields come from a schema at runtime, use `features/schema-form`. When they are

package/docs/learn/framework-wiring.md

@@ -22,7 +22,9 @@ cells. Write it once:
 import type { LinkRenderer } from "themelia-ui/layout/sidebar"
 
 export const renderLink: LinkRenderer = ({ href, children, active, disabled, external, ...rest }) =>
-  disabled || !href ? <span {...rest}>{children}</span> : <AppLink to={href} {...rest}>{children}</AppLink>
+  disabled || !href ? <span {...rest}>{children}</span>
+    : external ? <a href={href} {...rest}>{children}</a>
+    : <AppLink to={href} {...rest}>{children}</AppLink>
 ```
 
 Return one element and spread the rest of the props onto it: they carry the class, the
@@ -50,6 +52,20 @@ async lifecycle; the application decides cache invalidation, retries, and error
 </ResourceIndexShell>
 ```
 
+## Lookup and navigation lifetimes
+
+Pass a stable `scopeKey` to ResourceCombobox, SuggestionsCombobox or useSuggestions when the lookup's workspace, locale or
+permission context changes. Changing callback identity alone does not refetch. A scope
+change aborts old work, hides old results/errors and refetches an eligible open query while
+retaining query, controlled value and open state. Late responses from an old scope cannot
+complete the current lookup. The app owns whether the selected id remains valid.
+
+Sidebar workspace disclosure keeps the mobile sheet open. A selected workspace marked
+`external: false` dismisses the sheet after selection; external destinations retain native
+target/rel behavior. Forward renderer props, including the click handler, to the real link.
+The app's router handles same-app addresses and preserves modifiers and new-tab gestures.
+See the [workspace reference](./reference-workflows.md).
+
 ## Permissions
 
 Resolve authorization before constructing actions. Omit an action the user cannot perform;
@@ -58,29 +74,41 @@ through the module's tooltip or description seam.
 
 ## Translation
 
-Supply user-facing package copy through each component's `strings` prop. Keep product copy
+Supply component-owned copy through the selected API's documented `strings` prop. Passive
+components whose copy comes from children need no strings object. Keep product copy
 in application data or children. The default objects are exported so a locale can start
 from the complete shape rather than guessing keys; see [Internationalization](./i18n.md).
 
 ## Server rendering and client boundaries
 
-Import server-pure formatting modules freely. Interactive modules carry their own
-`"use client"` boundary in the published entrypoint. Do not wrap the whole package in one
-client module: exact subpaths keep server-pure imports server-pure and optional peers
-isolated.
+Interactive and provider-dependent entrypoints carry `"use client"`, including
+`themelia-ui/primitives` and `themelia-ui/ui-provider`; passive modules such as
+`themelia-ui/base/structure` can remain server-pure. Inspect the exact published entrypoint
+rather than inferring its boundary from its name. In a React Server Components framework, a server component
+can render those client components with serializable props; callbacks, hooks and live
+controlled state belong in an application client component. A provider can receive server
+rendered children, so keep the boundary around the interactive region rather than the whole
+page. Check your framework's serialization rules for config containing functions or modules.
+
+Formatting helpers exported from `primitives` share its client boundary: do not call them
+from an RSC server component as if they came from a server-pure subpath. Format server data
+with the application's server utilities or render the corresponding display primitive.
+`themelia-ui/theming` exports pure derivation helpers without a client directive. Exact
+subpaths also keep optional peers isolated. Ordinary Node SSR can load and render the
+component modules; that does not make their exports server-callable in RSC.
 
 For CSP, portals, nested theme regions, and defaults, use
 [Provider and scoping](./provider-and-scoping.md). Do not recreate provider context in an
 application adapter unless the documented public hooks are insufficient.
 
-## Vite, Next.js, and CSS entrypoints
+## Vite, Next.js, and CSS
 
-The JavaScript imports no CSS: import the exact module stylesheet beside the component. In a
-framework that restricts where global CSS may be imported, collect the same module
-stylesheets in its permitted application or route-layout entry. Do not replace them with
-source paths. `style.css` loads every module; prefer module stylesheets when a route uses a
-few. Server rendering and test runners are covered in
-[Loading the CSS](./installation.md#loading-the-css).
+A component brings its own CSS, so there is no stylesheet to collect: it arrives through the
+component's JavaScript, which your bundler processes. Frameworks that render on the server
+with Vite, such as Astro, React Router, TanStack Start and Vike, list the package in
+`ssr.noExternal`; see [Server rendering with Vite](./installation.md#server-rendering-with-vite).
+Parcel needs its `packageExports` option. Next.js needs nothing. Pages with no bundler link
+`style.css`.
 
 Server-rendered HTML and the client bundle must load the same theme tokens before hydration.
 Apply the theme attribute and provider configuration from the same persisted value to avoid

package/docs/learn/i18n.md

@@ -5,8 +5,10 @@ overridable, and nothing in it inspects `navigator.language` or imports a transl
 
 ## Strings
 
-Each module exports a `*Strings` interface and a `default*Strings` object, and its
-components take a `strings` prop:
+Components that own visible or accessible copy document a `strings` prop; their modules
+export the matching `*Strings` interface and `default*Strings` object. Passive structures
+and components whose copy comes entirely from children need no strings object. Read the
+selected API rather than adding `strings` by analogy:
 
 ```tsx fragment — shape only, not a program
 <Copyable strings={{ copy: "Kopieren", copied: "Kopiert" }} value={apiKey} />

package/docs/learn/installation.md

@@ -4,16 +4,19 @@
 npm install themelia-ui
 ```
 
-React 19 and `react-dom` are required peers. Everything else is optional and only pulled in
-by the module that needs it; see [Optional peers](#optional-peers).
+React 19 and `react-dom` are required peers. The package's regular dependencies install
+automatically; additional peer packages are optional and resolved only by the modules
+that need them. See [Optional peers](#optional-peers).
 
 ## Browser support
 
-Chrome and Edge 125, Firefox 121 and Safari 16.4 or newer. The stylesheets rely on
-`round()`, `:has()`, `:dir()` and `color-mix()` with no fallback below those versions.
-Entrance transitions use `@starting-style` and simply don't animate where it is missing.
-If your bundler lowers CSS for older targets, keep `:dir()` out of it: lowered, it becomes a
-list of right-to-left languages and ignores `dir="rtl"`.
+Chrome and Edge 125, Firefox 121 and Safari 17.5 or newer. The stylesheets rely on
+`round()`, `:has()`, `:dir()`, `color-mix()` and `light-dark()` with no fallback below those
+versions. Entrance transitions use `@starting-style` and simply don't animate where it is
+missing. If your bundler lowers CSS for older targets, keep `:dir()` and `light-dark()` out of
+it: lowered, `:dir()` becomes a list of right-to-left languages and ignores `dir="rtl"`, and
+`light-dark()` resolves where a theme variable is declared, so a dark region inside a light
+page keeps the light colours.
 
 ## Import exactly what you use
 
@@ -36,41 +39,67 @@ The exact import for every module is in
 
 ## Loading the CSS
 
-The package ships three kinds of stylesheet:
+### In a bundled app
 
-| Import | Contains |
-| --- | --- |
-| `themelia-ui/<module>.css` | `core.css`, then the rules of the module and of the modules it draws with |
-| `themelia-ui/style.css` | `core.css` and every module, in one file |
-| `themelia-ui/core.css` | Tokens, themes, typefaces, the base reset and the cascade layer order; no component rules |
+A component brings its own CSS. Import it from its subpath and nothing else: Vite, webpack,
+Rspack and the frameworks built on them, such as Next.js and React Router, add its stylesheet
+with its JavaScript, include each stylesheet once however many components need it, and leave
+out the CSS of any module the application never imports. Your bundler processes the kit's CSS
+like your own, so the note on lowering under [Browser support](#browser-support) applies to it.
+
+Do not also import `themelia-ui/style.css` or a module stylesheet from JavaScript; that loads
+the same rules twice. The upgrade codemod removes those imports.
 
-[`imports.md`](../generated/imports.md) gives each module's stylesheet path. A module whose
-components draw nothing has no stylesheet.
+Parcel reads a package's `exports` only when the application's `package.json` sets
+`"@parcel/resolver-default": { "packageExports": true }`.
 
-### Import the stylesheets
+### Server rendering with Vite
+
+Astro, React Router, TanStack Start, Vike and other frameworks that render on the server with
+Vite hand installed packages to Node, which loads the kit without its CSS. List `themelia-ui`,
+and any installed package that imports it, in `ssr.noExternal`, so Vite processes it:
+
+```ts fragment — the consuming application's bundler config, not compiled against the package
+// vite.config.ts, or the `vite` key of astro.config.mjs
+export default {
+  ssr: { noExternal: ["themelia-ui"] },
+}
+```
 
-The JavaScript imports no CSS. Import each module's stylesheet beside its JavaScript, as the
-examples in these docs do, or `style.css` once. Vite, webpack, Rspack, Next.js and other
-bundlers that handle CSS imports include each file once, however many modules import it. A
-component whose stylesheet is not imported renders unstyled.
+Astro gathers a page's CSS on the server, so without this line it renders the kit unstyled.
+React Router takes CSS from the client build; the line fixes its development server's first
+render. Next.js needs nothing.
+
+### Without a bundler
+
+A page that links stylesheets directly links `style.css`, which includes `core.css`:
+
+| Stylesheet | Contains |
+| --- | --- |
+| `themelia-ui/core.css` | Tokens, themes, typefaces, the base reset and the cascade layer order; no component rules |
+| `themelia-ui/style.css` | `core.css` and every module, in one file |
 
 ### In Node
 
-The package is ES modules, and its JavaScript imports no CSS, so Node loads it as it is:
-server rendering and test runners need no configuration for it, and CommonJS code on Node
-20.19 or later can `require()` it. Jest is the exception, because it transforms nothing in
-`node_modules` by default: exempt the package in `transformIgnorePatterns`.
+The package is ES modules. Its JavaScript imports its CSS through the package's private
+`imports` map, which resolves to an empty module outside a bundler, so Node loads it as it
+is, without the CSS. Test runners need no configuration for it, and CommonJS code on Node
+20.19 or later can `require()` it; a server render needs configuration only where the
+framework gathers CSS on the server, as in
+[Server rendering with Vite](#server-rendering-with-vite). Jest is the exception: it needs
+29.4 or newer, which resolves the `imports` map, and it transforms nothing in `node_modules`
+by default, so exempt the package in `transformIgnorePatterns`.
 
 ### `core.css` on its own
 
-Every module stylesheet begins by importing `core.css`, so a component never needs a
-separate core import to render correctly. Import `core.css` on its own when application CSS
-uses the tokens on a page without kit components, or to place the kit's layers next to
-another layered stylesheet, as in the [Tailwind setup](./theming.md#tailwind-css-v4).
+Import `core.css` on its own when application CSS uses the tokens on a page without kit
+components, or to place the kit's layers next to another layered stylesheet: import it from
+JavaScript before that stylesheet. It is the file the components import, so a bundler keeps
+one copy; an `@import` from a CSS file inlines a second one.
 
 ### Overriding the kit
 
-Component rules live in the cascade layers `tokens, theming, base, components, utilities`,
+Component rules live in the cascade layers `tokens, base, components, utilities`,
 so unlayered application CSS wins over them whatever its order or specificity. Select with
 the stable `data-slot` attributes and BEM hooks such as `{name}--component`, and select a
 state with the attributes the primitives set (`data-open`, `data-checked`, `data-disabled`,
@@ -79,8 +108,8 @@ releases.
 
 ## Optional peers
 
-Every peer other than React is optional, and each is reachable only from the modules that
-use it: a consumer who never imports `features/map` never resolves Leaflet.
+Every peer other than `react` and `react-dom` is optional, and each is reachable only from
+the modules that use it: a consumer who never imports `features/map` never resolves Leaflet.
 
 The peer-to-module table is in [`docs/generated/imports.md`](../generated/imports.md).