bonsai-js 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -8,6 +8,15 @@ From 1.0.0, entries are generated at release time from the bump files in
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 
+
+## 1.2.0
+<sub>2026-10-25</sub>
+
+- *(minor)*
+  Add `bonsai-js/runtime/core` and `bonsai-js/builtins`: a runtime with only the built-in functions passed in `builtins`, so a browser bundle carries just what its rules call (about 30 KB gzipped for typical rules, against 43 KB for `bonsai-js/runtime`). `bonsai()` takes the same `builtins` option, and a call to a built-in left out is a CHECK error, so rules are checked against what the browser can run.
+- *(patch)*
+  Built-in function descriptions, which only `describeFunction()`, `listFunctions()`, and the language service read, are no longer bundled with `bonsai-js/runtime`, which is about 1.2 KB smaller gzipped (43 KB). Making each built-in separately removable adds about 0.8 KB to `bonsai-js` (69 KB), `bonsai-js/lite` (57 KB), and the language service (47 KB).
+
 ## 1.1.0
 <sub>2026-10-24</sub>
 

package/README.md

@@ -62,7 +62,7 @@ Try it in the [Playground](https://danfry1.github.io/bonsai-js/playground).
 | Evaluation budget for untrusted input (as documented) | Yes, on by default | Parse-time limits only | No expression budget | No | No | No | No |
 | SQL or MongoDB translation | Yes | No | No | No | No | No | No |
 
-Bonsai is the largest of these in the browser (about 56 KB from `bonsai-js/lite`, without explaining and partial evaluation, and about 44 KB from `bonsai-js/runtime` for rules checked and compiled on a server) and the newest. If rules must also run in Go or Java, CEL or ZEN fit better; if rules are JSON produced by a form builder and size matters most, json-logic-js does. The [full comparison](https://danfry1.github.io/bonsai-js/guide/comparison) covers more libraries, throughput, and the method behind every number.
+Bonsai is the largest of these in the browser (about 57 KB from `bonsai-js/lite`, without explaining and partial evaluation, and about 30 KB from `bonsai-js/runtime/core` for rules checked and compiled on a server, with only the built-in functions they call) and the newest. If rules must also run in Go or Java, CEL or ZEN fit better; if rules are JSON produced by a form builder and size matters most, json-logic-js does. The [full comparison](https://danfry1.github.io/bonsai-js/guide/comparison) covers more libraries, throughput, and the method behind every number.
 
 ## Install
 
@@ -74,7 +74,7 @@ Upgrading from 0.x? The [migration guide](https://danfry1.github.io/bonsai-js/gu
 
 Requires Node.js 22 or newer, current Bun, or a modern browser. The package is ESM; `require('bonsai-js')` works where Node can load ES modules synchronously (22.12 and newer); for the TypeScript settings that allow it, see [Install](https://danfry1.github.io/bonsai-js/guide/install#typescript-settings).
 
-In a browser bundle, an app that evaluates expressions adds about 68 KB minified and gzipped: the parser, type checker, compiler, and built-in library, with explaining and partial evaluation included. `bonsai-js/lite` leaves those two out, for about 56 KB, and `bonsai-js/runtime`, which evaluates rules checked and compiled elsewhere, leaves out the checker too, for about 44 KB. `bonsai-js/query` and `bonsai-js/service` are separate entry points; the language service on its own is about 46 KB, since it includes the type checker. Unused modules are tree-shaken: importing only `t` adds under 1 KB, and all the error classes about 1.6 KB. CI enforces these budgets (`bun run check:size`).
+In a browser bundle, an app that evaluates expressions adds about 69 KB minified and gzipped: the parser, type checker, compiler, and built-in library, with explaining and partial evaluation included. `bonsai-js/lite` leaves those two out, for about 57 KB, and `bonsai-js/runtime`, which evaluates rules checked and compiled elsewhere, leaves out the checker too, for about 43 KB, or about 30 KB from `bonsai-js/runtime/core` with only the built-in functions your rules call. `bonsai-js/query` and `bonsai-js/service` are separate entry points; the language service on its own is about 47 KB, since it includes the type checker. Unused modules are tree-shaken: importing only `t` adds under 1 KB, and all the error classes about 1.6 KB. CI enforces these budgets (`bun run check:size`).
 
 ## The language in one screen
 
@@ -94,7 +94,7 @@ startOfDay(order.placedAt, "Europe/Berlin")             // calendar math in time
 // comments work too
 ```
 
-The full reference is [docs/language.md](https://github.com/danfry1/bonsai-js/blob/v1.1.0/docs/language.md). The rules that matter most:
+The full reference is [docs/language.md](https://github.com/danfry1/bonsai-js/blob/v1.2.0/docs/language.md). The rules that matter most:
 
 - There is one absent value, `null`. Missing properties and host `undefined` read as `null`, so `x == null` means "missing or null". A key holding `undefined` is absent everywhere: `{ a: 1, b: undefined }` equals `{ a: 1 }`, and `"b" in` it is false.
 - `==` compares by value (lists and maps deeply). There is no type coercion: `1 == "1"` is `false` and `"a" + 1` is an error.
@@ -201,7 +201,7 @@ Every limit except `timeout` is on by default; `limits` changes the budget. `0`
 | `maxPatternLength` | 4,096 | regular expression patterns passed to `matches` |
 | `timeout` | none | wall-clock milliseconds per evaluation |
 
-The step budget is deterministic: the same expression over the same data uses the same steps on every machine, and at the default budget any expression finishes or fails within about 100 ms on Node (about 150 ms for the slowest shapes we have found). Host functions are trusted code: limits cannot interrupt a synchronous host function that is already running, and a getter or Proxy you put in the context runs when it is read. Set a `timeout` when expressions call slow host functions. See [SECURITY.md](https://github.com/danfry1/bonsai-js/blob/main/SECURITY.md) and [docs/threat-model.md](https://github.com/danfry1/bonsai-js/blob/v1.1.0/docs/threat-model.md).
+The step budget is deterministic: the same expression over the same data uses the same steps on every machine, and at the default budget any expression finishes or fails within about 100 ms on Node (about 150 ms for the slowest shapes we have found). Host functions are trusted code: limits cannot interrupt a synchronous host function that is already running, and a getter or Proxy you put in the context runs when it is read. Set a `timeout` when expressions call slow host functions. See [SECURITY.md](https://github.com/danfry1/bonsai-js/blob/main/SECURITY.md) and [docs/threat-model.md](https://github.com/danfry1/bonsai-js/blob/v1.2.0/docs/threat-model.md).
 
 ## Built-in functions
 

package/dist/builtins/index.d.mts

@@ -0,0 +1,91 @@
+import { Builtin } from "../environment.mjs";
+//#region src/builtins/index.d.ts
+export declare const toUpperCase: Builtin;
+export declare const toLowerCase: Builtin;
+export declare const trim: Builtin;
+export declare const trimStart: Builtin;
+export declare const trimEnd: Builtin;
+export declare const startsWith: Builtin;
+export declare const endsWith: Builtin;
+export declare const includes: Builtin;
+export declare const indexOf: Builtin;
+export declare const lastIndexOf: Builtin;
+export declare const slice: Builtin;
+export declare const split: Builtin;
+export declare const replace: Builtin;
+export declare const replaceAll: Builtin;
+export declare const padStart: Builtin;
+export declare const padEnd: Builtin;
+export declare const repeat: Builtin;
+export declare const at: Builtin;
+export declare const matches: Builtin;
+export declare const toString: Builtin;
+export declare const toNumber: Builtin;
+export declare const round: Builtin;
+export declare const floor: Builtin;
+export declare const ceil: Builtin;
+export declare const trunc: Builtin;
+export declare const abs: Builtin;
+export declare const sqrt: Builtin;
+export declare const clamp: Builtin;
+export declare const toFixed: Builtin;
+export declare const formatNumber: Builtin;
+export declare const formatCurrency: Builtin;
+export declare const min: Builtin;
+export declare const max: Builtin;
+export declare const sum: Builtin;
+export declare const avg: Builtin;
+export declare const map: Builtin;
+export declare const filter: Builtin;
+export declare const find: Builtin;
+export declare const findIndex: Builtin;
+export declare const some: Builtin;
+export declare const every: Builtin;
+export declare const none: Builtin;
+export declare const flatMap: Builtin;
+export declare const sortBy: Builtin;
+export declare const groupBy: Builtin;
+export declare const count: Builtin;
+export declare const reduce: Builtin;
+export declare const sort: Builtin;
+export declare const reverse: Builtin;
+export declare const unique: Builtin;
+export declare const flat: Builtin;
+export declare const first: Builtin;
+export declare const last: Builtin;
+export declare const join: Builtin;
+export declare const isEmpty: Builtin;
+export declare const keys: Builtin;
+export declare const values: Builtin;
+export declare const entries: Builtin;
+export declare const type: Builtin;
+export declare const now: Builtin;
+export declare const timestamp: Builtin;
+export declare const duration: Builtin;
+export declare const weeks: Builtin;
+export declare const days: Builtin;
+export declare const hours: Builtin;
+export declare const minutes: Builtin;
+export declare const seconds: Builtin;
+export declare const milliseconds: Builtin;
+export declare const inDays: Builtin;
+export declare const inHours: Builtin;
+export declare const inMinutes: Builtin;
+export declare const inSeconds: Builtin;
+export declare const inMilliseconds: Builtin;
+export declare const year: Builtin;
+export declare const month: Builtin;
+export declare const day: Builtin;
+export declare const hour: Builtin;
+export declare const minute: Builtin;
+export declare const second: Builtin;
+export declare const dayOfWeek: Builtin;
+export declare const startOfDay: Builtin;
+export declare const startOfMonth: Builtin;
+export declare const startOfYear: Builtin;
+export declare const addDays: Builtin;
+export declare const addMonths: Builtin;
+export declare const addYears: Builtin;
+export declare const formatDate: Builtin;
+//#endregion
+export type { Builtin };

package/dist/builtins/index.mjs

@@ -0,0 +1,93 @@
+import { abs as abs$1, addDays as addDays$1, addMonths as addMonths$1, addYears as addYears$1, at as at$1, avg as avg$1, ceil as ceil$1, clamp as clamp$1, count as count$1, day as day$1, dayOfWeek as dayOfWeek$1, days as days$1, duration as duration$1, endsWith as endsWith$1, entries as entries$1, every as every$1, filter as filter$1, find as find$1, findIndex as findIndex$1, first as first$1, flat as flat$1, flatMap as flatMap$1, floor as floor$1, formatCurrency as formatCurrency$1, formatDate as formatDate$1, formatNumber as formatNumber$1, groupBy as groupBy$1, hour as hour$1, hours as hours$1, inDays as inDays$1, inHours as inHours$1, inMilliseconds as inMilliseconds$1, inMinutes as inMinutes$1, inSeconds as inSeconds$1, includes as includes$1, indexOf as indexOf$1, isEmpty as isEmpty$1, join as join$1, keys as keys$1, last as last$1, lastIndexOf as lastIndexOf$1, map as map$1, matches as matches$1, max as max$1, milliseconds as milliseconds$1, min as min$1, minute as minute$1, minutes as minutes$1, month as month$1, none as none$1, now as now$1, padEnd as padEnd$1, padStart as padStart$1, reduce as reduce$1, repeat as repeat$1, replace as replace$1, replaceAll as replaceAll$1, reverse as reverse$1, round as round$1, second as second$1, seconds as seconds$1, slice as slice$1, some as some$1, sort as sort$1, sortBy as sortBy$1, split as split$1, sqrt as sqrt$1, startOfDay as startOfDay$1, startOfMonth as startOfMonth$1, startOfYear as startOfYear$1, startsWith as startsWith$1, sum as sum$1, timestamp as timestamp$1, toFixed as toFixed$1, toLowerCase as toLowerCase$1, toNumber as toNumber$1, toString as toString$1, toUpperCase as toUpperCase$1, trim as trim$1, trimEnd as trimEnd$1, trimStart as trimStart$1, trunc as trunc$1, type as type$1, unique as unique$1, values as values$1, weeks as weeks$1, year as year$1 } from "../functions/builtins.mjs";
+//#region src/builtins/index.ts
+const toUpperCase = toUpperCase$1;
+const toLowerCase = toLowerCase$1;
+const trim = trim$1;
+const trimStart = trimStart$1;
+const trimEnd = trimEnd$1;
+const startsWith = startsWith$1;
+const endsWith = endsWith$1;
+const includes = includes$1;
+const indexOf = indexOf$1;
+const lastIndexOf = lastIndexOf$1;
+const slice = slice$1;
+const split = split$1;
+const replace = replace$1;
+const replaceAll = replaceAll$1;
+const padStart = padStart$1;
+const padEnd = padEnd$1;
+const repeat = repeat$1;
+const at = at$1;
+const matches = matches$1;
+const toString = toString$1;
+const toNumber = toNumber$1;
+const round = round$1;
+const floor = floor$1;
+const ceil = ceil$1;
+const trunc = trunc$1;
+const abs = abs$1;
+const sqrt = sqrt$1;
+const clamp = clamp$1;
+const toFixed = toFixed$1;
+const formatNumber = formatNumber$1;
+const formatCurrency = formatCurrency$1;
+const min = min$1;
+const max = max$1;
+const sum = sum$1;
+const avg = avg$1;
+const map = map$1;
+const filter = filter$1;
+const find = find$1;
+const findIndex = findIndex$1;
+const some = some$1;
+const every = every$1;
+const none = none$1;
+const flatMap = flatMap$1;
+const sortBy = sortBy$1;
+const groupBy = groupBy$1;
+const count = count$1;
+const reduce = reduce$1;
+const sort = sort$1;
+const reverse = reverse$1;
+const unique = unique$1;
+const flat = flat$1;
+const first = first$1;
+const last = last$1;
+const join = join$1;
+const isEmpty = isEmpty$1;
+const keys = keys$1;
+const values = values$1;
+const entries = entries$1;
+const type = type$1;
+const now = now$1;
+const timestamp = timestamp$1;
+const duration = duration$1;
+const weeks = weeks$1;
+const days = days$1;
+const hours = hours$1;
+const minutes = minutes$1;
+const seconds = seconds$1;
+const milliseconds = milliseconds$1;
+const inDays = inDays$1;
+const inHours = inHours$1;
+const inMinutes = inMinutes$1;
+const inSeconds = inSeconds$1;
+const inMilliseconds = inMilliseconds$1;
+const year = year$1;
+const month = month$1;
+const day = day$1;
+const hour = hour$1;
+const minute = minute$1;
+const second = second$1;
+const dayOfWeek = dayOfWeek$1;
+const startOfDay = startOfDay$1;
+const startOfMonth = startOfMonth$1;
+const startOfYear = startOfYear$1;
+const addDays = addDays$1;
+const addMonths = addMonths$1;
+const addYears = addYears$1;
+const formatDate = formatDate$1;
+//#endregion
+export { abs, addDays, addMonths, addYears, at, avg, ceil, clamp, count, day, dayOfWeek, days, duration, endsWith, entries, every, filter, find, findIndex, first, flat, flatMap, floor, formatCurrency, formatDate, formatNumber, groupBy, hour, hours, inDays, inHours, inMilliseconds, inMinutes, inSeconds, includes, indexOf, isEmpty, join, keys, last, lastIndexOf, map, matches, max, milliseconds, min, minute, minutes, month, none, now, padEnd, padStart, reduce, repeat, replace, replaceAll, reverse, round, second, seconds, slice, some, sort, sortBy, split, sqrt, startOfDay, startOfMonth, startOfYear, startsWith, sum, timestamp, toFixed, toLowerCase, toNumber, toString, toUpperCase, trim, trimEnd, trimStart, trunc, type, unique, values, weeks, year };
+
+//# sourceMappingURL=index.mjs.map

package/dist/builtins/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["defs.toUpperCase","defs.toLowerCase","defs.trim","defs.trimStart","defs.trimEnd","defs.startsWith","defs.endsWith","defs.includes","defs.indexOf","defs.lastIndexOf","defs.slice","defs.split","defs.replace","defs.replaceAll","defs.padStart","defs.padEnd","defs.repeat","defs.at","defs.matches","defs.toString","defs.toNumber","defs.round","defs.floor","defs.ceil","defs.trunc","defs.abs","defs.sqrt","defs.clamp","defs.toFixed","defs.formatNumber","defs.formatCurrency","defs.min","defs.max","defs.sum","defs.avg","defs.map","defs.filter","defs.find","defs.findIndex","defs.some","defs.every","defs.none","defs.flatMap","defs.sortBy","defs.groupBy","defs.count","defs.reduce","defs.sort","defs.reverse","defs.unique","defs.flat","defs.first","defs.last","defs.join","defs.isEmpty","defs.keys","defs.values","defs.entries","defs.type","defs.now","defs.timestamp","defs.duration","defs.weeks","defs.days","defs.hours","defs.minutes","defs.seconds","defs.milliseconds","defs.inDays","defs.inHours","defs.inMinutes","defs.inSeconds","defs.inMilliseconds","defs.year","defs.month","defs.day","defs.hour","defs.minute","defs.second","defs.dayOfWeek","defs.startOfDay","defs.startOfMonth","defs.startOfYear","defs.addDays","defs.addMonths","defs.addYears","defs.formatDate"],"sources":["../../src/builtins/index.ts"],"sourcesContent":["/**\n * `bonsai-js/builtins`: every built-in function as its own export, for the\n * `builtins` option of bonsai-js/runtime/core's runtime() and of bonsai(). A\n * bundle keeps only the built-ins it imports. Namespace imports avoid clashes\n * with names such as `map` and `keys` in your own code:\n *\n * ```ts\n * import * as b from 'bonsai-js/builtins'\n * const builtins = [b.includes, b.some, b.now, b.days]\n * ```\n *\n * It lists every built-in in src/functions/builtins.ts; tests/runtime-core.test.ts\n * checks that it names each one.\n */\nimport type { Builtin } from '../environment.js'\nimport * as defs from '../functions/builtins.js'\n\nexport const toUpperCase = defs.toUpperCase as unknown as Builtin\nexport const toLowerCase = defs.toLowerCase as unknown as Builtin\nexport const trim = defs.trim as unknown as Builtin\nexport const trimStart = defs.trimStart as unknown as Builtin\nexport const trimEnd = defs.trimEnd as unknown as Builtin\nexport const startsWith = defs.startsWith as unknown as Builtin\nexport const endsWith = defs.endsWith as unknown as Builtin\nexport const includes = defs.includes as unknown as Builtin\nexport const indexOf = defs.indexOf as unknown as Builtin\nexport const lastIndexOf = defs.lastIndexOf as unknown as Builtin\nexport const slice = defs.slice as unknown as Builtin\nexport const split = defs.split as unknown as Builtin\nexport const replace = defs.replace as unknown as Builtin\nexport const replaceAll = defs.replaceAll as unknown as Builtin\nexport const padStart = defs.padStart as unknown as Builtin\nexport const padEnd = defs.padEnd as unknown as Builtin\nexport const repeat = defs.repeat as unknown as Builtin\nexport const at = defs.at as unknown as Builtin\nexport const matches = defs.matches as unknown as Builtin\nexport const toString = defs.toString as unknown as Builtin\nexport const toNumber = defs.toNumber as unknown as Builtin\nexport const round = defs.round as unknown as Builtin\nexport const floor = defs.floor as unknown as Builtin\nexport const ceil = defs.ceil as unknown as Builtin\nexport const trunc = defs.trunc as unknown as Builtin\nexport const abs = defs.abs as unknown as Builtin\nexport const sqrt = defs.sqrt as unknown as Builtin\nexport const clamp = defs.clamp as unknown as Builtin\nexport const toFixed = defs.toFixed as unknown as Builtin\nexport const formatNumber = defs.formatNumber as unknown as Builtin\nexport const formatCurrency = defs.formatCurrency as unknown as Builtin\nexport const min = defs.min as unknown as Builtin\nexport const max = defs.max as unknown as Builtin\nexport const sum = defs.sum as unknown as Builtin\nexport const avg = defs.avg as unknown as Builtin\nexport const map = defs.map as unknown as Builtin\nexport const filter = defs.filter as unknown as Builtin\nexport const find = defs.find as unknown as Builtin\nexport const findIndex = defs.findIndex as unknown as Builtin\nexport const some = defs.some as unknown as Builtin\nexport const every = defs.every as unknown as Builtin\nexport const none = defs.none as unknown as Builtin\nexport const flatMap = defs.flatMap as unknown as Builtin\nexport const sortBy = defs.sortBy as unknown as Builtin\nexport const groupBy = defs.groupBy as unknown as Builtin\nexport const count = defs.count as unknown as Builtin\nexport const reduce = defs.reduce as unknown as Builtin\nexport const sort = defs.sort as unknown as Builtin\nexport const reverse = defs.reverse as unknown as Builtin\nexport const unique = defs.unique as unknown as Builtin\nexport const flat = defs.flat as unknown as Builtin\nexport const first = defs.first as unknown as Builtin\nexport const last = defs.last as unknown as Builtin\nexport const join = defs.join as unknown as Builtin\nexport const isEmpty = defs.isEmpty as unknown as Builtin\nexport const keys = defs.keys as unknown as Builtin\nexport const values = defs.values as unknown as Builtin\nexport const entries = defs.entries as unknown as Builtin\nexport const type = defs.type as unknown as Builtin\nexport const now = defs.now as unknown as Builtin\nexport const timestamp = defs.timestamp as unknown as Builtin\nexport const duration = defs.duration as unknown as Builtin\nexport const weeks = defs.weeks as unknown as Builtin\nexport const days = defs.days as unknown as Builtin\nexport const hours = defs.hours as unknown as Builtin\nexport const minutes = defs.minutes as unknown as Builtin\nexport const seconds = defs.seconds as unknown as Builtin\nexport const milliseconds = defs.milliseconds as unknown as Builtin\nexport const inDays = defs.inDays as unknown as Builtin\nexport const inHours = defs.inHours as unknown as Builtin\nexport const inMinutes = defs.inMinutes as unknown as Builtin\nexport const inSeconds = defs.inSeconds as unknown as Builtin\nexport const inMilliseconds = defs.inMilliseconds as unknown as Builtin\nexport const year = defs.year as unknown as Builtin\nexport const month = defs.month as unknown as Builtin\nexport const day = defs.day as unknown as Builtin\nexport const hour = defs.hour as unknown as Builtin\nexport const minute = defs.minute as unknown as Builtin\nexport const second = defs.second as unknown as Builtin\nexport const dayOfWeek = defs.dayOfWeek as unknown as Builtin\nexport const startOfDay = defs.startOfDay as unknown as Builtin\nexport const startOfMonth = defs.startOfMonth as unknown as Builtin\nexport const startOfYear = defs.startOfYear as unknown as Builtin\nexport const addDays = defs.addDays as unknown as Builtin\nexport const addMonths = defs.addMonths as unknown as Builtin\nexport const addYears = defs.addYears as unknown as Builtin\nexport const formatDate = defs.formatDate as unknown as Builtin\n\nexport type { Builtin } from '../environment.js'\n"],"mappings":";;AAiBA,MAAa,cAAcA;AAC3B,MAAa,cAAcC;AAC3B,MAAa,OAAOC;AACpB,MAAa,YAAYC;AACzB,MAAa,UAAUC;AACvB,MAAa,aAAaC;AAC1B,MAAa,WAAWC;AACxB,MAAa,WAAWC;AACxB,MAAa,UAAUC;AACvB,MAAa,cAAcC;AAC3B,MAAa,QAAQC;AACrB,MAAa,QAAQC;AACrB,MAAa,UAAUC;AACvB,MAAa,aAAaC;AAC1B,MAAa,WAAWC;AACxB,MAAa,SAASC;AACtB,MAAa,SAASC;AACtB,MAAa,KAAKC;AAClB,MAAa,UAAUC;AACvB,MAAa,WAAWC;AACxB,MAAa,WAAWC;AACxB,MAAa,QAAQC;AACrB,MAAa,QAAQC;AACrB,MAAa,OAAOC;AACpB,MAAa,QAAQC;AACrB,MAAa,MAAMC;AACnB,MAAa,OAAOC;AACpB,MAAa,QAAQC;AACrB,MAAa,UAAUC;AACvB,MAAa,eAAeC;AAC5B,MAAa,iBAAiBC;AAC9B,MAAa,MAAMC;AACnB,MAAa,MAAMC;AACnB,MAAa,MAAMC;AACnB,MAAa,MAAMC;AACnB,MAAa,MAAMC;AACnB,MAAa,SAASC;AACtB,MAAa,OAAOC;AACpB,MAAa,YAAYC;AACzB,MAAa,OAAOC;AACpB,MAAa,QAAQC;AACrB,MAAa,OAAOC;AACpB,MAAa,UAAUC;AACvB,MAAa,SAASC;AACtB,MAAa,UAAUC;AACvB,MAAa,QAAQC;AACrB,MAAa,SAASC;AACtB,MAAa,OAAOC;AACpB,MAAa,UAAUC;AACvB,MAAa,SAASC;AACtB,MAAa,OAAOC;AACpB,MAAa,QAAQC;AACrB,MAAa,OAAOC;AACpB,MAAa,OAAOC;AACpB,MAAa,UAAUC;AACvB,MAAa,OAAOC;AACpB,MAAa,SAASC;AACtB,MAAa,UAAUC;AACvB,MAAa,OAAOC;AACpB,MAAa,MAAMC;AACnB,MAAa,YAAYC;AACzB,MAAa,WAAWC;AACxB,MAAa,QAAQC;AACrB,MAAa,OAAOC;AACpB,MAAa,QAAQC;AACrB,MAAa,UAAUC;AACvB,MAAa,UAAUC;AACvB,MAAa,eAAeC;AAC5B,MAAa,SAASC;AACtB,MAAa,UAAUC;AACvB,MAAa,YAAYC;AACzB,MAAa,YAAYC;AACzB,MAAa,iBAAiBC;AAC9B,MAAa,OAAOC;AACpB,MAAa,QAAQC;AACrB,MAAa,MAAMC;AACnB,MAAa,OAAOC;AACpB,MAAa,SAASC;AACtB,MAAa,SAASC;AACtB,MAAa,YAAYC;AACzB,MAAa,aAAaC;AAC1B,MAAa,eAAeC;AAC5B,MAAa,cAAcC;AAC3B,MAAa,UAAUC;AACvB,MAAa,YAAYC;AACzB,MAAa,WAAWC;AACxB,MAAa,aAAaC"}

package/dist/check/checker.mjs

@@ -4,7 +4,7 @@ import { TypeBudgetExceeded, chargeTypeWork, exactObject, fieldOf, freshLiteral,
 import { signatureText } from "../functions/define.mjs";
 import { forEachChild } from "../syntax/ast.mjs";
 import { bindImplicit } from "./bind.mjs";
-import { RESULT_REFINERS } from "../functions/builtins.mjs";
+import { BUILTINS, RESULT_REFINERS } from "../functions/builtins.mjs";
 import { isStackOverflow, tooDeep } from "../runtime/overflow.mjs";
 import { closest, didYouMean } from "../suggest.mjs";
 import { writtenWithExponent } from "../syntax/parser.mjs";
@@ -920,9 +920,25 @@ function analyzeWithin(root, env, options) {
 			return argType;
 		});
 		if (def === void 0) {
-			const alias = Object.hasOwn(FUNCTION_ALIASES, node.name) ? FUNCTION_ALIASES[node.name] : void 0;
-			const suggestion = alias === void 0 ? suggest(node.name, () => env.functionNames()) : /"(?<name>[^"]+)"/u.exec(alias)?.groups?.name;
-			const hint = alias === void 0 ? didYouMean(suggestion) : `; ${alias}`;
+			const excluded = BUILTINS.has(node.name);
+			let alias = !excluded && Object.hasOwn(FUNCTION_ALIASES, node.name) ? FUNCTION_ALIASES[node.name] : void 0;
+			const replacement = alias === void 0 ? void 0 : /"(?<name>[^"]+)"/u.exec(alias)?.groups?.name;
+			let leftOut;
+			if (replacement !== void 0 && env.lookup(replacement) === void 0) {
+				alias = void 0;
+				if (BUILTINS.has(replacement)) leftOut = replacement;
+			}
+			let suggestion;
+			let hint;
+			if (excluded) hint = `; ${node.name} is a built-in this environment does not include (add it to builtins)`;
+			else if (leftOut !== void 0) hint = `; the built-in for this is ${leftOut}, which this environment does not include (add it to builtins)`;
+			else if (alias === void 0) {
+				suggestion = suggest(node.name, () => env.functionNames());
+				hint = didYouMean(suggestion);
+			} else {
+				suggestion = replacement;
+				hint = `; ${alias}`;
+			}
 			report("UNKNOWN_FUNCTION", `Unknown function "${node.name}"${hint}`, {
 				start: node.nameStart ?? node.start,
 				end: node.nameEnd ?? node.end