bonsai-js 0.3.0 → 0.5.0

package/CHANGELOG.md

@@ -5,6 +5,47 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [0.5.0] - 2026-06-02
+
+### Security
+
+- Bounded parser recursion: pathologically nested input (deep parentheses, unary chains) now fails closed with a typed `ExpressionError` ("Maximum expression nesting depth exceeded") instead of overflowing the native call stack with an uncaught `RangeError`. `validate()` reports it as a normal syntax error rather than a stack-overflow message.
+- `maxArrayLength` is now enforced on array-returning methods (`split`, `map`, `flatMap`, `flat`, `concat`, `toSorted`, `toReversed`, `with`, `toSpliced`), not just array literals and spread, in both the sync and async evaluators.
+- Added `maxStringLength` (default 100,000) and enforced it as a ceiling on every string produced by a method call, in both the sync and async evaluators. `padStart`/`padEnd`/`repeat` are checked before allocation (capping the produced length, not just the repeat count); all other string-returning methods (`join`, `concat`, `slice`, `toUpperCase`, ...) are checked on their output. This closes single-operation amplifiers such as `arr.join(sep)`, whose output length is array length times separator length in one native call that the cooperative timeout cannot interrupt.
+
+### Added
+
+- `maxStringLength` option on `bonsai(options)` and a `BonsaiSecurityError('MAX_STRING_LENGTH', ...)` error code.
+- `bonsai(options)` now validates its options and throws a `RangeError`/`TypeError` at construction for out-of-range values (negative `cacheSize`, non-positive `maxDepth`, negative `maxArrayLength`/`maxStringLength`, negative or non-finite `timeout`, allow/deny lists that are not arrays of strings). Previously a negative `cacheSize` silently disabled caching and other bad values failed later with confusing errors.
+
+### Fixed
+
+- Async/sync parity for higher-order array methods (`map`, `filter`, `find`, `some`, `every`, `findIndex`, `flatMap`). Predicates now evaluate sequentially in the async evaluator, matching the synchronous one: `some`/`every`/`find`/`findIndex` short-circuit at the first decisive element, and `maxDepth` is no longer inflated by array length (an expression that succeeded with `evaluateSync` could previously throw a spurious `Maximum expression depth` error with `evaluate`).
+- Malformed numeric literals now raise a parse-time `ExpressionError` instead of silently evaluating to `NaN` or coercing: a base prefix or exponent with no digits (`1e`, `1e+`, `0x`, `0b`, `0o`), and misplaced numeric separators (`1_`, `1__0`, `0xff_`), which are rejected the way JavaScript rejects them.
+- Template interpolations containing string literals or nested template literals with braces (for example `` `${ "x}" }` `` or `` `${ `a}b` }` ``) now parse correctly instead of failing with an "Unterminated string"/"Unterminated template literal" error.
+- Higher-order array helpers now fail loud on a non-function callback instead of silently doing the wrong thing. The lambda shorthand (`.x`, `. > 0`) is a function value; passing it to a function (for example `map(inc(.x))`) evaluates to a plain value, which previously made the stdlib `map`/`filter`/`find`/`some`/`every` transforms silently return the input unchanged and the `.map`/`.filter`/`.find`/`.findIndex`/`.some`/`.every`/`.flatMap` methods throw a raw `TypeError`. Both now throw a typed `BonsaiTypeError` naming the helper. No-argument forms (`|> map`, `|> filter`) are unaffected.
+- Autocomplete no longer suggests `array.toString`, which the evaluator rejects (the method allowlist and the autocomplete catalog now derive from one shared source, so they cannot drift). Method completions also respect `allowedProperties`, matching the evaluator, so a method that would be rejected at runtime is no longer offered.
+- stdlib correctness: `formatDate` now replaces every occurrence of a token (not just the first, so `"YYYY/YYYY"` works); `min`/`max` validate their arguments are numbers and return `undefined` for no arguments instead of leaking `Infinity`/`-Infinity`; `clamp` rejects non-finite bounds and `min > max`; `sort` orders strings by code point for deterministic, locale-independent results. NaN passthrough in the numeric transforms is now documented.
+
+## [0.4.0] - 2026-06-02
+
+### Added
+
+- **Context-aware functions** (`addContextFunction`): register functions that receive the evaluation context as their first parameter (typed `Readonly<TCtx>`, passed by reference), enabling auth/permission/personalization patterns without threading context through expression arguments. Pure and context-aware functions share a single namespace; `isContextFunction(name)` introspects the kind.
+- **Generic context typing** (`bonsai<TCtx>()`): the factory is now generic over context type, with end-to-end type safety through `evaluate`, `evaluateSync`, `compile`, and `addContextFunction`. Backward compatible: defaults to `Record<string, unknown>` when unspecified.
+- New exported types: `ContextFunctionFn`, generic `BonsaiPlugin<TCtx>`, generic `CompiledExpression<TCtx>`, generic `BonsaiInstance<TCtx>`.
+- Internal: pure and context-aware functions share one tagged registry, and the cached `Bindings` snapshot consolidates transforms and that registry into a single object passed to the evaluator.
+
+### Resolves
+
+- #33: context access from registered functions.
+
+### Credits
+
+- Thanks to @jaenyf for raising #33 and contributing PR #34.
+
 ## [0.3.0] - 2026-03-21
 
 ### Added
