ferrovue 0.2.0 → 0.3.0

package/dist/model.d.ts

@@ -109,6 +109,12 @@ export declare const RUST_KEYWORDS: Set<string>;
 /** Types the generated code names, which an interface of the same name would shadow. */
 export declare const RUST_PRELUDE: Set<string>;
 export declare function snake(js: string): string;
+/** `camelize` in `@vue/shared`: how Vue matches an attribute a parent passes to a declared prop. */
+export declare function camelize(key: string): string;
+/** Whether a component declares the prop a parent passes as `key`, as `setFullProps` decides. */
+export declare function declares(comp: Component, key: string): boolean;
+/** Whether a component may be passed attributes beyond its props, and so takes `fv::Attrs`. */
+export declare function takesAttrs(comp: Component): boolean;
 export declare function rustStr(s: string): string;
 /** One character as a Rust `char` literal. */
 export declare function rustChar(ch: string): string;
@@ -129,6 +135,9 @@ export interface Component {
         line: number;
         column: number;
     };
+    /** A root `<Transition>` or `<KeepAlive>` around anything but one plain element — a `v-if`, a
+     * `<template>` — whose content Vue's server gives no attributes and its client does. */
+    attrsDropped?: N;
     props: Struct;
     structs: Map<string, Struct>;
     /** The local name `TrustedHtml` was imported under from `ferrovue/types`, if it was. */
