ferrovue 0.11.0 → 0.12.0

package/README.md

@@ -4,6 +4,7 @@
 [![npm](https://img.shields.io/npm/v/ferrovue.svg)](https://www.npmjs.com/package/ferrovue)
 [![docs.rs](https://img.shields.io/docsrs/ferrovue)](https://docs.rs/ferrovue)
 [![CI](https://github.com/Kinsmir/ferrovue/actions/workflows/ci.yml/badge.svg)](https://github.com/Kinsmir/ferrovue/actions/workflows/ci.yml)
+[![Mutation score](https://img.shields.io/endpoint?url=https%3A%2F%2Fbadge-api.stryker-mutator.io%2Fgithub.com%2FKinsmir%2Fferrovue%2Fmain)](https://dashboard.stryker-mutator.io/reports/github.com/Kinsmir/ferrovue/main)
 [![License: MIT OR Apache-2.0](https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-blue.svg)](#licence)
 
 Documentation: [docs.rs/ferrovue](https://docs.rs/ferrovue) (API and guide) · [kinsmir.github.io/ferrovue](https://kinsmir.github.io/ferrovue/) (guide and overview)
@@ -34,7 +35,7 @@ element structure, attribute order, whitespace and fragment markers.
 | | What it is | Published as |
 |---|---|---|
 | `packages/ferrovue` | The compiler, the `ferrovue` command, the Vite plugin and the browser client (TypeScript) | npm: [`ferrovue`](https://www.npmjs.com/package/ferrovue) |
-| `crates/ferrovue` | The runtime the generated Rust calls: escaping, slots, islands, `<RouterLink>` matching. It re-exports `ferrovue-router`, `ferrovue-i18n` and `ferrovue-core`, released with it | crates.io: [`ferrovue`](https://crates.io/crates/ferrovue) ([API docs](https://docs.rs/ferrovue)) |
+| `crates/ferrovue` | The runtime the generated Rust calls: escaping, slots, islands, `<RouterLink>` matching. It holds `ferrovue-core`, `ferrovue-router` and `ferrovue-i18n`, released with it, as its modules `core`, `router` and `i18n` | crates.io: [`ferrovue`](https://crates.io/crates/ferrovue) ([API docs](https://docs.rs/ferrovue)) |
 
 ## Quick start
 
@@ -56,7 +57,7 @@ the configuration at your project root yourself:
 
 ```json
 {
-  "$schema": "https://cdn.jsdelivr.net/npm/ferrovue@0.8.0/schema.json",
+  "$schema": "https://cdn.jsdelivr.net/npm/ferrovue@0.12.0/schema.json",
   "components": "client/components",
   "out": "src/generated"
 }
@@ -75,8 +76,9 @@ read `$schema`. Offline, the copy in the installed package works as well:
 | `routes` | no | JSON file listing the app's routes: each a vue-router path, or `{ "path", "name", "children" }`. Or `{ "pages": "client/pages" }`: a folder of pages, whose file names give the routes as vue-router's file-based routing reads them (`index.vue`, `[id].vue`, `[[id]].vue`, `[...path].vue`, `(group)` folders, a `name.vue` beside `name/` as its layout), each page compiled as a component. Needed for `<RouterLink>`, `<RouterView>` and `useRoute()` |
 | `router` | no | Instead of `routes`: `{ routes, base?, linkActiveClass?, linkExactActiveClass? }`, matching `createWebHistory(base)` and `createRouter`'s options |
 | `stores` | no | Directory of Pinia option stores whose state components may read |
-| `trustedHtml` | no | Rust type of a `TrustedHtml` prop (needed for `v-html`): `ferrovue::BasicHtml` (text with a few formatting tags, built in), `ferrovue::InlineHtml` (inline formatting tags only, built in, which makes every `TrustedHtml` prop inline HTML), `ferrovue::Sanitised` (HTML cleaned by ammonia, the `ammonia` feature), or a type of your own such as `crate::html::CleanHtml` |
-| `dateType` | no | Rust type of a `Date` prop: `ferrovue::JsDate` (the default), `chrono::DateTime<chrono::Utc>` (the `chrono` feature), or a type of your own that implements `ferrovue::JsTime`. See [`dates_and_prices`](https://docs.rs/ferrovue/latest/ferrovue/guide/dates_and_prices/index.html#date-props) |
+| `trustedHtml` | no | Rust type of a `TrustedHtml` prop (needed for `v-html`): `ferrovue::html::BasicHtml` (text with a few formatting tags, built in), `ferrovue::html::InlineHtml` (inline formatting tags only, built in, which makes every `TrustedHtml` prop inline HTML), `ferrovue::html::Sanitised` (HTML cleaned by ammonia, the `ammonia` feature), or a type of your own such as `crate::html::CleanHtml` |
+| `dateType` | no | Rust type of a `Date` prop: `ferrovue::date::JsDate` (the default), `chrono::DateTime<chrono::Utc>` (the `chrono` feature), or a type of your own that implements `ferrovue::date::JsTime`. See [`dates_and_prices`](https://docs.rs/ferrovue/latest/ferrovue/guide/dates_and_prices/index.html#date-props) |
+| `unions` | no | Rust enums of your own for unions of string literals, by `type` alias: `{ "Tone": "crate::domain::Tone" }`. Generated code uses the enum, which implements `ferrovue::props::Union` and has the variants ferrovue would generate, and generates none for the union. See [`props`](https://docs.rs/ferrovue/latest/ferrovue/guide/props/index.html#unions-mapped-to-existing-enums) |
 | `helpers` | no | `{ module, functions }`: functions a template may call, each mapped to a Rust twin |
 | `twins` | no | Components ferrovue does not compile, each rendered by a Rust function of yours: `{ "VBtn": { "rust": "crate::ui::v_btn", "props": { "label": "string" }, "slots": ["default"] } }`. See [Rust twins](https://docs.rs/ferrovue/latest/ferrovue/guide/errors_and_limits/index.html#rust-twins) |
 | `i18n` | no | vue-i18n: `{ messages, locale?, fallbackLocale? }`, the directory of locale files (`en.json`, `nl.json`), the default locale and the fallbacks |
@@ -171,7 +173,7 @@ The crate's features:
 
 - `router` and `i18n`, both on by default: vue-router and vue-i18n. An application with neither
   routes nor translations can leave them out, and build neither `ferrovue-router` nor
-  `ferrovue-i18n`: `ferrovue = { version = "0.8", default-features = false }`.
+  `ferrovue-i18n`: `ferrovue = { version = "0.12", default-features = false }`.
 - `axum` and `actix-web`: `Html` is an `IntoResponse` or a `Responder`, so a handler responds with
   the component as `text/html; charset=utf-8`. `into_html(props)` and `into_island(props)` take the
   props by value, so a handler that builds them returns the page:
@@ -184,12 +186,12 @@ The crate's features:
 
 - `stream`, which `axum` and `actix-web` turn on: `HtmlStream`, a page sent in the order its parts
   are ready.
-- `maud`: `ferrovue::Html` implements `maud::Render`, so `(greeting::html(&props))` goes straight
+- `maud`: `ferrovue::html::Html` implements `maud::Render`, so `(greeting::html(&props))` goes straight
   into a `maud::html!` page.
 - `dioxus`: `{greeting::island(&props)}` in a Dioxus 0.7 `rsx!` is the island element itself, with
   exactly the markup Vue hydrates inside it (`examples/dioxus`).
-- `ammonia`: `ferrovue::Sanitised`, HTML cleaned by [ammonia](https://docs.rs/ammonia), for
-  `v-html`. `ferrovue::BasicHtml` and `ferrovue::InlineHtml` are built in; the
+- `ammonia`: `ferrovue::html::Sanitised`, HTML cleaned by [ammonia](https://docs.rs/ammonia), for
+  `v-html`. `ferrovue::html::BasicHtml` and `ferrovue::html::InlineHtml` are built in; the
   [`escaping`](https://docs.rs/ferrovue/latest/ferrovue/guide/escaping/index.html) guide describes
   all three.
 
@@ -221,11 +223,11 @@ ferrovue compiles `<script setup lang="ts">` components, and components with no
 
 | Area | Supported |
 |---|---|
-| Prop types | `string`, `number` (integers, `i64`, written and computed as JavaScript does, exact within ±2⁵³), `Float` from `ferrovue/types` (fractions, `f64`), `boolean`, unions of two or more string literals (`"sm" \| "md"`, an alias, or written in place), each a Rust enum generated for it (`Size::Md`, `"md".parse::<Size>()`, written and serialised as its literal; see the crate's [`props`](https://docs.rs/ferrovue/latest/ferrovue/guide/props/index.html#unions-of-string-literals) guide), `T \| undefined`, `T \| null` (an `Option` written as `null`), arrays (`T[]`, `Array<T>`, `readonly T[]`), interfaces and object type aliases (recursive ones too), dictionaries (`Record<string, T>`, `{ [key: string]: T }`, `ferrovue::Record` in Rust, which keeps JavaScript's order of keys), another component's exported `Props`, `TrustedHtml`, `InlineHtml`, `Date` (a prop, optional or nullable too, and inside lists, dictionaries and interfaces: `ferrovue::JsDate`, or `chrono::DateTime<Utc>` with the `chrono` feature) |
+| Prop types | `string`, `number` (integers, `i64`, written and computed as JavaScript does, exact within ±2⁵³), `Float` from `ferrovue/types` (fractions, `f64`), `boolean`, unions of two or more string literals (`"sm" \| "md"`, an alias, or written in place), each a Rust enum generated for it (`Size::Md`, `"md".parse::<Size>()`, written and serialised as its literal; see the crate's [`props`](https://docs.rs/ferrovue/latest/ferrovue/guide/props/index.html#unions-of-string-literals) guide), or an enum of the application's own that `unions` names for the alias; a list of such a union, a list of its enum (`Size[]` is `Vec<Size>`); `T \| undefined`, `T \| null` (an `Option` written as `null`), arrays (`T[]`, `Array<T>`, `readonly T[]`), interfaces and object type aliases (recursive ones too), dictionaries (`Record<string, T>`, `{ [key: string]: T }`, `ferrovue::props::Record` in Rust, which keeps JavaScript's order of keys), another component's exported `Props`, `TrustedHtml`, `InlineHtml`, `Date` (a prop, optional or nullable too, and inside lists, dictionaries and interfaces: `ferrovue::date::JsDate`, or `chrono::DateTime<Utc>` with the `chrono` feature) |
 | Shared types | Interfaces and type aliases imported from `.ts` files (generated once, into `types.rs`; imported by a relative path or through an alias the project declares, in its tsconfig.json's `compilerOptions.paths` or, with the Vite plugin, Vite's `resolve.alias`: `@/lib/format`), from a store's file, or from another component's `.vue` file; objects of a shared type can be passed between components. A TypeScript `enum` of string members is a Rust enum, as a union of string literals is, its variants named after its members; one of numbers is a number |
-| Constants | Constants imported from `.ts` files, object constants declared in `<script setup>`, and `enum`s (imported, or declared in the component), evaluated when the component is compiled: strings, numbers, booleans, `null`, arithmetic and joined strings of them as JavaScript evaluates them (`60 * MINUTE`, `` `${BASE}/feed` ``, `"#" + 1.5`, and `**` where it gives an exact integer within ±2⁵³), lists of them, objects of them read field by field (`LABELS.save`, `Tone.Loud`, `Rank[5]`), and lists of objects of them, which become a `const` in `types.rs` (`{ value, label }` items get a type named after the constant, `OptionsItem`, unless the constant is typed with an interface: `OPTIONS: Option[]`; a field that is `null` in some items is `T | null`); lookup tables: an object constant (`as const`, `Record<Size, T>` or untyped, keys computed from enum members too) read by a key whose type is a union of string or integer literals or an `enum` (a prop, a `computed`, a `v-for` item's field, a `?:` of literals), compiled to a `match` over the members (over the variants of a union's enum, with no catch-all arm), read on by field (`THEME[tone].fg`) in text, attributes, `:class` and `:style`, with `undefined` for a member the object lacks (`ICONS[kind] ?? "none"`, `ICONS[kind]?.label`, `v-if="ICONS[kind]"`, `kind && ICONS[kind]`); a free-text key tested with `Object.hasOwn(ROLES, key)`, against the object's own keys, which narrows the key for `ROLES[key]` in what follows; `Object.keys()` of an object constant; a constant `new Map([[key, value], …])` of string or integer keys, read with `.get(key)` (`undefined` for a key it lacks) and `.has(key)`. See the crate's [`props`](https://docs.rs/ferrovue/latest/ferrovue/guide/props/index.html#constants) guide |
-| Props | `withDefaults`, destructured props with defaults (`const { size = "md" } = defineProps<…>()`), the props object (`const props = defineProps<…>()`, then `props.label` in the template or in script code), optional booleans (Vue casts an absent one to `false`), `defineModel` (named, required, with defaults), components with no props. A generic component (`<script setup generic="T extends Item">`) renders each type parameter as its constraint, which is all the template can rely on |
-| Setup | `ref`/`shallowRef`, `computed` (an expression, or a body of statements: see Statements; one that may throw, through `.repeat()`, `.padStart()`, a date, `$t` or a helper, is evaluated where the render first reads it, once, as Vue does), refs that start empty, typed by their type argument (`ref<Row[]>([])`, `ref<Row>()`, `ref<string \| undefined>(undefined)`), plain `const`/`let`, `.value` in script code, helpers with Rust twins, functions (see Functions), a plain `<script>` block beside setup. Lifecycle hooks, `watch` (not `immediate`), `defineEmits`, `defineSlots`, `defineOptions`, `defineExpose` and template refs (`ref(null)`, `useTemplateRef`) are client-only, as is a function only an event handler calls. The template may name them only from event handlers, which the server drops |
+| Constants | Constants imported from `.ts` files, object constants declared in `<script setup>`, and `enum`s (imported, or declared in the component, with members set to such constants or to earlier members), evaluated when the component is compiled: strings, numbers, booleans, `null`, arithmetic and joined strings of them as JavaScript evaluates them (`60 * MINUTE`, `` `${BASE}/feed` ``, `"#" + 1.5`, and `**` where it gives an exact integer within ±2⁵³), lists of them, objects of them read field by field (`LABELS.save`, `Tone.Loud`, `Rank[5]`), and lists of objects of them, which become a `const` in `types.rs` (`{ value, label }` items get a type named after the constant, `OptionsItem`, unless the constant is typed with an interface: `OPTIONS: Option[]`; a field that is `null` in some items is `T | null`); lookup tables: an object constant (`as const`, `Record<Size, T>` or untyped, keys computed from enum members too) read by a key whose type is a union of string or integer literals or an `enum` (a prop, a `computed`, a `v-for` item's field, a `?:` of literals), compiled to a `match` over the members (over the variants of a union's enum, with no catch-all arm; a table of a union's members, `Record<Tone, Tone>`, reaches a union prop as a `match` from variant to variant), read on by field (`THEME[tone].fg`) in text, attributes, `:class` and `:style`, with `undefined` for a member the object lacks (`ICONS[kind] ?? "none"`, `ICONS[kind]?.label`, `v-if="ICONS[kind]"`, `kind && ICONS[kind]`); a free-text key tested with `Object.hasOwn(ROLES, key)`, against the object's own keys, which narrows the key for `ROLES[key]` in what follows; `Object.keys()` of an object constant; a constant `new Map([[key, value], …])` of string or integer keys, read with `.get(key)` (`undefined` for a key it lacks) and `.has(key)`. See the crate's [`props`](https://docs.rs/ferrovue/latest/ferrovue/guide/props/index.html#constants) guide |
+| Props | `withDefaults`, destructured props with defaults and new names (`const { size = "md", label: text } = defineProps<…>()`), the props object (`const props = defineProps<…>()`, then `props.label` in the template or in script code), optional booleans (Vue casts an absent one to `false`), `defineModel` (named, required, with defaults), components with no props. A generic component (`<script setup generic="T extends Item">`) renders each type parameter as its constraint, which is all the template can rely on |
+| Setup | `ref`/`shallowRef`, `computed` (an expression, or a body of statements: see Statements; one that may throw, through `.repeat()`, `.padStart()`, a date, `$t` or a helper, is evaluated where the render first reads it, once, as Vue does), refs that start empty, typed by their type argument (`ref<Row[]>([])`, `ref<Row>()`, `ref<string \| undefined>(undefined)`), refs of a union of string literals, held as its enum (`ref<Choice>(props.tone ?? "")`, a member, a value of the union, a lookup table's value, or a `?:` or `??` of them), plain `const`/`let`, `.value` in script code, helpers with Rust twins, functions (see Functions), a plain `<script>` block beside setup. Lifecycle hooks, `watch` (not `immediate`), `defineEmits`, `defineSlots`, `defineOptions`, `defineExpose` and template refs (`ref(null)`, `useTemplateRef`) are client-only, as is a function only an event handler calls. The template may name them only from event handlers, which the server drops |
 | Statements | in a `computed`'s body and in a list method's callback (`.map()`, `.filter()`, `.find()`, `.some()`, `.reduce()`, a `.toSorted()` comparator and the others): `const` and `let` of any value the template may compute, destructured too (`const { name, posts: count } = author`); `if` / `else if` / `else` and early `return`, narrowing what follows as TypeScript narrows it (`if (!user) return ""; return user.name`, `if (!a \|\| !a.title) return "-"`); `switch` over a string or a number, with stacked `case`s, `default` and `break`; assignments to the body's `let`s (`=`, `+=`, `-=`, `*=`, `++`, `--` and the others), with the type TypeScript gives them; `for (const x of list)` over a list, `list.entries()`, `Object.keys()` or `Object.entries()`, `for (const ch of text)` over a string by its characters (a character beyond U+FFFF is one), and counting loops `for (let i = 0; i < n; i++)` to an integer bound, with `break`, `continue`, nested loops and `return` inside them, carrying strings, numbers and booleans from one item to the next (`let total = 0; for (const r of rows) total += r.n;`, thousands separators, the largest of a list). Each value is evaluated once, where JavaScript evaluates it, and only on the path that reaches it. `while`, `do…while` and `for…in` loops, assignments to props, refs, `const`s, parameters and fields, `try`, `throw`, `var` and a path that ends without `return` are refused. See the crate's [`script_logic`](https://docs.rs/ferrovue/latest/ferrovue/guide/script_logic/index.html) guide |
 | Functions | functions the template or a `computed` calls: declared in `<script setup>` (`function f(a: T): R { … }`, `const f = (a: T) => …`) or exported from a `.ts` file the component imports, whose bodies hold what a `computed`'s may (see Statements), arrow functions of their own included (`const pad = (k: number) => …`, reading the body's names) and read props, refs, `computed`s, constants and other such functions (a `.ts` file's own constants, functions and imports); parameters by name, optional (`x?: T`), with defaults (`x = 1`, also after an earlier parameter: ``plural = `${word}s` ``) and as object patterns. Each call is translated where it is written, its arguments evaluated once and in order, with the types they have there, so one function serves an integer and a `Float`. A function imported from a `.ts` file needs no `helpers` entry. Recursion, `...rest`, `async` and generators are refused. See the crate's [`script_logic`](https://docs.rs/ferrovue/latest/ferrovue/guide/script_logic/index.html#functions) guide |
 | Object literals | object literals built as the Rust struct of the interface where they go: a `computed` annotated with it (`computed<Card>(…)`, `computed((): Card => …)`, `ComputedRef<Card>`), a function's return type or parameter, a `.map()` callback's return type or the list type its result is given (`computed<Row[]>`, a child's `Row[]` prop: `:rows="items.map((x) => ({ … }))"`), a child's prop typed with an interface (`:item="{ id, label }"`, `v-bind="{ item: { … } }"`), an annotated `const`, `satisfies`; shorthand keys, computed keys the compiler knows (a constant, an enum member), nested literals and array literals of them, a spread of the same type before the other keys (`{ ...card, title }`), optional fields left out or `undefined`, `null` for a `T \| null` field, a member of a field's union of string literals as its enum's variant (`{ size: "md" }`). An untyped literal is refused with a message that says how to type it. See the crate's [`script_logic`](https://docs.rs/ferrovue/latest/ferrovue/guide/script_logic/index.html#object-literals) guide |
@@ -234,7 +236,7 @@ ferrovue compiles `<script setup lang="ts">` components, and components with no
 | Text | `{{ }}` of strings, integers and booleans; `+`, `-`, `*`, `/`, `%`, with integers and fractions as JavaScript computes them; `<`, `>`, `<=`, `>=` (between numbers, or between strings by UTF-16 code unit), `===`, `!==`; unary `-`, `!`; `??`, `\|\|`, `&&`, `?:` (whose branches may differ in type where the value is only written out: in `{{ }}`, a string-valued attribute and a template literal, each branch is written as JavaScript writes it, `{{ n > 0 ? n : "none" }}`); template literals and `String()` of strings, numbers, booleans, values that may be absent (`undefined` or `null`, as JavaScript writes them) and lists (their items joined by `,`); `typeof`; optional chaining `a?.b`, `a?.[i]` and chains that go on past it (`a?.b.c`, `s?.trim().length`, `list?.at(-1)?.name`), with every property and method the value has when present, `undefined` as a whole once `a` is absent; `.length`; `.toString()`, `.toFixed()`, `.toPrecision()` and `.toExponential()` (with no argument or a literal one), `Math.max`/`min` (of a spread list too, `Math.max(...xs)`)/`abs`/`round`/`floor`/`ceil`/`trunc`/`sqrt`/`sign`, the constants of `Math` and `Number`, `**` and `Math.pow()` of an integer and a whole exponent known when compiling, exact within ±2⁵³; `Number()`, `parseInt()` (no radix, 10 or 16), `parseFloat()`; `Number.isNaN()`, `Number.isFinite()`, `Number.isInteger()` and `Number.isSafeInteger()` of a number, present or optional, and `isNaN()` and `isFinite()` of a present number; `JSON.stringify()` of strings, numbers, booleans and lists of those; `encodeURIComponent()` and `encodeURI()`; array literals |
 | Strings | `.trim()`, `.trimStart()`, `.trimEnd()`, `.trimLeft()`, `.trimRight()`, `.toUpperCase()`, `.toLowerCase()`, `.includes()`, `.startsWith()`, `.endsWith()`, `.indexOf()` and `.lastIndexOf()`, with a position or without, `.slice()`, `.substring()`, `.substr()`, `.at()`, `.charAt()`, `.charCodeAt()`, `.codePointAt()`, `.concat()`, `.split()` with a limit or without, `.replace()` and `.replaceAll()` with string patterns (`$&`, `` $` ``, `$'`, `$$` read as JavaScript reads them), `.padStart()`, `.padEnd()`, `.repeat()`, `s[i]`; indices and lengths count UTF-16 code units, as JavaScript's do; a string known to hold ASCII alone (`String(n)`, `n.toFixed(2)`, literals and what is built of them) may be cut into characters and joined again, as a thousands separator is (`String(n).split("").reduce(…)`, slices) (see the crate's [`strings`](https://docs.rs/ferrovue/latest/ferrovue/guide/strings/index.html) guide) |
 | Dates | `new Date(s)` and `Date.parse(s)` of an ISO string (a date alone, or a date and time with a `Z` or an offset, as ECMAScript's date time string format specifies), `new Date(ms)`, `Date.UTC(…)` of one to seven parts, `.toISOString()`, `.toUTCString()`, `.toJSON()`, `JSON.stringify()`, `.getTime()`, `.valueOf()` and the `.getUTC…()` methods, and `<`, `<=`, `>` and `>=` between two dates, invalid dates included, as JavaScript computes them, a date's validity tested with `Number.isNaN(d.getTime())`, and dates chosen with `?:`, `??` and `||` (a date is always truthy, an invalid one too), of a date built in the template or of a `Date` prop, which an island's `data-props` carries as its ISO string and the client turns back into a `Date` before hydrating, and which may be handed to a child's `Date` prop. A date inside a list (`Date[]`, `(Date \| null)[]`), a dictionary (`Record<string, Date>`) or an interface of the props or of a loader's result (`rows: Row[]` with `at: Date`) is read as a prop's date is, walked with `v-for` and the list methods that do not compare or write dates as text, built in an object literal, and turned back into a `Date` in the browser from a plan the compiler writes beside the props (`data-dates`) and the loaders' results. Prices and formatted dates are written in Rust and passed as strings, or filled into a `$t` message. See the crate's [`dates_and_prices`](https://docs.rs/ferrovue/latest/ferrovue/guide/dates_and_prices/index.html) guide |
-| Conditions | `v-if` / `v-else-if` / `v-else`, `?:`, `&&` and `||`, with optional and nullable values narrowed as TypeScript narrows them: `v-if="user"`, `user !== undefined`, `user !== null`, `user != null`, `typeof user !== "undefined"`, and `!user`, `user === undefined` or `user === null` for the `v-else`; a test narrows every operand after it in a chain (`n != null && n > 1 && n < 9`, `n == null \|\| n < 0 \|\| n > 9`, `n != null && n > 1 ? n * 2 : 0`), and `a && b` gives `undefined` where `a`, whose present values are all truthy, is absent (`kind && ICONS[kind]`) |
+| Conditions | `v-if` / `v-else-if` / `v-else`, `?:`, `&&` and `||`, with optional and nullable values narrowed as TypeScript narrows them: `v-if="user"`, `user !== undefined`, `user !== null`, `user != null`, `typeof user !== "undefined"`, and `!user`, `user === undefined` or `user === null` for the `v-else`; a test narrows every operand after it in a chain (`n != null && n > 1 && n < 9`, `n == null \|\| n < 0 \|\| n > 9`, `n != null && n > 1 ? n * 2 : 0`), and `a && b` gives `undefined` where `a`, whose present values are all truthy, is absent (`kind && ICONS[kind]`); a string of a union of string literals narrowed the same way, by `===` and `!==` with a literal, by its truth and by `||`, so that a `ref<Tone | "">` reaches a child's `Tone` prop as `tone \|\| undefined`, `tone === '' ? undefined : tone`, under `v-if="tone !== ''"` or through a `computed` annotated `Tone \| undefined` |
 | Lists | `v-for` over arrays (of strings, numbers, objects or child props), array literals and number ranges (`n in 5`); with an index; with destructured items (`{ id, name } in rows`); nested; on `<template>`. `.includes()` (a number looked for in a list of numbers whether either is a `number` or a `Float`, as JavaScript compares them), `.join()`, and `.filter()`, `.map()`, `.some()`, `.every()`, `.find()`, `.findIndex()`, `.findLast()`, `.findLastIndex()` with an arrow function of the item (a name, or destructured) and its index, whose body is an expression or a body of statements (see Statements), narrowing inside as outside, or with `Boolean`; `.filter(Boolean)` of a list or an array literal whose items may be `null` or `undefined`, which keeps the ones present and truthy as a list of the values (`[name, title, city].filter(Boolean).join(" · ")`); `Boolean(x)`; `.slice()`; an item by its index, `list[i]` with an integer `i` and `list.at(i)` (from the end when negative), `undefined` outside the list and narrowed as other optional values are (`v-if="rows[0]"`); `.indexOf()` and `.lastIndexOf()` of a string, number or boolean, compared with `===` (`NaN` found nowhere, `-0` found as `0`); `.concat()` of lists of one item type (numbers whether `number` or `Float`); `.reduce()` and `.reduceRight()` with an initial value, into a string, a number or a boolean; `.toReversed()`, and `.toSorted()` by `String(x)` as JavaScript sorts without a comparator (`[10, 9, 1]` to `[1, 10, 9]`) or by a comparator `(a, b) => a - b`, `a.k - b.k` of integers or `?:` over `<` and `>` of integers or strings, stable as JavaScript's; `[...list].sort(…)` and `[...list].reverse()`; spread in array literals (`[...a, x, ...b]`) of one item type; `.flat()` of lists of lists, to a literal depth or `Infinity`, and `.flatMap()` with an arrow function that gives a list (flattened one level) or a value (kept as `.map()` keeps it); chained and nested; a computed list read by `v-for`, `.join()`, `.length`, `.includes()`, kept by `computed`, or handed to a child |
 | Dictionaries | `v-for="(value, key, index) in r"` over a `Record<string, T>`, and `([key, value], index) in Object.entries(r)`, in JavaScript's order: keys that are array indices first, in numeric order, then the others as the props give them; `Object.keys(r)`, `Object.values(r)` (of a record of lists too, which `.flat()` joins), `Object.hasOwn(r, key)`, and `Object.entries(r)` read by the list methods, whose arrow functions destructure each pair (`([key, value]) => …`, `([, value]) => …`, `([key, { id }]) => …`) or read its parts (`pair[0]`, `pair[1]`), and walked by `v-for="[key, value] in Object.entries(r).filter(…)"`, kept by `computed` and sorted by a comparator of either part; handed to a child |
 | Attributes | static and bound attributes, boolean attributes, `:hidden`, `data-*` and `aria-*`, `v-bind` objects |
@@ -245,7 +247,7 @@ ferrovue compiles `<script setup lang="ts">` components, and components with no
 | CSS modules | `<style module>` and `<style module="name">`, read as `$style.x`, `name.x`, `$style['x-y']` and through `useCssModule()`, each class a constant in the generated code, when `cssModules` mirrors Vite's `css.modules.generateScopedName`: computed as postcss-modules computes it in Vite (`[local]`, `[name]`, `[hash:base64:5]`, `[path]` and the rest), composed classes, `@value`s and keyframes included |
 | Components | imported child components, `v-bind` of a child's own `Props`, listeners in any form (`@x`, `v-on="obj"`, `@[name]`), which the server skips, `v-model` on a child's `defineModel`, recursion; props named in `kebab-case` or `camelCase`; props named like listeners (`on1`, `onSale`), left out when falsy where Vue's `mergeProps` joins a child's props, as Vue leaves them out; `defineAsyncComponent(() => import("./X.vue"))` (or `{ loader: … }`), rendered as the component it loads, which Vue's server renderer waits for |
 | `<component :is>` | over a closed set of choices, compiled to a `match`: an imported component (`:is="Card"`), an HTML element's name (`is="h2"`), a `computed` or `?:` choosing among them, a prop typed as a union of string literals (`as: "h1" \| "h2"`, a `match` over its enum's variants), and an object of imported components (or element names) declared in setup or imported from a `.ts` file, read by such a prop (`ICONS[name]`); props, fallthrough attributes, slots and scope ids reach each choice as they reach a static child; also inside `<KeepAlive>` and `<Transition>`. See the crate's [`generated_code`](https://docs.rs/ferrovue/latest/ferrovue/guide/generated_code/index.html#component-is) guide |
-| Escape hatches | `<ClientOnly>` from `ferrovue/client`, whose default slot the server never renders, so anything may go in it; components listed in `twins`, rendered by Rust functions of yours. See the crate's [`errors_and_limits`](https://docs.rs/ferrovue/latest/ferrovue/guide/errors_and_limits/index.html#client-only-content) guide |
+| Escape hatches | `<ClientOnly>` from `ferrovue`, whose default slot the server never renders, so anything may go in it; components listed in `twins`, rendered by Rust functions of yours. See the crate's [`errors_and_limits`](https://docs.rs/ferrovue/latest/ferrovue/guide/errors_and_limits/index.html#client-only-content) guide |
 | Fallthrough attributes | what a parent passes a child beyond its props (static and bound attributes, `class`, `style`, `data-*`, `aria-*`, booleans, `undefined`): onto its single root, merged with the root's own class and style and replacing its other attributes where they stand, as Vue's `mergeProps` merges them; none for two roots; on through a root that is a component, or a `<RouterLink>`; with `inheritAttrs: false`, onto the elements or components that bind `v-bind="$attrs"` or a `useAttrs()` binding, before or after their own; beside scope ids. Listeners are dropped, as Vue's server drops them. See the crate's [`generated_code`](https://docs.rs/ferrovue/latest/ferrovue/guide/generated_code/index.html#fallthrough-attributes) guide |
 | Slots | default and named slots, fallbacks, `$slots.name` tests and the same through `useSlots()`, scoped slots (`<slot :item="x">` and `#item="{ item }"` or `v-slot="props"`), whose props a parent can hand to its own children |
 | Forms | `v-model` on text inputs, checkboxes, radios, `<select>` and `<textarea>` (renders the initial state); a `<textarea>`, or an `<input>` with `v-model`, sits inside another element when it would be the component's root (FV0424) |
@@ -253,8 +255,8 @@ ferrovue compiles `<script setup lang="ts">` components, and components with no
 | Vue Router | `<RouterLink>` (resolved by name or imported) with a string `to` or `{ name, params, query, hash }` / `{ path, query, hash }`, `active-class`, `exact-active-class`, `aria-current-value`, `replace`; vue-router's own encoding and active-link matching, nested routes included (a parent link is active on its children's pages, exact only on its own); a history base; optional parameters (`:id?`); routes built from a folder of pages, which the Vite plugin also gives the client as `ferrovue/routes`. `useRoute()` and `$route`: `path`, `fullPath`, `hash`, `name`, `params`, and `query` (a value written once, without `=`, or repeated, exactly as vue-router parses it; `typeof route.query.q === "string"` narrows one to a single string). `<RouterView>`, at the top and in nested route components: each takes the page it shows as a slot |
 | Pinia | option stores with a typed `state`, and setup stores (`defineStore(id, () => { … })`) whose returned refs are typed by `ref<T>()` or their initial literal; read through `useX()` or `storeToRefs`, in the template or in `computed`; getters that are an expression of the state, and a setup store's computeds, which may read each other |
 | vue-i18n | `$t` and `useI18n()`'s `t` and `locale`: named and list values, plurals by vue-i18n's rule, literals, linked messages with `upper`/`lower`/`capitalize`, nested and flat keys, fallback locales, a missing key shown as itself. Messages are parsed at build time by vue-i18n's own compiler |
-| `v-html` | only on a `TrustedHtml` prop (`import type { TrustedHtml } from "ferrovue/types"`), or an `InlineHtml` one (inline tags only, `ferrovue::InlineHtml` on the server, with no `trustedHtml` needed), the only HTML it may write inside a `<p>`; never on a table's structure, a `<select>` or `<optgroup>`, or an SVG or MathML element that holds no HTML. See the crate's [`escaping`](https://docs.rs/ferrovue/latest/ferrovue/guide/escaping/index.html#where-v-html-may-go) guide |
-| Page head | `useHead` (and `useServerHead`) from `@unhead/vue` 3: `title`, `titleTemplate`, `base`, `meta`, `link`, `script`, `style`, `noscript`, `htmlAttrs` and `bodyAttrs`, with values the server computes (props, setup bindings, getters such as `() => props.title`, `list.map(x => ({ … }))` for a list of tags), `key`, `tagPosition`, `tagPriority` and `tagDuplicateStrategy`; `useSeoMeta` (and `useServerSeoMeta`) of string, number, boolean and `null` values. Collected into a `ferrovue::Head` in the order Vue's server runs them, and written as unhead's `renderSSRHead` writes them: its tag order, deduplication, title template and escaping. See the crate's [`head`](https://docs.rs/ferrovue/latest/ferrovue/guide/head/index.html) guide |
+| `v-html` | only on a `TrustedHtml` prop (`import type { TrustedHtml } from "ferrovue/types"`), or an `InlineHtml` one (inline tags only, `ferrovue::html::InlineHtml` on the server, with no `trustedHtml` needed), the only HTML it may write inside a `<p>`; never on a table's structure, a `<select>` or `<optgroup>`, or an SVG or MathML element that holds no HTML. See the crate's [`escaping`](https://docs.rs/ferrovue/latest/ferrovue/guide/escaping/index.html#where-v-html-may-go) guide |
+| Page head | `useHead` (and `useServerHead`) from `@unhead/vue` 3: `title`, `titleTemplate`, `base`, `meta`, `link`, `script`, `style`, `noscript`, `htmlAttrs` and `bodyAttrs`, with values the server computes (props, setup bindings, getters such as `() => props.title`, `list.map(x => ({ … }))` for a list of tags), `key`, `tagPosition`, `tagPriority` and `tagDuplicateStrategy`; `useSeoMeta` (and `useServerSeoMeta`) of string, number, boolean and `null` values. Collected into a `ferrovue::head::Head` in the order Vue's server runs them, and written as unhead's `renderSSRHead` writes them: its tag order, deduplication, title template and escaping. See the crate's [`head`](https://docs.rs/ferrovue/latest/ferrovue/guide/head/index.html) guide |
 
 Anything else is refused at compile time, with an error that names the file, line and column,
 quotes the line and puts a caret under the construct. The
@@ -305,7 +307,8 @@ The crate's guide, `ferrovue::guide` on docs.rs, covers each topic in depth:
   from a Node server that renders with Vue, and the
   [support policy](https://docs.rs/ferrovue/latest/ferrovue/guide/support/index.html): supported
   versions, fixes, deprecations and where to report a problem
-- Upgrading a project [from 0.10 to 0.11](https://docs.rs/ferrovue/latest/ferrovue/guide/upgrading_to_0_11/index.html),
+- Upgrading a project [from 0.11 to 0.12](https://docs.rs/ferrovue/latest/ferrovue/guide/upgrading_to_0_12/index.html),
+  [from 0.10 to 0.11](https://docs.rs/ferrovue/latest/ferrovue/guide/upgrading_to_0_11/index.html),
   [from 0.9 to 0.10](https://docs.rs/ferrovue/latest/ferrovue/guide/upgrading_to_0_10/index.html),
   [from 0.8 to 0.9](https://docs.rs/ferrovue/latest/ferrovue/guide/upgrading_to_0_9/index.html)
   and [from 0.7 to 0.8](https://docs.rs/ferrovue/latest/ferrovue/guide/upgrading_to_0_8/index.html)

package/dist/args.d.ts

@@ -1,4 +1,4 @@
-import { GenError } from "./model.ts";
+import { GenError } from "./errors.ts";
 import type { Deprecation } from "./schema.ts";
 /** A command-line option: its names, short one first, the value it takes, and its line in `--help`. */
 export interface Flag {

package/dist/args.js

@@ -1,4 +1,4 @@
-import { GenError } from "./model.js";
+import { GenError } from "./errors.js";
 /** The commands `ferrovue` takes, with their lines in `--help`. */
 export const COMMANDS = {
     init: "scaffold starter ferrovue.config.json and components",

package/dist/attrs.js

@@ -1,7 +1,9 @@
 import { escapeHtml, hyphenate, isBooleanAttr, isSSRSafeAttrName, isSVGTag, propsToAttrMap } from "@vue/shared";
-import { fail, nothing, GenError, rustStr } from "./model.js";
+import { fail, nothing, rustStr } from "./model.js";
+import { GenError } from "./errors.js";
 import { asWritten } from "./numbers.js";
-import { CONFIG_FILE, ctx } from "./context.js";
+import { CONFIG_FILE } from "./config.js";
+import { ctx } from "./context.js";
 import { describeTy, expr, shown } from "./expr.js";
 import { known, truthy } from "./narrowing.js";
 import { asCow, isTemporary, unquote } from "./strings.js";
@@ -20,10 +22,10 @@ export function display(e, v) {
     else if (v.ty.k === "bool" && v.konst !== undefined)
         e.lit(String(v.konst));
     else if (v.ty.k === "str")
-        e.stmt(`fv::escape_into(out, ${strArg(v.code)});`);
+        e.stmt(`fv::core::escape_into(out, ${strArg(v.code)});`);
     else if (v.ty.k === "int" || v.ty.k === "float") {
         const w = asWritten(v);
-        e.stmt(`fv::${w.ty.k === "int" ? "push_int" : "push_number"}(out, ${bare(w.code)});`);
+        e.stmt(`fv::core::${w.ty.k === "int" ? "push_int" : "push_number"}(out, ${bare(w.code)});`);
         e.expect(NUMBER_BYTES);
     }
     else if (v.ty.k === "bool")
@@ -188,7 +190,7 @@ export function renderAttrs(s, e, n) {
     else
         e.close(" else {");
     if (parts.length === 1 && parts[0] === n) {
-        e.stmt(`fv::passed_attrs_into(out, ${s.fallthrough}.list(), ${isAttrs(n) && s.attrs !== null ? s.attrs : '""'});`);
+        e.stmt(`fv::attrs::passed_attrs_into(out, ${s.fallthrough}.list(), ${isAttrs(n) && s.attrs !== null ? s.attrs : '""'});`);
         e.close();
         return;
     }
@@ -209,7 +211,7 @@ export function renderAttrs(s, e, n) {
             fail(s.comp, "FV0407", "attributes must be an object literal", p);
     }
     const ids = idsAt >= 0 && s.attrs !== null ? s.attrs : '""';
-    e.stmt(`fv::attrs_into(out, &[${sources.join(", ")}], ${idsAt >= 0 ? idsAt : sources.length}, ${ids});`);
+    e.stmt(`fv::attrs::attrs_into(out, &[${sources.join(", ")}], ${idsAt >= 0 ? idsAt : sources.length}, ${ids});`);
     e.close();
 }
 function staticAttrs(s, e, n) {
@@ -324,27 +326,27 @@ export function attrOf(s, key, n, side) {
     if (key === "style")
         return styleAttr(s, n);
     if (n.type === "NullLiteral")
-        return "fv::Attr::Undefined";
+        return "fv::attrs::Attr::Undefined";
     return valueAttr(s, attrShown(s, key, n), n);
 }
 export function valueAttr(s, v, n) {
     switch (v.ty.k) {
         case "str":
-            return isTemporary(v) ? `fv::Attr::Str(${asCow(v)})` : `fv::Attr::str(${strArg(v.code)})`;
+            return isTemporary(v) ? `fv::attrs::Attr::Str(${asCow(v)})` : `fv::attrs::Attr::str(${strArg(v.code)})`;
         case "int":
-            return `fv::Attr::Int(${bare(v.code)})`;
+            return `fv::attrs::Attr::Int(${bare(v.code)})`;
         case "float":
-            return `fv::Attr::Float(${bare(v.code)})`;
+            return `fv::attrs::Attr::Float(${bare(v.code)})`;
         case "bool":
-            return `fv::Attr::Bool(${bare(v.code)})`;
+            return `fv::attrs::Attr::Bool(${bare(v.code)})`;
         case "undef":
         case "null":
-            return "fv::Attr::Undefined";
+            return "fv::attrs::Attr::Undefined";
         case "opt": {
             const of = v.ty.of.k;
-            const make = of === "str" ? "fv::Attr::str" : of === "int" ? "fv::Attr::Int" : of === "float" ? "fv::Attr::Float" : of === "bool" ? "fv::Attr::Bool" : null;
+            const make = of === "str" ? "fv::attrs::Attr::str" : of === "int" ? "fv::attrs::Attr::Int" : of === "float" ? "fv::attrs::Attr::Float" : of === "bool" ? "fv::attrs::Attr::Bool" : null;
             if (make !== null)
-                return `${atom(v.code)}.map_or(fv::Attr::Undefined, ${make})`;
+                return `${atom(v.code)}.map_or(fv::attrs::Attr::Undefined, ${make})`;
             break;
         }
         default:

package/dist/blocks.js

@@ -1,4 +1,5 @@
-import { fail, GenError, nothing } from "./model.js";
+import { fail, nothing, UNION_STR, unionStr } from "./model.js";
+import { GenError } from "./errors.js";
 import { ctx } from "./context.js";
 import { fresh, jsHint } from "./names.js";
 import { expr, typedBy } from "./expr.js";
@@ -27,7 +28,7 @@ export function bindingOf(v) {
     const lone = v.lone ? { lone: true } : {};
     if (v.variant !== undefined) {
         const optional = v.ty.k === "opt";
-        return { init: bare(v.variant), read: (at) => ({ code: optional ? `${at}.map(|v| v.as_str())` : `${at}.as_str()`, ty: v.ty, variant: at, ...lone }), owned: false };
+        return { init: bare(v.variant), read: (at) => ({ code: optional ? `${at}.map(${UNION_STR})` : unionStr(at), ty: v.ty, variant: at, ...lone }), owned: false };
     }
     if (v.owned)
         return { init: bare(v.code), read: (at) => ({ code: v.ty.k === "opt" ? `${at}.as_ref()` : at, ty: v.ty, ...lone }), owned: true };

package/dist/calls.js

@@ -62,7 +62,7 @@ export function call(s, n) {
             if (a.ty.k === "str")
                 return a;
             if (isNumber(a.ty))
-                return { code: `&*fv::Js(${bare(asWritten(a).code)}).to_string()`, ty: asciiTy() };
+                return { code: `&*fv::core::Js(${bare(asWritten(a).code)}).to_string()`, ty: asciiTy() };
             if (a.ty.k === "bool")
                 return { code: `if ${condition(a.code)} { "true" } else { "false" }`, ty: asciiTy() };
             return formatted(comp, [stringOf(comp, a, args[0], "`String()`", "FV0723")], n, "`String()`");
@@ -75,12 +75,12 @@ export function call(s, n) {
             if (a.lone)
                 fail(comp, "FV0706", `${lonely(name)}; it throws a \`URIError\` on a half`, n);
             const text = a.ty.k === "str" ? a : formatted(comp, [stringOf(comp, a, args[0], name, "FV0723")], n, name);
-            return { code: `&*fv::js_${callee.name === "encodeURI" ? "encode_uri" : "encode_uri_component"}(${strArg(text.code)})`, ty: STR };
+            return { code: `&*fv::core::js_${callee.name === "encodeURI" ? "encode_uri" : "encode_uri_component"}(${strArg(text.code)})`, ty: STR };
         }
         if (callee.name === "Number" && args.length === 1) {
             const a = expr(s, args[0]);
             if (a.ty.k === "str")
-                return { code: `fv::js_number(${strArg(a.code)})`, ty: FLOAT };
+                return { code: `fv::strings::js_number(${strArg(a.code)})`, ty: FLOAT };
             if (isNumber(a.ty))
                 return a;
             if (a.ty.k === "bool")
@@ -92,12 +92,12 @@ export function call(s, n) {
             if (a.ty.k !== "str")
                 fail(comp, "FV0702", `\`${callee.name}()\` takes a string`, args[0]);
             if (callee.name === "parseFloat")
-                return { code: `fv::js_parse_float(${strArg(a.code)})`, ty: FLOAT };
+                return { code: `fv::strings::js_parse_float(${strArg(a.code)})`, ty: FLOAT };
             const radix = args[1];
             if (radix && !(radix.type === "NumericLiteral" && (radix.value === 10 || radix.value === 16))) {
                 fail(comp, "FV0703", "`parseInt()` takes a radix of 10 or 16, written as a literal", radix);
             }
-            return { code: `fv::js_parse_int(${strArg(a.code)}, ${radix ? radix.value : 0})`, ty: FLOAT };
+            return { code: `fv::strings::js_parse_int(${strArg(a.code)}, ${radix ? radix.value : 0})`, ty: FLOAT };
         }
         if ((callee.name === "isNaN" || callee.name === "isFinite") && global)
             return numberTest(s, callee.name, args, n, true);
@@ -157,7 +157,7 @@ export function call(s, n) {
                 if ((method === "max" || method === "min") && vals.length >= 2) {
                     if (ints && !vals.some(isCast))
                         return { code: vals.slice(1).reduce((acc, v) => `${atom(acc)}.${method}(${bare(v.code)})`, vals[0].code), ty: INT };
-                    const extreme = vals.slice(1).reduce((acc, v) => `fv::js_${method}(${bare(acc)}, ${bare(asF64(v))})`, asF64(vals[0]));
+                    const extreme = vals.slice(1).reduce((acc, v) => `fv::core::js_${method}(${bare(acc)}, ${bare(asF64(v))})`, asF64(vals[0]));
                     if (ints)
                         return intFromF64(extreme, vals.find(isCast)?.at ?? refusalAt(comp, n));
                     return { code: extreme, ty: FLOAT };
@@ -167,7 +167,7 @@ export function call(s, n) {
                     if (method === "abs")
                         return ints ? intFromF64(`${receiver(asF64(x))}.abs()`, refusalAt(comp, n)) : { code: `${receiver(x.code)}.abs()`, ty: FLOAT };
                     if (method === "round")
-                        return { code: `fv::js_round(${bare(asF64(x))})`, ty: FLOAT };
+                        return { code: `fv::core::js_round(${bare(asF64(x))})`, ty: FLOAT };
                     if (method === "floor" || method === "ceil" || method === "trunc")
                         return { code: `${receiver(asF64(x))}.${method}()`, ty: FLOAT };
                     if (method === "sqrt")
@@ -175,7 +175,7 @@ export function call(s, n) {
                     if (method === "sign") {
                         if (x.num !== undefined)
                             return numberVal(Math.sign(x.num), ints);
-                        const sign = `fv::js_sign(${bare(asF64(x))})`;
+                        const sign = `fv::core::js_sign(${bare(asF64(x))})`;
                         return ints ? intFromF64(sign, null) : { code: sign, ty: FLOAT };
                     }
                 }
@@ -203,14 +203,14 @@ export function call(s, n) {
             const same = strTy(isAscii(target.ty));
             switch (args.length === 0 ? method : "") {
                 case "trim":
-                    return { code: `fv::js_trim(${strArg(target.code)})`, ty: same, ...lone };
+                    return { code: `fv::strings::js_trim(${strArg(target.code)})`, ty: same, ...lone };
                 case "trimStart":
-                    return { code: `fv::js_trim_start(${strArg(target.code)})`, ty: same, ...lone };
+                    return { code: `fv::strings::js_trim_start(${strArg(target.code)})`, ty: same, ...lone };
                 case "trimEnd":
                 case "trimRight":
-                    return { code: `fv::js_trim_end(${strArg(target.code)})`, ty: same, ...lone };
+                    return { code: `fv::strings::js_trim_end(${strArg(target.code)})`, ty: same, ...lone };
                 case "trimLeft":
-                    return { code: `fv::js_trim_start(${strArg(target.code)})`, ty: same, ...lone };
+                    return { code: `fv::strings::js_trim_start(${strArg(target.code)})`, ty: same, ...lone };
                 case "toUpperCase":
                     return { code: `&*${receiver(target.code)}.to_uppercase()`, ty: same, ...lone };
                 case "toLowerCase":
@@ -231,15 +231,15 @@ export function call(s, n) {
                 fail(comp, code, `\`.${method}()\` takes a literal ${what}, from ${low} to 100`, n);
             const x = bare(asF64(target));
             if (method === "toFixed")
-                return { code: `&*fv::js_to_fixed(${x}, ${given ?? 0})`, ty: asciiTy() };
+                return { code: `&*fv::core::js_to_fixed(${x}, ${given ?? 0})`, ty: asciiTy() };
             if (method === "toExponential")
-                return { code: `&*fv::js_to_exponential(${x}, ${given === undefined ? "None" : `Some(${given})`})`, ty: asciiTy() };
+                return { code: `&*fv::core::js_to_exponential(${x}, ${given === undefined ? "None" : `Some(${given})`})`, ty: asciiTy() };
             if (given === undefined)
-                return { code: `&*fv::Js(${bare(asWritten(target).code)}).to_string()`, ty: asciiTy() };
-            return { code: `&*fv::js_to_precision(${x}, ${given})`, ty: asciiTy() };
+                return { code: `&*fv::core::Js(${bare(asWritten(target).code)}).to_string()`, ty: asciiTy() };
+            return { code: `&*fv::core::js_to_precision(${x}, ${given})`, ty: asciiTy() };
         }
         if (isNumber(target.ty) && method === "toString" && args.length === 0) {
-            return { code: `&*fv::Js(${bare(asWritten(target).code)}).to_string()`, ty: asciiTy() };
+            return { code: `&*fv::core::Js(${bare(asWritten(target).code)}).to_string()`, ty: asciiTy() };
         }
         if (target.owned)
             refuseInPlace(comp, `\`.${method}()\``, n);
@@ -266,7 +266,7 @@ export function call(s, n) {
                 const sep = args.length ? expr(s, args[0]) : { code: '","', ty: STR };
                 if (sep.ty.k !== "str")
                     fail(comp, "FV0802", "`.join()` takes a string", args[0]);
-                const each = of.k === "str" ? `${atom(target.code)}.iter().map(|v| &**v)` : `${atom(target.code)}.iter().map(|v| fv::Js(*v).to_string())`;
+                const each = of.k === "str" ? `${atom(target.code)}.iter().map(|v| &**v)` : `${atom(target.code)}.iter().map(|v| fv::core::Js(*v).to_string())`;
                 return { code: `&*${each}.collect::<Vec<_>>().join(${strArg(sep.code)})`, ty: strTy(writesAscii(target.ty) && isAscii(sep.ty)), ...loneOf(sep) };
             }
         }
@@ -349,11 +349,11 @@ function json(s, v, n) {
     const one = (code, ty) => {
         switch (ty.k) {
             case "str":
-                return `fv::js_json_string(${code === "v" ? "&v" : strArg(code)})`;
+                return `fv::strings::js_json_string(${code === "v" ? "&v" : strArg(code)})`;
             case "int":
-                return `fv::Js(${bare(code)}).to_string()`;
+                return `fv::core::Js(${bare(code)}).to_string()`;
             case "float":
-                return `fv::js_json_number(${bare(code)})`;
+                return `fv::strings::js_json_number(${bare(code)})`;
             case "bool":
                 return `(if ${condition(code)} { "true" } else { "false" }).to_owned()`;
             default:

package/dist/children.js

@@ -1,8 +1,8 @@
 import { isSSRSafeAttrName, propsToAttrMap } from "@vue/shared";
-import { absence, camelize, declares, enumOf, fail, nothing, REFUSALS, refusalAt, rustStr, sameTy, snake, takesAttrs, variantPath } from "./model.js";
+import { absence, camelize, declares, enumItems, enumOf, fail, literalsOf, nothing, REFUSALS, refusalAt, rustStr, sameTy, snake, takesAttrs, variantPath } from "./model.js";
 import { ctx } from "./context.js";
 import { known } from "./narrowing.js";
-import { intoEnum, knownLiteral } from "./enums.js";
+import { enumItemVal, intoEnum, knownLiteral, refuseUnproven } from "./enums.js";
 import { bareDates, markHome } from "./typescript.js";
 import { items } from "./lists.js";
 import { describeTy, expr, fieldVal, holdsNothing, typedBy } from "./expr.js";
@@ -254,10 +254,10 @@ function childAttrsArg(s, child, parts, merges, fallthrough, ids, n) {
         return ids;
     }
     if (!sources.length)
-        return ids === null ? "&fv::Attrs::NONE" : `&fv::Attrs::scoped(${ids})`;
+        return ids === null ? "&fv::attrs::Attrs::NONE" : `&fv::attrs::Attrs::scoped(${ids})`;
     if (sources.length === 1 && !merges)
-        return `&fv::Attrs::new(${sources[0]}, ${ids ?? '""'})`;
-    return `&fv::Attrs::merged(&[${sources.join(", ")}], ${ids ?? '""'})`;
+        return `&fv::attrs::Attrs::new(${sources[0]}, ${ids ?? '""'})`;
+    return `&fv::attrs::Attrs::merged(&[${sources.join(", ")}], ${ids ?? '""'})`;
 }
 export function fieldInit(name, value) {
     return value === name ? name : `${name}: ${bare(value)}`;
@@ -271,7 +271,7 @@ export function extraParams(c, unread = () => false) {
 export function callChild(s, e, child, propsCode, slots, attrs, later = false) {
     const m = `super::${child.module}`;
     const scoped = child.inherits || takesAttrs(child);
-    const trailing = paramsOf(child).map((p) => `, ${p.name}`).join("") + (scoped ? `, ${attrs ?? (takesAttrs(child) ? "&fv::Attrs::NONE" : '""')}` : "");
+    const trailing = paramsOf(child).map((p) => `, ${p.name}`).join("") + (scoped ? `, ${attrs ?? (takesAttrs(child) ? "&fv::attrs::Attrs::NONE" : '""')}` : "");
     const render = scoped ? "try_render_scoped" : "try_render";
     const around = later ? ctx.plugins.flatMap((p) => p.loadedLater?.(child) ?? []) : [];
     if (around.length) {
@@ -377,19 +377,19 @@ export function callWith(s, e, child, m, head, slotsTy, trailing, slots, vnode =
             e.close("),");
         }
         else if (sid !== null) {
-            e.open(`${field}: Some(fv::Slot::slotted(&|out: &mut String${sidParam}| -> bool`);
+            e.open(`${field}: Some(fv::render::Slot::slotted(&|out: &mut String${sidParam}| -> bool`);
             const opened = e.lines.length - 1;
             content(inner);
             unread(opened, sid);
             e.close(")),");
         }
         else if (staticallyFilled(body)) {
-            e.open(`${field}: Some(fv::Slot::new(&|out: &mut String|`);
+            e.open(`${field}: Some(fv::render::Slot::new(&|out: &mut String|`);
             statements({ ...inner, fill: false }, e, body);
             e.close(")),");
         }
         else {
-            e.open(`${field}: Some(fv::Slot::markup(&|out: &mut String| -> bool`);
+            e.open(`${field}: Some(fv::render::Slot::markup(&|out: &mut String| -> bool`);
             e.stmt("let mut filled = false;");
             statements({ ...inner, fill: true }, e, body);
             e.stmt("filled");
@@ -402,6 +402,32 @@ function datesInto(of, at) {
     const date = `|fv_t| ${REFUSALS}.date(fv_t, ${at})`;
     return of.k === "date" ? `.map(${date})` : `.map(|v| v.map(${date}))`;
 }
+function enumListInto(comp, v, want, node) {
+    const refuse = () => fail(comp, "FV0511", `the prop is ${describeTy(want)}, and the value given is ${describeTy(v.ty)}`, node);
+    if (want.k === "opt") {
+        if (v.ty.k === "list")
+            return `Some(${enumListInto(comp, v, want.of, node)})`;
+        if (v.ty.k !== "opt" || v.ty.of.k !== "list" || absence(v.ty) !== absence(want))
+            return refuse();
+        if (v.enums === undefined)
+            return `${atom(v.code)}.map(|v| ${enumListInto(comp, { code: "v", ty: v.ty.of, slice: true }, want.of, node)})`;
+        return `${atom(v.enums.place)}.as_ref().map(|v| ${enumListInto(comp, { ...v, code: "v", ty: v.ty.of, enums: { ...v.enums, place: "v" } }, want.of, node)})`;
+    }
+    if (want.k !== "list" || v.ty.k !== "list")
+        return refuse();
+    if (v.ty.of.k === "undef")
+        return "Vec::new()";
+    const of = v.ty.of;
+    if (v.enums !== undefined) {
+        const item = ownInto(comp, enumItemVal("v", of, v.enums.def), want.of, node);
+        return item === "v" ? `${atom(v.enums.place)}.to_vec()` : `${atom(v.enums.place)}.iter().map(|&v| ${item}).collect()`;
+    }
+    if (of.k !== "str" && (of.k !== "opt" || of.of.k !== "str"))
+        return refuse();
+    const each = of.k === "str" ? { code: v.iter !== undefined ? "&*v" : "&**v", ty: of } : { code: v.iter !== undefined ? "v" : "v.as_deref()", ty: of };
+    const iter = v.iter ?? `${atom(v.code)}.iter()`;
+    return `${iter}.map(|v| ${ownInto(comp, each, want.of, node)}).collect()`;
+}
 export function ownInto(comp, v, want, node) {
     holdsNothing(comp, v, want, node, "the prop");
     if (v.owned && sameTy(v.ty, want))
@@ -410,13 +436,22 @@ export function ownInto(comp, v, want, node) {
         return `Some(${bare(v.code)})`;
     if (want.k === "opt" && nothing(v.ty))
         return "None";
+    if (enumItems(want) !== undefined)
+        return enumListInto(comp, v, want, node);
     const def = enumOf(want);
     if (def !== undefined) {
-        const into = (v.ty.k === "opt" ? v.ty.of : v.ty).k === "str" ? intoEnum(comp, v, def) : null;
+        const into = (v.ty.k === "opt" ? v.ty.of : v.ty).k === "str" ? intoEnum(comp, v, def, node) : null;
         if (into === null) {
+            refuseUnproven(v);
             const literal = knownLiteral(v);
-            const given = literal !== undefined ? `is ${JSON.stringify(literal)}` : (v.ty.k === "opt" ? v.ty.of : v.ty).k === "str" ? "is a string that may be any other" : `is ${describeTy(v.ty)}`;
-            fail(comp, "FV0515", `the prop is one of ${def.literals.map((l) => JSON.stringify(l)).join(" | ")}, the members of \`${def.name}\`, and the value given ${given}: pass one of them, or a value typed as the union`, node);
+            const inner = v.ty.k === "opt" ? v.ty.of : v.ty;
+            const outside = literal === undefined && inner.k === "str" ? literalsOf(inner)?.filter((l) => typeof l !== "string" || !def.literals.includes(l)) : undefined;
+            const union = `the prop is one of ${def.literals.map((l) => JSON.stringify(l)).join(" | ")}, the members of \`${def.name}\``;
+            if (outside !== undefined && outside.length > 0) {
+                fail(comp, "FV0515", `${union}, and the value given may be ${outside.map((l) => JSON.stringify(l)).join(" or ")}: narrow it to the members, by \`===\` or \`!==\` with a literal, by its truth or by \`||\`, in \`?:\`, \`&&\` or \`v-if\`, or pass a value typed as the union`, node);
+            }
+            const given = literal !== undefined ? `is ${JSON.stringify(literal)}` : inner.k === "str" ? "is a string that may be any other" : `is ${describeTy(v.ty)}`;
+            fail(comp, "FV0515", `${union}, and the value given ${given}: pass one of them, or a value typed as the union`, node);
         }
         return want.k === "opt" && v.ty.k !== "opt" ? `Some(${bare(into)})` : into;
     }

package/dist/classes.js

@@ -36,7 +36,7 @@ export function classItems(s, n) {
                     keys.push(key);
                     return `(${bare(cond(s, p.value))}, ${bare(key.code)})`;
                 });
-                return [{ code: `&*fv::class_object(&[${entries.join(", ")}])` }];
+                return [{ code: `&*fv::attrs::class_object(&[${entries.join(", ")}])` }];
             }
             return n.properties.flatMap((p) => {
                 if (p.type !== "ObjectProperty")
@@ -52,7 +52,7 @@ export function classItems(s, n) {
                     const k = expr(s, p.key);
                     if (k.ty.k !== "str")
                         fail(s.comp, "FV1002", "a computed class name is a string", p.key);
-                    name = { code: `fv::js_trim(${strArg(k.code)})` };
+                    name = { code: `fv::strings::js_trim(${strArg(k.code)})` };
                 }
                 const v = expr(s, p.value);
                 const on = known(v);
@@ -115,7 +115,7 @@ export function renderClass(s, e, n, after = false) {
     }
     if (i < items.length) {
         const rest = items.slice(i).map((it) => ("lit" in it ? rustStr(it.lit) : it.code));
-        e.stmt(`fv::class_into(out, ${wrote}, &[${rest.join(", ")}]);`);
+        e.stmt(`fv::attrs::class_into(out, ${wrote}, &[${rest.join(", ")}]);`);
     }
 }
 const UNWRITTEN = new Set(["on", "if", "else-if", "else", "for", "slot", "once", "memo", "cloak", "pre"]);
@@ -202,23 +202,23 @@ export function literalClass(n) {
 export function classAttr(s, n, side) {
     switch (n.type) {
         case "StringLiteral":
-            return `fv::Attr::str(${rustStr(n.value)})`;
+            return `fv::attrs::Attr::str(${rustStr(n.value)})`;
         case "NullLiteral":
-            return 'fv::Attr::str("")';
+            return 'fv::attrs::Attr::str("")';
         case "ArrayExpression":
         case "ObjectExpression": {
             const items = classItems(s, n);
             const names = items.every((it) => "lit" in it)
                 ? rustStr(items.map((it) => ("lit" in it ? it.lit : "")).join(" "))
-                : `fv::class_names(&[${items.map((it) => ("lit" in it ? rustStr(it.lit) : it.code)).join(", ")}])`;
+                : `fv::attrs::class_names(&[${items.map((it) => ("lit" in it ? rustStr(it.lit) : it.code)).join(", ")}])`;
             const literal = names.startsWith('"');
             if (side === "vnode")
-                return literal ? `fv::Attr::str(${names})` : `fv::Attr::from(${names})`;
-            return `fv::Attr::Names(${literal ? `std::borrow::Cow::Borrowed(${names})` : `${names}.into()`})`;
+                return literal ? `fv::attrs::Attr::str(${names})` : `fv::attrs::Attr::from(${names})`;
+            return `fv::attrs::Attr::Names(${literal ? `std::borrow::Cow::Borrowed(${names})` : `${names}.into()`})`;
         }
         case "LogicalExpression":
             if (n.operator === "&&") {
-                return narrowed(s, n.left, true, (inner) => classAttr(inner, n.right, side), () => 'fv::Attr::str("")') ?? `if ${condition(cond(s, n.left))} { ${classAttr(s, n.right, side)} } else { fv::Attr::str("") }`;
+                return narrowed(s, n.left, true, (inner) => classAttr(inner, n.right, side), () => 'fv::attrs::Attr::str("")') ?? `if ${condition(cond(s, n.left))} { ${classAttr(s, n.right, side)} } else { fv::attrs::Attr::str("") }`;
             }
             break;
         case "ConditionalExpression":

package/dist/cli.js

@@ -2,7 +2,9 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, watch, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { relativePath } from "./paths.js";
-import { CONFIG_FILE, generate, isGenerated, loadConfig, VERSION, write } from "./compiler.js";
+import { CONFIG_FILE, loadConfig } from "./config.js";
+import {} from "./errors.js";
+import { generate, isGenerated, VERSION, write } from "./compiler.js";
 import { helpText, parseArgs } from "./args.js";
 import { unifiedDiff } from "./diff.js";
 import { diagnose, diagnoseAll, formatRefusal, formatWarning, isRefusal } from "./diagnostics.js";