ferrovue 0.7.2 → 0.9.0

package/dist/errors.js

@@ -18,6 +18,7 @@ export const AREAS = {
     "15": { name: "Raw HTML, client-only content, teleports and Rust twins", guide: "errors_and_limits" },
     "16": { name: "Provide and inject", guide: "provide_inject" },
     "17": { name: "Page head", guide: "head" },
+    "18": { name: "Dates and locale formatting", guide: "dates_and_prices" },
 };
 /** Every code the compiler raises. A code is never reused: one the compiler stops raising is marked
  * `retired` and stays listed. `pnpm errors:generate` writes the guide's index from this list. */
@@ -149,13 +150,13 @@ export const ERRORS = {
     FV0601: { title: "Name or function not available on the server" },
     FV0602: { title: "Unsupported method" },
     FV0603: { title: "Unsupported call" },
-    FV0604: { title: "Field read on a value that is not an object" },
+    FV0604: { title: "Field read on a value that is not an object, or that may be absent" },
     FV0605: { title: "Field the type does not have" },
     FV0606: { title: "Value that may be absent where its target cannot take it as it is" },
     FV0607: { title: "Value of an unexpected type" },
     FV0608: { title: "`+` between unsupported types" },
     FV0609: { title: "Comparison between unsupported or absent values" },
-    FV0610: { title: "Spread or hole in an array literal" },
+    FV0610: { title: "Hole in an array literal" },
     FV0611: { title: "Array literal of different types" },
     FV0612: { title: "Computed member access" },
     FV0613: { title: "Value set up in a way the server cannot evaluate" },
@@ -174,17 +175,28 @@ export const ERRORS = {
     FV0626: { title: "Strict test of a value that may be `null` or `undefined`" },
     FV0627: { title: "Strict test against the absence a value cannot have" },
     FV0628: { title: "`as` or `satisfies` stating a type the value does not have" },
+    FV0629: { title: "Optional call `?.()`" },
+    FV0630: { title: "`??` between a list an optional chain computes and another list" },
+    FV0631: {
+        title: "`in` or `instanceof`",
+        detail: "`in` and `instanceof` read an object's keys and prototype as the page renders, which the server's typed values do not carry. Test a record's key with `Object.keys(r).includes(key)`.",
+    },
+    FV0632: { title: "Bitwise or shift operator" },
+    FV0633: {
+        title: "Part of JavaScript's own globals the server does not translate",
+        detail: "`JSON`, `Math`, `Number`, `String` and the other globals a template may name are translated only in part: `JSON.stringify(x)` of one value, `String(x)`, `Number(x)` and the `Number.is…()` tests, the `Math` methods and constants the [`numbers`](crate::guide::numbers) page lists, `encodeURI` and `encodeURIComponent`. The message names what the server translates of the one used.",
+    },
     FV0701: { title: "`Number()` of an unsupported value" },
     FV0702: { title: "`parseInt()` or `parseFloat()` of a value that is not a string" },
     FV0703: { title: "`parseInt()` with a radix other than a literal 10 or 16" },
     FV0704: { title: "Unsupported `Math` method" },
     FV0705: { title: "`.toFixed()` without a literal number of digits from 0 to 100" },
     FV0706: {
-        title: "String that may hold half of a surrogate pair compared, searched or joined",
-        detail: "`slice`, `substring`, `at`, `charAt` and `split(\"\")` can cut a surrogate pair in half. JavaScript keeps the half where ferrovue holds U+FFFD, so two such strings may compare, search or join differently. See [`strings`](crate::guide::strings#halves-of-surrogate-pairs).",
+        title: "String that may hold half of a surrogate pair compared, searched, joined or encoded",
+        detail: "`slice`, `substring`, `substr`, `at`, `charAt` and `split(\"\")` can cut a surrogate pair in half. JavaScript keeps the half where ferrovue holds U+FFFD, so two such strings may compare, search or join differently, `charCodeAt` and `codePointAt` would read U+FFFD's code, and `encodeURI` and `encodeURIComponent`, which throw a `URIError` on a half, would encode U+FFFD. See [`strings`](crate::guide::strings#halves-of-surrogate-pairs).",
     },
     FV0707: { title: "`JSON.stringify()` of an unsupported value" },
-    FV0708: { title: "Template literal of values that are not present strings, numbers or booleans" },
+    FV0708: { title: "Template literal of a value it cannot write" },
     FV0709: { title: "String method with the wrong number of arguments" },
     FV0710: { title: "Regular expression given to a string method" },
     FV0711: { title: "String method given a value that is not a present string" },
@@ -192,6 +204,23 @@ export const ERRORS = {
     FV0713: { title: "Function given to a string method" },
     FV0714: { title: "`.repeat()` by a negative or infinite count" },
     FV0715: { title: "Case mapping by the server's locale" },
+    FV0716: { title: "`.toPrecision()` without a literal precision from 1 to 100" },
+    FV0717: { title: "`.toExponential()` without a literal number of digits from 0 to 100" },
+    FV0718: {
+        title: "`isNaN()`, `isFinite()` or a `Number.is…()` test of a value that is not a number",
+        detail: "`Number.isNaN()`, `Number.isFinite()`, `Number.isInteger()` and `Number.isSafeInteger()` take a number, present or optional, and are `false` for any other value, which they do not convert; the global `isNaN()` and `isFinite()` convert theirs as `Number()` does and take a present number. Test a date with `Number.isNaN(d.getTime())`, and a string with `Number.isNaN(Number(s))`.",
+    },
+    FV0719: {
+        title: "`Math` function engines round differently",
+        detail: "`Math.cbrt`, `Math.hypot`, `Math.exp`, `Math.log`, the trigonometric functions and their kin are computed by each JavaScript engine's own routine, which the specification leaves free to round differently, and Rust's do not promise V8's digits either. Compute the value in Rust and pass it as a prop.",
+    },
+    FV0720: {
+        title: "`**` or `Math.pow()` other than an exact integer power known when compiling",
+        detail: "Engines compute powers by different routines: Node 22's V8 writes `10 ** -20` as `1.0000000000000001e-20`, Node 24's and Firefox's as `1e-20`, and above 2⁵³ they round in their own ways. The compiler works out `a ** b` and `Math.pow(a, b)` when both are known, `a` an integer and `b` a whole number from 0, with a result within ±2⁵³, which every engine gives exactly.",
+    },
+    FV0721: { title: "Value that may be `null` or `undefined` written as a string" },
+    FV0722: { title: "`typeof` the compiler cannot work out" },
+    FV0723: { title: "`String()`, `.concat()` or `encodeURI…()` of a value it cannot write" },
     FV0801: { title: "`.includes()` of a value of another type than the list's" },
     FV0802: { title: "`.join()` with a separator that is not a string" },
     FV0803: { title: "List method on a value that is not a list" },
@@ -215,6 +244,16 @@ export const ERRORS = {
     FV0821: { title: "Defaults or nested patterns in a `v-for` item" },
     FV0822: { title: "`v-for` item bound by an unsupported pattern" },
     FV0823: { title: "`v-for` key or index that is not a plain name" },
+    FV0824: { title: "List item read by an index that is not an integer" },
+    FV0825: { title: "`.at()` of a list given anything but one number" },
+    FV0826: { title: "`.indexOf()` or `.lastIndexOf()` given anything but one value of the list's type" },
+    FV0827: { title: "`.concat()` of anything but lists of the same item type" },
+    FV0828: { title: "`.reduce()` or `.reduceRight()` without an initial value" },
+    FV0829: { title: "`.reduce()` or `.reduceRight()` whose accumulator changes type or is not a string, number or boolean" },
+    FV0830: { title: "`.toSorted()` with a comparator of a shape the server does not order by" },
+    FV0831: { title: "`.toSorted()` without a comparator of a list of objects" },
+    FV0832: { title: "`.sort()` or `.reverse()` of a list in place" },
+    FV0833: { title: "Array spread of anything but lists of the same item type" },
     FV0901: { title: "Slots that are not an object literal" },
     FV0902: { title: "Computed or spread slot name" },
     FV0903: { title: "Content for a slot the child does not have" },
@@ -325,7 +364,7 @@ export const ERRORS = {
     FV1231: { title: "Route field not available on the server" },
     FV1232: { title: "Routes file that is not an array" },
     FV1233: { title: "Route entry of an unsupported shape" },
-    FV1234: { title: "`typeof` of anything but a query value" },
+    FV1234: { title: "`typeof` of anything but a query value", retired: "0.9.0" },
     FV1235: { title: "`??` after a query value with a fallback that is not a string" },
     FV1236: { title: "`<RouterView>` in a component with `<style scoped>`" },
     FV1237: { title: "`<RouterView>` in a child component" },
@@ -448,6 +487,42 @@ export const ERRORS = {
         detail: "unhead's server renderer throws on a `class` or `style` of `null`. Write `?? undefined`, which leaves the attribute out.",
     },
     FV1711: { title: "`innerHTML` or `textContent` on a head tag that has no content" },
+    FV1801: {
+        title: "The current time: `new Date()` or `Date.now()`",
+        detail: "The server renders at one moment and the browser hydrates at another, so the text would differ. Read the time in Rust and pass it as a prop: an ISO string, or a number of milliseconds. See [`dates_and_prices`](crate::guide::dates_and_prices).",
+    },
+    FV1802: {
+        title: "`new Date()` or `Date.parse()` of anything but one present string or number",
+        detail: "`new Date(year, month, …)` reads its parts in the time zone of the machine running it. A value that may be absent gives an invalid date for `undefined` and the epoch for `null`. See [`dates_and_prices`](crate::guide::dates_and_prices).",
+    },
+    FV1803: {
+        title: "Date string that browsers may read differently",
+        detail: "ECMAScript specifies how a date alone (`2024-05-01`, `2024-05`, `2024`) and a date and time with a `Z` or an offset (`2024-05-01T09:30:00.000Z`, `2024-05-01T09:30+02:00`) are read. A date and time with neither is read in the time zone of the machine running it, and every other string by each engine's own rules, as are fields out of range (`2024-02-30`, `T24:00`) and fields beyond the range of dates that an offset brings back within it (`+275760-09-13T01:00+01:00`), which Safari reads as invalid. A literal is checked when the component is compiled; a string from the props is checked as it renders, and one outside the format panics. See [`dates_and_prices`](crate::guide::dates_and_prices).",
+    },
+    FV1804: {
+        title: "`Date` method or function ferrovue does not translate",
+        detail: "A date is read with `.toISOString()`, `.toUTCString()`, `.toJSON()`, `.getTime()`, `.valueOf()` and the `.getUTC…()` methods, which do not depend on the time zone. The local getters (`.getFullYear()`, `.getHours()`), `.getTimezoneOffset()` and `.toString()` read the time zone of the machine running them, which differs between the server and the reader's browser. See [`dates_and_prices`](crate::guide::dates_and_prices).",
+    },
+    FV1805: {
+        title: "Locale formatting with `Intl`, `.toLocaleString()`, `.localeCompare()`, `$d` or `$n`",
+        detail: "`Intl` formats from locale data each JavaScript engine ships, and Node, Chromium, Firefox and Safari write some dates, times and numbers differently (spaces, separators, abbreviations), so no server can write what every reader's browser writes. This refusal is permanent. Format the value in Rust and pass it as a string prop, or write it with `.toFixed()` and `.toISOString()` into a message `$t` translates. See [`dates_and_prices`](crate::guide::dates_and_prices).",
+    },
+    FV1806: {
+        title: "`Date` anywhere but a component's own prop",
+        detail: "A prop typed `Date` (optional or nullable too) is a `ferrovue::JsDate`, or the type `dateType` names, and an island's `data-props` carries it as its ISO string, which the client turns back into a `Date` because the prop's declared type says it is one. A `Date` inside a list, a dictionary or an object prop, and one in an interface the props do not declare, in Pinia state, `inject`, `ref` or `defineModel`, have no declared type the client could read, so they would reach the browser as strings. Pass the ISO string or the number of milliseconds and build the date with `new Date()`. See [`dates_and_prices`](crate::guide::dates_and_prices).",
+    },
+    FV1807: {
+        title: "`Date.UTC()` of anything but one to seven numbers that are present",
+        detail: "`Date.UTC(year, month, date, hours, minutes, seconds, ms)` takes numbers, each truncated toward zero, the month counted from 0. A value that may be absent would give `NaN` for `undefined` and `0` for `null`: narrow it with `v-if` or give it a default. See [`dates_and_prices`](crate::guide::dates_and_prices).",
+    },
+    FV1808: {
+        title: "`Date.UTC()` of parts engines compute differently",
+        detail: "V8 computes a year beyond ±1,000,000, a month beyond ±10,000,000 and a year before −399,999 by rules of its own, which Firefox and Safari do not share, so a day or hours that bring the date back within the range give another date in each; and Node rounds a part worth more than 2⁵³ ms that the others bring back within the range otherwise than the browsers. Literal parts are checked when the component is compiled; parts from the props are checked as it renders, and `js_date_utc` panics on them. See [`dates_and_prices`](crate::guide::dates_and_prices).",
+    },
+    FV1809: {
+        title: "`===`, `!==`, `==` or `!=` with a `Date`",
+        detail: "Two `Date`s are equal in JavaScript only when they are one object, so two dates of the same time are unequal, and `==` with a string compares the date's `.toString()`, in the time zone of the machine running it. Compare time values: `a.getTime() === b.getTime()`. `<`, `<=`, `>` and `>=` between two dates compare their time values, and are false when either is invalid. See [`dates_and_prices`](crate::guide::dates_and_prices).",
+    },
 };
 /** Where a code is documented. */
 export function docsUrl(code) {

package/dist/expr.js

@@ -2,13 +2,16 @@ import { absence, BOOL, fail, FLOAT, GenError, INT, joinAbsence, nothing, NULL,
 import { ctx } from "./context.js";
 import { lookupStruct, markHome, tyOfTs } from "./typescript.js";
 import { claim } from "./plugin.js";
-import { atom, bare, binary, enclosed, logical, negate, not, occurrences, strArg } from "./parens.js";
-import { collected, sliced, typedEmpty, untypedEmpty } from "./lists.js";
+import { atom, bare, binary, enclosed, logical, negate, not, occurrences, receiver, strArg } from "./parens.js";
+import { collected, picked, sliced, spreadLiteral, typedEmpty, untypedEmpty } from "./lists.js";
 import { asCow, formatted, isTemporary, loneOf, meet, stringsEqual } from "./strings.js";
-import { arithmetic, asF64, compare, intFromF64, isNumber, negatedOrder, numberVal } from "./numbers.js";
-import { boolOf, checkNullTest, choice, known, narrowing, narrowTo, nullTest, pathOf, presence, truthy } from "./narrowing.js";
-import { call, isObjectCall } from "./calls.js";
+import { arithmetic, asF64, compare, intFromF64, isNumber, negatedOrder, numberVal, power } from "./numbers.js";
+import { boolOf, checkNullTest, choice, known, narrowing, narrowTo, nullTest, pathOf, presence, truthy, typeofCompare, typeofTest, typeofVal } from "./narrowing.js";
+import { BUILTINS, builtin, call, isObjectCall } from "./calls.js";
 import { constOf, constVal } from "./constants.js";
+import { localeRefusal } from "./plugins/dates.js";
+const MATH_CONSTANTS = new Map(["E", "LN10", "LN2", "LOG10E", "LOG2E", "PI", "SQRT1_2", "SQRT2"].map((k) => [k, Math[k]]));
+const NUMBER_CONSTANTS = new Map(["EPSILON", "MAX_SAFE_INTEGER", "MAX_VALUE", "MIN_SAFE_INTEGER", "MIN_VALUE", "NaN", "NEGATIVE_INFINITY", "POSITIVE_INFINITY"].map((k) => [k, Number[k]]));
 export function describeTy(ty) {
     switch (ty.k) {
         case "str":
@@ -41,8 +44,11 @@ export function describeTy(ty) {
     }
 }
 export function fieldVal(comp, base, ty, js, node) {
-    if (ty.k !== "struct")
-        fail(comp, "FV0604", `\`.${js}\` on a value that is not an object`, node);
+    if (ty.k !== "struct") {
+        if (ty.k === "opt" || nothing(ty))
+            fail(comp, "FV0604", `\`.${js}\` of ${describeTy(ty)}, which may be absent: narrow it with \`v-if\` first, or read it with \`?.${js}\``, node);
+        fail(comp, "FV0604", `\`.${js}\` of ${describeTy(ty)}, which has no field \`${js}\``, node);
+    }
     const { st, owner } = lookupStruct(comp, ty);
     const found = st?.fields.find((x) => x.js === js);
     if (!found) {
@@ -69,7 +75,11 @@ export function fieldVal(comp, base, ty, js, node) {
         case "html":
         case "child":
             return { code: `&${place}`, ty: f.ty };
+        case "date":
+            return { code: `fv::js_time_of(&${place})`, ty: f.ty };
         case "opt":
+            if (f.ty.of.k === "date")
+                return { code: `${place}.as_ref().map(fv::js_time_of)`, ty: f.ty };
             if (f.ty.of.k === "html")
                 return { code: `${place}.as_ref()`, ty: f.ty };
             if (f.ty.of.k === "str")
@@ -170,6 +180,76 @@ function stated(s, n) {
         return v;
     return fail(comp, "FV0628", `\`${keyword}\` states ${describeTy(want)} of ${describeTy(v.ty)}, which the server keeps as it is: write the value with the type it has`, n);
 }
+function indexed(s, list, key, n) {
+    const i = expr(s, key);
+    if (i.ty.k !== "int") {
+        const is = i.ty.k === "float" ? "a `Float`, which may hold a fraction" : describeTy(i.ty);
+        return fail(s.comp, "FV0824", `\`[…]\` reads a list's item by an integer index, a \`number\` that is present, and this index is ${is}: \`.at()\` takes any number`, key);
+    }
+    if (i.num !== undefined && i.num >= 0 && list.iter === undefined)
+        return picked(s, list, n, (l) => (i.num === 0 ? `${l}.first()` : `${l}.get(${i.num})`), (it) => it);
+    const at = `usize::try_from(${bare(i.code)}).unwrap_or(usize::MAX)`;
+    return picked(s, list, n, (l) => `${l}.get(${at})`, (it) => `${atom(it)}.nth(${at})`);
+}
+function plainChain(n, link, hole) {
+    if (n === link)
+        return { ...n, type: "MemberExpression", optional: undefined, object: hole };
+    if (n.type === "OptionalCallExpression")
+        return { ...n, type: "CallExpression", optional: undefined, callee: plainChain(n.callee, link, hole) };
+    return { ...n, type: "MemberExpression", optional: undefined, object: plainChain(n.object, link, hole) };
+}
+function ownedCow(v) {
+    if (!isTemporary(v))
+        return `std::borrow::Cow::<str>::Owned(${receiver(v.code)}.to_owned())`;
+    const cow = asCow(v);
+    return cow.startsWith("std::borrow::Cow::<str>::Owned(") ? cow : `std::borrow::Cow::<str>::Owned(${atom(cow)}.into_owned())`;
+}
+function optionalChain(s, n) {
+    const comp = s.comp;
+    let link = n;
+    while (!link.optional) {
+        link = link.type === "OptionalCallExpression" ? link.callee : link.object;
+        if (link?.type !== "OptionalMemberExpression" && link?.type !== "OptionalCallExpression")
+            return fail(comp, "FV0625", "this optional chain is not supported in a template", n);
+    }
+    if (link.type === "OptionalCallExpression") {
+        return fail(comp, "FV0629", "`?.()` calls a function that may be absent, and a template's functions are always present: write the call without `?.`", link);
+    }
+    const base = expr(s, link.object);
+    if (nothing(base.ty))
+        return { code: "None", ty: UNDEF };
+    const k = ++ctx.narrowCount;
+    const hole = { ...link.object, type: "Identifier", name: `fv$o${k}` };
+    const rest = plainChain(n, link, hole);
+    const within = (v) => ({ ...s, locals: new Map(s.locals).set(hole.name, v) });
+    if (base.ty.k !== "opt")
+        return expr(within(base), rest);
+    const name = `fv_o${k}`;
+    const inner = expr(within({ code: name, ty: base.ty.of, ...loneOf(base) }), rest);
+    if (nothing(inner.ty))
+        return { code: "None", ty: UNDEF };
+    const lone = loneOf(base, inner);
+    const over = (body, flat) => {
+        if (bare(body) === name)
+            return base.code;
+        const named = new RegExp(`^([\\w:]+)\\(${name}\\)$`).exec(bare(body))?.[1];
+        return `${atom(base.code)}.${flat ? "and_then" : "map"}(${named ?? `|${name}| ${bare(body)}`})`;
+    };
+    const heldBy = (held, ty) => ({ code: `${atom(held)}.as_deref()`, ty, held, ...lone });
+    if (inner.ty.k === "list" && inner.iter !== undefined)
+        return heldBy(over(collected(inner), false), opt(inner.ty));
+    if (inner.ty.k === "opt") {
+        if (inner.held !== undefined)
+            return heldBy(over(inner.held, true), opt(inner.ty));
+        if (base.held !== undefined && inner.ty.of.k === "str")
+            return heldBy(over(`${atom(inner.code)}.map(|v| std::borrow::Cow::<str>::Owned(v.to_owned()))`, true), opt(inner.ty));
+        return { code: over(inner.code, true), ty: opt(inner.ty), ...lone };
+    }
+    if (inner.ty.k === "str" && (isTemporary(inner) || base.held !== undefined))
+        return heldBy(over(ownedCow(inner), false), opt(STR));
+    const place = ["list", "record", "struct"].includes(inner.ty.k) && new RegExp(`^${name}(?:\\.[\\w#]+)+$`).test(inner.code);
+    return { code: over(place ? `&${inner.code}` : inner.code, false), ty: opt(inner.ty), ...lone };
+}
 export function expr(s, n) {
     const comp = s.comp;
     const path = pathOf(n);
@@ -215,10 +295,24 @@ export function expr(s, n) {
             return arithmetic(a, "+", b, a.ty.k === "int" && b.ty.k === "int");
         return fail(comp, "FV0608", "`+` joins a string to a string or a number, or adds two numbers", n);
     }
+    if (n.type === "BinaryExpression" && n.operator === "**")
+        return power(s, n.left, n.right, n, "`**`");
+    if (n.type === "BinaryExpression" && (n.operator === "in" || n.operator === "instanceof")) {
+        const what = n.operator === "in"
+            ? "tests whether an object has a key, which the server does not translate: for a record, write `Object.keys(r).includes(key)`"
+            : "tests an object's prototype, which the server's typed values do not carry: each value's type is known when compiling";
+        return fail(comp, "FV0631", `\`${n.operator}\` ${what}`, n);
+    }
+    if (n.type === "BinaryExpression" && ["&", "|", "^", "<<", ">>", ">>>"].includes(n.operator)) {
+        return fail(comp, "FV0632", `\`${n.operator}\` works on the 32-bit integers JavaScript converts its operands to, which the server does not translate: compute it in Rust and pass it as a prop`, n);
+    }
     if (n.type === "BinaryExpression" && ["-", "*", "%", "/", "<", ">", "<=", ">="].includes(n.operator)) {
         const a = expr(s, n.left);
         const b = expr(s, n.right);
         const comparison = ["<", ">", "<=", ">="].includes(n.operator);
+        const ordered = comparison ? claim((p) => p.values?.order?.(a, n.operator, b)) : undefined;
+        if (ordered)
+            return ordered;
         if (comparison && a.ty.k === "str" && b.ty.k === "str") {
             meet(comp, a, b, `\`${n.operator}\``, n, "order");
             const is = { "<": "lt", ">": "gt", "<=": "le", ">=": "ge" }[n.operator];
@@ -228,7 +322,7 @@ export function expr(s, n) {
             const why = a.ty.k === "opt" || b.ty.k === "opt"
                 ? "narrow an optional one with `v-if` first"
                 : `the other is ${describeTy(isNumber(a.ty) ? b.ty : a.ty)}`;
-            const between = comparison ? "two numbers, or two strings," : "two numbers";
+            const between = comparison ? "two numbers, two strings or two dates" : "two numbers";
             return fail(comp, "FV0609", `\`${n.operator}\` is supported between ${between} that are present: ${why}`, n);
         }
         if (["<", ">", "<=", ">="].includes(n.operator))
@@ -250,9 +344,11 @@ export function expr(s, n) {
         case "ArrayExpression": {
             if (n.elements.length === 0)
                 return { code: "[]", ty: { k: "list", of: UNDEF } };
+            if (n.elements.some((el) => el?.type === "SpreadElement"))
+                return spreadLiteral(s, n);
             const values = n.elements.map((el) => {
-                if (!el || el.type === "SpreadElement")
-                    fail(comp, "FV0610", "an array literal holds plain values", n);
+                if (!el)
+                    fail(comp, "FV0610", "an array literal holds plain values, without holes", n);
                 return expr(s, el);
             });
             const of = values[0].ty;
@@ -261,21 +357,9 @@ export function expr(s, n) {
             }
             return { code: `[${values.map((v) => bare(v.code)).join(", ")}]`, ty: { k: "list", of }, ...loneOf(...values) };
         }
-        case "OptionalMemberExpression": {
-            if (n.computed)
-                return fail(comp, "FV0612", "computed member access", n);
-            const base = expr(s, n.object);
-            if (nothing(base.ty))
-                return { code: "None", ty: UNDEF };
-            if (base.ty.k !== "opt")
-                return fieldVal(comp, base.code, base.ty, n.property.name, n);
-            const field = fieldVal(comp, "v", base.ty.of, n.property.name, n);
-            const place = ["list", "record", "struct"].includes(field.ty.k) && /^v(?:\.[\w#]+)+$/.test(field.code);
-            const f = place ? { ...field, code: `&${field.code}` } : field;
-            if (f.ty.k === "opt")
-                return { code: `${atom(base.code)}.and_then(|v| ${f.code})`, ty: opt(f.ty) };
-            return { code: `${atom(base.code)}.map(|v| ${f.code})`, ty: opt(f.ty) };
-        }
+        case "OptionalMemberExpression":
+        case "OptionalCallExpression":
+            return optionalChain(s, n);
         case "StringLiteral":
             return { code: rustStr(n.value), ty: STR };
         case "NumericLiteral":
@@ -295,6 +379,12 @@ export function expr(s, n) {
             }
             if (n.name === s.propsIdent)
                 return { code: "props", ty: { k: "struct", name: "Props" } };
+            if (n.name === "Infinity" || n.name === "NaN")
+                return numberVal(Number(n.name), false);
+            if (n.name === "Intl")
+                return localeRefusal(s, "`Intl`", n);
+            if (BUILTINS.has(n.name))
+                return builtin(s, n.name, n);
             return fail(comp, "FV0601", `\`${n.name}\` is not available when rendering on the server`, n);
         }
         case "MemberExpression": {
@@ -305,13 +395,15 @@ export function expr(s, n) {
                 if (n.object.type === "Identifier" && n.object.name === "$setup" && n.property.type === "StringLiteral") {
                     return expr(s, { ...n.property, type: "Identifier", name: n.property.value });
                 }
+                const base = expr(s, n.object);
                 if (n.property.type === "StringLiteral") {
-                    const base = expr(s, n.object);
                     const own = claim((p) => p.member?.(s, base, n.property.value, n, true));
                     if (own)
                         return own;
                 }
-                return fail(comp, "FV0612", "computed member access", n);
+                if (base.ty.k === "list")
+                    return indexed(s, base, n.property, n);
+                return fail(comp, "FV0612", `computed member access of ${describeTy(base.ty)}: \`[…]\` reads an item of a list, by an integer index`, n);
             }
             const prop = n.property.name;
             const slots = slotsObject(s, n.object);
@@ -320,6 +412,12 @@ export function expr(s, n) {
                     fail(comp, "FV0907", `\`${slots}.${prop}\` names a slot this template does not render`, n);
                 return { code: `fv_slots.${snake(prop)}.is_some()`, ty: BOOL };
             }
+            if (n.object.type === "Identifier" && BUILTINS.has(n.object.name) && !s.locals.has(n.object.name) && !s.setup.has(n.object.name)) {
+                const value = n.object.name === "Math" ? MATH_CONSTANTS.get(prop) : n.object.name === "Number" ? NUMBER_CONSTANTS.get(prop) : undefined;
+                if (value !== undefined)
+                    return numberVal(value, Number.isSafeInteger(value));
+                return builtin(s, `${n.object.name}.${prop}`, n);
+            }
             if (n.object.type === "Identifier") {
                 switch (n.object.name) {
                     case "$props":
@@ -365,7 +463,7 @@ export function expr(s, n) {
             }
             const a = expr(s, n.left);
             const b = expr(s, n.right);
-            if (n.operator === "??") {
+            if (n.operator === "??" || (n.operator === "||" && (a.ty.k === "opt" ? a.ty.of : a.ty).k === "date")) {
                 const own = claim((p) => p.values?.nullish?.(s, a, b, n));
                 if (own)
                     return own;
@@ -377,8 +475,10 @@ export function expr(s, n) {
                     return { ...a, ty: withAbsence(a.ty.of, absence(b.ty)) };
                 if (b.iter !== undefined)
                     fail(comp, "FV0615", "`??` falling back to a computed list", n);
+                if (a.held !== undefined && b.ty.k === "list" && !untypedEmpty(b))
+                    fail(comp, "FV0630", "`??` after an optional chain that computes a list, falling back to another list: fall back to `[]`", n);
                 if (a.ty.of.k === "list" && b.ty.k === "list" && (untypedEmpty(b) || (sameTy(a.ty.of, b.ty) && !b.code.startsWith("[")))) {
-                    return { code: `${atom(a.code)}.map(|v| &v[..]).unwrap_or(${untypedEmpty(b) ? "&[]" : sliced(b)})`, ty: a.ty.of, slice: true, ...loneOf(a, b) };
+                    return { code: `${atom(a.code)}${a.held !== undefined ? "" : ".map(|v| &v[..])"}.unwrap_or(${untypedEmpty(b) ? "&[]" : sliced(b)})`, ty: a.ty.of, slice: true, ...loneOf(a, b) };
                 }
                 if (a.held !== undefined && b.ty.k === "str")
                     return { code: `&*${atom(a.held)}.unwrap_or(${asCow(b)})`, ty: STR, ...loneOf(a, b) };
@@ -393,7 +493,7 @@ export function expr(s, n) {
                     return { code: `${atom(a.code)}.unwrap_or(${bare(asF64(b))})`, ty: FLOAT };
                 if (a.ty.of.k === "int" && b.ty.k === "float")
                     return { code: `${atom(a.code)}.map(|v| v as f64).unwrap_or(${bare(b.code)})`, ty: FLOAT };
-                return fail(comp, "FV0616", "`??` between different types", n);
+                return n.operator === "??" ? fail(comp, "FV0616", "`??` between different types", n) : fail(comp, "FV0617", "`||` between these types", n);
             }
             if (n.operator === "||") {
                 if (a.ty.k === "bool" && b.ty.k === "bool")
@@ -434,9 +534,18 @@ export function expr(s, n) {
                 if (a.ty.k === "float")
                     return { code: negate(a.code), ty: FLOAT };
             }
+            if (n.operator === "typeof")
+                return typeofVal(s, n);
             return fail(comp, "FV0618", `unary \`${n.operator}\``, n);
         case "BinaryExpression": {
+            const tested = typeofCompare(n);
+            if (tested)
+                return claim((p) => p.equality?.(s, n)) ?? typeofTest(s, tested, n);
             const test = nullTest(n);
+            if (n.operator !== "===" && n.operator !== "!==" && !test) {
+                const [a, b] = [expr(s, n.left), expr(s, n.right)];
+                claim((p) => p.values?.refuseEquality?.(s, a, b, n));
+            }
             if (n.operator !== "===" && n.operator !== "!==" && !test)
                 fail(comp, "FV0619", `\`${n.operator}\`: \`==\` and \`!=\` compare with \`null\` or \`undefined\` only; use \`===\``, n);
             const whole = claim((p) => p.equality?.(s, n));
@@ -467,6 +576,7 @@ export function expr(s, n) {
             const strish = (t) => t.k === "str" || (t.k === "opt" && t.of.k === "str");
             if (strish(a.ty) && strish(b.ty))
                 meet(comp, a, b, `\`${n.operator}\``, n, "equal");
+            claim((p) => p.values?.refuseEquality?.(s, a, b, n));
             const own = claim((p) => p.values?.equals?.(a, b));
             if (own !== undefined)
                 eq = own;
@@ -583,6 +693,9 @@ export function expr(s, n) {
         case "TSSatisfiesExpression":
             return stated(s, n);
         case "NewExpression": {
+            const own = claim((p) => p.construct?.(s, n));
+            if (own)
+                return own;
             const made = n.callee.type === "Identifier" ? n.callee.name : n.callee.type === "MemberExpression" && !n.callee.computed ? `${n.callee.object.name ?? "…"}.${n.callee.property.name}` : "…";
             return fail(comp, "FV0624", `\`new ${made}(…)\` builds an object the server has no twin for: compute the value in Rust and pass it as a prop`, n);
         }

package/dist/fixture.js

@@ -1,5 +1,6 @@
 import { createApp, createSSRApp, createStaticVNode, createTextVNode, defineComponent, h } from "vue";
 import { routeRecords } from "./routes.js";
+import { reviveDates } from "./client.js";
 export { routeRecords } from "./routes.js";
 /** A fixture's JSON, split into the props and the rest. */
 export function readFixture(json) {
@@ -64,7 +65,7 @@ export async function fixtureApp(component, fixture, routes, options = {}) {
     const slots = Object.fromEntries(Object.entries(fixture.slots)
         .filter(([name]) => name !== "routerView")
         .map(([name, html]) => [name, () => [staticNode(html)]]));
-    const app = (options.client ? createApp : createSSRApp)({ render: () => h(component, fixture.props, slots) });
+    const app = (options.client ? createApp : createSSRApp)({ render: () => h(component, reviveDates(component, fixture.props), slots) });
     const head = await optionalHead(options.hydrate ?? false);
     if (head)
         app.use(head);

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { ClientOnly, hydrateState, mountIslands, type IslandComponent, type Islands, type MountOptions, type StateText } from "./client.ts";
+export { ClientOnly, hydrateState, mountIslands, reviveDates, type IslandComponent, type Islands, type MountOptions, type StateText } from "./client.ts";
 export { createPageApp, mountPage, readPage, renderPage, type PageAppOptions, type PageOptions, type PagePart, type PageRecord, type ReadPage, type ReadPageOptions, type RenderPageOptions, } from "./client.ts";
 export type { Float, InlineHtml, TrustedHtml } from "./types.ts";

package/dist/index.js

@@ -1,2 +1,2 @@
-export { ClientOnly, hydrateState, mountIslands } from "./client.js";
+export { ClientOnly, hydrateState, mountIslands, reviveDates } from "./client.js";
 export { createPageApp, mountPage, readPage, renderPage, } from "./client.js";

package/dist/lists.d.ts

@@ -18,6 +18,15 @@ export declare function isBoolean(s: Scope, n: N): boolean;
  * be absent, which is an ordinary array literal.
  */
 export declare function presentLiteral(s: Scope, n: N): Val | null;
+/**
+ * The item of `target` that `fromList` (given the list) or `fromIter` (given its items) picks, as
+ * an optional value: `undefined` where the list has no item there.
+ */
+export declare function picked(s: Scope, target: Val, n: N, fromList: (list: string) => string, fromIter: (items: string) => string): Val;
+/** An array literal holding spread lists (`[...a, x, ...b]`): the items of each part in turn, as a computed list. */
+export declare function spreadLiteral(s: Scope, n: N): Val;
+/** `Math.max(...xs)` and `Math.min(...xs)`: every number of the parts folded from `-Infinity` or `Infinity`, as JavaScript folds them. */
+export declare function spreadExtreme(s: Scope, method: "max" | "min", args: N[]): Val;
 export declare function listMethod(s: Scope, target: Val, method: string, args: N[], n: N): Val | null;
 export declare function objectCall(s: Scope, method: string, args: N[], n: N): Val;
 export declare function computedListMethod(s: Scope, target: Val, method: string, args: N[], n: N): Val | null;