@barefootjs/xslate 0.8.0 → 0.9.1

package/src/adapter/xslate-adapter.ts

@@ -39,6 +39,7 @@ import type {
   CompilerError,
   TypeInfo,
   TemplatePrimitiveRegistry,
+  IRMetadata,
 } from '@barefootjs/jsx'
 import {
   BaseAdapter,
@@ -59,8 +60,12 @@ import {
   emitParsedExpr,
   emitIRNode,
   emitAttrValue,
+  augmentInheritedPropAccesses,
+  parseRecordIndexAccess,
+  evalStringArrayJoin,
 } from '@barefootjs/jsx'
 import { isAriaBooleanAttr, isBooleanResultExpr } from './boolean-result'
+import ts from 'typescript'
 
 /**
  * Xslate adapter's IRNode render context. Like the Mojo adapter, Kolon's
@@ -108,6 +113,25 @@ const XSLATE_PRIMITIVE_EMIT_MAP: Record<string, (args: string[]) => string> =
  * AttrValue `kind` discriminator so adapter code stays type-safe if the IR
  * shape evolves.
  */
+/**
+ * Escape a string for a Kolon/Perl single-quoted literal: backslash first
+ * (so it doesn't double-escape the quote we add next), then the quote. Used
+ * by every `'…'` hashref key/value emitter below.
+ */
+function escapeKolonSingleQuoted(s: string): string {
+  return s.replace(/\\/g, '\\\\').replace(/'/g, "\\'")
+}
+
+/**
+ * Quote a hashref KEY for Kolon when it isn't a bare-identifier-safe name.
+ * Kolon parses `data-slot` as `data - slot` (subtraction) and faults on the
+ * undefined `data` symbol, so a hyphenated key (`data-slot`, `aria-label`)
+ * must be single-quoted: `'data-slot'`. Bare identifiers pass through unquoted.
+ */
+function kolonHashKey(name: string): string {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) ? name : `'${escapeKolonSingleQuoted(name)}'`
+}
+
 function resolveJsxChildrenProp(props: readonly IRProp[]): IRNode[] {
   const prop = props.find(p => p.name === 'children')
   if (!prop) return []
@@ -159,6 +183,33 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
    */
   private stringValueNames: Set<string> = new Set()
 
+  /**
+   * Module-scope pure-string consts (`const x = 'literal'`), keyed by name →
+   * unescaped value. A className template literal that references such a const
+   * (`className={`${x} ${className}`}`) must inline the literal: the const is
+   * module-scope, so it never reaches the per-render template stash and a bare
+   * `$x` reference would render empty. Mirrors the Mojo adapter's
+   * `moduleStringConsts` fix.
+   */
+  private moduleStringConsts: Map<string, string> = new Map()
+
+  /**
+   * Local + module constants from the IR, used by the conditional-spread and
+   * `Record<staticKeys, scalar>[propKey]` lowering paths (#textarea / #checkbox).
+   * Stashed at `generate()` entry so `emitSpread` can resolve a bare local
+   * const (`const sizeAttrs = size ? {…} : {}`) to its initializer text.
+   */
+  private localConstants: IRMetadata['localConstants'] = []
+
+  /**
+   * Optional, no-default props that are `undef` when the caller omits them.
+   * Their bare-reference attribute emission is guarded with Kolon `defined` so
+   * the attribute DROPS rather than rendering `attr=""` (Hono-style nullish
+   * omission, e.g. textarea's `rows`). The filter excludes destructure-
+   * defaulted, rest, and concrete-primitive props.
+   */
+  private nullableOptionalProps: Set<string> = new Set()
+
   constructor(options: XslateAdapterOptions = {}) {
     super()
     this.options = {
@@ -170,7 +221,25 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
   generate(ir: ComponentIR, options?: AdapterGenerateOptions): AdapterOutput {
     this.componentName = ir.metadata.componentName
     this.propsObjectName = ir.metadata.propsObjectName ?? null
+    // (#checkbox) Enumerate the props-object pattern's inherited attribute
+    // accesses (`props.className`/`id`/`disabled`) into propsParams via the
+    // shared helper, before deriving `nullableOptionalProps` below.
+    augmentInheritedPropAccesses(ir)
     this.propsParams = ir.metadata.propsParams.map(p => ({ name: p.name }))
+    this.localConstants = ir.metadata.localConstants ?? []
+    // Bare references to optional, no-default, non-primitive props (e.g.
+    // textarea's `rows`) are `undef` when omitted → `defined`-guarded in
+    // `emitExpression`. See the `nullableOptionalProps` field docstring.
+    this.nullableOptionalProps = new Set(
+      ir.metadata.propsParams
+        .filter(
+          p =>
+            p.defaultValue === undefined &&
+            !p.isRest &&
+            p.type?.kind !== 'primitive',
+        )
+        .map(p => p.name),
+    )
     // Record string-typed signals and props so equality comparisons against
     // them lower to `eq`/`ne`. A signal is string-typed when its inferred
     // type is `string` (or, defensively, when its initial value is a bare
@@ -184,6 +253,7 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
     for (const p of ir.metadata.propsParams) {
       if (isStringTypeInfo(p.type)) this.stringValueNames.add(p.name)
     }
+    this.moduleStringConsts = collectModuleStringConsts(ir.metadata.localConstants)
     this.errors = []
     this.childrenCaptureCounter = 0
 
@@ -653,12 +723,12 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
    * below, not threaded through the hashref entry list.
    */
   private readonly componentPropEmitter: AttrValueEmitter = {
-    emitLiteral: (value, name) => `${name} => '${value.value}'`,
+    emitLiteral: (value, name) => `${kolonHashKey(name)} => '${value.value}'`,
     emitExpression: (value, name) => {
       if (value.parts) {
-        return `${name} => ${this.convertTemplateLiteralPartsToKolon(value.parts)}`
+        return `${kolonHashKey(name)} => ${this.convertTemplateLiteralPartsToKolon(value.parts)}`
       }
-      return `${name} => ${this.convertExpressionToKolon(value.expr)}`
+      return `${kolonHashKey(name)} => ${this.convertExpressionToKolon(value.expr)}`
     },
     emitSpread: (value) => {
       // Kolon hashrefs can't be splatted into the entry list the way Perl
@@ -670,9 +740,9 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
       return this.convertExpressionToKolon(value.expr)
     },
     emitTemplate: (value, name) =>
-      `${name} => ${this.convertTemplateLiteralPartsToKolon(value.parts)}`,
-    emitBooleanAttr: (_value, name) => `${name} => 1`,
-    emitBooleanShorthand: (_value, name) => `${name} => 1`,
+      `${kolonHashKey(name)} => ${this.convertTemplateLiteralPartsToKolon(value.parts)}`,
+    emitBooleanAttr: (_value, name) => `${kolonHashKey(name)} => 1`,
+    emitBooleanShorthand: (_value, name) => `${kolonHashKey(name)} => 1`,
     // JSX children flow through the Kolon macro capture below; they're not
     // part of the hashref entry list.
     emitJsxChildren: () => '',
@@ -824,6 +894,34 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
       if (this.refuseUnsupportedAttrExpression(value.expr, name)) {
         return ''
       }
+      // Hono-style nullish omission: a bare reference to an optional,
+      // no-default prop (`nullableOptionalProps`) is `defined`-guarded so the
+      // attribute drops instead of rendering `attr=""`. Narrowly scoped to bare
+      // identifiers — member exprs, calls, and concrete/defaulted props are
+      // unaffected.
+      const bareId = value.expr.trim()
+      // Normalize a props-object access (`props.id`) to its bare prop name
+      // (`id`) so the nullable-optional set — keyed by bare name — matches the
+      // SolidJS props-object pattern, not just destructured params.
+      const normalizedBareId =
+        this.propsObjectName && bareId.startsWith(`${this.propsObjectName}.`)
+          ? bareId.slice(this.propsObjectName.length + 1)
+          : bareId
+      if (
+        !isBooleanAttr(name) &&
+        !value.presenceOrUndefined &&
+        /^[A-Za-z_$][\w$]*$/.test(normalizedBareId) &&
+        this.nullableOptionalProps.has(normalizedBareId)
+      ) {
+        const perl = this.convertExpressionToKolon(value.expr)
+        const body =
+          isBooleanResultExpr(value.expr) || isAriaBooleanAttr(name)
+            ? `${name}="<: $bf.bool_str(${perl}) :>"`
+            : `${name}="<: ${perl} :>"`
+        // Kolon `:` line directives must each stand alone on their own line, so
+        // wrap in newlines (`normalizeHTML` collapses the surrounding space).
+        return `\n: if (defined ${perl}) {\n${body}\n: }\n`
+      }
       if (isBooleanAttr(name) || value.presenceOrUndefined) {
         // Boolean attributes: render conditionally (present or absent).
         return `<: ${this.convertExpressionToKolon(value.expr)} ? '${name}' : '' :>`
@@ -856,6 +954,35 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
         )
         return `<: $bf.spread_attrs({${entries.join(', ')}}) | mark_raw :>`
       }
+      // Conditional inline-object spread (#textarea):
+      //   `{...(COND ? { 'aria-describedby': describedBy } : {})}`
+      // Emit a Kolon inline ternary of hashrefs — Perl truthiness handles the
+      // condition for free, and the falsy `{}` branch OMITS the key
+      // (`spread_attrs` does NOT emit empty hashref entries).
+      const ternaryHashref = this.conditionalSpreadToKolon(trimmed)
+      if (ternaryHashref !== null) {
+        return `<: $bf.spread_attrs(${ternaryHashref}) | mark_raw :>`
+      }
+      // Function-scope local const holding a conditional inline-object
+      //   `const sizeAttrs = size ? {…} : {}` then `{...sizeAttrs}`
+      // (#checkbox / icon). Resolve the bare identifier to its initializer text
+      // and route through the same conditional-spread lowering. Only
+      // function-scope (`!isModule`) consts whose value is NOT itself a bare
+      // identifier (loop guard) are considered.
+      if (/^[A-Za-z_$][\w$]*$/.test(trimmed)) {
+        const localConst = (this.localConstants ?? []).find(
+          c => c.name === trimmed && !c.isModule,
+        )
+        if (localConst?.value !== undefined) {
+          const initTrimmed = localConst.value.trim()
+          if (!/^[A-Za-z_$][\w$]*$/.test(initTrimmed)) {
+            const resolved = this.conditionalSpreadToKolon(initTrimmed)
+            if (resolved !== null) {
+              return `<: $bf.spread_attrs(${resolved}) | mark_raw :>`
+            }
+          }
+        }
+      }
       const perlExpr = this.convertExpressionToKolon(value.expr)
       return `<: $bf.spread_attrs(${perlExpr}) | mark_raw :>`
     },
@@ -1090,6 +1217,98 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
     return true
   }
 
+  /**
+   * Lower a conditional inline-object spread
+   *   `COND ? { 'aria-describedby': describedBy } : {}`
+   * to a Kolon inline ternary of hashrefs
+   *   `$describedBy ? { 'aria-describedby' => $describedBy } : {}`.
+   * Both branches must be object literals; the condition + values route through
+   * `convertExpressionToKolon`. Returns `null` for any other shape so the caller
+   * falls back to its normal lowering. Mirror of `conditionalSpreadToPerl`.
+   */
+  private conditionalSpreadToKolon(expr: string): string | null {
+    const sf = ts.createSourceFile('__spread.ts', `(${expr})`, ts.ScriptTarget.Latest, true)
+    if (sf.statements.length !== 1) return null
+    const stmt = sf.statements[0]
+    if (!ts.isExpressionStatement(stmt)) return null
+    let node: ts.Expression = stmt.expression
+    while (ts.isParenthesizedExpression(node)) node = node.expression
+    if (!ts.isConditionalExpression(node)) return null
+    const unwrap = (e: ts.Expression): ts.Expression => {
+      let n = e
+      while (ts.isParenthesizedExpression(n)) n = n.expression
+      return n
+    }
+    const whenTrue = unwrap(node.whenTrue)
+    const whenFalse = unwrap(node.whenFalse)
+    if (!ts.isObjectLiteralExpression(whenTrue) || !ts.isObjectLiteralExpression(whenFalse)) {
+      return null
+    }
+    const condPerl = this.convertExpressionToKolon(node.condition.getText(sf))
+    const truePerl = this.objectLiteralToKolonHashref(whenTrue, sf)
+    const falsePerl = this.objectLiteralToKolonHashref(whenFalse, sf)
+    if (truePerl === null || falsePerl === null) return null
+    return `${condPerl} ? ${truePerl} : ${falsePerl}`
+  }
+
+  /**
+   * Convert a static object literal into a Kolon hashref string for a
+   * conditional spread. Only static string/identifier keys are allowed; values
+   * resolve via `convertExpressionToKolon` (or the `Record[propKey]` index
+   * lowering). Returns `null` for any computed/spread/dynamic key. Empty object
+   * → `{}`. Mirror of `objectLiteralToPerlHashref`.
+   */
+  private objectLiteralToKolonHashref(
+    obj: ts.ObjectLiteralExpression,
+    sf: ts.SourceFile,
+  ): string | null {
+    const entries: string[] = []
+    for (const prop of obj.properties) {
+      if (!ts.isPropertyAssignment(prop)) return null
+      let key: string
+      if (ts.isIdentifier(prop.name)) {
+        key = prop.name.text
+      } else if (ts.isStringLiteral(prop.name) || ts.isNoSubstitutionTemplateLiteral(prop.name)) {
+        key = prop.name.text
+      } else {
+        return null
+      }
+      const initNode = (() => {
+        let n: ts.Expression = prop.initializer
+        while (ts.isParenthesizedExpression(n)) n = n.expression
+        return n
+      })()
+      const indexed = this.recordIndexAccessToKolon(initNode)
+      const valPerl =
+        indexed !== null
+          ? indexed
+          : this.convertExpressionToKolon(prop.initializer.getText(sf))
+      entries.push(`'${escapeKolonSingleQuoted(key)}' => ${valPerl}`)
+    }
+    return entries.length === 0 ? '{}' : `{ ${entries.join(', ')} }`
+  }
+
+  /**
+   * Lower a spread-object VALUE of the form `IDENT[KEY]` (CheckIcon's
+   * `sizeMap[size]`) to an inline indexed Kolon hashref
+   *   `{ 'sm' => 16, 'md' => 20, ... }[$size]`.
+   * Reuses the shared structural parse (`parseRecordIndexAccess`); this wrapper
+   * only does the single-quote escaping + Kolon index emit. NB: Kolon indexes a
+   * hashref literal with bracket syntax `{…}[$key]`, NOT Perl's arrow-deref
+   * `{…}->{$key}` (which Kolon's parser rejects) — this is the one divergence
+   * from the Mojo `recordIndexAccessToPerl` emit.
+   */
+  private recordIndexAccessToKolon(val: ts.Expression): string | null {
+    const parsed = parseRecordIndexAccess(val, this.localConstants ?? [], this.propsParams)
+    if (!parsed) return null
+    const entries = parsed.entries.map(e => {
+      const mapVal =
+        e.value.kind === 'number' ? e.value.text : `'${escapeKolonSingleQuoted(e.value.text)}'`
+      return `'${escapeKolonSingleQuoted(e.key)}' => ${mapVal}`
+    })
+    return `{ ${entries.join(', ')} }[$${parsed.indexPropName}]`
+  }
+
   private convertExpressionToKolon(expr: string): string {
     // Parse-first lowering — parity with the Mojo adapter's
     // `convertExpressionToPerl`. Parse the JS expression once, gate it on the
@@ -1134,6 +1353,21 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
     return this.stringValueNames.has(name)
   }
 
+  /**
+   * Resolve an identifier to its inlined Kolon single-quoted literal when it
+   * names a module pure-string const, else `null` (caller falls back to the
+   * normal `$name` stash lowering). Loop-bound names shadow module consts, so
+   * never inline inside a loop body. Returns `'<escaped>'`.
+   */
+  _resolveModuleStringConst(name: string): string | null {
+    // A loop body may bind `my $<param>` that shadows a module const of the
+    // same name; never inline inside one (conservative — drop to `$name`).
+    if (this.inLoop) return null
+    const value = this.moduleStringConsts.get(name)
+    if (value === undefined) return null
+    return `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`
+  }
+
   _recordExprBF101(message: string, reason?: string): void {
     this.errors.push({
       code: 'BF101',
@@ -1179,6 +1413,9 @@ function renderArrayMethod(
 ): string {
   switch (method) {
     case 'join': {
+      // Route through the runtime (`$bf.join`) rather than Kolon's builtin
+      // `.join`, so the JS-compat element handling (undef → empty, default
+      // separator) is applied consistently — same reasoning as $bf.lc / etc.
       const obj = emit(object)
       const sep = args.length >= 1 ? emit(args[0]) : `','`
       return `$bf.join(${obj}, ${sep})`
@@ -1211,7 +1448,9 @@ function renderArrayMethod(
     case 'slice': {
       const recv = emit(object)
       const start = args.length >= 1 ? emit(args[0]) : '0'
-      const end = args.length >= 2 ? emit(args[1]) : 'undef'
+      // Kolon's undefined literal is `nil`, not Perl's `undef` — the
+      // runtime `slice` treats it as "to end".
+      const end = args.length >= 2 ? emit(args[1]) : 'nil'
       return `$bf.slice(${recv}, ${start}, ${end})`
     }
     case 'reverse':
@@ -1220,6 +1459,8 @@ function renderArrayMethod(
       return `$bf.reverse(${recv})`
     }
     case 'toLowerCase': {
+      // Kolon has no builtin string `lc` / `uc`, so these go through the
+      // runtime object (consistent with $bf.includes / $bf.slice / etc.).
       const recv = emit(object)
       return `$bf.lc(${recv})`
     }
@@ -1339,6 +1580,74 @@ function renderFlatMapMethod(recv: string, op: FlatMapOp): string {
   return `$bf.flat_map(${recv}, 'field', '${proj.field}')`
 }
 
+/**
+ * Parse a const initializer's source text. Returns the unescaped string value
+ * when the whole initializer is a single pure string literal — single/double
+ * quoted, or a no-substitution backtick template (no `${}`) — else `null`.
+ * Only such a value can be inlined byte-for-byte; template literals with
+ * interpolation, numbers, objects, and `Record<T,string>` maps are excluded.
+ */
+function parsePureStringLiteral(source: string): string | null {
+  let s = source.trim()
+  // Peel a single layer of wrapping parens.
+  while (s.startsWith('(') && s.endsWith(')')) s = s.slice(1, -1).trim()
+  const quote = s[0]
+  if ((quote === "'" || quote === '"') && s[s.length - 1] === quote) {
+    const body = s.slice(1, -1)
+    // Reject if an unescaped matching quote appears inside (not a single
+    // literal then).
+    if (containsUnescaped(body, quote)) return null
+    return unescapeStringLiteralBody(body)
+  }
+  if (quote === '`' && s[s.length - 1] === '`') {
+    const body = s.slice(1, -1)
+    if (body.includes('${')) return null
+    if (containsUnescaped(body, '`')) return null
+    return unescapeStringLiteralBody(body)
+  }
+  // `[<literals>].join(' ')` module consts (e.g. Switch's `trackStateClasses`)
+  // → inline the flattened string byte-for-byte. See `evalStringArrayJoin`.
+  return evalStringArrayJoin(source)
+}
+
+/** Whether `s` contains an unescaped occurrence of `ch`. */
+function containsUnescaped(s: string, ch: string): boolean {
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === '\\') { i++; continue }
+    if (s[i] === ch) return true
+  }
+  return false
+}
+
+/** Unescape a JS string-literal body's common escape sequences. */
+function unescapeStringLiteralBody(s: string): string {
+  return s.replace(/\\(.)/g, (_, c) => {
+    switch (c) {
+      case 'n': return '\n'
+      case 'r': return '\r'
+      case 't': return '\t'
+      case '0': return '\0'
+      default: return c
+    }
+  })
+}
+
+/**
+ * Build the module pure-string-const map from the IR's localConstants. A const
+ * qualifies only when module-scope (`isModule`) and its initializer parses to a
+ * single pure string literal.
+ */
+function collectModuleStringConsts(constants: IRMetadata['localConstants'] | undefined): Map<string, string> {
+  const map = new Map<string, string>()
+  for (const c of constants ?? []) {
+    if (!c.isModule) continue
+    if (c.value === undefined) continue
+    const literal = parsePureStringLiteral(c.value)
+    if (literal !== null) map.set(c.name, literal)
+  }
+  return map
+}
+
 /** True when `type` is the `string` primitive. */
 function isStringTypeInfo(type: TypeInfo | undefined): boolean {
   return type?.kind === 'primitive' && type.primitive === 'string'
@@ -1396,14 +1705,16 @@ class XslateFilterEmitter implements ParsedExprEmitter {
   literal(value: string | number | boolean | null, literalType: LiteralType): string {
     if (literalType === 'string') return `'${value}'`
     if (literalType === 'boolean') return value ? '1' : '0'
-    if (literalType === 'null') return 'undef'
+    if (literalType === 'null') return 'nil'
     return String(value)
   }
 
   member(object: ParsedExpr, property: string, _computed: boolean, emit: (e: ParsedExpr) => string): string {
-    // `.length` on an array — Kolon's array length is `$arr.size()`.
+    // `.length` — route through `$bf.length` (handles both array element
+    // count and string char count, JS-compatibly). Kolon's builtin `.size()`
+    // is array-only and faults on a string.
     if (property === 'length') {
-      return `${emit(object)}.size()`
+      return `$bf.length(${emit(object)})`
     }
     // Hash field access — Kolon dot works on hash refs.
     return `${emit(object)}.${property}`
@@ -1430,14 +1741,10 @@ class XslateFilterEmitter implements ParsedExprEmitter {
   binary(op: string, left: ParsedExpr, right: ParsedExpr, emit: (e: ParsedExpr) => string): string {
     const l = emit(left)
     const r = emit(right)
-    const isStr = (e: ParsedExpr) => isStringTypedOperand(e, this.isStringName)
-    const stringCmp = isStr(left) || isStr(right)
-    if ((op === '===' || op === '==') && stringCmp) {
-      return `${l} eq ${r}`
-    }
-    if ((op === '!==' || op === '!=') && stringCmp) {
-      return `${l} ne ${r}`
-    }
+    // Kolon's `==` / `!=` are value-equality operators that compare strings
+    // and numbers correctly — unlike Perl's numeric `==` (which the Mojo
+    // adapter must steer around with `eq`/`ne`). Kolon has no `eq`/`ne`
+    // operator at all, so string comparisons stay on `==` / `!=` here.
     const opMap: Record<string, string> = {
       '===': '==', '!==': '!=', '>': '>', '<': '<', '>=': '>=', '<=': '<=',
       '+': '+', '-': '-', '*': '*', '/': '/',
@@ -1532,13 +1839,17 @@ class XslateTopLevelEmitter implements ParsedExprEmitter {
   constructor(private readonly adapter: XslateAdapter) {}
 
   identifier(name: string): string {
+    // Inline a module-scope pure-string const (`const x = 'literal'`) — it
+    // never reaches the per-render stash, so a bare `$x` would render empty.
+    const inlined = this.adapter._resolveModuleStringConst(name)
+    if (inlined !== null) return inlined
     return `$${name}`
   }
 
   literal(value: string | number | boolean | null, literalType: LiteralType): string {
     if (literalType === 'string') return `'${value}'`
     if (literalType === 'boolean') return value ? '1' : '0'
-    if (literalType === 'null') return 'undef'
+    if (literalType === 'null') return 'nil'
     return String(value)
   }
 
@@ -1549,8 +1860,9 @@ class XslateTopLevelEmitter implements ParsedExprEmitter {
       return `$${property}`
     }
     const obj = emit(object)
-    // Kolon array length is `$arr.size()`.
-    if (property === 'length') return `${obj}.size()`
+    // `.length` → `$bf.length` (array count or string char count, JS-compat);
+    // Kolon's builtin `.size()` is array-only and faults on a string.
+    if (property === 'length') return `$bf.length(${obj})`
     // Kolon dot access works for hash refs.
     return `${obj}.${property}`
   }
@@ -1588,14 +1900,10 @@ class XslateTopLevelEmitter implements ParsedExprEmitter {
   binary(op: string, left: ParsedExpr, right: ParsedExpr, emit: (e: ParsedExpr) => string): string {
     const l = emit(left)
     const r = emit(right)
-    const isStr = (e: ParsedExpr) => isStringTypedOperand(e, n => this.adapter._isStringValueName(n))
-    const stringCmp = isStr(left) || isStr(right)
-    if ((op === '===' || op === '==') && stringCmp) {
-      return `${l} eq ${r}`
-    }
-    if ((op === '!==' || op === '!=') && stringCmp) {
-      return `${l} ne ${r}`
-    }
+    // Kolon's `==` / `!=` are value-equality operators handling both strings
+    // and numbers (unlike Perl's numeric `==`, which the Mojo adapter must
+    // route around with `eq`/`ne`). Kolon has no `eq`/`ne` operator, so all
+    // equality comparisons — string or numeric — stay on `==` / `!=`.
     const opMap: Record<string, string> = {
       '===': '==', '!==': '!=', '>': '>', '<': '<', '>=': '>=', '<=': '<=',
       '+': '+', '-': '-', '*': '*',
@@ -1618,27 +1926,25 @@ class XslateTopLevelEmitter implements ParsedExprEmitter {
     predicate: ParsedExpr,
     emit: (e: ParsedExpr) => string,
   ): string {
-    // `.filter` / `.every` / `.some` route through `$bf` array helpers that
-    // accept a Kolon code-ref predicate. `.find*` have no lowering yet.
-    if (method === 'find' || method === 'findIndex' || method === 'findLast' || method === 'findLastIndex') {
-      this.adapter._recordExprBF101(
-        `Xslate adapter has not lowered Array.prototype.${method} yet`,
-      )
-      return "''"
-    }
-    // Standalone `.filter` / `.every` / `.some` would need v1 runtime array
-    // helpers that accept a Kolon code-ref predicate, which the Xslate runtime
-    // doesn't expose. Refuse with a clear diagnostic rather than emit a call to
-    // a non-existent helper. The common `.filter(...).map(...)` *loop* form is
-    // handled separately by renderLoop's inline predicate, so it still works.
-    if (method === 'filter' || method === 'every' || method === 'some') {
-      this.adapter._recordExprBF101(
-        `Xslate adapter does not lower a standalone Array.prototype.${method} yet ` +
-        `(the .filter(...).map(...) loop form is supported). ` +
-        `Use /* @client */ or precompute the value.`,
-      )
-      return "''"
-    }
+    // Higher-order array methods all take a JS arrow predicate, lowered to a
+    // Kolon lambda `-> $param { PRED }` (callable from Perl as a code ref), and
+    // go through the runtime object — consistent with the other array helpers
+    // ($bf.includes / $bf.slice / ...). `.find*` map to snake_case runtime
+    // methods (like index_of / last_index_of). The `.filter(...).map(...)`
+    // *loop* form is handled separately by renderLoop's inline predicate.
+    const arrayExpr = emit(object)
+    const predBody = this.adapter._renderKolonFilterExprPublic(predicate, param)
+    const lambda = `-> $${param} { ${predBody} }`
+    const fn: Record<string, string> = {
+      filter: 'filter',
+      every: 'every',
+      some: 'some',
+      find: 'find',
+      findIndex: 'find_index',
+      findLast: 'find_last',
+      findLastIndex: 'find_last_index',
+    }
+    if (fn[method]) return `$bf.${fn[method]}(${arrayExpr}, ${lambda})`
     void predicate
     void param
     return emit(object)