@@ -58,11 +99,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Bare dot identity lambda:** `. > 2` and `. * 10` now work as lambda shorthand for the current item itself, in both method calls and pipe transforms (e.g., `[1,2,3,4].filter(. > 2)`, `[1,2,3] |> map(. * 10)`)
 - Async-safe evaluation for all higher-order array methods — lambda predicates that return Promises are correctly resolved in both top-level and nested contexts via `evaluate()`
 - Documentation for array methods, lambda shorthand, and method chaining in README and website docs
-
-## [Unreleased]
-
-### Added
-
 - Deterministic property-based parser and evaluator invariant tests
 - Random fuzz coverage for malformed parser input
 - Adversarial regression tests for deep nesting, oversized arrays, nested blocked keys, and spread misuse

package/README.md

@@ -125,6 +125,58 @@ expr.addFunction('lookupTier', async (userId) => {
 await expr.evaluate('lookupTier(userId) == "pro"', { userId: 'u_123' })
 ```
 
+### Context-aware functions
+
+Register functions that read the evaluation context directly. The function
+receives the evaluation context as its first parameter (typed read-only), so
+you can keep expressions terse and let the function pull what it needs:
+
+```ts
+import { bonsai } from 'bonsai-js'
+
+interface AppContext {
+  currentUserId: string
+  perms: readonly string[]
+}
+
+const app = bonsai<AppContext>()
+
+app.addContextFunction('lookupCurrentUserTier', async (ctx) => {
+  const row = await db.users.findById(ctx.currentUserId)
+  return row?.tier ?? 'free'
+})
+
+app.addContextFunction('hasPermission', (ctx, action) =>
+  ctx.perms.includes(String(action)))
+
+await app.evaluate(
+  'lookupCurrentUserTier() == "pro" && hasPermission("admin")',
+  { currentUserId: 'u_123', perms: ['admin', 'write'] },
+)
+```
+
+The instance is generic over the context type (`bonsai<AppContext>()`), giving
+you end-to-end type safety: `ctx` is typed inside the function, and the call
+site is type-checked against the same shape. If your context type has required
+fields, TypeScript also requires you to pass the `context` argument to
+`evaluate`, `evaluateSync`, and compiled-expression evaluation.
+
+The context is passed to your function by reference, not copied or frozen. The
+`Readonly<TCtx>` parameter type signals that you should treat it as read-only:
+TypeScript flags reassigning its top-level fields. Bonsai does not deep-freeze
+it, so nested mutation and writes from untyped JavaScript reach the object you
+passed in. If you need isolation between evaluations, pass a fresh context
+object each time.
+
+Pure functions (`addFunction`) and context-aware functions (`addContextFunction`)
+share a single namespace. Registering the same name with either method
+overwrites the prior registration, so re-registering a context-aware name with
+`addFunction` turns it back into a pure function (check `isContextFunction(name)`
+if the kind matters). Functions registered with `addFunction` never receive the
+context; reach for `addContextFunction` when a function needs it. Plugins typed
+against a minimal context requirement can still be applied to instances with a
+wider context shape.
+
 ### Editor validation
 
 ```ts
@@ -151,6 +203,8 @@ Inside array methods, `.` refers to the current item:
 
 Compound predicates work too: `.age >= 18 && .active`
 
+A lambda is built from the accessor plus operators, member access, and methods. The shorthand is itself a function value, so it cannot be passed *into* another function call: `map(myFn(.x))` does not mean `map(item => myFn(item.x))` and will throw a `BonsaiTypeError`. To transform each item through a function, chain instead: `items |> map(.x) |> map(myFn)` (or `items.map(.x).map(myFn)`).
+
 ### Pipe transforms (via stdlib)
 
 ```ts
@@ -244,13 +298,15 @@ const expr = bonsai(options?: BonsaiOptions)
 | --- | --- | --- | --- |
 | `timeout` | `number` | `0` | Evaluation timeout in milliseconds. `0` disables the timeout check. |
 | `maxDepth` | `number` | `100` | Maximum evaluation depth before throwing `BonsaiSecurityError('MAX_DEPTH', ...)`. |
-| `maxArrayLength` | `number` | `100000` | Maximum array literal or expanded spread size. |
-| `cacheSize` | `number` | `256` | Per-instance cache size for compiled expressions and parsed AST reuse. |
+| `maxArrayLength` | `number` | `100000` | Maximum array size produced during evaluation, including array literals, expanded spread, and array-returning methods (`split`, `map`, `flat`, `concat`, ...). Exceeding it throws `BonsaiSecurityError('MAX_ARRAY_LENGTH', ...)`. |
+| `maxStringLength` | `number` | `100000` | Maximum string size produced by a string-returning method (`padStart`, `padEnd`, `repeat`, `join`, `concat`, `slice`, ...). Applies to the produced length (e.g. `arr.join(sep)` is bounded by its full output, not just the inputs). Exceeding it throws `BonsaiSecurityError('MAX_STRING_LENGTH', ...)`. |
+| `cacheSize` | `number` | `256` | Per-instance cache size for compiled expressions and parsed AST reuse. `0` disables caching. |
 | `allowedProperties` | `string[]` | `undefined` | Whitelist of allowed member/method names. Does not apply to root identifiers or object-literal keys. |
 | `deniedProperties` | `string[]` | `undefined` | Denylist of blocked member/method names. Does not apply to root identifiers or object-literal keys. |
 
 Important notes:
 
+- Options are validated at construction: out-of-range values (a negative `cacheSize`, a non-positive `maxDepth`, a negative size limit, a negative/non-finite `timeout`) throw a `RangeError`/`TypeError` immediately rather than failing silently later.
 - `allowedProperties` and `deniedProperties` apply to **member access** (`obj.name`) and **method calls** (`str.slice()`), not root identifiers (`name`) or object-literal keys (`{ name: value }`).
 - If you whitelist `user.name`, you must allow both `user` and `name` as member names.
 - Numeric array indices (e.g., `items[0]`) bypass allow/deny lists automatically.
@@ -361,20 +417,25 @@ evaluateExpression<number>('x * 2', { x: 21 }) // 42
 ## Instance Methods
 
 ```ts
-interface BonsaiInstance {
-  use(plugin: BonsaiPlugin): this
+type EvaluationContextArgs<TCtx extends object = Record<string, unknown>> =
+  {} extends TCtx ? [context?: TCtx] : [context: TCtx]
+
+interface BonsaiInstance<TCtx extends object = Record<string, unknown>> {
+  use(plugin: BonsaiPlugin<TCtx>): this
   addTransform(name: string, fn: TransformFn): this
   addFunction(name: string, fn: FunctionFn): this
+  addContextFunction(name: string, fn: ContextFunctionFn<TCtx>): this
   removeTransform(name: string): boolean
   removeFunction(name: string): boolean
   hasTransform(name: string): boolean
   hasFunction(name: string): boolean
+  isContextFunction(name: string): boolean
   listTransforms(): string[]
   listFunctions(): string[]
   clearCache(): void
-  compile(expression: string): CompiledExpression
-  evaluate<T = unknown>(expression: string, context?: Record<string, unknown>): Promise<T>
-  evaluateSync<T = unknown>(expression: string, context?: Record<string, unknown>): T
+  compile(expression: string): CompiledExpression<TCtx>
+  evaluate<T = unknown>(expression: string, ...args: EvaluationContextArgs<TCtx>): Promise<T>
+  evaluateSync<T = unknown>(expression: string, ...args: EvaluationContextArgs<TCtx>): T
   validate(expression: string): ValidationResult
 }
 ```
@@ -382,9 +443,12 @@ interface BonsaiInstance {
 Method notes:
 
 - `use()` runs a plugin immediately and returns the same instance.
-- `addTransform()` and `addFunction()` overwrite any existing registration with the same name.
-- `listTransforms()` and `listFunctions()` return the currently registered names.
+- `addTransform()`, `addFunction()`, and `addContextFunction()` overwrite any existing registration with the same name. Pure and context-aware functions share a single namespace.
+- `addContextFunction()` registers a function that receives the live evaluation context as its first argument (typed read-only; passed by reference, not copied or frozen). See [Context-aware functions](#context-aware-functions).
+- `isContextFunction()` returns `true` if the named function was registered via `addContextFunction()`.
+- `listTransforms()` and `listFunctions()` return the currently registered names. `listFunctions()` includes both pure and context-aware functions.
 - `clearCache()` clears the internal AST cache and compiled-expression cache. It does not remove registered transforms/functions.
+- Pass a context type generic to `bonsai<MyContext>()` for end-to-end type safety: `evaluate`, `evaluateSync`, `addContextFunction`, `compile`, and `use` all propagate the type. If `MyContext` has required fields, TypeScript requires a context argument when evaluating.
 
 ## Extending the Runtime
 
@@ -470,6 +534,12 @@ Modules:
 | `dates` | function `now`; transforms `formatDate`, `diffDays` |
 | `all` | registers every stdlib module above |
 
+Notes on stdlib semantics:
+
+- **`sort`** orders strings by code point (not locale), so results are deterministic across runtimes and locales. Numbers sort numerically.
+- **`min`/`max`** validate that every argument is a number and return `undefined` for no arguments (rather than `Infinity`/`-Infinity`). **`clamp`** requires finite bounds with `min <= max`.
+- **`NaN` is passed through** by the numeric transforms (`sum`, `avg`, `round`, etc.): a `NaN` input yields a `NaN` result (which serializes to `null` in JSON). Validate inputs upstream if you need to reject non-finite numbers.
+
 ## Error Handling
 
 Runtime exports:
@@ -532,7 +602,8 @@ Bonsai is designed to safely evaluate expressions, but it is not a process sandb
 What Bonsai does:
 
 - blocks access to `__proto__`, `constructor`, and `prototype` at every access level, even if explicitly allowed
-- enforces `maxDepth`, `maxArrayLength`, and optional `timeout`
+- enforces `maxDepth`, `maxArrayLength`, `maxStringLength`, and optional `timeout`
+- bounds parser recursion so pathologically nested input fails closed with a typed `ExpressionError` instead of overflowing the call stack
 - lets you allowlist or denylist member/method names via `allowedProperties`/`deniedProperties`
 - prevents expressions from reaching globals or importing modules
 - looks up root identifiers via own-property checks only (`Object.hasOwn`), so context prototype chains cannot leak
@@ -544,7 +615,7 @@ What Bonsai does:
 Important operational caveats:
 
 - `allowedProperties` and `deniedProperties` apply to member access (`obj.name`) and method calls (`str.slice()`), not root identifiers (`name`) or object-literal keys (`{ name: value }`)
-- `timeout` is cooperative and checked during evaluator traversal; it cannot forcibly interrupt arbitrary synchronous code inside your own custom transforms/functions
+- `timeout` is cooperative and checked at evaluator step boundaries (not inside a single native operation); it cannot forcibly interrupt arbitrary synchronous code inside your own custom transforms/functions, so the size limits (`maxArrayLength`, `maxStringLength`) are the primary guard against single-operation resource exhaustion
 - async transforms/functions are bounded only at awaited boundaries
 - custom transforms/functions/plugins are trusted host code
 
@@ -725,8 +796,8 @@ interface Completion {
 
 Bonsai follows SemVer for the documented package entrypoints `bonsai-js`, `bonsai-js/stdlib`, and `bonsai-js/autocomplete`.
 
-- Supported runtimes are Node 20+ and current Bun releases.
-- The packed npm artifact is smoke-tested on Node 20 and 22.
+- Supported runtimes are Node 22+ and current Bun releases.
+- The packed npm artifact is smoke-tested on Node 22 and 24.
 - Internal modules under `src/*` are not public API.
 
 See [stability policy](./docs/stability-policy.md) for the compatibility boundary and release rules.

package/dist/autocomplete/index.d.mts

@@ -1,4 +1,4 @@
-import { c as InferredTypeName, n as BonsaiInstance } from "../types-BhsZZsLY.mjs";
+import { r as BonsaiInstance, u as InferredTypeName } from "../types-DkXfy5IJ.mjs";
 
 //#region src/autocomplete/tokenizer.d.ts
 /** Known phases where errors can occur during completion. */

package/dist/autocomplete/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/autocomplete/tokenizer.ts","../../src/autocomplete/completions.ts","../../src/autocomplete/index.ts"],"mappings":";;;;KAcY,eAAA;AAAA,KAOA,YAAA,IAAgB,KAAA,WAAgB,KAAA,EAAO,eAAA;;;KCd9C,gBAAA;EACC,UAAA;EAAwB,YAAA;AAAA;EACxB,UAAA;EAAoB,YAAA;AAAA;AAAA,UAEhB,cAAA;EACR,KAAA;EACA,IAAA;EACA,MAAA;EDO0C;ECL1C,YAAA;AAAA;AAAA,KAGU,UAAA,GAAa,cAAA,GAAiB,gBAAA;;;UCTzB,mBAAA;EACf,OAAA,GAAU,MAAA;EFGe;;AAO3B;;;;EEHE,cAAA,GAAiB,MAAA,SAAe,gBAAA;EFGiB;;;EECjD,OAAA,GAAU,YAAA;AAAA;AAAA,UAGK,oBAAA;EACf,QAAA,CAAS,UAAA,UAAoB,MAAA,WAAiB,UAAA;EAC9C,UAAA,CAAW,OAAA,EAAS,MAAA;AAAA;AAAA,iBAcN,kBAAA,CACd,QAAA,EAAU,cAAA,EACV,OAAA,GAAS,mBAAA,GACR,oBAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/autocomplete/tokenizer.ts","../../src/autocomplete/completions.ts","../../src/autocomplete/index.ts"],"mappings":";;;;KAcY,eAAA;AAAA,KAOA,YAAA,IAAgB,KAAA,WAAgB,KAAA,EAAO,eAAe;;;KCd7D,gBAAA;EACC,UAAA;EAAwB,YAAA;AAAA;EACxB,UAAA;EAAoB,YAAA;AAAA;AAAA,UAEhB,cAAA;EACR,KAAA;EACA,IAAA;EACA,MAAA;EDO0C;ECL1C,YAAA;AAAA;AAAA,KAGU,UAAA,GAAa,cAAA,GAAiB,gBAAgB;;;UCTzC,mBAAA;EACf,OAAA,GAAU,MAAA;EFGe;AAAA;AAO3B;;;;EEHE,cAAA,GAAiB,MAAA,SAAe,gBAAA;EFGiB;;;EECjD,OAAA,GAAU,YAAA;AAAA;AAAA,UAGK,oBAAA;EACf,QAAA,CAAS,UAAA,UAAoB,MAAA,WAAiB,UAAA;EAC9C,UAAA,CAAW,OAAA,EAAS,MAAM;AAAA;AAAA,iBAcZ,kBAAA,CACd,QAAA,EAAU,cAAA,EACV,OAAA,GAAS,mBAAA,GACR,oBAAA"}

package/dist/autocomplete/index.mjs

@@ -1,5 +1,5 @@
-import { i as ExpressionError, n as BonsaiSecurityError, r as BonsaiTypeError, t as BonsaiReferenceError } from "../errors-t5i9AEaf.mjs";
-import { i as tokenize, t as BLOCKED_PROPERTIES } from "../execution-context-DqYC3L92.mjs";
+import { i as ExpressionError, n as BonsaiSecurityError, r as BonsaiTypeError, t as BonsaiReferenceError } from "../errors-CCZDd1gK.mjs";
+import { a as methodsForReceiverType, o as tokenize, t as BLOCKED_PROPERTIES } from "../execution-context-b6FBfEdv.mjs";
 //#region src/autocomplete/tokenizer.ts
 function tolerantTokenize(expression, cursor, onError) {
 	if (expression.length === 0) return {
@@ -66,7 +66,7 @@ function isCursorInsideString(expression, cursor) {
 	}
 	return inSingle || inDouble || inTemplate && templateDepth === 0;
 }
-const TOKEN_RE = /\?\.|\.\.\.|\|>|\?\?|&&|\|\||[!=<>]=?|[+\-*/%]|\*\*|[.(){}[\],?:]|"(?:[^"\\]|\\.)*"?|'(?:[^'\\]|\\.)*'?|`(?:[^`\\$]|\\.|\$(?!\{))*`?|\d[\d_]*(?:\.\d[\d_]*)?(?:[eE][+-]?\d+)?|[a-zA-Z_$][\w$]*/g;
+const TOKEN_RE = /\?\.|\.\.\.|\|>|\?\?|&&|\|\||[!=<>]=?|[+\-*/%]|\*\*|[.(){}[\],?:]|"(?:[^"\\]|\\.)*"?|'(?:[^'\\]|\\.)*'?|`(?:[^`\\$]|\\.|\$(?!\{))*`?|\d[\d_]*(?:\.\d[\d_]*)?(?:[eE][+-]?\d+)?|[a-zA-Z_$][\w$]*/gu;
 function regexScan(expression, cursor) {
 	const tokens = [];
 	const text = expression.slice(0, cursor);
@@ -121,13 +121,13 @@ function classifyToken(value, start, end) {
 		start,
 		end
 	};
-	if (/^[a-zA-Z_$]/.test(value)) return {
+	if (/^[a-zA-Z_$]/u.test(value)) return {
 		type: "Identifier",
 		value,
 		start,
 		end
 	};
-	if (/^\d/.test(value)) return {
+	if (/^\d/u.test(value)) return {
 		type: "Number",
 		value,
 		start,
@@ -279,56 +279,15 @@ function buildLambdaState(tokens) {
 }
 //#endregion
 //#region src/autocomplete/catalog.ts
-/** Methods allowed per receiver type. Must stay in sync with isAllowedReceiver in eval-ops.ts. */
+/**
+* Methods offered per receiver type, derived from the shared SAFE_METHODS
+* allowlist (src/safe-methods.ts) so autocomplete and the evaluator can never
+* disagree about what is callable.
+*/
 const METHODS_BY_TYPE = {
-	string: [
-		"trim",
-		"trimStart",
-		"trimEnd",
-		"toLowerCase",
-		"toUpperCase",
-		"startsWith",
-		"endsWith",
-		"includes",
-		"indexOf",
-		"lastIndexOf",
-		"slice",
-		"substring",
-		"at",
-		"replace",
-		"replaceAll",
-		"split",
-		"padStart",
-		"padEnd",
-		"charAt",
-		"charCodeAt",
-		"repeat",
-		"concat",
-		"toString"
-	],
-	array: [
-		"filter",
-		"map",
-		"find",
-		"findIndex",
-		"some",
-		"every",
-		"flatMap",
-		"join",
-		"flat",
-		"includes",
-		"indexOf",
-		"lastIndexOf",
-		"slice",
-		"at",
-		"concat",
-		"toReversed",
-		"toSorted",
-		"toSpliced",
-		"with",
-		"toString"
-	],
-	number: ["toFixed", "toString"]
+	string: methodsForReceiverType("string"),
+	array: methodsForReceiverType("array"),
+	number: methodsForReceiverType("number")
 };
 /** Return type keyed by "receiverType.method" to disambiguate shared method names. */
 const RETURN_TYPES = {
@@ -374,7 +333,6 @@ const RETURN_TYPES = {
 	"array.includes": "boolean",
 	"array.at": "unknown",
 	"array.with": "array",
-	"array.toString": "string",
 	"number.toFixed": "string",
 	"number.toString": "string"
 };
@@ -560,9 +518,12 @@ function addMethodCompletions(results, env) {
 	if (!type || !isMethodReceiverType(type)) return;
 	const cached = METHOD_COMPLETIONS_BY_TYPE[type];
 	if (!cached) return;
-	if (env.policy.deniedProperties) {
-		for (const c of cached) if (!env.policy.deniedProperties.has(c.label)) results.push(c);
-	} else for (const c of cached) results.push(c);
+	const { allowedProperties, deniedProperties } = env.policy;
+	for (const c of cached) {
+		if (allowedProperties && !allowedProperties.has(c.label)) continue;
+		if (deniedProperties && deniedProperties.has(c.label)) continue;
+		results.push(c);
+	}
 }
 function addLambdaPropertyCompletions(results, env) {
 	if (!env.lambda?.elementProperties) return;
@@ -686,7 +647,7 @@ function comparator(a, b) {
 }
 //#endregion
 //#region src/autocomplete/index.ts
-const VALID_IDENTIFIER = /^[a-zA-Z_$][\w$]*$/;
+const VALID_IDENTIFIER = /^[a-zA-Z_$][\w$]*$/u;
 /** Check if an error is an expected Bonsai error (syntax, security, type, or reference). */
 function isExpectedError(err) {
 	return err instanceof ExpressionError || err instanceof BonsaiSecurityError || err instanceof BonsaiTypeError || err instanceof BonsaiReferenceError;
@@ -962,9 +923,9 @@ function probeAcceptedTransforms(instance, inputType, cache, currentTransforms,
 	return accepted;
 }
 function inferPipeInputType(expression, cursor, instance, context, onError) {
-	const pipeMatch = expression.slice(0, cursor).match(/^(.*)\|>\s*\w*\s*$/s);
+	const pipeMatch = expression.slice(0, cursor).match(/^(?<input>.*)\|>\s*\w*\s*$/su);
 	if (!pipeMatch) return void 0;
-	const exprBefore = pipeMatch[1].trim();
+	const exprBefore = (pipeMatch.groups?.input ?? "").trim();
 	if (!exprBefore) return void 0;
 	try {
 		const result = instance.evaluateSync(exprBefore, context);