@barefootjs/mojolicious 0.14.0 → 0.15.0

package/src/adapter/mojo-adapter.ts

@@ -44,6 +44,7 @@ import {
   parseStyleObjectEntries,
   isSupported,
   exprToString,
+  parseProviderObjectLiteral,
   identifierPath,
   emitParsedExpr,
   emitIRNode,
@@ -55,7 +56,10 @@ import {
   collectContextConsumers,
   isLowerableObjectRestDestructure,
   type ContextConsumer,
-  extractSsrDefaults,
+  collectModuleStringConsts,
+  lookupStaticRecordLiteral,
+  searchParamsLocalNames,
+  matchSearchParamsMethodCall
 } from '@barefootjs/jsx'
 import { isAriaBooleanAttr, isBooleanResultExpr } from './boolean-result.ts'
 
@@ -68,7 +72,7 @@ import { isAriaBooleanAttr, isBooleanResultExpr } from './boolean-result.ts'
  */
 type MojoRenderCtx = Record<string, never>
 import type { ParsedExpr, ParsedStatement, SortComparator, ReduceOp, FlatDepth, FlatMapOp, TemplatePart } from '@barefootjs/jsx'
-import { BF_SLOT, BF_COND } from '@barefootjs/shared'
+import { BF_SLOT, BF_COND, BF_REGION } from '@barefootjs/shared'
 
 interface PrimitiveSpec {
   arity: number
@@ -249,6 +253,7 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
    */
   private propsObjectName: string | null = null
   private propsParams: { name: string }[] = []
+  private booleanTypedProps: Set<string> = new Set()
   /**
    * Names (signal getters + props) whose value is a string, so `===`/`!==`
    * against them lowers to Perl `eq`/`ne` rather than numeric `==`/`!=`.
@@ -256,6 +261,15 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
    * true — selecting the string operator from the operand's type avoids that.
    */
   private stringValueNames: Set<string> = new Set()
+  /**
+   * (#1922) Local binding names the request-scoped `searchParams()` env signal
+   * is imported under (handles `import { searchParams as sp }`). When non-empty
+   * the emitter lowers a `<binding>().get(k)` call to a real method call on the
+   * per-request `$searchParams` reader (`$searchParams->get('sort')`) instead of
+   * the generic hash deref. Set at `generate()` entry from `ir.metadata.imports`;
+   * read by the top-level ParsedExpr emitter.
+   */
+  _searchParamsLocals: Set<string> = new Set()
   /**
    * Module-scope pure string-literal constants (`const X = 'literal'` at
    * file top-level), keyed by name → resolved literal value. Populated at
@@ -322,6 +336,15 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
     // serialization happens before `generate`, so this mutation doesn't reach it).
     augmentInheritedPropAccesses(ir)
     this.propsParams = ir.metadata.propsParams.map(p => ({ name: p.name }))
+    // Props whose declared TS type is boolean — a bare binding of one
+    // (`data-active={props.isActive}`) must stringify as JS
+    // `String(boolean)` ("true"/"false"), not Perl's native `1`/`''`
+    // (#1897, pagination's data-active).
+    this.booleanTypedProps = new Set(
+      ir.metadata.propsParams
+        .filter(prop => prop.type?.primitive === 'boolean' || prop.type?.raw === 'boolean')
+        .map(prop => prop.name),
+    )
     // No-destructure-default props → `undef` when the caller omits them
     // → guard their bare-reference attribute emission with Perl `defined`
     // so the attribute drops instead of rendering `attr=""` (Hono-style
@@ -361,7 +384,8 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
     for (const p of ir.metadata.propsParams) {
       if (isStringTypeInfo(p.type)) this.stringValueNames.add(p.name)
     }
-    this.moduleStringConsts = this.collectModuleStringConsts(ir.metadata.localConstants)
+    this.moduleStringConsts = collectModuleStringConsts(ir.metadata.localConstants)
+    this._searchParamsLocals = searchParamsLocalNames(ir.metadata)
     this.localConstants = ir.metadata.localConstants ?? []
     this.loopBoundNames.clear()
     this.errors = []
@@ -430,25 +454,6 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
     }
   }
 
-  /**
-   * Build the module pure-string-const map from the IR's localConstants.
-   * A const qualifies only when it is module-scope (`isModule`) and its
-   * initializer parses to a single string literal (`ts.StringLiteral` or
-   * `ts.NoSubstitutionTemplateLiteral`). Template literals with `${}`,
-   * numeric/object initializers, `Record<T,string>` maps, memos, and
-   * signals are all excluded — only a pure compile-time string can be
-   * inlined byte-for-byte.
-   */
-  private collectModuleStringConsts(constants: IRMetadata['localConstants']): 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
-  }
 
   /**
    * Resolve an identifier to its inlined Perl single-quoted string literal
@@ -456,6 +461,78 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
    * falls back to its normal `$name` stash lowering). Returns the Perl
    * literal form `'<escaped>'` ready to drop into an expression.
    */
+  /**
+   * Resolve `IDENT.key` over a module object-literal const to its Perl
+   * literal (`variantClasses.ghost` in a class template literal —
+   * #1897). Same compile-time inlining family as
+   * `resolveModuleStringConst`; returns `null` for any non-static shape.
+   */
+  /**
+   * Whether `expr` is a bare reference to a boolean-TYPED prop
+   * (`props.isActive` / destructured `isActive`) — used to route the
+   * binding through `bool_str` even though the expression itself is
+   * structurally opaque (#1897).
+   */
+  isBooleanTypedPropRef(expr: string): boolean {
+    let bare = expr.trim()
+    if (this.propsObjectName && bare.startsWith(`${this.propsObjectName}.`)) {
+      bare = bare.slice(this.propsObjectName.length + 1)
+    }
+    if (!/^[A-Za-z_$][\w$]*$/.test(bare)) return false
+    return this.booleanTypedProps.has(bare)
+  }
+
+  /**
+   * Parse `cond ? value : undefined` (or `: null`), returning the
+   * condition/consequent source spans, else `null`. Used for the
+   * attribute-omission rule (#1897); mirrors the Xslate adapter.
+   */
+  parseUndefinedAlternateTernary(
+    expr: string,
+  ): { condition: string; consequent: string } | null {
+    const parsed = parseExpression(expr.trim())
+    if (parsed?.kind !== 'conditional') return null
+    const alt = parsed.alternate
+    const isUndef =
+      (alt.kind === 'identifier' && (alt.name === 'undefined' || alt.name === 'null')) ||
+      (alt.kind === 'literal' && (alt.value === null || alt.value === undefined))
+    if (!isUndef) return null
+    // Serialise the parsed sub-expressions back to JS source rather than
+    // slicing `expr` text — `indexOf('?')` / `lastIndexOf(':')` would
+    // mis-split when the consequent itself contains `?` / `:` inside a
+    // string or nested ternary (`cond ? 'a:b' : undefined`).
+    return {
+      condition: exprToString(parsed.test),
+      consequent: exprToString(parsed.consequent),
+    }
+  }
+
+  /**
+   * Inline a const (any scope) whose initializer is a pure numeric or
+   * quoted string literal (`const totalPages = 5`, #1897 pagination) —
+   * function-scope consts never reach the per-render stash, so a bare
+   * `$totalPages` faults under strict mode.
+   */
+  resolveLiteralConst(name: string): string | null {
+    if (this.loopBoundNames?.has?.(name)) return null
+    const c = (this.localConstants ?? []).find(lc => lc.name === name)
+    if (c?.value === undefined) return null
+    const v = c.value.trim()
+    if (/^-?\d+(\.\d+)?$/.test(v)) return v
+    const strLit = /^'([^'\\]*)'$/.exec(v) ?? /^"([^"\\]*)"$/.exec(v)
+    if (strLit) return `'${strLit[1].replace(/[\\']/g, m => `\\${m}`)}'`
+    return null
+  }
+
+  resolveStaticRecordLiteral(objectName: string, key: string): string | null {
+    if (this.loopBoundNames?.has?.(objectName)) return null
+    const hit = lookupStaticRecordLiteral(objectName, key, this.localConstants)
+    if (!hit) return null
+    return hit.kind === 'number'
+      ? hit.text
+      : `'${hit.text.replace(/[\\']/g, m => `\\${m}`)}'`
+  }
+
   resolveModuleStringConst(name: string): string | null {
     // A loop body introduces `my $<param>` / `my $<index>` bindings that
     // shadow a module const of the same name — never inline inside one.
@@ -570,13 +647,49 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
         ? `'${v.value.replace(/[\\']/g, m => `\\${m}`)}'`
         : String(v.value)
     }
