@bpmnkit/feel 0.0.20 → 0.1.0

package/dist/builtins.js

@@ -41,14 +41,43 @@ function epochDaysToDate(days) {
     }
     return { type: "date", year, month, day: remaining + 1 };
 }
+// The widest year XSD's date types allow, which bounds DMN's too.
+const MAX_YEAR = 999999999;
+/** Builds a date, or null when the day does not exist in that month. */
+function makeDate(year, month, day) {
+    if (!Number.isInteger(year) || !Number.isInteger(month) || !Number.isInteger(day))
+        return null;
+    if (Math.abs(year) > MAX_YEAR)
+        return null;
+    if (month < 1 || month > 12)
+        return null;
+    if (day < 1 || day > daysInMonth(year, month))
+        return null;
+    return { type: "date", year, month, day };
+}
 function parseDate(s) {
-    const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(s);
+    // Exactly four year digits: "01211" carries a leading zero and
+    // "9999999999" is past any calendar, and neither is a date.
+    const m = /^(-?)(\d{4})-(\d{2})-(\d{2})$/.exec(s);
     if (!m)
         return null;
-    return { type: "date", year: Number(m[1]), month: Number(m[2]), day: Number(m[3]) };
+    const year = Number(m[2]) * (m[1] === "-" ? -1 : 1);
+    return makeDate(year, Number(m[3]), Number(m[4]));
+}
+// The largest UTC offset XSD allows.
+const MAX_OFFSET_SECONDS = 18 * 3600;
+/** True for a zone name the platform's time zone database knows. */
+function isKnownTimezone(name) {
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone: name });
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 function parseTime(s) {
-    const m = /^(\d{2}):(\d{2}):(\d{2}(?:\.\d+)?)(?:([+-])(\d{2}):(\d{2})|Z)?(@(.+))?$/.exec(s);
+    const m = /^(\d{2}):(\d{2}):(\d{2}(?:\.\d+)?)(?:([+-])(\d{2}):(\d{2})(?::(\d{2}))?|Z)?(?:@(.+))?$/.exec(s);
     if (!m)
         return null;
     const hour = Number(m[1]);
@@ -58,19 +87,39 @@ function parseTime(s) {
     let timezone;
     if (m[4]) {
         const sign = m[4] === "+" ? 1 : -1;
-        offsetSeconds = sign * (Number(m[5]) * 3600 + Number(m[6]) * 60);
+        offsetSeconds = sign * (Number(m[5]) * 3600 + Number(m[6]) * 60 + (m[7] ? Number(m[7]) : 0));
+        if (Math.abs(offsetSeconds) > MAX_OFFSET_SECONDS)
+            return null;
     }
-    else if (m[3] && s.includes("Z")) {
+    else if (s.includes("Z")) {
         offsetSeconds = 0;
     }
-    if (m[8])
+    if (m[8]) {
+        // A zone and an offset name the same thing twice, and may disagree.
+        if (offsetSeconds !== undefined)
+            return null;
+        if (!isKnownTimezone(m[8]))
+            return null;
         timezone = m[8];
+    }
+    if (!isValidTime(hour, minute, second))
+        return null;
     return { type: "time", hour, minute, second, offsetSeconds, timezone };
 }
+/** 24:00:00 is the end-of-day form the ISO calendar allows; 24:00:01 is not. */
+function isValidTime(hour, minute, second) {
+    if (hour < 0 || hour > 24 || minute < 0 || minute > 59 || second < 0 || second >= 60)
+        return false;
+    return hour !== 24 || (minute === 0 && second === 0);
+}
 function parseDateTime(s) {
     const idx = s.indexOf("T");
-    if (idx < 0)
-        return null;
+    if (idx < 0) {
+        const dateOnly = parseDate(s);
+        return dateOnly
+            ? { type: "date-time", date: dateOnly, time: { type: "time", hour: 0, minute: 0, second: 0 } }
+            : null;
+    }
     const d = parseDate(s.slice(0, idx));
     const t = parseTime(s.slice(idx + 1));
     if (!d || !t)
@@ -80,14 +129,15 @@ function parseDateTime(s) {
 function parseDuration(s) {
     // P[n]Y[n]M or P[n]DT[n]H[n]M[n]S
     const ymMatch = /^-?P(\d+Y)?(\d+M)?$/.exec(s);
-    if (ymMatch) {
+    if (ymMatch && /\d/.test(s)) {
         const sign = s.startsWith("-") ? -1 : 1;
         const years = ymMatch[1] ? Number(ymMatch[1].slice(0, -1)) : 0;
         const months = ymMatch[2] ? Number(ymMatch[2].slice(0, -1)) : 0;
-        return { type: "years-months-duration", months: sign * (years * 12 + months) };
+        // "|| 0" keeps a negative zero out: -P0M is the same duration as P0M.
+        return { type: "years-months-duration", months: sign * (years * 12 + months) || 0 };
     }
-    const dtMatch = /^-?P(\d+D)?(?:T(\d+H)?(\d+M)?(\d+(?:\.\d+)?S)?)?$/.exec(s);
-    if (dtMatch && s.length > 1) {
+    const dtMatch = /^-?P(\d+D)?(?:T(\d+H)?(\d+M)?(\d+(?:\.\d*)?S)?)?$/.exec(s);
+    if (dtMatch && /\d/.test(s)) {
         const sign = s.startsWith("-") ? -1 : 1;
         const days = dtMatch[1] ? Number(dtMatch[1].slice(0, -1)) : 0;
         const hours = dtMatch[2] ? Number(dtMatch[2].slice(0, -1)) : 0;
@@ -95,7 +145,7 @@ function parseDuration(s) {
         const seconds = dtMatch[4] ? Number(dtMatch[4].slice(0, -1)) : 0;
         return {
             type: "days-time-duration",
-            seconds: sign * (days * 86400 + hours * 3600 + minutes * 60 + seconds),
+            seconds: sign * (days * 86400 + hours * 3600 + minutes * 60 + seconds) || 0,
         };
     }
     return null;
@@ -120,8 +170,14 @@ function parseTemporal(raw) {
 function formatDate(d) {
     return `${String(d.year).padStart(4, "0")}-${String(d.month).padStart(2, "0")}-${String(d.day).padStart(2, "0")}`;
 }
+/** Two digits before the decimal point, and the fraction as written. */
+function formatSeconds(second) {
+    const whole = Math.floor(second);
+    const fraction = `${second}`.split(".")[1];
+    return String(whole).padStart(2, "0") + (fraction ? `.${fraction}` : "");
+}
 function formatTime(t) {
-    let s = `${String(t.hour).padStart(2, "0")}:${String(t.minute).padStart(2, "0")}:${String(t.second).padStart(2, "0")}`;
+    let s = `${String(t.hour).padStart(2, "0")}:${String(t.minute).padStart(2, "0")}:${formatSeconds(t.second)}`;
     if (t.offsetSeconds !== undefined) {
         if (t.offsetSeconds === 0) {
             s += "Z";
@@ -129,7 +185,11 @@ function formatTime(t) {
         else {
             const sign = t.offsetSeconds >= 0 ? "+" : "-";
             const abs = Math.abs(t.offsetSeconds);
-            s += `${sign}${String(Math.floor(abs / 3600)).padStart(2, "0")}:${String(Math.floor((abs % 3600) / 60)).padStart(2, "0")}`;
+            const pad = (n) => String(n).padStart(2, "0");
+            s += `${sign}${pad(Math.floor(abs / 3600))}:${pad(Math.floor((abs % 3600) / 60))}`;
+            // Offsets are written to the second only when they have one.
+            if (abs % 60 !== 0)
+                s += `:${pad(abs % 60)}`;
         }
     }
     if (t.timezone)
@@ -150,14 +210,57 @@ function dayOfYear(d) {
 // -------------------------------------------------------------------------
 // Helpers
 // -------------------------------------------------------------------------
+/**
+ * A number argument. FEEL does not coerce, so "1.5" is not a number here;
+ * number() is the way to convert one.
+ */
 function toNum(v) {
-    if (typeof v === "number")
-        return v;
-    if (typeof v === "string") {
-        const n = Number(v);
-        return Number.isNaN(n) ? null : n;
-    }
-    return null;
+    return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+/**
+ * A rounding scale: an optional integer. Absent means 0, but an explicitly
+ * null or non-numeric scale is an error. Beyond float64's reach the value is
+ * already exact at that scale, so it is returned unrounded.
+ */
+const MIN_SCALE = -6111;
+const MAX_SCALE = 6176;
+const SCALE_LIMIT = 300;
+function toScale(v) {
+    if (v === undefined)
+        return 0;
+    const n = toNum(v);
+    if (n === null)
+        return null;
+    const scale = Math.trunc(n);
+    return scale < MIN_SCALE || scale > MAX_SCALE ? null : scale;
+}
+/** Rounds `n` at `scale` with the given rounding of a value exactly halfway. */
+function roundAt(n, scale, round) {
+    if (Math.abs(scale) > SCALE_LIMIT)
+        return n;
+    const factor = 10 ** scale;
+    // Re-reading the scaled value through its decimal form keeps a product like
+    // 1.005 * 100 from landing just under the halfway point it should sit on.
+    const scaled = Number(`${n}e${scale}`);
+    return Number(`${round(scaled)}e${-scale}`) || round(scaled) / factor;
+}
+/** Round half to even, the rounding DMN's decimal() uses. */
+function roundHalfEven(x) {
+    const floor = Math.floor(x);
+    const diff = x - floor;
+    if (diff > 0.5)
+        return floor + 1;
+    if (diff < 0.5)
+        return floor;
+    return floor % 2 === 0 ? floor : floor + 1;
+}
+/** Round half away from zero. */
+function roundHalfUp(x) {
+    return x >= 0 ? Math.floor(x + 0.5) : Math.ceil(x - 0.5);
+}
+/** Round half toward zero. */
+function roundHalfDown(x) {
+    return x >= 0 ? Math.ceil(x - 0.5) : Math.floor(x + 0.5);
 }
 function toStr(v) {
     if (typeof v === "string")
@@ -188,6 +291,55 @@ function inRange(v, r) {
     const endOk = r.endIncluded ? cmpEnd <= 0 : cmpEnd < 0;
     return startOk && endOk;
 }
+const offsetCache = new Map();
+/**
+ * The UTC offset a zone is on at the given wall-clock day. Resolved through
+ * the platform's time zone database, so it follows daylight saving: Melbourne
+ * is +11:00 in April and +10:00 in October.
+ */
+function zoneOffsetSeconds(timezone, epochDays) {
+    const key = `${timezone}/${epochDays}`;
+    const cached = offsetCache.get(key);
+    if (cached !== undefined)
+        return cached;
+    let offset = 0;
+    try {
+        const parts = new Intl.DateTimeFormat("en-US", {
+            timeZone: timezone,
+            timeZoneName: "longOffset",
+        }).formatToParts(new Date(epochDays * 86400_000));
+        const name = parts.find((part) => part.type === "timeZoneName")?.value ?? "";
+        const m = /GMT([+-])(\d{2}):(\d{2})/.exec(name);
+        if (m)
+            offset = (m[1] === "-" ? -1 : 1) * (Number(m[2]) * 3600 + Number(m[3]) * 60);
+    }
+    catch {
+        offset = 0;
+    }
+    if (offsetCache.size > 512)
+        offsetCache.clear();
+    offsetCache.set(key, offset);
+    return offset;
+}
+/** The offset a time is on, or undefined when it is a local time. */
+function offsetOf(t, epochDays) {
+    if (t.offsetSeconds !== undefined)
+        return t.offsetSeconds;
+    if (t.timezone !== undefined)
+        return zoneOffsetSeconds(t.timezone, epochDays);
+    return undefined;
+}
+/**
+ * Seconds since midnight, shifted to UTC where the time says which UTC it
+ * means. A local time carries no offset, so it is left where it is.
+ */
+function timeToSeconds(t, epochDays = 0) {
+    return t.hour * 3600 + t.minute * 60 + t.second - (offsetOf(t, epochDays) ?? 0);
+}
+/** True when both times are local, or both say which UTC they mean. */
+function sameTimeKind(a, b, epochA, epochB) {
+    return (offsetOf(a, epochA) === undefined) === (offsetOf(b, epochB) === undefined);
+}
 function compareValues(a, b) {
     if (typeof a === "number" && typeof b === "number")
         return a - b;
@@ -195,12 +347,30 @@ function compareValues(a, b) {
         return a < b ? -1 : a > b ? 1 : 0;
     if (isFeelDate(a) && isFeelDate(b))
         return dateToEpochDays(a) - dateToEpochDays(b);
+    if (isFeelTime(a) && isFeelTime(b)) {
+        // A local time and one at a known offset name different things and
+        // cannot be ordered against each other.
+        if (!sameTimeKind(a, b, 0, 0))
+            return null;
+        return timeToSeconds(a) - timeToSeconds(b);
+    }
+    if (isFeelDateTime(a) && isFeelDateTime(b)) {
+        const epochA = dateToEpochDays(a.date);
+        const epochB = dateToEpochDays(b.date);
+        if (!sameTimeKind(a.time, b.time, epochA, epochB))
+            return null;
+        return dateTimeToSeconds(a) - dateTimeToSeconds(b);
+    }
     if (isFeelDayTimeDuration(a) && isFeelDayTimeDuration(b))
         return a.seconds - b.seconds;
     if (isFeelYearsMonthsDuration(a) && isFeelYearsMonthsDuration(b))
         return a.months - b.months;
     return null;
 }
+function dateTimeToSeconds(dt) {
+    const epochDays = dateToEpochDays(dt.date);
+    return epochDays * 86400 + timeToSeconds(dt.time, epochDays);
+}
 const builtinMap = new Map();
 function reg(name, fn) {
     builtinMap.set(name, fn);
@@ -209,8 +379,30 @@ function reg(name, fn) {
 // String functions
 // -------------------------------------------------------------------------
 reg("string", (v) => {
+    if (v === undefined)
+        return null;
+    return stringify(v, false);
+});
+/**
+ * Renders a value the way FEEL's string() does. Strings nested inside a list
+ * or context are quoted; a string rendered on its own is not.
+ */
+function stringify(v, nested) {
     if (v === null)
-        return "null";
+        return null;
+    if (typeof v === "string")
+        return nested ? JSON.stringify(v) : v;
+    if (isFeelList(v)) {
+        const parts = v.map((item) => stringify(item, true) ?? "null");
+        return `[${parts.join(", ")}]`;
+    }
+    if (isFeelContext(v)) {
+        const parts = Object.entries(v).map(([k, value]) => `${k}: ${stringify(value, true) ?? "null"}`);
+        return `{${parts.join(", ")}}`;
+    }
+    return scalarToString(v);
+}
+function scalarToString(v) {
     if (typeof v === "string")
         return v;
     if (typeof v === "number")
@@ -252,10 +444,11 @@ reg("string", (v) => {
         return r;
     }
     return null;
-});
+}
 reg("string length", (s) => {
     const str = toStr(s);
-    return str === null ? null : str.length;
+    // FEEL counts characters, so an astral character counts once, not twice.
+    return str === null ? null : [...str].length;
 });
 reg("substring", (str, start, length) => {
     const s = toStr(str);
@@ -264,15 +457,17 @@ reg("substring", (str, start, length) => {
     const st = toNum(start);
     if (st === null)
         return null;
-    // FEEL substring is 1-based, negative counts from end
-    const idx = st > 0 ? st - 1 : Math.max(0, s.length + st);
+    // FEEL substring is 1-based over characters, and a negative start counts
+    // back from the end.
+    const chars = [...s];
+    const idx = st > 0 ? st - 1 : Math.max(0, chars.length + st);
     if (length !== undefined && length !== null) {
         const len = toNum(length);
         if (len === null)
             return null;
-        return s.slice(idx, idx + len);
+        return chars.slice(idx, idx + len).join("");
     }
-    return s.slice(idx);
+    return chars.slice(idx).join("");
 });
 reg("substring before", (str, match) => {
     const s = toStr(str);
@@ -319,18 +514,85 @@ reg("ends with", (str, match) => {
         return null;
     return s.endsWith(m);
 });
+// Patterns in FEEL come from static expression text, so the same few regexes
+// are compiled over and over inside loops and decision tables; keep them.
+const REGEX_CACHE_LIMIT = 256;
+const regexCache = new Map();
+/** Compiled regex for `pattern`/`flags`, or null when the pattern is invalid. */
+/**
+ * Translates the XPath flags FEEL uses into a JavaScript regex. "i", "s" and
+ * "m" map straight across; "x" (ignore whitespace in the pattern) and "q"
+ * (treat the pattern as a literal) have no JavaScript equivalent and are
+ * applied to the pattern instead. Any other flag makes the call fail.
+ */
+function toJsRegExp(pattern, flags) {
+    let jsFlags = "";
+    for (const flag of flags) {
+        if (flag === "i" || flag === "s" || flag === "m" || flag === "g") {
+            if (!jsFlags.includes(flag))
+                jsFlags += flag;
+            continue;
+        }
+        if (flag !== "x" && flag !== "q")
+            return null;
+    }
+    let source = pattern;
+    if (flags.includes("q")) {
+        source = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    else if (flags.includes("x")) {
+        source = stripPatternWhitespace(pattern);
+    }
+    try {
+        return new RegExp(source, jsFlags);
+    }
+    catch {
+        return null;
+    }
+}
+/** Removes the whitespace an "x"-flagged pattern ignores, keeping character classes intact. */
+function stripPatternWhitespace(pattern) {
+    let out = "";
+    let inClass = false;
+    for (let i = 0; i < pattern.length; i++) {
+        const c = pattern[i];
+        if (c === "\\" && i + 1 < pattern.length) {
+            out += c + pattern[i + 1];
+            i++;
+            continue;
+        }
+        if (c === "[")
+            inClass = true;
+        else if (c === "]")
+            inClass = false;
+        if (!inClass && /\s/.test(c))
+            continue;
+        out += c;
+    }
+    return out;
+}
+function cachedRegExp(pattern, flags) {
+    const key = `${flags}/${pattern}`;
+    const hit = regexCache.get(key);
+    if (hit !== undefined)
+        return hit;
+    const re = toJsRegExp(pattern, flags);
+    if (regexCache.size >= REGEX_CACHE_LIMIT)
+        regexCache.clear();
+    regexCache.set(key, re);
+    return re;
+}
 reg("matches", (str, pattern, flags) => {
     const s = toStr(str);
     const p = toStr(pattern);
     if (s === null || p === null)
         return null;
     const f = flags !== undefined && flags !== null ? (toStr(flags) ?? "") : "";
-    try {
-        return new RegExp(p, f).test(s);
-    }
-    catch {
+    const re = cachedRegExp(p, f);
+    if (re === null)
         return null;
-    }
+    re.lastIndex = 0;
+    return re.test(s);
 });
 reg("replace", (str, pattern, replacement, flags) => {
     const s = toStr(str);
@@ -339,121 +601,128 @@ reg("replace", (str, pattern, replacement, flags) => {
     if (s === null || p === null || r === null)
         return null;
     const f = flags !== undefined && flags !== null ? (toStr(flags) ?? "g") : "g";
-    try {
-        return s.replace(new RegExp(p, f.includes("g") ? f : `${f}g`), r);
-    }
-    catch {
+    const re = cachedRegExp(p, f.includes("g") ? f : `${f}g`);
+    if (re === null)
         return null;
-    }
+    re.lastIndex = 0;
+    // $0 is XPath's whole match, which JavaScript spells $&.
+    return s.replace(re, r.replace(/\$&/g, "$$$$&").replace(/\$0/g, "$$&"));
 });
 reg("split", (str, delimiter) => {
     const s = toStr(str);
     const d = toStr(delimiter);
     if (s === null || d === null)
         return null;
-    try {
-        return s.split(new RegExp(d));
-    }
-    catch {
-        return s.split(d);
-    }
+    const re = cachedRegExp(d, "");
+    return re === null ? s.split(d) : s.split(re);
 });
-reg("string join", (...args) => {
-    const flat = flattenToList(args);
-    // string join(list) or string join(list, delimiter) or string join(list, delimiter, prefix, suffix)
-    let list;
-    let delimiter = "";
-    const first = flat[0];
-    if (flat.length >= 1 && first !== undefined && isFeelList(first)) {
-        list = first;
-        delimiter = flat.length >= 2 ? (toStr(at(flat, 1)) ?? "") : "";
-    }
-    else {
-        list = flat;
-    }
+reg("string join", (value, delimiter, prefix, suffix) => {
+    // A value that is not a list joins as a list of one, so the delimiter
+    // never appears. A null, or anything in the list that is not a string,
+    // has no joined form.
+    if (value === null || value === undefined)
+        return null;
+    const list = isFeelList(value) ? value : [value];
     const parts = [];
     for (const v of list) {
-        const s = toStr(v);
-        if (s !== null)
-            parts.push(s);
+        // Nulls are skipped; any other non-string is an error.
+        if (v === null)
+            continue;
+        const text = toStr(v);
+        if (text === null)
+            return null;
+        parts.push(text);
     }
-    return parts.join(delimiter);
+    const between = delimiter === undefined || delimiter === null ? "" : toStr(delimiter);
+    if (between === null)
+        return null;
+    const head = prefix === undefined || prefix === null ? "" : toStr(prefix);
+    const tail = suffix === undefined || suffix === null ? "" : toStr(suffix);
+    if (head === null || tail === null)
+        return null;
+    return head + parts.join(between) + tail;
 });
 // -------------------------------------------------------------------------
 // Number functions
 // -------------------------------------------------------------------------
-reg("number", (v) => {
+reg("number", (v, groupingSeparator, decimalSeparator) => {
+    const hasSeparators = groupingSeparator !== undefined || decimalSeparator !== undefined;
     if (typeof v === "number")
-        return v;
-    if (typeof v === "string") {
-        const n = Number(v);
-        return Number.isNaN(n) ? null : n;
-    }
-    return null;
+        return hasSeparators ? null : v;
+    if (typeof v !== "string")
+        return null;
+    const grouping = separatorArg(groupingSeparator, [" ", ",", "."]);
+    const decimal = separatorArg(decimalSeparator, [",", "."]);
+    if (grouping === undefined || decimal === undefined)
+        return null;
+    if (grouping !== null && grouping === decimal)
+        return null;
+    let text = v;
+    if (grouping !== null)
+        text = text.split(grouping).join("");
+    if (decimal !== null)
+        text = text.split(decimal).join(".");
+    if (text.trim() === "")
+        return null;
+    const n = Number(text);
+    return Number.isNaN(n) ? null : n;
 });
+/** Reads a number() separator argument: null when absent, undefined when invalid. */
+function separatorArg(v, allowed) {
+    if (v === undefined || v === null)
+        return null;
+    if (typeof v !== "string" || !allowed.includes(v))
+        return undefined;
+    return v;
+}
 reg("decimal", (n, scale) => {
     const num = toNum(n);
-    const sc = toNum(scale);
-    if (num === null || sc === null)
+    const sc = toScale(scale);
+    if (num === null || sc === null || scale === undefined)
         return null;
-    const factor = 10 ** sc;
-    return Math.round(num * factor) / factor;
+    return roundAt(num, sc, roundHalfEven);
 });
 reg("floor", (n, scale) => {
     const num = toNum(n);
-    if (num === null)
+    const sc = toScale(scale);
+    if (num === null || sc === null)
         return null;
-    if (scale !== undefined && scale !== null) {
-        const sc = toNum(scale) ?? 0;
-        const factor = 10 ** sc;
-        return Math.floor(num * factor) / factor;
-    }
-    return Math.floor(num);
+    return roundAt(num, sc, Math.floor);
 });
 reg("ceiling", (n, scale) => {
     const num = toNum(n);
-    if (num === null)
+    const sc = toScale(scale);
+    if (num === null || sc === null)
         return null;
-    if (scale !== undefined && scale !== null) {
-        const sc = toNum(scale) ?? 0;
-        const factor = 10 ** sc;
-        return Math.ceil(num * factor) / factor;
-    }
-    return Math.ceil(num);
+    return roundAt(num, sc, Math.ceil);
 });
 reg("round half up", (n, scale) => {
     const num = toNum(n);
-    const sc = toNum(scale) ?? 0;
-    if (num === null)
+    const sc = toScale(scale);
+    if (num === null || sc === null)
         return null;
-    const factor = 10 ** sc;
-    return Math.round(num * factor) / factor;
+    return roundAt(num, sc, roundHalfUp);
 });
 reg("round half down", (n, scale) => {
     const num = toNum(n);
-    const sc = toNum(scale) ?? 0;
-    if (num === null)
+    const sc = toScale(scale);
+    if (num === null || sc === null)
         return null;
-    const factor = 10 ** sc;
-    const scaled = num * factor;
-    return (scaled > 0 ? Math.ceil(scaled - 0.5) : Math.floor(scaled + 0.5)) / factor;
+    return roundAt(num, sc, roundHalfDown);
 });
 reg("round up", (n, scale) => {
     const num = toNum(n);
-    const sc = toNum(scale) ?? 0;
-    if (num === null)
+    const sc = toScale(scale);
+    if (num === null || sc === null)
         return null;
-    const factor = 10 ** sc;
-    const scaled = num * factor;
-    return (scaled > 0 ? Math.ceil(scaled) : Math.floor(scaled)) / factor;
+    return roundAt(num, sc, (x) => (x >= 0 ? Math.ceil(x) : Math.floor(x)));
 });
 reg("round down", (n, scale) => {
     const num = toNum(n);
-    const sc = toNum(scale) ?? 0;
-    if (num === null)
+    const sc = toScale(scale);
+    if (num === null || sc === null)
         return null;
-    const factor = 10 ** sc;
-    return Math.trunc(num * factor) / factor;
+    return roundAt(num, sc, Math.trunc);
 });
 reg("abs", (n) => {
     if (typeof n === "number")
@@ -496,6 +765,9 @@ reg("random number", () => Math.random());
 // List functions
 // -------------------------------------------------------------------------
 reg("count", (...args) => {
+    // count() takes a list; a null argument is a type error, not a one-item list.
+    if (args.length === 1 && args[0] === null)
+        return null;
     const list = flattenToList(args);
     const first = list[0];
     if (list.length === 1 && first !== undefined && isFeelList(first))
@@ -549,7 +821,11 @@ reg("sum", (...args) => {
     return s;
 });
 reg("product", (...args) => {
+    if (args.length === 0)
+        return null;
     const list = unwrapList(flattenToList(args));
+    if (list.length === 0)
+        return null;
     let p = 1;
     for (const v of list) {
         const n = toNum(v);
@@ -603,24 +879,28 @@ reg("stddev", (...args) => {
     return Math.sqrt(variance);
 });
 reg("mode", (...args) => {
+    if (args.length === 0)
+        return null;
     const list = unwrapList(flattenToList(args));
     const counts = new Map();
     for (const v of list) {
-        counts.set(v, (counts.get(v) ?? 0) + 1);
-    }
-    let maxCount = 0;
-    for (const cnt of counts.values()) {
-        if (cnt > maxCount)
-            maxCount = cnt;
-    }
-    const modes = [];
-    for (const [v, cnt] of counts) {
-        if (cnt === maxCount)
-            modes.push(v);
+        const n = toNum(v);
+        if (n === null)
+            return null;
+        counts.set(n, (counts.get(n) ?? 0) + 1);
     }
-    return modes;
+    if (counts.size === 0)
+        return [];
+    const maxCount = Math.max(...counts.values());
+    // The most frequent values, in ascending order.
+    return [...counts]
+        .filter(([, count]) => count === maxCount)
+        .map(([value]) => value)
+        .sort((a, b) => a - b);
 });
 reg("all", (...args) => {
+    if (args.length === 0)
+        return null;
     const list = unwrapList(flattenToList(args));
     let hasNull = false;
     for (const v of list) {
@@ -628,10 +908,14 @@ reg("all", (...args) => {
             return false;
         if (v === null)
             hasNull = true;
+        else if (typeof v !== "boolean")
+            return null;
     }
     return hasNull ? null : true;
 });
 reg("any", (...args) => {
+    if (args.length === 0)
+        return null;
     const list = unwrapList(flattenToList(args));
     let hasNull = false;
     for (const v of list) {
@@ -639,6 +923,8 @@ reg("any", (...args) => {
             return true;
         if (v === null)
             hasNull = true;
+        else if (typeof v !== "boolean")
+            return null;
     }
     return hasNull ? null : false;
 });
@@ -713,45 +999,40 @@ reg("index of", (list, match) => {
     }
     return result;
 });
+// Set membership is SameValueZero, exactly what Array#includes used here, so
+// de-duplication keeps its semantics while dropping from O(n²) to O(n).
 reg("union", (...args) => {
-    const result = [];
+    const seen = new Set();
     for (const v of args) {
         if (isFeelList(v)) {
-            for (const item of v) {
-                if (!result.includes(item))
-                    result.push(item);
-            }
+            for (const item of v)
+                seen.add(item);
         }
-        else if (!result.includes(v)) {
-            result.push(v);
+        else {
+            seen.add(v);
         }
     }
-    return result;
+    return [...seen];
 });
 reg("distinct values", (list) => {
     if (!isFeelList(list))
         return null;
-    const result = [];
-    for (const v of list) {
-        if (!result.includes(v))
-            result.push(v);
-    }
-    return result;
+    return [...new Set(list)];
 });
 reg("flatten", (list) => {
     if (!isFeelList(list))
         return null;
+    const result = [];
     const flat = (arr) => {
-        const result = [];
         for (const v of arr) {
             if (isFeelList(v))
-                result.push(...flat(v));
+                flat(v);
             else
                 result.push(v);
         }
-        return result;
     };
-    return flat(list);
+    flat(list);
+    return result;
 });
 reg("sort", (list, fn) => {
     if (!isFeelList(list))
@@ -787,11 +1068,19 @@ reg("get or else", (v, defaultVal) => {
 reg("get value", (ctx, key) => {
     if (!isFeelContext(ctx))
         return null;
-    const k = toStr(key);
-    if (k === null)
-        return null;
-    const val = ctx[k];
-    return val !== undefined ? val : null;
+    // A list of keys walks into nested contexts: get value(c, ["y", "a"]).
+    const path = isFeelList(key) ? key : [key];
+    let current = ctx;
+    for (const step of path) {
+        const name = toStr(step);
+        if (name === null || !isFeelContext(current))
+            return null;
+        const next = current[name];
+        if (next === undefined)
+            return null;
+        current = next;
+    }
+    return current;
 });
 reg("get entries", (ctx) => {
     if (!isFeelContext(ctx))
@@ -801,18 +1090,42 @@ reg("get entries", (ctx) => {
 reg("context put", (ctx, key, value) => {
     if (!isFeelContext(ctx))
         return null;
-    const k = toStr(key);
-    if (k === null)
+    if (value === undefined)
         return null;
-    const result = {};
-    for (const [ck, cv] of Object.entries(ctx))
-        result[ck] = cv;
-    result[k] = value ?? null;
-    return result;
+    const path = isFeelList(key) ? key : [key];
+    if (path.length === 0)
+        return null;
+    return putPath(ctx, path, value);
 });
+/** Copies a context with `path` set to `value`, creating contexts on the way. */
+function putPath(ctx, path, value) {
+    const name = toStr(path[0] ?? null);
+    if (name === null)
+        return null;
+    const result = { ...ctx };
+    if (path.length === 1) {
+        result[name] = value;
+        return result;
+    }
+    const nested = result[name];
+    // A step onto something that is not a context has nowhere to go.
+    if (nested !== undefined && !isFeelContext(nested))
+        return null;
+    const inner = putPath(nested ?? {}, path.slice(1), value);
+    if (inner === null)
+        return null;
+    result[name] = inner;
+    return result;
+}
 reg("context merge", (...args) => {
+    // The signature is one list of contexts; a bare argument list is accepted
+    // too, the way the other list built-ins are.
+    const first = args[0] ?? null;
+    const contexts = args.length === 1 && isFeelList(first) ? first : args;
+    if (contexts.length === 0)
+        return null;
     const result = {};
-    for (const v of args) {
+    for (const v of contexts) {
         if (!isFeelContext(v))
             return null;
         for (const [k, cv] of Object.entries(v))
@@ -820,17 +1133,19 @@ reg("context merge", (...args) => {
     }
     return result;
 });
-reg("context", (list) => {
-    if (!isFeelList(list))
-        return null;
+reg("context", (entries) => {
+    const list = isFeelList(entries) ? entries : [entries];
     const result = {};
     for (const item of list) {
         if (!isFeelContext(item))
             return null;
         const k = item.key;
-        const v = item.value;
-        if (typeof k === "string")
-            result[k] = v !== undefined ? v : null;
+        if (typeof k !== "string")
+            return null;
+        // An entry naming a key already set is a conflict, not an overwrite.
+        if (k in result)
+            return null;
+        result[k] = item.value !== undefined ? item.value : null;
     }
     return result;
 });
@@ -844,6 +1159,8 @@ reg("date", (...args) => {
             return parseDate(v);
         if (isFeelDateTime(v))
             return v.date;
+        if (isFeelDate(v))
+            return v;
         return null;
     }
     if (args.length === 3) {
@@ -852,7 +1169,7 @@ reg("date", (...args) => {
         const d = toNum(at(args, 2));
         if (y === null || m === null || d === null)
             return null;
-        return { type: "date", year: y, month: m, day: d };
+        return makeDate(y, m, d);
     }
     return null;
 });
@@ -863,6 +1180,10 @@ reg("time", (...args) => {
             return parseTime(v);
         if (isFeelDateTime(v))
             return v.time;
+        if (isFeelTime(v))
+            return v;
+        if (isFeelDate(v))
+            return { type: "time", hour: 0, minute: 0, second: 0 };
         return null;
     }
     if (args.length >= 3) {
@@ -871,6 +1192,8 @@ reg("time", (...args) => {
         const s = toNum(at(args, 2));
         if (h === null || m === null || s === null)
             return null;
+        if (!isValidTime(h, m, s))
+            return null;
         const t = { type: "time", hour: h, minute: m, second: s };
         const off = at(args, 3);
         if (off !== null && isFeelDayTimeDuration(off))
@@ -915,9 +1238,29 @@ reg("years and months duration", (from, to) => {
         d2 = to.date;
     if (!d1 || !d2)
         return null;
-    const months = (d2.year - d1.year) * 12 + (d2.month - d1.month);
+    let months = (d2.year - d1.year) * 12 + (d2.month - d1.month);
+    // Only whole months count, so a end that has not yet reached the start's
+    // day-and-time within the month gives back the month it was counted.
+    const remainder = compareWithinMonth(from, to);
+    if (months > 0 && remainder < 0)
+        months -= 1;
+    else if (months < 0 && remainder > 0)
+        months += 1;
     return { type: "years-months-duration", months };
 });
+/** Orders two temporals by day of month and time of day, ignoring year and month. */
+function compareWithinMonth(a, b) {
+    const partsOf = (v) => {
+        if (isFeelDate(v))
+            return [v.day, 0];
+        if (isFeelDateTime(v))
+            return [v.date.day, timeToSeconds(v.time)];
+        return [0, 0];
+    };
+    const [dayA, secA] = partsOf(a);
+    const [dayB, secB] = partsOf(b);
+    return dayB - dayA || secB - secA;
+}
 // -------------------------------------------------------------------------
 // Temporal utility functions
 // -------------------------------------------------------------------------
@@ -974,17 +1317,26 @@ reg("week of year", (d) => {
         date = d.date;
     if (!date)
         return null;
-    // ISO week number
-    const epochDays = dateToEpochDays(date);
-    // 1970-01-01 was Thursday (dow=4), ISO week 1
-    const jan4 = dateToEpochDays({ type: "date", year: date.year, month: 1, day: 4 });
-    const jan4dow = ((jan4 % 7) + 7 + 4) % 7; // Monday=0
-    const weekStart = jan4 - ((jan4dow + 6) % 7);
-    const week = Math.floor((epochDays - weekStart) / 7) + 1;
+    // ISO 8601: week 1 is the one holding the first Thursday, so the turn of
+    // the year can fall in the neighbouring year's last or first week.
+    const weekday = isoWeekday(date);
+    const week = Math.floor((dayOfYear(date) - weekday + 10) / 7);
     if (week < 1)
-        return 52; // last week of previous year (simplified)
+        return isoWeeksInYear(date.year - 1);
+    if (week > isoWeeksInYear(date.year))
+        return 1;
     return week;
 });
+/** Monday is 1, Sunday is 7. Epoch day 0, 1970-01-01, was a Thursday. */
+function isoWeekday(d) {
+    return ((((dateToEpochDays(d) + 3) % 7) + 7) % 7) + 1;
+}
+/** 52 or 53, whichever ISO 8601 gives the year. */
+function isoWeeksInYear(year) {
+    const jan1 = isoWeekday({ type: "date", year, month: 1, day: 1 });
+    const long = jan1 === 4 || (isLeapYear(year) && jan1 === 3);
+    return long ? 53 : 52;
+}
 reg("month of year", (d) => {
     const MONTH_NAMES = [
         "January",
@@ -1131,41 +1483,101 @@ reg("includes", (a, b) => {
     return cmpPts(as_, bs, "start") <= 0 && cmpPts(be, ae, "end") <= 0;
 });
 reg("starts", (a, b) => {
-    if (!isFeelRange(a) || !isFeelRange(b))
+    // starts(point, range): the range begins at that point, inclusively.
+    if (!isFeelRange(b))
         return null;
-    const as_ = startOf(a);
-    const bs = startOf(b);
-    const ae = endOf(a);
-    const be = endOf(b);
-    return cmpPts(as_, bs, "start") === 0 && cmpPts(ae, be, "end") <= 0;
+    if (!isFeelRange(a)) {
+        return b.startIncluded && compareValues(a, b.start) === 0;
+    }
+    return cmpPts(startOf(a), startOf(b), "start") === 0 && cmpPts(endOf(a), endOf(b), "end") <= 0;
 });
 reg("started by", (a, b) => {
-    if (!isFeelRange(a) || !isFeelRange(b))
+    if (!isFeelRange(a))
         return null;
-    const as_ = startOf(a);
-    const bs = startOf(b);
-    const ae = endOf(a);
-    const be = endOf(b);
-    return cmpPts(as_, bs, "start") === 0 && cmpPts(be, ae, "end") <= 0;
+    if (!isFeelRange(b)) {
+        return a.startIncluded && compareValues(a.start, b) === 0;
+    }
+    return cmpPts(startOf(a), startOf(b), "start") === 0 && cmpPts(endOf(b), endOf(a), "end") <= 0;
 });
 reg("finishes", (a, b) => {
-    if (!isFeelRange(a) || !isFeelRange(b))
+    // finishes(point, range): the range ends at that point, inclusively.
+    if (!isFeelRange(b))
         return null;
-    const ae = endOf(a);
-    const be = endOf(b);
-    const as_ = startOf(a);
-    const bs = startOf(b);
-    return cmpPts(ae, be, "end") === 0 && cmpPts(bs, as_, "start") <= 0;
+    if (!isFeelRange(a)) {
+        return b.endIncluded && compareValues(a, b.end) === 0;
+    }
+    return cmpPts(endOf(a), endOf(b), "end") === 0 && cmpPts(startOf(b), startOf(a), "start") <= 0;
 });
 reg("finished by", (a, b) => {
-    if (!isFeelRange(a) || !isFeelRange(b))
+    if (!isFeelRange(a))
         return null;
-    const ae = endOf(a);
-    const be = endOf(b);
-    const as_ = startOf(a);
-    const bs = startOf(b);
-    return cmpPts(ae, be, "end") === 0 && cmpPts(as_, bs, "start") <= 0;
-});
+    if (!isFeelRange(b)) {
+        return a.endIncluded && compareValues(a.end, b) === 0;
+    }
+    return cmpPts(endOf(a), endOf(b), "end") === 0 && cmpPts(startOf(a), startOf(b), "start") <= 0;
+});
+/**
+ * DMN's is(): whether two values are the same value, not merely equal ones.
+ * Temporal values differ when they are written differently even where they
+ * name the same instant, so a local time is not the same value as one at
+ * UTC, and a zone is not the same value as the offset it currently has.
+ */
+reg("is", (a, b, ...rest) => {
+    if (rest.length > 0)
+        return null;
+    if (b === undefined)
+        return false;
+    if (a === null || b === null)
+        return a === null && b === null;
+    if (isFeelTime(a) || isFeelDateTime(a) || isFeelTime(b) || isFeelDateTime(b)) {
+        return sameTemporal(a, b);
+    }
+    if (valueType(a) !== valueType(b))
+        return false;
+    return compareValues(a, b) === 0 || deepEquals(a, b);
+});
+/** Compares the written form of a time or date-time, field by field. */
+function sameTemporal(a, b) {
+    if (isFeelTime(a) && isFeelTime(b)) {
+        return (a.hour === b.hour &&
+            a.minute === b.minute &&
+            a.second === b.second &&
+            a.offsetSeconds === b.offsetSeconds &&
+            a.timezone === b.timezone);
+    }
+    if (isFeelDateTime(a) && isFeelDateTime(b)) {
+        return (a.date.year === b.date.year &&
+            a.date.month === b.date.month &&
+            a.date.day === b.date.day &&
+            sameTemporal(a.time, b.time));
+    }
+    return false;
+}
+/** The FEEL type of a value, for deciding whether two values are the same kind. */
+function valueType(v) {
+    if (v === null)
+        return "null";
+    if (Array.isArray(v))
+        return "list";
+    if (typeof v !== "object")
+        return typeof v;
+    const tagged = v.type;
+    return typeof tagged === "string" ? tagged : "context";
+}
+function deepEquals(a, b) {
+    if (a === b)
+        return true;
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.length === b.length && a.every((x, i) => deepEquals(x, b[i] ?? null));
+    }
+    if (isFeelContext(a) && isFeelContext(b)) {
+        const keys = Object.keys(a);
+        if (keys.length !== Object.keys(b).length)
+            return false;
+        return keys.every((k) => deepEquals(a[k] ?? null, b[k] ?? null));
+    }
+    return false;
+}
 reg("coincides", (a, b) => {
     if (isFeelRange(a) && isFeelRange(b)) {
         return cmpPts(startOf(a), startOf(b), "start") === 0 && cmpPts(endOf(a), endOf(b), "end") === 0;
@@ -1176,14 +1588,236 @@ reg("coincides", (a, b) => {
     return null;
 });
 // -------------------------------------------------------------------------
+// Parameter names
+// -------------------------------------------------------------------------
+// Parameter names of every built-in, in declaration order, so that a named
+// invocation such as `substring(start position: 2, string: "hello")` binds by
+// name rather than by the order the arguments happen to appear in. Built-ins
+// with several signatures list one entry per signature.
+const PARAM_SIGNATURES = {
+    // Conversion
+    string: [["from"]],
+    number: [
+        ["from"],
+        ["from", "grouping separator"],
+        ["from", "grouping separator", "decimal separator"],
+    ],
+    context: [["entries"]],
+    date: [["from"], ["year", "month", "day"]],
+    time: [["from"], ["hour", "minute", "second"], ["hour", "minute", "second", "offset"]],
+    "date and time": [["from"], ["date", "time"], ["date", "timezone"]],
+    duration: [["from"]],
+    "years and months duration": [["from", "to"]],
+    // Boolean
+    not: [["negand"]],
+    is: [["value1"], ["value2"], ["value1", "value2"]],
+    "is defined": [["value"]],
+    "get or else": [["value", "default"]],
+    // String
+    substring: [
+        ["string", "start position"],
+        ["string", "start position", "length"],
+    ],
+    "string length": [["string"]],
+    "upper case": [["string"]],
+    "lower case": [["string"]],
+    "substring before": [["string", "match"]],
+    "substring after": [["string", "match"]],
+    contains: [["string", "match"]],
+    "starts with": [["string", "match"]],
+    "ends with": [["string", "match"]],
+    matches: [
+        ["input", "pattern"],
+        ["input", "pattern", "flags"],
+    ],
+    replace: [
+        ["input", "pattern", "replacement"],
+        ["input", "pattern", "replacement", "flags"],
+    ],
+    split: [["string", "delimiter"]],
+    "string join": [["list"], ["list", "delimiter"], ["list", "delimiter", "prefix", "suffix"]],
+    // List
+    "list contains": [["list", "element"]],
+    count: [["list"]],
+    min: [["list"]],
+    max: [["list"]],
+    sum: [["list"]],
+    product: [["list"]],
+    mean: [["list"]],
+    median: [["list"]],
+    stddev: [["list"]],
+    mode: [["list"]],
+    all: [["list"]],
+    any: [["list"]],
+    sublist: [
+        ["list", "start position"],
+        ["list", "start position", "length"],
+    ],
+    append: [["list", "items"]],
+    concatenate: [["lists"]],
+    "insert before": [["list", "position", "newItem"]],
+    remove: [["list", "position"]],
+    reverse: [["list"]],
+    "index of": [["list", "match"]],
+    union: [["list"]],
+    "distinct values": [["list"]],
+    flatten: [["list"]],
+    sort: [["list", "precedes"]],
+    // Numeric
+    decimal: [["n", "scale"]],
+    floor: [["n"], ["n", "scale"]],
+    ceiling: [["n"], ["n", "scale"]],
+    "round up": [["n", "scale"]],
+    "round down": [["n", "scale"]],
+    "round half up": [["n", "scale"]],
+    "round half down": [["n", "scale"]],
+    abs: [["number"], ["n"]],
+    modulo: [["dividend", "divisor"]],
+    sqrt: [["number"]],
+    log: [["number"]],
+    exp: [["number"]],
+    odd: [["number"]],
+    even: [["number"]],
+    "random number": [[]],
+    // Context
+    "get value": [
+        ["context", "key"],
+        ["context", "keys"],
+        ["m", "key"],
+        ["m", "keys"],
+    ],
+    "get entries": [["context"], ["m"]],
+    "context put": [
+        ["context", "key", "value"],
+        ["context", "keys", "value"],
+    ],
+    "context merge": [["contexts"]],
+    // Temporal
+    now: [[]],
+    today: [[]],
+    "day of week": [["date"]],
+    "day of year": [["date"]],
+    "week of year": [["date"]],
+    "month of year": [["date"]],
+    "last day of month": [["date"]],
+    // Range
+    before: [
+        ["point1", "point2"],
+        ["range", "point"],
+        ["point", "range"],
+        ["range1", "range2"],
+    ],
+    after: [
+        ["point1", "point2"],
+        ["range", "point"],
+        ["point", "range"],
+        ["range1", "range2"],
+    ],
+    meets: [["range1", "range2"]],
+    "met by": [["range1", "range2"]],
+    overlaps: [["range1", "range2"]],
+    "overlaps before": [["range1", "range2"]],
+    "overlaps after": [["range1", "range2"]],
+    finishes: [
+        ["point", "range"],
+        ["range1", "range2"],
+    ],
+    "finished by": [
+        ["range", "point"],
+        ["range1", "range2"],
+    ],
+    includes: [
+        ["range", "point"],
+        ["range1", "range2"],
+    ],
+    during: [
+        ["point", "range"],
+        ["range1", "range2"],
+    ],
+    starts: [
+        ["point", "range"],
+        ["range1", "range2"],
+    ],
+    "started by": [
+        ["range", "point"],
+        ["range1", "range2"],
+    ],
+    coincides: [
+        ["point1", "point2"],
+        ["range1", "range2"],
+    ],
+};
+// Built-ins DMN also defines over a bare argument list, so that max(1,2,3)
+// means max([1,2,3]). Their arity is not checked; everything else's is.
+const VARIADIC = new Set([
+    "min",
+    "max",
+    "sum",
+    "product",
+    "mean",
+    "median",
+    "stddev",
+    "mode",
+    "all",
+    "any",
+    "count",
+    "append",
+    "concatenate",
+    "union",
+    "context merge",
+]);
+/** The argument counts a built-in accepts, or undefined when it takes any. */
+function aritiesOf(name) {
+    if (VARIADIC.has(name))
+        return undefined;
+    const signatures = PARAM_SIGNATURES[name];
+    if (!signatures)
+        return undefined;
+    return new Set(signatures.map((params) => params.length));
+}
+/**
+ * Orders the arguments of a named invocation to match a built-in's signature.
+ * Returns, for each parameter position, the index of the argument supplying
+ * it, or null when no signature of the built-in accepts exactly these names —
+ * which FEEL treats as an invocation error rather than a positional call.
+ */
+export function orderNamedArgs(name, argNames) {
+    const signatures = PARAM_SIGNATURES[name];
+    if (!signatures)
+        return null;
+    for (const params of signatures) {
+        if (params.length !== argNames.length)
+            continue;
+        const order = params.map((param) => argNames.indexOf(param));
+        if (order.every((idx) => idx >= 0))
+            return order;
+    }
+    return null;
+}
+// -------------------------------------------------------------------------
 // Exports
 // -------------------------------------------------------------------------
+// One FeelFunction wrapper per built-in, created on first use and shared: name
+// resolution runs for every identifier the evaluator meets, so allocating a
+// wrapper and closure per lookup showed up on every loop iteration.
+const builtinWrappers = new Map();
 /** Look up a built-in function by name. Returns undefined if not found. */
 export function getBuiltin(name) {
+    const cached = builtinWrappers.get(name);
+    if (cached)
+        return cached;
     const fn = builtinMap.get(name);
     if (!fn)
         return undefined;
-    return { type: "function", call: (args) => fn(...args) };
+    const arities = aritiesOf(name);
+    const wrapper = {
+        type: "function",
+        // Calling a built-in with a number of arguments no signature accepts is
+        // an error, and FEEL reports an error as null.
+        call: (args) => (arities && !arities.has(args.length) ? null : fn(...args)),
+    };
+    builtinWrappers.set(name, wrapper);
+    return wrapper;
 }
 /** All built-in names. */
 export function builtinNames() {