@@ -183,6 +192,13 @@ export interface Component {
     /** Whether its outlets may pass slot content a slot scope id, which the content then takes as
      * `fv_sid`. Known once every component is read, as `inherits` is. */
     passesSlotIds: boolean;
+    /** The attributes a parent may pass it beyond its props, by name: what falls through to its root,
+     * or to the element that binds `$attrs`. With any, its `render_scoped` takes them as
+     * `fv::Attrs`. Known once every component is read (`attrsFlow`). */
+    attrNames: Set<string>;
+    /** Whether its `$attrs` may hold scope ids: it is the root of a component that may be handed
+     * some, which passes them on as attributes. */
+    idsInAttrs: boolean;
 }
 export interface Scope {
     comp: Component;
@@ -229,6 +245,11 @@ export interface Scope {
     /** The Rust value of `_attrs`, the scope ids this render's root inherits, as `ssrRenderAttrs`
      * writes them; `null` when the component inherits none. */
     attrs: string | null;
+    /** The Rust `fv::Attrs` a parent passes this render beyond its props — `$attrs`, and what
+     * `_attrs` holds before the scope ids — or `null` when no parent passes any. */
+    fallthrough: string | null;
+    /** Setup bindings holding `useAttrs()`, which the template may bind as `$attrs`. */
+    attrsBindings: Set<string>;
     /** The Rust value of `_scopeId` inside slot content: the slot scope id the content is given, or
      * `null` where it is always empty. */
     sid: string | null;

package/dist/model.js

@@ -12,6 +12,19 @@ export function snake(js) {
     const s = js.replace(/[A-Z]/g, (c) => "_" + c.toLowerCase()).replace(/^_/, "");
     return RUST_KEYWORDS.has(s) ? `r#${s}` : s;
 }
+/** `camelize` in `@vue/shared`: how Vue matches an attribute a parent passes to a declared prop. */
+export function camelize(key) {
+    return key.replace(/-(\w)/g, (_, c) => c.toUpperCase());
+}
+/** Whether a component declares the prop a parent passes as `key`, as `setFullProps` decides. */
+export function declares(comp, key) {
+    const camel = camelize(key);
+    return comp.props.fields.some((f) => camelize(f.js) === camel);
+}
+/** Whether a component may be passed attributes beyond its props, and so takes `fv::Attrs`. */
+export function takesAttrs(comp) {
+    return comp.attrNames.size > 0;
+}
 export function rustStr(s) {
     let out = '"';
     for (const ch of s) {

package/dist/router.js

@@ -2,12 +2,12 @@
 import { escapeHtml } from "@vue/shared";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-import { fail, GenError, rustStr } from "./model.js";
+import { camelize, fail, GenError, rustStr } from "./model.js";
 import { allRoutes, CONFIG_FILE, ctx } from "./context.js";
 import { expr, lonely } from "./expr.js";
 import { bare, condition, strArg } from "./parens.js";
 import { Emitter } from "./emitter.js";
-import { classItems, IGNORED_PROPS, mergeProps, renderDynamicAttr, renderStyle } from "./attrs.js";
+import { attrOf, classItems, dollarAttrs, IGNORED_PROPS, isAttrs, mergedParts, mergeProps, renderDynamicAttr, renderStyle } from "./attrs.js";
 import { slotBody, statements } from "./template.js";
 export const ROUTER_LINK_PROPS = new Set(["to", "class", "activeClass", "exactActiveClass", "ariaCurrentValue"]);
 /** `<RouterLink>` props that change only what a click does, which the server does not render. */
@@ -202,6 +202,22 @@ export function routerLink(s, e, n) {
     e.open("");
     resolveLink(s, e, to);
     e.lit("<a");
+    /* Attributes this component is passed fall through to the link: merged into its virtual node's
+     * props with the template's, then onto the `<a>` vue-router renders. */
+    const parts = mergedParts(rawProps);
+    const passedOn = (p) => s.fallthrough !== null && ((isAttrs(p) && s.comp.inheritAttrs) || dollarAttrs(s, p));
+    const fallsThrough = parts.some(passedOn);
+    if (fallsThrough) {
+        for (const name of s.comp.attrNames) {
+            const key = camelize(name);
+            if ((ROUTER_LINK_PROPS.has(key) && key !== "class") || ROUTER_LINK_INERT.has(key) || key === "custom" || key === "viewTransition") {
+                fail(s.comp, `\`${name}\`, an attribute ${s.comp.name} may be passed, would reach its \`<RouterLink>\` as a prop`, n);
+            }
+            if (key === "href" || key === "ariaCurrent")
+                fail(s.comp, `\`${name}\`, an attribute ${s.comp.name} may be passed, would replace its \`<RouterLink>\`'s own`, n);
+        }
+        e.open(`if ${s.fallthrough}.is_empty()`);
+    }
     e.open("if fv_link.exact");
     e.lit(` aria-current="${escapeHtml(ariaCurrent)}"`);
     e.close();
@@ -233,6 +249,40 @@ export function routerLink(s, e, n) {
     }
     else
         e.stmt(`out.push_str(&fv::scope_attrs(${base ?? '""'}, ${scopeId === null ? '""' : rustStr(scopeId)}, ${slotted ?? '""'}));`);
+    if (fallsThrough) {
+        e.close(" else {");
+        // The template's attributes for the link, merged in their order with those passed on.
+        const sources = [];
+        for (const p of parts) {
+            if (passedOn(p))
+                sources.push(`${s.fallthrough}.list()`);
+            else if (p.type === "ObjectExpression") {
+                const entries = p.properties
+                    .filter((q) => {
+                    const raw = q.key?.type === "Identifier" ? q.key.name : String(q.key?.value);
+                    const key = camelize(raw);
+                    return key === "class" || (!ROUTER_LINK_PROPS.has(key) && !ROUTER_LINK_INERT.has(key) && !/^on[^a-z]/.test(raw) && !IGNORED_PROPS.has(raw));
+                })
+                    .map((q) => {
+                    const raw = q.key.type === "Identifier" ? q.key.name : String(q.key.value);
+                    return `(${rustStr(raw)}, ${attrOf(s, raw, q.value, "vnode")})`;
+                });
+                if (entries.length)
+                    sources.push(`&[${entries.join(", ")}]`);
+            }
+        }
+        const ids = base === null && slotted === null
+            ? rustStr(scopeId === null ? "" : ` ${scopeId}`)
+            : `&fv::scope_attrs(${base ?? '""'}, ${scopeId === null ? '""' : rustStr(scopeId)}, ${slotted ?? '""'})`;
+        // vue-router's own: `aria-current` (`null` when the link is not exact), `href`, its classes.
+        const linkOwn = [
+            `("aria-current", if fv_link.exact { fv::Attr::str(${rustStr(ariaCurrent)}) } else { fv::Attr::Undefined })`,
+            '("href", fv::Attr::str(&fv_link.href))',
+            `("class", fv::Attr::from(fv::class_names(&[${linkItems.join(", ")}])))`,
+        ];
+        e.stmt(`fv::attrs_into(out, &[&[${linkOwn.join(", ")}], &fv::merge_props(&[${sources.join(", ")}])], 1, ${ids});`);
+        e.close();
+    }
     e.lit(">");
     if (slots && slots.type !== "NullLiteral") {
         if (slots.type !== "ObjectExpression")

package/dist/rust.d.ts

@@ -7,6 +7,9 @@ export declare function structSource(st: Struct, comp: Component, doc: string):
 export declare function header(source: string, edit?: string): string;
 /** Rust expressions summing the lengths of the strings a value of type `ty` at `place` holds. */
 export declare function textLen(comp: Component, place: string, ty: Ty, seen?: Set<string>): string[];
+/** Whether the component gets an `island()`: it renders from its props alone, which `data-props` is
+ * all the client gets to mount it with. */
+export declare function isIsland(comp: Component): boolean;
 export declare function componentSource(comp: Component, ast: N[], ssr: string, components: Map<string, Component>): string;
 export declare function modSource(comps: Component[]): string;
 export declare function storesSource(dir: string): string;

package/dist/rust.js

@@ -1,7 +1,7 @@
 /* The Rust source written for each component, and the modules beside them. */
 import { parse as parseJs } from "@babel/parser";
 import { basename } from "node:path";
-import { fail, GenError, rustStr, snake, tagAst } from "./model.js";
+import { fail, GenError, rustStr, snake, tagAst, takesAttrs } from "./model.js";
 import { allRoutes, ctx } from "./context.js";
 import { lookupStruct } from "./typescript.js";
 import { childOf } from "./expr.js";
@@ -179,27 +179,40 @@ export function textLen(comp, place, ty, seen = new Set()) {
             return [];
     }
 }
-/** `render`, and for a component a parent may hand scope ids to, `render_scoped`, which takes them
- * last, as `ssrRenderAttrs` writes them onto its root; `render` hands it none. */
+/** `render`, and for a component a parent may hand scope ids or pass attributes to,
+ * `render_scoped`, which takes them last, as `ssrRenderAttrs` writes them onto its root; `render`
+ * hands it none. */
 function renderSource(comp, life, args, e) {
     const doc = "/// Write the component's server render into `out`.\n";
     // Props or ids the render never reads, as when a component only passes its slot on.
     const props = e.reads("props", 0) ? "props" : "_props";
-    if (!comp.inherits)
+    if (!comp.inherits && !takesAttrs(comp))
         return `${doc}pub fn render(out: &mut String, ${props}: &Props${life}${extraParams(comp)}) {\n${e.lines.join("\n")}\n}`;
     // A root that is a fragment, or a `<Teleport>`, takes no ids.
     const attrs = e.reads("fv_attrs", 0) ? "fv_attrs" : "_fv_attrs";
+    // A component a parent may pass attributes takes them with the ids, as one `fv::Attrs`.
+    const [none, ty, what] = takesAttrs(comp)
+        ? ["&fv::Attrs::NONE", "&fv::Attrs<'_>", "the attributes a parent passes beyond the props, and the scope ids it hands the root"]
+        : ['""', "&str", "the scope ids a parent hands the root: ` data-v-…` each"];
     return `${doc}pub fn render(out: &mut String, props: &Props${life}${extraParams(comp)}) {
-    render_scoped(out, props${args}, "");
+    render_scoped(out, props${args}, ${none});
 }
 
-/// [\`render\`], with the scope ids a parent hands the root: \` data-v-…\` each.
+/// [\`render\`], with ${what}.
 #[doc(hidden)]
-pub fn render_scoped(out: &mut String, ${props}: &Props${life}${extraParams(comp)}, ${attrs}: &str) {
+pub fn render_scoped(out: &mut String, ${props}: &Props${life}${extraParams(comp)}, ${attrs}: ${ty}) {
 ${e.lines.join("\n")}
 }`;
 }
+/** Whether the component gets an `island()`: it renders from its props alone, which `data-props` is
+ * all the client gets to mount it with. */
+export function isIsland(comp) {
+    return !takesSlots(comp) && !comp.usesRoute && !comp.usesStores && !comp.usesI18n && !comp.usesTeleports;
+}
 export function componentSource(comp, ast, ssr, components) {
+    if (takesAttrs(comp) && comp.inheritAttrs && comp.attrsDropped) {
+        fail(comp, `a root \`<Transition>\` or \`<KeepAlive>\` around a \`v-if\` in ${comp.name}, which a parent passes attributes: Vue's server drops them, where its client puts them on the element; set \`inheritAttrs: false\` and bind \`$attrs\` on the element`, comp.attrsDropped);
+    }
     const { scope, lets } = scopeFor(comp, ast, components);
     const program = parseJs(ssr, { sourceType: "module" }).program;
     tagAst(program, "template");
@@ -229,6 +242,9 @@ export function componentSource(comp, ast, ssr, components) {
     const life = structLifetime(comp.props, comp) ? "<'_>" : "";
     const gen = life ? "<'p, 'a>" : "<'p>";
     const named = life ? "<'a>" : "";
+    // What holds its props borrows only what they borrow.
+    const owned = life ? "<'a>" : "";
+    const ownedLife = life ? "'a" : "'static";
     // An `interface Props` that `defineProps` takes is the props struct itself, written once below.
     const structs = [...comp.structs.values()]
         .filter((st) => st.name !== "Props" && !st.slot)
@@ -237,7 +253,7 @@ export function componentSource(comp, ast, ssr, components) {
     // `Cow` is imported only where a field is one: a lifetime that comes from another component's props
     // alone borrows through that type, not through a `Cow` written here.
     const usesCow = /Cow</.test(structs + structSource(comp.props, comp, ""));
-    const plain = !takesSlots(comp) && !comp.usesRoute && !comp.usesStores && !comp.usesI18n && !comp.usesTeleports;
+    const plain = isIsland(comp);
     const slotFields = [
         ...comp.slotNames.map((n) => {
             const outlet = `\`<slot${n === "default" ? "" : ` name="${n}"`}>\``;
@@ -288,6 +304,16 @@ pub fn html${gen}(props: &'p Props${named}) -> fv::Html<'p, Props${named}> {
 pub fn island${gen}(props: &'p Props${named}) -> fv::Html<'p, Props${named}> {
     fv::Html::island(NAME, props, render)
 }
+
+/// [\`html\`], holding the props: a handler that builds them can return it.
+pub fn into_html${owned}(props: Props${named}) -> fv::Html<${ownedLife}, Props${named}> {
+    fv::Html::markup_owned(props, render)
+}
+
+/// [\`island\`], holding the props.
+pub fn into_island${owned}(props: Props${named}) -> fv::Html<${ownedLife}, Props${named}> {
+    fv::Html::island_owned(NAME, props, render)
+}
 `
         : `/// The component's markup, for a maud page that shows it.
 pub fn html${gen}(props: &'p Props${named}${params}) -> fv::Html<'p, Props${named}, impl Fn(&mut String, &Props${named}) + 'p> {
@@ -393,8 +419,9 @@ impl Fixture {
 //! The component renderers, one module per \`.vue\` file.
 
 // The modules pass rustc's default warnings and clippy's default lints, with one exception:
-// \`dead_code\`. Every component gets the whole of its API (\`render\`, \`html\`, \`island\`, \`NAME\`, a
-// constructor and a setter per optional prop) and an app calls only what it needs.
+// \`dead_code\`. Every component gets the whole of its API (\`render\`, \`html\`, \`island\`, their
+// \`into_\` forms, \`NAME\`, a constructor and a setter per optional prop) and an app calls only what
+// it needs.
 #![allow(dead_code)]
 
 ${comps.map((c) => `pub mod ${c.module};`).join("\n")}${ctx.routes ? "\npub mod route_table;" : ""}${ctx.stores.size ? "\npub mod stores;" : ""}${ctx.typeStructs.size ? "\npub mod types;" : ""}${ctx.i18n ? "\npub mod i18n;" : ""}

package/dist/scoped.d.ts

@@ -1,4 +1,4 @@
-import type { Component } from "./model.ts";
+import { type Component, type N } from "./model.ts";
 /** Set every component's `inherits` and `passesSlotIds`, each a least fixed point: a component's
  * slot content may be given an id when one of its outlets passes one, or forwards what the slot
  * content it sits in was given; a root may be handed ids by a scoped parent, by a parent that
@@ -8,3 +8,17 @@ export declare function scopeFlow(read: {
     ssr: string;
     children: Map<string, string>;
 }[]): void;
+/** Whether `n` is the template's `$attrs`: `_ctx.$attrs`, or a setup binding of `useAttrs()`. */
+export declare function isDollarAttrs(n: N, bindings: Set<string>): boolean;
+/** Whether a key a parent passes a child reaches it as an attribute, unless it is a prop: not one
+ * Vue reserves, not a listener (which the server drops), not a model's modifiers. */
+export declare function passedKey(child: Component, key: string): boolean;
+/** Set every component's `attrNames` and `idsInAttrs`: the attributes its parents' calls pass it
+ * beyond its props, and those passed on to it — by a parent whose root it is, or that binds
+ * `$attrs` to it — from that parent's own, a least fixed point. Runs after `scopeFlow`. */
+export declare function attrsFlow(read: {
+    comp: Component;
+    ssr: string;
+    children: Map<string, string>;
+    attrsBindings: Set<string>;
+}[]): void;

package/dist/scoped.js

@@ -8,8 +8,13 @@
  * child's `_attrs`: the id of the component that created it, what its parent passes on when the
  * child is that parent's root, and the slot scope ids of the slot content it is rendered in
  * (`renderComponentSubTree`). A component with `:slotted()` styles gives its slot content
- * `data-v-…-s` as well, which the content writes onto its elements as `_scopeId`. */
+ * `data-v-…-s` as well, which the content writes onto its elements as `_scopeId`.
+ *
+ * The same `_attrs` carries the attributes a parent passes a child beyond its props, ahead of the
+ * ids: which components may be passed some (`attrsFlow`) decides whether `fv_attrs` is an
+ * `fv::Attrs` holding both, or the ids alone. */
 import { parse as parseJs } from "@babel/parser";
+import { declares } from "./model.js";
 /** The child components and outlets in one component's compiled template. */
 function flowOf(comp, ssr, children) {
     const calls = [];
@@ -88,3 +93,85 @@ export function scopeFlow(read) {
         }
     }
 }
+/** Whether `n` is the template's `$attrs`: `_ctx.$attrs`, or a setup binding of `useAttrs()`. */
+export function isDollarAttrs(n, bindings) {
+    if (n?.type !== "MemberExpression" || n.object.type !== "Identifier")
+        return false;
+    const prop = n.computed ? n.property.value : n.property.name;
+    if (n.object.name === "_ctx")
+        return prop === "$attrs";
+    return n.object.name === "$setup" && prop !== undefined && bindings.has(prop);
+}
+/** Whether a key a parent passes a child reaches it as an attribute, unless it is a prop: not one
+ * Vue reserves, not a listener (which the server drops), not a model's modifiers. */
+export function passedKey(child, key) {
+    if (["", "key", "ref", "ref_for", "ref_key", "innerHTML", "textContent"].includes(key) || /^on[^a-z]/.test(key))
+        return false;
+    return !(key.endsWith("Modifiers") && declares(child, key === "modelModifiers" ? "modelValue" : key.slice(0, -"Modifiers".length)));
+}
+/** Set every component's `attrNames` and `idsInAttrs`: the attributes its parents' calls pass it
+ * beyond its props, and those passed on to it — by a parent whose root it is, or that binds
+ * `$attrs` to it — from that parent's own, a least fixed point. Runs after `scopeFlow`. */
+export function attrsFlow(read) {
+    const byName = new Map(read.map((r) => [r.comp.name, r.comp]));
+    const flows = read.map((r) => {
+        const calls = [];
+        const self = new Set();
+        const walk = (n) => {
+            if (!n || typeof n !== "object")
+                return;
+            if (Array.isArray(n)) {
+                n.forEach(walk);
+                return;
+            }
+            if (n.type === "VariableDeclarator" && n.init?.type === "CallExpression" && n.init.callee.name === "_resolveComponent") {
+                if (n.init.arguments[0]?.value === r.comp.name && n.init.arguments[1])
+                    self.add(n.id.name);
+            }
+            if (n.type === "CallExpression" && n.callee.type === "Identifier" && n.callee.name === "_ssrRenderComponent") {
+                const target = n.arguments[0];
+                const child = target?.type === "MemberExpression" && target.object.name === "$setup"
+                    ? r.children.get(target.computed ? target.property.value : target.property.name)
+                    : target?.type === "Identifier" && self.has(target.name)
+                        ? r.comp.name
+                        : undefined;
+                const props = n.arguments[1];
+                const parts = props?.type === "CallExpression" && props.callee.name === "_mergeProps" ? props.arguments : props ? [props] : [];
+                if (child) {
+                    calls.push({
+                        child,
+                        keys: parts.filter((p) => p.type === "ObjectExpression").flatMap((p) => p.properties.filter((q) => q.type === "ObjectProperty" && !q.computed).map((q) => q.key.name ?? String(q.key.value))),
+                        passesAttrs: parts.some((p) => p.type === "Identifier" && p.name === "_attrs"),
+                        passesDollar: parts.some((p) => isDollarAttrs(p, r.attrsBindings)),
+                    });
+                }
+            }
+            for (const [key, v] of Object.entries(n))
+                if (key !== "loc" && key !== "start" && key !== "end")
+                    walk(v);
+        };
+        walk(parseJs(r.ssr, { sourceType: "module" }).program);
+        return { comp: r.comp, calls };
+    });
+    for (let changed = true; changed;) {
+        changed = false;
+        for (const f of flows) {
+            for (const c of f.calls) {
+                const child = byName.get(c.child);
+                if (!child)
+                    continue;
+                const names = c.keys.filter((k) => passedKey(child, k));
+                if ((c.passesAttrs && f.comp.inheritAttrs) || c.passesDollar)
+                    names.push(...f.comp.attrNames);
+                for (const name of names) {
+                    if (declares(child, name) || child.attrNames.has(name))
+                        continue;
+                    child.attrNames.add(name);
+                    changed = true;
+                }
+                if (c.passesAttrs && f.comp.inherits && !child.idsInAttrs)
+                    child.idsInAttrs = changed = true;
+            }
+        }
+    }
+}

package/dist/script.js

@@ -1,6 +1,6 @@
 /* `<script setup>` read: what the server evaluates, and what stays on the client. */
 import { basename } from "node:path";
-import { fail, GenError, snake, STR } from "./model.js";
+import { fail, GenError, snake, STR, takesAttrs } from "./model.js";
 import { CONFIG_FILE, ctx } from "./context.js";
 import { definePropsType } from "./typescript.js";
 import { expr, fieldVal, storeGetter, theRoute } from "./expr.js";
@@ -92,7 +92,10 @@ export function scopeFor(comp, ast, components) {
         i18nT: new Set(),
         fill: false,
         vnode: false,
-        attrs: comp.inherits ? "fv_attrs" : null,
+        // A component a parent may pass attributes takes them with the scope ids, as one `fv::Attrs`.
+        attrs: comp.inherits ? (takesAttrs(comp) ? "fv_attrs.ids()" : "fv_attrs") : null,
+        fallthrough: takesAttrs(comp) ? "fv_attrs" : null,
+        attrsBindings: new Set(),
         sid: null,
     };
     const lets = [];
@@ -100,6 +103,7 @@ export function scopeFor(comp, ast, components) {
     let storeToRefsName = null;
     let useRouteName = null;
     let useI18nName = null;
+    let useAttrsName = null;
     /** Setup bindings holding a store, by name. */
     const storeValues = new Map();
     for (const st of ast) {
@@ -142,6 +146,12 @@ export function scopeFor(comp, ast, components) {
                         scope.clientOnly.set(sp.local.name, `\`${name}\` from vue-i18n does not run on the server`);
                 }
             }
+            else if (from === "vue") {
+                for (const sp of st.specifiers) {
+                    if (sp.type === "ImportSpecifier" && (sp.imported.name ?? sp.imported.value) === "useAttrs")
+                        useAttrsName = sp.local.name;
+                }
+            }
             else if (from === "pinia") {
                 for (const sp of st.specifiers) {
                     const name = sp.type === "ImportSpecifier" ? (sp.imported.name ?? sp.imported.value) : null;
@@ -252,6 +262,12 @@ export function scopeFor(comp, ast, components) {
                 scope.setup.set(local, theRoute(scope, d));
                 continue;
             }
+            // `const attrs = useAttrs()`: `$attrs`, which the template may bind whole.
+            if (useAttrsName !== null && init0?.type === "CallExpression" && init0.callee.type === "Identifier" && init0.callee.name === useAttrsName) {
+                scope.attrsBindings.add(local);
+                scope.clientOnly.set(local, "`useAttrs()` is bound whole, with `v-bind`; a value read from it has no type");
+                continue;
+            }
             // `const model = defineModel<string>()`: the model's prop.
             const model = comp.models.get(local);
             if (model !== undefined) {

package/dist/stores.js

@@ -223,5 +223,7 @@ export function storeHome(file) {
         inheritAttrs: true,
         inherits: false,
         passesSlotIds: false,
+        attrNames: new Set(),
+        idsInAttrs: false,
     };
 }

package/dist/template.d.ts

@@ -4,8 +4,11 @@ import { Emitter } from "./emitter.ts";
 export declare function slot(s: Scope, e: Emitter, n: N): void;
 /** `isComment` in `@vue/server-renderer`: a chunk that is only comments and whitespace. */
 export declare function isComment(text: string): boolean;
-/** Whether a `_push` argument is content to `ssrRenderSlot`, rather than only comments. */
-export declare function pushesContent(s: Scope, n: N): boolean;
+/** Whether a `_push` argument is content to `ssrRenderSlot` rather than only comments — `"run"`
+ * when that depends on the values it interpolates (`${of1}<!--[-->` is a comment when `of1` writes
+ * nothing). Vue asks it of each pushed string, so the generated code asks `fv::is_comment` of what
+ * that push wrote. */
+export declare function pushesContent(n: N): boolean | "run";
 export declare function push(s: Scope, e: Emitter, n: N): void;
 export declare function renderChild(s: Scope, e: Emitter, n: N): void;
 /** `name: value` in a struct literal, or the name alone when the value is a variable of that name. */
@@ -15,8 +18,8 @@ export declare function takesSlots(c: Component): boolean;
 /** The arguments after `props` that a component's `render` takes. */
 export declare function extraParams(c: Component): string;
 /** `render(out, props[, slots][, route])` for a child, with the slot content this template gives
- * it as closures; `render_scoped`, with the scope ids its root is handed last, for a child that may
- * be handed some. */
+ * it as closures; `render_scoped`, with the scope ids its root is handed last — and the attributes
+ * it is passed, as `fv::Attrs` — for a child that may be handed some. */
 export declare function callChild(s: Scope, e: Emitter, child: Component, propsCode: string, slots: N, attrs: string | null): void;
 /** The statements a parent's slot content pushes: the `if (_push)` half of its `_withCtx`. */
 export declare function slotBody(s: Scope, value: N): N[];
@@ -28,7 +31,7 @@ export declare function slotContent(s: Scope, value: N): {
 };
 /** Whether slot content always pushes something that is not a comment: a push of content outside
  * any `if` or loop. Then nothing has to be decided at run time. */
-export declare function staticallyFilled(s: Scope, body: N[]): boolean;
+export declare function staticallyFilled(body: N[]): boolean;
 /** `RowSlotProps`, `RowSlot`: the names of a scoped slot's props struct and content type. */
 export declare function slotTypeName(slotName: string, suffix: string): string;
 /** Whether a scoped slot prop's Rust type borrows, and so needs the props' lifetime `'v`. */