-    if (v.kind === 'expression') return this.convertExpressionToPerl(v.expr)
+    if (v.kind === 'expression') {
+      const hashref = this.providerObjectLiteralPerl(v.expr)
+      if (hashref !== null) return hashref
+      return this.convertExpressionToPerl(v.expr)
+    }
     if (v.kind === 'template') return this.convertTemplateLiteralPartsToPerl(v.parts)
     // Out-of-shape value (spread / jsx-children) — render as undef rather
     // than emit invalid Perl; the consumer falls back to its default.
     return 'undef'
   }
 
+  /**
+   * Lower an object-literal provider value (`value={{ open: () => props.open
+   * ?? false, onOpenChange: … }}`) to a Perl hashref (#1897). The SSR
+   * lowering is a per-member snapshot of what a consumer would READ during
+   * the same render:
+   *
+   * - zero-param expression-body arrows are getters — lower the body (the
+   *   value is fixed for the render, so the call-time indirection drops out)
+   * - `on[A-Z]`-named members and function-shaped values are client-only
+   *   behavior SSR never invokes — lower to `undef`
+   * - anything else lowers through the normal expression pipeline (so an
+   *   unsupported getter body still refuses loudly with BF101)
+   *
+   * Keys keep their JS names verbatim so a consumer-side `ctx.open` access
+   * maps onto the same key. Returns `null` when the expression is not a
+   * plain object literal (spread / computed key) — the caller falls back to
+   * the whole-expression path, which refuses those shapes with BF101.
+   */
+  private providerObjectLiteralPerl(expr: string): string | null {
+    const members = parseProviderObjectLiteral(expr.trim())
+    if (members === null) return null
+    const entries = members.map(m => {
+      // String-literal JS keys can carry `'` / `\` — escape for the
+      // single-quoted Perl key string.
+      const key = `'${m.name.replace(/[\\']/g, c => `\\${c}`)}'`
+      if (m.kind === 'function' || /^on[A-Z]/.test(m.name)) return `${key} => undef`
+      const src = m.kind === 'getter' ? m.body : m.expr
+      return `${key} => ${this.convertExpressionToPerl(src)}`
+    })
+    return `{ ${entries.join(', ')} }`
+  }
+
   /** Perl literal for a context-consumer's `createContext` default. */
   private contextDefaultPerl(c: ContextConsumer): string {
     const d = c.defaultValue
@@ -619,7 +732,6 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
     const memos = ir.metadata.memos ?? []
     const signals = ir.metadata.signals ?? []
     if (memos.length === 0 && signals.length === 0) return ''
-    const ssrDefaults = extractSsrDefaults(ir.metadata) ?? {}
     // Props seed first; each signal/memo adds its own name as it lands so a
     // later one can reference an earlier one.
     const available = new Set<string>(ir.metadata.propsParams.map(p => p.name))
@@ -641,17 +753,20 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
     }
 
     for (const memo of memos) {
-      const def = ssrDefaults[memo.name]
-      const isNull = !def || (typeof def === 'object' && 'value' in def && def.value === null)
-      if (!isNull) {
-        available.add(memo.name)
-        continue
-      }
+      // Seed every memo whose body lowers cleanly — not just the ones whose
+      // static SSR default is null. A statically-foldable prop-derived memo
+      // (`createMemo(() => props.disabled ?? false)` → default `false`)
+      // still depends on the per-call prop: the static stash seed bakes in
+      // the absent-prop fold, so a caller passing `disabled => 1` would
+      // render the default branch (#1897, select's disabled item). The
+      // in-template recomputation reads the prop lexical the stash already
+      // seeded, so it's correct per call; block-bodied arrows /
+      // out-of-scope references fall back to the static ssr-defaults seed.
       const body = extractArrowBodyExpression(memo.computation)
-      // Block-bodied arrows / non-expression shapes stay on the null path.
-      if (body === null) continue
-      const perl = this.tryLowerToPerl(body, available)
-      if (perl !== null) lines.push(`% my $${memo.name} = ${perl};`)
+      if (body !== null) {
+        const perl = this.tryLowerToPerl(body, available)
+        if (perl !== null) lines.push(`% my $${memo.name} = ${perl};`)
+      }
       available.add(memo.name)
     }
     return lines.length > 0 ? lines.join('\n') + '\n' : ''
