ferrovue 0.9.0 → 0.10.0

package/dist/blocks.js

@@ -0,0 +1,476 @@
+import { fail, GenError, nothing } from "./model.js";
+import { ctx } from "./context.js";
+import { expr, typedBy } from "./expr.js";
+import { collected, heldList } from "./lists.js";
+import { atom, bare, occurrences, operand, UNARY } from "./parens.js";
+import { presence } from "./narrowing.js";
+import { asCow, heldStr, isTemporary } from "./strings.js";
+import { intFromF64 } from "./numbers.js";
+const COW = "std::borrow::Cow::<str>";
+/** Runtime calls that panic where JavaScript throws, or user code that may. */
+export const PANICS = /\bfv::js_(?:repeat|pad_start|pad_end|date_parse|date_utc|to_iso_string)\(|\bfv_i18n\.t\(/;
+export function panicky(code) {
+    return PANICS.test(code) || Object.values(ctx.helpers).some((h) => code.includes(`${h.rust}(`));
+}
+/** How a value is held in a Rust `let`: what the `let` is given, how the name reads back, and
+ * whether the `let` owns what a read borrows (a `String`, a `Cow`, a `Vec`). */
+export function bindingOf(v) {
+    const lone = v.lone ? { lone: true } : {};
+    if (v.slice)
+        return { init: bare(v.code), read: (at) => ({ code: at, ty: v.ty, slice: true, ...lone }), owned: false };
+    if (v.ty.k === "list" && v.iter !== undefined)
+        return { init: collected(v), read: (at) => heldList(at, v.ty.k === "list" ? v.ty.of : v.ty, v.lone), owned: true };
+    if (v.held !== undefined)
+        return { init: v.held, read: (at) => ({ code: `${at}.as_deref()`, ty: v.ty, ...lone }), owned: true };
+    if (v.ty.k === "int" && v.f64 !== undefined && (v.code.endsWith(" as i64") || Object.is(v.num, -0))) {
+        return {
+            init: bare(v.f64),
+            read: (at) => ({ ...intFromF64(at), ...lone, ...(v.num !== undefined ? { num: v.num } : {}), ...(v.konst !== undefined ? { konst: v.konst } : {}) }),
+            owned: false,
+        };
+    }
+    if (isTemporary(v))
+        return { init: heldStr(v), read: (at) => ({ code: `&*${at}`, ty: v.ty, ...lone }), owned: true };
+    const place = v.ty.k === "list" || v.ty.k === "record" || v.ty.k === "struct" || v.ty.k === "child";
+    return {
+        init: place ? `&${operand(v.code, UNARY)}` : bare(v.code),
+        read: (at) => ({ code: at, ty: v.ty, ...lone, ...(v.konst !== undefined ? { konst: v.konst } : {}) }),
+        owned: false,
+    };
+}
+const SKIP = new Set(["loc", "start", "end", "extra", "range", "typeAnnotation", "typeParameters", "returnType", "leadingComments", "trailingComments", "innerComments", "__fv", "label"]);
+let renames = 0;
+function spot(from) {
+    return { loc: from?.loc, start: from?.start, end: from?.end, __fv: from?.__fv };
+}
+function declared(st) {
+    if (st?.type === "VariableDeclaration")
+        return st.declarations.flatMap((d) => patternNames(d.id));
+    return [];
+}
+function patternNames(p) {
+    switch (p?.type) {
+        case "Identifier":
+            return [p.name];
+        case "ObjectPattern":
+            return p.properties.flatMap((q) => patternNames(q.type === "RestElement" ? q.argument : q.value));
+        case "ArrayPattern":
+            return p.elements.flatMap((q) => (q ? patternNames(q) : []));
+        case "AssignmentPattern":
+            return patternNames(p.left);
+        case "RestElement":
+            return patternNames(p.argument);
+        default:
+            return [];
+    }
+}
+class Renamer {
+    comp;
+    constructor(comp) {
+        this.comp = comp;
+    }
+    statements(sts, outer) {
+        const env = new Map(outer);
+        for (const st of sts)
+            for (const name of declared(st))
+                env.set(name, null);
+        return sts.map((st) => {
+            if (st.type !== "VariableDeclaration")
+                return this.node(st, env);
+            const declarations = st.declarations.map((d) => {
+                const init = this.node(d.init, env);
+                return { ...d, init, id: this.pattern(d.id, env) };
+            });
+            return { ...st, declarations };
+        });
+    }
+    pattern(p, env) {
+        switch (p?.type) {
+            case "Identifier": {
+                const to = `${p.name}#${++renames}`;
+                env.set(p.name, to);
+                return { ...p, name: to, fvName: p.name };
+            }
+            case "ObjectPattern":
+                return {
+                    ...p,
+                    properties: p.properties.map((q) => q.type === "RestElement" ? { ...q, argument: this.pattern(q.argument, env) } : { ...q, key: q.computed ? this.node(q.key, env) : q.key, value: this.pattern(q.value, env), shorthand: false }),
+                };
+            case "ArrayPattern":
+                return { ...p, elements: p.elements.map((q) => (q ? this.pattern(q, env) : q)) };
+            case "AssignmentPattern":
+                return { ...p, right: this.node(p.right, env), left: this.pattern(p.left, env) };
+            case "RestElement":
+                return { ...p, argument: this.pattern(p.argument, env) };
+            default:
+                return p;
+        }
+    }
+    node(n, env) {
+        if (!n || typeof n !== "object")
+            return n;
+        if (Array.isArray(n))
+            return n.map((x) => this.node(x, env));
+        switch (n.type) {
+            case "Identifier": {
+                const to = env.get(n.name);
+                if (to === null)
+                    fail(this.comp, "FV1901", `\`${n.name}\` is read before its declaration, where JavaScript throws a \`ReferenceError\``, n);
+                return to === undefined ? n : { ...n, name: to, fvName: n.name };
+            }
+            case "MemberExpression":
+            case "OptionalMemberExpression":
+                return { ...n, object: this.node(n.object, env), property: n.computed ? this.node(n.property, env) : n.property };
+            case "ObjectProperty":
+                return { ...n, key: n.computed ? this.node(n.key, env) : n.key, value: this.node(n.value, env), shorthand: false };
+            case "ArrowFunctionExpression":
+            case "FunctionExpression":
+            case "FunctionDeclaration":
+            case "ObjectMethod": {
+                const inner = new Map(env);
+                for (const p of n.params)
+                    for (const name of patternNames(p))
+                        inner.delete(name);
+                if (n.type === "FunctionExpression" && n.id)
+                    inner.delete(n.id.name);
+                const body = n.body.type === "BlockStatement" ? { ...n.body, body: this.statements(n.body.body, inner) } : this.node(n.body, inner);
+                return { ...n, body };
+            }
+            case "BlockStatement":
+                return { ...n, body: this.statements(n.body, env) };
+            case "SwitchStatement":
+                return { ...n, discriminant: this.node(n.discriminant, env), cases: n.cases.map((c) => ({ ...c, test: this.node(c.test, env), consequent: this.statements(c.consequent, env) })) };
+        }
+        const copy = { ...n };
+        for (const key of Object.keys(n)) {
+            if (SKIP.has(key))
+                continue;
+            const v = n[key];
+            if (v && typeof v === "object")
+                copy[key] = this.node(v, env);
+        }
+        return copy;
+    }
+}
+const LOOPS = {
+    ForStatement: "a `for` loop",
+    ForOfStatement: "a `for…of` loop",
+    ForInStatement: "a `for…in` loop",
+    WhileStatement: "a `while` loop",
+    DoWhileStatement: "a `do…while` loop",
+};
+const OTHERS = {
+    TryStatement: "`try`, which only catches what the body throws",
+    ThrowStatement: "`throw`, which ends the render with an error",
+    LabeledStatement: "a labelled statement",
+    ContinueStatement: "`continue`",
+    FunctionDeclaration: "a function declared inside it",
+    ClassDeclaration: "a class declared inside it",
+    DebuggerStatement: "`debugger`",
+    WithStatement: "`with`",
+};
+const SUBSET = "it holds `const` (and `let` never assigned again), `if` / `else`, `switch` and `return`";
+function assignments(comp, body) {
+    const lets = new Set();
+    const visit = (n) => {
+        if (!n || typeof n !== "object")
+            return;
+        if (Array.isArray(n)) {
+            n.forEach(visit);
+            return;
+        }
+        if (n.type === "VariableDeclaration" && n.kind === "let")
+            for (const d of n.declarations)
+                for (const name of patternNames(d.id))
+                    lets.add(name);
+        if (n.type === "AssignmentExpression" || n.type === "UpdateExpression") {
+            const target = n.type === "AssignmentExpression" ? n.left : n.argument;
+            const shown = `\`${n.operator}\``;
+            if (target.type === "Identifier" && lets.has(target.name)) {
+                fail(comp, "FV1902", `\`let ${target.name}\` is assigned again with ${shown}, which a function's body does not translate: give each value a \`const\` of its own`, n);
+            }
+            fail(comp, "FV1902", `an assignment (${shown}) changes a value, which a function's body does not translate: give each value a \`const\` of its own`, n);
+        }
+        for (const key of Object.keys(n))
+            if (!SKIP.has(key) && n[key] && typeof n[key] === "object")
+                visit(n[key]);
+    };
+    visit(body);
+}
+/** How many times a body's statements may be translated again after an `if` or a `case` that
+ * falls off its end: each such path continues with the statements after it, translated on its own,
+ * so sequential `switch`es of `break`ing cases multiply them. */
+export const PATH_BUDGET = 4096;
+class Desugar {
+    comp;
+    paths = 0;
+    constructor(comp) {
+        this.comp = comp;
+    }
+    run(sts, k, brk, from) {
+        for (let i = 0; i < sts.length; i++) {
+            const st = sts[i];
+            const rest = sts.slice(i + 1);
+            const after = rest.length ? { sts: rest, next: k, brk } : k;
+            switch (st.type) {
+                case "EmptyStatement":
+                    continue;
+                case "ReturnStatement":
+                    if (!st.argument)
+                        fail(this.comp, "FV1903", "`return` without a value returns `undefined`: return the value the function gives on this path", st);
+                    this.dead(rest, "`return`");
+                    return st.argument;
+                case "BreakStatement":
+                    if (st.label || brk === undefined)
+                        fail(this.comp, "FV1901", "`break` outside a `switch`'s case, which only a loop could take", st);
+                    this.dead(rest, "`break`");
+                    return this.go(brk, st);
+                case "BlockStatement":
+                    return this.run(st.body, after, brk, st);
+                case "IfStatement": {
+                    const yes = this.run(this.branch(st.consequent), after, brk, st);
+                    const no = st.alternate ? this.run(this.branch(st.alternate), after, brk, st) : this.go(after, st);
+                    return { type: "ConditionalExpression", test: st.test, consequent: yes, alternate: no, fvIf: true, ...spot(st) };
+                }
+                case "SwitchStatement":
+                    return this.switched(st, after);
+                case "VariableDeclaration": {
+                    if (st.kind !== "const" && st.kind !== "let")
+                        fail(this.comp, "FV1901", `a function's body may not hold \`${st.kind}\`: declare the value with \`const\``, st);
+                    const body = this.run(rest, k, brk, st);
+                    return st.declarations.reduceRight((inner, d) => this.bind(d, inner), body);
+                }
+                case "ExpressionStatement":
+                    return fail(this.comp, "FV1901", `a function's body may not hold an expression statement (\`${st.expression.type}\`), whose value is dropped and which could only change something: ${SUBSET}`, st);
+                default: {
+                    const what = LOOPS[st.type] ?? OTHERS[st.type] ?? `\`${st.type}\``;
+                    const why = LOOPS[st.type] ? `: ${SUBSET}; compute a list with \`.map()\`, \`.filter()\` or \`.reduce()\`` : `: ${SUBSET}`;
+                    return fail(this.comp, "FV1901", `a function's body may not hold ${what}${why}`, st);
+                }
+            }
+        }
+        return this.go(k, from);
+    }
+    branch(st) {
+        return st.type === "BlockStatement" ? st.body : [st];
+    }
+    dead(rest, after) {
+        const first = rest.find((r) => r.type !== "EmptyStatement");
+        if (first)
+            fail(this.comp, "FV1904", `code after ${after}, which never runs: remove it`, first);
+    }
+    go(k, from) {
+        if (k === null) {
+            return fail(this.comp, "FV1903", "the function can reach its end here without a `return`, and JavaScript then returns `undefined`: return a value on every path", from);
+        }
+        if (k.falls)
+            fail(this.comp, "FV1904", "this case falls through into the next one, which runs its statements too: end it with `return` or `break`", k.falls);
+        if (k.sts.length && ++this.paths > PATH_BUDGET) {
+            fail(this.comp, "FV1905", `the body's \`if\`s and \`switch\`es continue with the statements after them on more than ${PATH_BUDGET} paths, each translated on its own: end the cases in \`return\`, or split the body into \`computed\`s`, from);
+        }
+        return this.run(k.sts, k.next, k.brk, from);
+    }
+    bind(d, body) {
+        if (!d.init)
+            fail(this.comp, "FV1901", `\`${d.id.fvName ?? d.id.name ?? "a pattern"}\` is declared without a value: give it one where it is declared`, d);
+        const typed = d.id.typeAnnotation?.typeAnnotation;
+        const init = typed ? typedBy(d.init, typed) : d.init;
+        return this.pattern(d.id, init, body, d);
+    }
+    pattern(p, value, body, d) {
+        switch (p.type) {
+            case "Identifier":
+                return { type: "FvLet", name: p.name, js: p.fvName ?? p.name, init: value, body, ...spot(d) };
+            case "ObjectPattern":
+            case "ArrayPattern": {
+                const tmp = `fv#${++renames}`;
+                const ref = () => ({ type: "Identifier", name: tmp, ...spot(value) });
+                const parts = [];
+                if (p.type === "ObjectPattern") {
+                    for (const q of p.properties) {
+                        if (q.type === "RestElement" || q.computed)
+                            fail(this.comp, "FV1901", "a destructuring pattern names each field it reads, without `...rest` or a computed key", q);
+                        const key = q.key.type === "Identifier" ? q.key.name : String(q.key.value);
+                        parts.push([q.value, { type: "MemberExpression", computed: false, object: ref(), property: { type: "Identifier", name: key, ...spot(q.key) }, ...spot(q) }]);
+                    }
+                }
+                else {
+                    p.elements.forEach((q, i) => {
+                        if (!q)
+                            return;
+                        if (q.type === "RestElement")
+                            fail(this.comp, "FV1901", "a destructuring pattern names each item it reads, without `...rest`", q);
+                        parts.push([q, { type: "MemberExpression", computed: true, object: ref(), property: { type: "NumericLiteral", value: i, ...spot(q) }, ...spot(q) }]);
+                    });
+                }
+                for (const [q] of parts)
+                    if (q.type === "AssignmentPattern")
+                        fail(this.comp, "FV1901", "a default in a destructuring pattern, which applies to `undefined` alone: write `?? fallback` where it is read", q);
+                const inner = parts.reduceRight((acc, [q, v]) => this.pattern(q, v, acc, d), body);
+                return { type: "FvLet", name: tmp, js: "the destructured value", init: value, body: inner, ...spot(d) };
+            }
+            default:
+                return fail(this.comp, "FV1901", "a declaration binds a name, or an object or array pattern of names", p);
+        }
+    }
+    switched(st, after) {
+        const d = `switch#${++renames}`;
+        const subject = () => ({ type: "Identifier", name: d, ...spot(st.discriminant) });
+        const groups = [];
+        let open = null;
+        for (const c of st.cases) {
+            if (!open) {
+                open = { tests: [], body: [], dflt: false, at: c };
+                groups.push(open);
+            }
+            if (c.test)
+                open.tests.push(c.test);
+            else
+                open.dflt = true;
+            const lexical = c.consequent.find((x) => x.type === "VariableDeclaration" || x.type === "FunctionDeclaration" || x.type === "ClassDeclaration");
+            if (lexical)
+                fail(this.comp, "FV1904", "a declaration directly in a `case`, which the whole `switch` shares: wrap the case's statements in `{ … }`", lexical);
+            if (c.consequent.some((x) => x.type !== "EmptyStatement")) {
+                open.body = c.consequent;
+                open = null;
+            }
+        }
+        const brk = after;
+        const bodyOf = (g, i) => {
+            const last = i === groups.length - 1;
+            const k = last ? after : { sts: [], next: null, brk: undefined, falls: g.body.at(-1) ?? g.at };
+            if (!g.body.length)
+                return last ? this.go(after, g.at) : this.go(k, g.at);
+            return this.run(g.body, k, brk, g.body.at(-1));
+        };
+        const fallback = groups.findIndex((g) => g.dflt);
+        let chain = fallback >= 0 ? bodyOf(groups[fallback], fallback) : this.go(after, st);
+        for (let i = groups.length - 1; i >= 0; i--) {
+            const g = groups[i];
+            if (i === fallback)
+                continue;
+            const test = g.tests
+                .map((t) => ({ type: "BinaryExpression", operator: "===", left: subject(), right: t, ...spot(t) }))
+                .reduce((a, b) => ({ type: "LogicalExpression", operator: "||", left: a, right: b, ...spot(b) }));
+            chain = { type: "ConditionalExpression", test, consequent: bodyOf(g, i), alternate: chain, ...spot(g.at) };
+        }
+        return { type: "FvLet", name: d, js: "the `switch`'s value", init: st.discriminant, body: chain, ...spot(st) };
+    }
+}
+const desugared = new WeakMap();
+/** The expression a function's body computes: the expression of an arrow function, or a block of
+ * statements in the subset ferrovue translates, written as one expression. */
+export function bodyExpr(comp, fn) {
+    if (fn.body.type !== "BlockStatement")
+        return fn.body;
+    const done = desugared.get(fn);
+    if (done)
+        return done;
+    assignments(comp, fn.body.body);
+    const shadowed = new Map();
+    const renamed = new Renamer(comp).statements(fn.body.body, shadowed);
+    const out = new Desugar(comp).run(renamed, null, undefined, fn.body.body.at(-1) ?? fn);
+    desugared.set(fn, out);
+    return out;
+}
+/** `p` (a name, or an object or array pattern of names) bound to `value` around `body`. */
+export function destructured(comp, p, value, body) {
+    return new Desugar(comp).pattern(p, value, body, p);
+}
+/** `fn` with an expression for its body, where it is an arrow or function expression with a block. */
+export function expressionBodied(comp, fn) {
+    if ((fn?.type !== "ArrowFunctionExpression" && fn?.type !== "FunctionExpression") || fn.body.type !== "BlockStatement")
+        return fn;
+    return { ...fn, body: bodyExpr(comp, fn) };
+}
+function simple(v) {
+    if (v.iter !== undefined || v.held !== undefined || v.format !== undefined)
+        return false;
+    if (nothing(v.ty))
+        return true;
+    return /^(?:&\*?|\*)?[A-Za-z_]\w*(?:\.\w+)*$/.test(v.code) || /^"(?:[^"\\]|\\.)*"$/.test(v.code) || /^-?\d[\w.]*$/.test(v.code);
+}
+function reps(v) {
+    return [v.code, v.iter, v.held, v.f64, ...(v.format?.args ?? [])].filter((r) => r !== undefined);
+}
+function ownedCow(v) {
+    if (!isTemporary(v))
+        return `${COW}::Owned(${atom(v.code).replace(/^&\*?/, "")}.to_owned())`;
+    const cow = asCow(v);
+    return cow.startsWith(`${COW}::Owned(`) ? cow : `${COW}::Owned(${atom(cow)}.into_owned())`;
+}
+/** `const name = init` around `body`: the value `body` computes with `name` bound once, as a Rust
+ * `let` in a block that hands out nothing borrowed from it. */
+export function letIn(s, n) {
+    return bound(s, n.name, expr(s, n.init), (inner) => expr(inner, n.body));
+}
+/** `v` bound once to `name` for `body`, which is given the scope that reads it. */
+export function bound(s, local, v, then) {
+    if (simple(v))
+        return then({ ...s, locals: new Map(s.locals).set(local, v) });
+    const name = `fv_c${++ctx.narrowCount}`;
+    const { init, read, owned } = bindingOf(v);
+    const held = read(name);
+    const body = then({ ...s, locals: new Map(s.locals).set(local, held) });
+    if (reps(body).join("\0") === reps(held).join("\0"))
+        return v;
+    const uses = reps(body).some((r) => occurrences(r, name) > 0);
+    if (!uses && !panicky(init))
+        return body;
+    const lead = `let ${uses ? name : "_"} = ${init};`;
+    const block = (code) => `{ ${lead} ${bare(code)} }`;
+    const lone = body.lone ? { lone: true } : {};
+    switch (body.ty.k) {
+        case "int":
+        case "float":
+        case "bool":
+        case "undef":
+        case "null":
+            return { code: block(body.code), ty: body.ty, ...lone, ...(body.f64 !== undefined ? { f64: block(body.f64) } : {}) };
+        case "str":
+            if (!owned && !isTemporary(body))
+                return { code: block(body.code), ty: body.ty, ...lone };
+            return { code: `&*${block(owned ? ownedCow(body) : asCow(body))}`, ty: body.ty, ...lone };
+        case "list": {
+            if (!owned && body.iter === undefined)
+                return { code: block(body.code), ty: body.ty, ...(body.slice ? { slice: true } : {}), ...lone };
+            const all = block(collected(body));
+            return { code: all, ty: body.ty, iter: `${all}.into_iter()`, ...lone };
+        }
+        case "opt":
+            if (body.ty.of.k === "str" && (owned || body.held !== undefined)) {
+                const kept = block(owned ? `${atom(body.code)}.map(|v| ${COW}::Owned(v.to_owned()))` : body.held);
+                return { code: `${kept}.as_deref()`, ty: body.ty, held: kept, ...lone };
+            }
+            return { code: block(body.code), ty: body.ty, ...lone };
+        default: {
+            const ref = /^\w+(?:\.[\w#]+)+$/.test(body.code) ? `&${body.code}` : body.code;
+            return { code: `(${block(ref)})`, ty: body.ty, ...lone };
+        }
+    }
+}
+/** Whether a desugared `if` whose test is `a && b` or `a || b` should be split, so that a side
+ * that narrows a value narrows what follows it, as TypeScript narrows it. */
+export function splits(s, test) {
+    if (test.type !== "LogicalExpression" || (test.operator !== "&&" && test.operator !== "||"))
+        return false;
+    const narrows = (side) => {
+        if (side.type === "LogicalExpression" && side.operator === test.operator)
+            return splits(s, side);
+        try {
+            return presence(s, side) !== null;
+        }
+        catch (e) {
+            if (e instanceof GenError)
+                return false;
+            throw e;
+        }
+    };
+    return narrows(test.left) || narrows(test.right);
+}
+/** `a && b ? x : y` as `a ? (b ? x : y) : y`, and `a || b ? x : y` as `a ? x : (b ? x : y)`. */
+export function split(n) {
+    const { left, right, operator } = n.test;
+    const inner = { ...n, test: right };
+    return operator === "&&" ? { ...n, test: left, consequent: inner, alternate: n.alternate } : { ...n, test: left, consequent: n.consequent, alternate: inner };
+}

package/dist/calls.js

@@ -6,7 +6,8 @@ import { computedListMethod, isBoolean, items, listMethod, objectCall, presentLi
 import { formatted, lonely, loneOf, meet, stringMethod, stringOf, stringsEqual } from "./strings.js";
 import { asF64, intFromF64, isNumber, numberVal, power } from "./numbers.js";
 import { boolOf, truthy } from "./narrowing.js";
-import { coerce, describeTy, expr } from "./expr.js";
+import { coerce, describeTy, expr, refuseClientOnly, refuseUnavailable } from "./expr.js";
+import { callFunction } from "./functions.js";
 const DIGITS = new Map([
     ["toFixed", ["FV0705", 0, "number of digits"]],
     ["toPrecision", ["FV0716", 1, "precision"]],
@@ -46,6 +47,9 @@ export function call(s, n) {
         const helper = s.helpers.get(callee.name);
         if (helper)
             return helperCall(s, helper, args, n);
+        const fn = s.locals.has(callee.name) ? undefined : s.functions.get(callee.name);
+        if (fn)
+            return callFunction(s, callee.name, fn, args, n);
         if (isBoolean(s, callee) && args.length === 1)
             return boolOf(truthy(expr(s, args[0])));
         const global = !s.locals.has(callee.name) && !s.setup.has(callee.name);
@@ -97,7 +101,7 @@ export function call(s, n) {
             return numberTest(s, callee.name, args, n, true);
         if (global && BUILTINS.has(callee.name))
             return builtin(s, `${callee.name}()`, n);
-        return fail(comp, "FV0601", `\`${callee.name}()\` is not available when rendering on the server`, n);
+        return refuseUnavailable(s, callee.name, n, true);
     }
     if (callee.type === "MemberExpression" && !callee.computed) {
         const method = callee.property.name;
@@ -129,8 +133,13 @@ export function call(s, n) {
             const helper = s.helpers.get(method);
             if (helper)
                 return helperCall(s, helper, args, n);
+            const fn = s.functions.get(method);
+            if (fn)
+                return callFunction(s, method, fn, args, n);
             if (s.clientOnly.has(method))
-                return fail(comp, "FV0613", `\`${method}\` is set up in a way the server cannot evaluate: ${s.clientOnly.get(method)}`, n);
+                return refuseClientOnly(s, method, n, true);
+            if (!s.setup.has(method) && !(callee.object.name === "_ctx" && comp.props.fields.some((f) => f.js === method)))
+                return refuseUnavailable(s, method, n, true);
         }
         if (callee.object.type === "Identifier" && callee.object.name === "Math") {
             if ((method === "max" || method === "min") && args.some((a) => a?.type === "SpreadElement"))

package/dist/children.js

@@ -1,8 +1,8 @@
 import { isSSRSafeAttrName, propsToAttrMap } from "@vue/shared";
-import { camelize, declares, fail, nothing, rustStr, sameTy, snake, takesAttrs } from "./model.js";
+import { absence, camelize, declares, fail, nothing, rustStr, sameTy, snake, takesAttrs } from "./model.js";
 import { ctx } from "./context.js";
 import { markHome } from "./typescript.js";
-import { expr, fieldVal, holdsNothing } from "./expr.js";
+import { describeTy, expr, fieldVal, holdsNothing } from "./expr.js";
 import { asF64 } from "./numbers.js";
 import { atom, bare } from "./parens.js";
 import { Emitter } from "./emitter.js";
@@ -337,6 +337,13 @@ export function ownInto(comp, v, want, node) {
         return asF64(v);
     if (want.k === "opt" && want.of.k === "float" && v.ty.k === "int")
         return `Some(${asF64(v)})`;
+    if (want.k === "opt" && v.ty.k === "opt" && absence(v.ty) === absence(want)) {
+        const of = want.of.k;
+        if (v.ty.of.k === of && (of === "int" || of === "float" || (of === "bool" && absence(want) === "null")))
+            return v.code;
+        if (of === "float" && v.ty.of.k === "int")
+            return `${atom(v.code)}.map(|n| n as f64)`;
+    }
     if (v.iter !== undefined && v.ty.k === "list" && want.k === "list" && sameTy(v.ty.of, want.of)) {
         return want.of.k === "struct" || want.of.k === "child" ? `${v.iter}.cloned().collect()` : `${v.iter}.collect()`;
     }
@@ -358,5 +365,5 @@ export function ownInto(comp, v, want, node) {
         if (want.of.k === "int" || want.of.k === "float" || want.of.k === "bool")
             return `${atom(v.code)}.to_vec()`;
     }
-    return fail(comp, "FV0511", `a ${JSON.stringify(v.ty)} into a ${JSON.stringify(want)} prop`, node);
+    return fail(comp, "FV0511", `the prop is ${describeTy(want)}, and the value given is ${describeTy(v.ty)}`, node);
 }

package/dist/cli.js

@@ -5,7 +5,7 @@ import { relativePath } from "./paths.js";
 import { CONFIG_FILE, generate, isGenerated, loadConfig, VERSION, write } from "./compiler.js";
 import { helpText, parseArgs } from "./args.js";
 import { unifiedDiff } from "./diff.js";
-import { diagnose, formatRefusal, formatWarning, isRefusal } from "./diagnostics.js";
+import { diagnose, diagnoseAll, formatRefusal, formatWarning, isRefusal } from "./diagnostics.js";
 import { affects, inputsOf } from "./inputs.js";
 const root = process.cwd();
 const SCHEMA_URL = `https://cdn.jsdelivr.net/npm/ferrovue@${VERSION}/schema.json`;
@@ -27,7 +27,7 @@ function report(e) {
     if (!isRefusal(e))
         throw e;
     if (json)
-        emit({ diagnostics: [diagnose(e)] });
+        emit({ diagnostics: diagnoseAll(e) });
     else
         console.error(formatRefusal(e));
 }
@@ -130,8 +130,6 @@ function watchProject(configPath) {
             once(config);
         }
         catch (e) {
-            // A refusal is reported as one; anything else (a folder renamed away, a file read as it is
-            // written) is shown too, and the watch carries on for the change that puts it right.
             if (isRefusal(e))
                 report(e);
             else
@@ -143,8 +141,6 @@ function watchProject(configPath) {
     };
     run();
     let timer = null;
-    // One recursive watch of the root, filtered to the inputs: watching each input directory instead
-    // would miss one created later, and the type files may be anywhere.
     const watcher = watch(root, { recursive: true }, (_event, name) => {
         if (!name || !affects(inputs, join(root, name)))
             return;

package/dist/client-render.d.ts

@@ -10,12 +10,13 @@ export declare function renderedShape(container: Element): string;
  * the selection the HTML parser gives it, from the `selected` attributes (the last one in a single
  * `<select>`, or its first enabled option without one), which happy-dom's property misreports. */
 export declare function parsedShape(container: Element): string;
-/** A plugin that takes what the app is mounted on, and its `renderedShape` as `mount` returns,
- * before any update an `onMounted` hook scheduled has run. */
+/** A plugin that takes what the app is mounted on, and its `renderedShape` once the root
+ * component's child is mounted: as `mount` returns, or, inside a `<Suspense>`, once it resolves,
+ * before any update an `onMounted` hook scheduled has run. `shape` resolves to it. */
 export declare function shapeAtMount(): {
     plugin: Plugin;
     container: () => Element | undefined;
-    shape: () => string | undefined;
+    shape: () => Promise<string>;
 };
 /** Set the custom properties `v-bind()` in `<style>` gives each component's root elements, as Vue's
  * client sets them once mounted, where Vue's build does not set them itself (its Node build) and a

package/dist/client-render.js

@@ -85,19 +85,32 @@ export function renderedShape(container) {
 export function parsedShape(container) {
     return nodes(container.childNodes, container.ownerDocument.createElement("div"), true);
 }
-/** A plugin that takes what the app is mounted on, and its `renderedShape` as `mount` returns,
- * before any update an `onMounted` hook scheduled has run. */
+/** A plugin that takes what the app is mounted on, and its `renderedShape` once the root
+ * component's child is mounted: as `mount` returns, or, inside a `<Suspense>`, once it resolves,
+ * before any update an `onMounted` hook scheduled has run. `shape` resolves to it. */
 export function shapeAtMount() {
     let container;
-    let shape;
+    let taken;
+    const shape = new Promise((done) => (taken = done));
     const plugin = {
         install(app) {
+            app.mixin({
+                mounted() {
+                    if (!this.$parent || this.$parent.$parent)
+                        return;
+                    const parent = this.$el?.parentNode;
+                    if (parent?.nodeType === 1)
+                        taken(renderedShape(parent));
+                },
+            });
             const mount = app.mount.bind(app);
             app.mount = (...args) => {
                 const root = mount(...args);
                 const [target] = args;
                 container = (typeof target === "string" ? document.querySelector(target) : target);
-                shape = renderedShape(container);
+                const pending = root.$.subTree.suspense?.pendingBranch;
+                if (!pending)
+                    taken(renderedShape(container));
                 return root;
             };
         },