@@ -703,6 +818,12 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
     if (element.slotId) {
       hydrationAttrs += ` ${this.renderSlotMarker(element.slotId)}`
     }
+    // Page-lifecycle boundary lowered from `<Region>` (spec/router.md). The id
+    // is a deterministic static string (`<file scope>:<index>`), so it emits as
+    // a plain literal attribute — no Mojolicious template tag.
+    if (element.regionId) {
+      hydrationAttrs += ` ${BF_REGION}="${element.regionId}"`
+    }
 
     const voidElements = [
       'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
@@ -1098,8 +1219,9 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
   renderComponent(comp: IRComponent): string {
     const propParts: string[] = []
     for (const p of comp.props) {
-      // Skip callback props (onXxx) — event handlers are client-only for SSR.
-      if (p.name.match(/^on[A-Z]/) && p.value.kind === 'expression') continue
+      // Skip callback props (onXxx) and `ref` — both are client-only for
+      // SSR (Hono renders neither; the client JS wires them at hydration).
+      if ((p.name.match(/^on[A-Z]/) || p.name === 'ref') && p.value.kind === 'expression') continue
       const lowered = emitAttrValue(p.value, this.componentPropEmitter, p.name)
       if (lowered) propParts.push(lowered)
     }
@@ -1132,7 +1254,10 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
       // `render_child` would let the inner `%>` close the outer tag.
       // `render_child` materializes the resulting CODE ref into the
       // captured Mojo::ByteStream.
+      const prevInLoop = this.inLoop
+      this.inLoop = false
       const childrenBody = this.renderChildren(effectiveChildren)
+      this.inLoop = prevInLoop
       const varName = `$bf_children_${comp.slotId ?? 'c' + this.childrenCaptureCounter++}`
       return `<% my ${varName} = begin %>${childrenBody}<% end %><%== bf->render_child('${tplName}'${propsStr}, children => ${varName}) %>`
     }
@@ -1141,6 +1266,10 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
 
   private childrenCaptureCounter = 0
 
+  /** Uniquifies the `presenceOrUndefined` temp binding (`$bf_puN`) so two
+   *  presence-folded attrs in one template don't collide. */
+  private presenceVarCounter = 0
+
   private toTemplateName(componentName: string): string {
     // Convert PascalCase to snake_case for Mojo template naming
     return componentName
@@ -1267,15 +1396,32 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
       ) {
         const perl = this.convertExpressionToPerl(value.expr)
         const body =
-          isBooleanResultExpr(value.expr) || isAriaBooleanAttr(name)
+          isBooleanResultExpr(value.expr) || isAriaBooleanAttr(name) || this.isBooleanTypedPropRef(value.expr)
             ? `${name}="<%= bf->bool_str(${perl}) %>"`
             : `${name}="<%= ${perl} %>"`
         return `<% if (defined ${perl}) { %>${body}<% } %>`
       }
-      if (isBooleanAttr(name) || value.presenceOrUndefined) {
+      if (isBooleanAttr(name)) {
         // Boolean attributes: render conditionally (present or absent).
         return `<%= ${this.convertExpressionToPerl(value.expr)} ? '${name}' : '' %>`
       }
+      if (value.presenceOrUndefined) {
+        // `attr={expr || undefined}` on a NON-boolean attribute: Hono
+        // renders the attr with its stringified value when truthy and
+        // omits it otherwise (`aria-disabled={isDisabled() || undefined}`
+        // → `aria-disabled="true"`), so bare presence would diverge.
+        // Route through `bool_str` when the name/shape witnesses a
+        // boolean value, same as the unconditional path below (#1897).
+        // Bind to a temp first so the expression evaluates once, not in
+        // both the guard and the value.
+        const perl = this.convertExpressionToPerl(value.expr)
+        const tmp = `$bf_pu${this.presenceVarCounter++}`
+        const body =
+          isBooleanResultExpr(value.expr) || isAriaBooleanAttr(name) || this.isBooleanTypedPropRef(value.expr)
+            ? `${name}="<%= bf->bool_str(${tmp}) %>"`
+            : `${name}="<%= ${tmp} %>"`
+        return `<% my ${tmp} = ${perl}; if (${tmp}) { %>${body}<% } %>`
+      }
       // Boolean-result handling (#1466 follow-up). Two trigger paths:
       //
       //   - `isBooleanResultExpr(expr)` — the JS source structurally
@@ -1294,8 +1440,21 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
       // Hono's / Go's `attr="false"` / `attr="true"`. Routing through
       // the `bf->bool_str` Perl helper realigns the wire bytes with
       // JS `String(boolean)` semantics.
+      // `attr={cond ? value : undefined}` OMITS the attribute on the
+      // falsy branch (Hono drops undefined-valued attributes) — wrap the
+      // whole attribute in the condition instead of rendering `attr=""`
+      // (#1897, pagination's `aria-current={props.isActive ? 'page' :
+      // undefined}`). Same parity rule as the Go / Xslate adapters.
+      {
+        const m = this.parseUndefinedAlternateTernary(value.expr)
+        if (m) {
+          const cond = this.convertExpressionToPerl(m.condition)
+          const val = this.convertExpressionToPerl(m.consequent)
+          return `<% if (${cond}) { %>${name}="<%= ${val} %>"<% } %>`
+        }
+      }
       const perl = this.convertExpressionToPerl(value.expr)
-      if (isBooleanResultExpr(value.expr) || isAriaBooleanAttr(name)) {
+      if (isBooleanResultExpr(value.expr) || isAriaBooleanAttr(name) || this.isBooleanTypedPropRef(value.expr)) {
         return `${name}="<%= bf->bool_str(${perl}) %>"`
       }
       return `${name}="<%= ${perl} %>"`
@@ -1768,6 +1927,35 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
         return n
       })()
       const indexed = this.recordIndexAccessToPerl(initNode)
+      if (
+        indexed === null &&
+        ts.isElementAccessExpression(initNode) &&
+        initNode.argumentExpression &&
+        !ts.isNumericLiteral(initNode.argumentExpression) &&
+        !ts.isStringLiteral(initNode.argumentExpression)
+      ) {
+        // Variable-index record access (`sizeMap[size]`) that the
+        // static-inline path couldn't resolve — a non-scalar record
+        // value, or a non-const receiver. Since #1897 made variable
+        // indices parseable (`index-access`), the generic value lowering
+        // would now emit `$sizeMap->{$size}` against an UNBOUND module
+        // const instead of refusing. Record BF101 and bail so the whole
+        // spread surfaces the out-of-shape diagnostic, matching the
+        // pre-#1897 behaviour (the refusal then was a side effect of the
+        // value lowering). (A bound receiver — a signal getter like
+        // `selected()[index]` — is an attribute value, not a spread
+        // member, and never reaches here.)
+        this.errors.push({
+          code: 'BF101',
+          severity: 'error',
+          message: `Spread object value '${initNode.getText(sf)}' indexes a record map whose values aren't scalar literals — it can't lower to an inline Perl hashref.`,
+          loc: { file: this.componentName + '.tsx', start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
+          suggestion: {
+            message: 'Index a record whose values are number/string literals, or move the spread into a `\'use client\'` component so hydration computes it.',
+          },
+        })
+        return null
+      }
       const valPerl =
         indexed !== null
           ? indexed
@@ -2010,6 +2198,13 @@ function renderArrayMethod(
       const recv = emit(object)
       return `bf->trim(${recv})`
     }
+    case 'toFixed': {
+      // `.toFixed(digits?)` — Number → fixed-decimal string. `bf->to_fixed`
+      // mirrors JS rounding + zero-padding (default 0 digits). #1897.
+      const recv = emit(object)
+      const digits = args.length >= 1 ? emit(args[0]) : '0'
+      return `bf->to_fixed(${recv}, ${digits})`
+    }
     case 'split': {
       // `.split()` / `.split(sep)` / `.split(sep, limit)` — string →
       // ARRAY ref via `bf->split`. With no separator the helper returns
@@ -2237,6 +2432,25 @@ function isStringTypedOperand(expr: ParsedExpr, isStringName: (n: string) => boo
   return false
 }
 
+/**
+ * Lower `arr[index]` to a Perl deref. Perl distinguishes array
+ * (`->[$i]`) from hash (`->{$k}`) access, which JS's single `[]` does
+ * not — so we pick by the index expression's type: a string-typed key
+ * derefs the hash, anything else (the common loop-index / arithmetic
+ * case, e.g. `selected()[index]`) derefs the array. #1897.
+ */
+function emitIndexAccessPerl(
+  object: ParsedExpr,
+  index: ParsedExpr,
+  emit: (e: ParsedExpr) => string,
+  isStringName: (n: string) => boolean,
+): string {
+  const i = emit(index)
+  return isStringTypedOperand(index, isStringName)
+    ? `${emit(object)}->{${i}}`
+    : `${emit(object)}->[${i}]`
+}
+
 /**
  * Lowering for the predicate body of a filter / every / some / find,
  * plus the same shape used by `renderBlockBodyCondition` for complex
@@ -2288,6 +2502,10 @@ class MojoFilterEmitter implements ParsedExprEmitter {
     return `${emit(object)}->{${property}}`
   }
 
+  indexAccess(object: ParsedExpr, index: ParsedExpr, emit: (e: ParsedExpr) => string): string {
+    return emitIndexAccessPerl(object, index, emit, this.isStringName)
+  }
+
   call(callee: ParsedExpr, args: ParsedExpr[], emit: (e: ParsedExpr) => string): string {
     // Signal getter calls: filter() → $filter
     if (callee.kind === 'identifier' && args.length === 0) {
@@ -2431,11 +2649,19 @@ class MojoTopLevelEmitter implements ParsedExprEmitter {
   constructor(private readonly adapter: MojoAdapter) {}
 
   identifier(name: string): string {
+    // `undefined` / `null` nested inside a larger expression tree
+    // (#1897, pagination's `props.isActive ? 'page' : undefined`) — the
+    // top-level short-circuits don't see them.
+    if (name === 'undefined' || name === 'null') return 'undef'
     // Module pure-string const (e.g. `const baseClasses = '...'` used in a
     // className template literal): inline the literal value rather than emit
     // `$baseClasses` against a stash variable that is never bound.
     const inlined = this.adapter.resolveModuleStringConst(name)
     if (inlined !== null) return inlined
+    // Same for a literal const of any scope (`const totalPages = 5`,
+    // #1897 pagination's `Page {currentPage()} of {totalPages}`).
+    const literalConst = this.adapter.resolveLiteralConst(name)
+    if (literalConst !== null) return literalConst
     return `$${name}`
   }
 
@@ -2453,16 +2679,38 @@ class MojoTopLevelEmitter implements ParsedExprEmitter {
     if (object.kind === 'identifier' && object.name === 'props') {
       return `$${property}`
     }
+    // Static property access on a module object-literal const
+    // (`variantClasses.ghost`, #1897) resolves at compile time — the
+    // generic hash lowering below would dereference a Perl var that
+    // doesn't exist server-side.
+    if (object.kind === 'identifier') {
+      const staticValue = this.adapter.resolveStaticRecordLiteral(object.name, property)
+      if (staticValue !== null) return staticValue
+    }
     const obj = emit(object)
     if (property === 'length') return `scalar(@{${obj}})`
     return `${obj}->{${property}}`
   }
 
+  indexAccess(object: ParsedExpr, index: ParsedExpr, emit: (e: ParsedExpr) => string): string {
+    return emitIndexAccessPerl(object, index, emit, n => this.adapter._isStringValueName(n))
+  }
+
   call(callee: ParsedExpr, args: ParsedExpr[], emit: (e: ParsedExpr) => string): string {
     // Signal getter: count() → $count
     if (callee.kind === 'identifier' && args.length === 0) {
       return `$${callee.name}`
     }
+    // Env-signal method call (#1922): `searchParams().get('sort')` is a real
+    // method call on the per-request `$searchParams` reader object, not the
+    // generic hash deref `member` would emit (`$searchParams->{get}`, which
+    // drops the arg). Matches the local import binding (incl. an alias).
+    if (this.adapter._searchParamsLocals.size > 0) {
+      const sp = matchSearchParamsMethodCall(callee, args, this.adapter._searchParamsLocals)
+      if (sp) {
+        return `$searchParams->${sp.method}(${sp.args.map(emit).join(', ')})`
+      }
+    }
     // Identifier-path templatePrimitive (#1189): `JSON.stringify(x)` /
     // `Math.floor(x)` → `bf->json($x)` / `bf->floor($x)`. Args render
     // recursively through this same emitter so prop refs / signal calls