@barefootjs/blade 0.1.0

package/dist/adapter/boolean-result.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Structural classifier for JS expressions whose result is a boolean value
+ * (or unambiguously stringifies to "true"/"false" in JS).
+ *
+ * Ported from `packages/adapter-jinja/src/adapter/boolean-result.ts`
+ * (itself ported from the Xslate/Mojo adapters' `bf->bool_str` classifier).
+ * Used by the Blade adapter for TWO purposes:
+ *
+ * 1. **Attribute/text stringification**: route a boolean-shaped reactive
+ *    binding through the runtime `bf.bool_str` helper so the serialised
+ *    value matches JS `String(boolean)` ("true"/"false"). PHP has a real
+ *    `bool` type, but PHP's own `(string) true` == `"1"` (not `"true"`) and
+ *    `(string) false` == `""` — still wrong for HTML output — so the same
+ *    explicit routing is required.
+ * 2. **Condition-position truthy wrapping**: PHP truthiness diverges from JS
+ *    specifically on the string `'0'` (falsy in PHP, truthy in JS) and empty
+ *    arrays (`[]` — JS objects/arrays are unconditionally truthy; a PHP
+ *    empty array is falsy). The Blade adapter's condition-emission call sites
+ *    (see `blade-adapter.ts`'s `convertConditionToBlade`) reuse this SAME
+ *    structural classifier: a condition that is already unambiguously
+ *    boolean-shaped emits directly; everything else is wrapped in
+ *    `bf.truthy(...)` (a JS-faithful `ToBoolean`) before being used as an
+ *    `{% if %}` / ternary test.
+ *
+ * The classifier walks a `ParsedExpr` produced by
+ * `@barefootjs/jsx::parseExpression` — same AST the filter / loop lowerings
+ * already use — so detection is structural rather than regex-text-matching.
+ * Wrapped expression text is left to the caller's existing
+ * `convertExpressionToBlade` pipeline; this module only decides whether to
+ * wrap.
+ *
+ * Detected shapes:
+ *   - `binary` with a comparison operator (`<`, `>`, `<=`, `>=`, `==`, `===`,
+ *     `!=`, `!==`)
+ *   - `unary` with logical `!`
+ *   - `literal` with `literalType: 'boolean'`
+ *   - `logical` (`&&` / `||` / `??`) when both sides are themselves
+ *     boolean-result (catches `x > 0 && y < 10`; intentionally does NOT
+ *     catch `x() || 'fallback'` whose right side stringifies as a regular
+ *     value)
+ *   - `conditional` (`?:`) when both branches are themselves boolean-result
+ *
+ * Anything else returns `false` — including bare identifiers (`accepted`)
+ * and call expressions (`accepted()`) whose return type the adapter has no
+ * way to infer from source text alone.
+ */
+import { type ParsedExpr } from '@barefootjs/jsx';
+/**
+ * Structural boolean-result check over an already-parsed `ParsedExpr` tree.
+ * Exported so the condition-position truthy-wrapping call sites can reuse it
+ * without a stringify → re-parse round-trip.
+ */
+export declare function isBooleanResultParsed(node: ParsedExpr): boolean;
+export declare function isBooleanResultExpr(expr: string): boolean;
+/**
+ * True when `expr`'s top-level shape is an explicit JS `String(x)` call
+ * (the `EVAL_BUILTIN_IDENTS` builtin the compiler recognizes structurally —
+ * `packages/jsx/src/expression-parser.ts`'s `EVAL_BUILTIN_IDENTS`; lowered
+ * by this adapter's `String` template primitive to `bf.string(x)`, see
+ * `lib/constants.ts`).
+ *
+ * Guards the `isAriaBooleanAttr`-driven `bf.bool_str(...)` override in
+ * `blade-adapter.ts`'s `elementAttrEmitter`: `bf.string` and `bf.bool_str`
+ * produce IDENTICAL text for a real PHP `bool` (both are `"true"` /
+ * `"false"`), so applying `bf.bool_str` to `String(x)`'s ALREADY-STRINGIFIED
+ * result is not a no-op — it is a PHP-truthiness test over that STRING
+ * ("false" is a non-empty PHP string, hence truthy, so
+ * `bf.bool_str(bf.string(false))` would wrongly render `"true"`). An author
+ * who explicitly writes `String(...)` has already opted into JS `String()`
+ * semantics — `bf.string(x)` alone (which DOES special-case booleans, see
+ * the PHP runtime's `string()` helper) is the complete, correct lowering; no
+ * attribute-name-driven override should run again on top of it.
+ */
+export declare function isExplicitStringCall(expr: string): boolean;
+export declare function isAriaBooleanAttr(name: string): boolean;
+//# sourceMappingURL=boolean-result.d.ts.map

package/dist/adapter/boolean-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean-result.d.ts","sourceRoot":"","sources":["../../src/adapter/boolean-result.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAalE;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAuB/D;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAIzD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAS1D;AAyCD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD"}

package/dist/adapter/emit-context.d.ts

@@ -0,0 +1,105 @@
+/**
+ * The contract the extracted expression-emitter modules depend on instead of
+ * the concrete `BladeAdapter`.
+ *
+ * Ported from `packages/adapter-jinja/src/adapter/emit-context.ts`. The Blade
+ * adapter's top-level expression lowering is mutually recursive with the
+ * adapter's own const/record resolution and its filter-predicate emitter, so
+ * the extracted `BladeTopLevelEmitter` still needs to call back into shared
+ * per-compile state and recursive entry points. `BladeEmitContext` is that
+ * seam: the emitter takes a `BladeEmitContext` built by the adapter's private
+ * `emitCtx` getter (the adapter does NOT `implements` this interface, so the
+ * wrapped members stay private and off its exported public type). The
+ * emitter depends on this narrow interface rather than the full class, so
+ * the coupling is explicit and it's unit-testable against a stub.
+ *
+ * Keep this surface minimal: add a member only when an extracted module
+ * genuinely needs it, so the seam documents the real cross-module coupling
+ * rather than re-exposing the whole adapter.
+ */
+import type { ParsedExpr, CompilerError, IRMetadata } from '@barefootjs/jsx';
+export interface BladeEmitContext {
+    /**
+     * (#1922) Local binding names the request-scoped `searchParams()` env signal
+     * is imported under. Non-empty enables the env-signal method-call lowering.
+     */
+    readonly _searchParamsLocals: Set<string>;
+    /**
+     * Inline a module-scope pure string-literal const by name as the resolved
+     * literal value, or null when the name is not such a const.
+     */
+    _resolveModuleStringConst(name: string): string | null;
+    /** Resolve a literal const (`const totalPages = 5`) to its Blade value, or null. */
+    _resolveLiteralConst(name: string): string | null;
+    /**
+     * Resolve a static property access on a module object-literal const
+     * (`variantClasses.ghost`) to its Blade value at compile time, or null.
+     */
+    _resolveStaticRecordLiteral(objectName: string, key: string): string | null;
+    /** Record a BF101 unsupported-expression diagnostic. */
+    _recordExprBF101(message: string, reason?: string): void;
+    /** Lower a filter/predicate body to its Blade form, bound to `param`. */
+    _renderBladeFilterExprPublic(expr: ParsedExpr, param: string): string;
+}
+/**
+ * The contract the extracted object-literal / conditional-spread lowering
+ * (`spread/spread-codegen.ts`) depends on. Declared separately from
+ * `BladeEmitContext` so each extracted module's real coupling is documented
+ * precisely. Mirror of the Jinja adapter's `JinjaSpreadContext`.
+ */
+export interface BladeSpreadContext {
+    /** Component name, for diagnostic source locations. */
+    readonly componentName: string;
+    /** Per-compile diagnostic list the spread lowering appends to. */
+    readonly errors: CompilerError[];
+    /** Local-constant metadata, for resolving `Record[key]` spread values. */
+    readonly localConstants: IRMetadata['localConstants'];
+    /** Prop params, for classifying a bare-identifier index as a prop. */
+    readonly propsParams: {
+        name: string;
+    }[];
+    /**
+     * Lower a JS expression to its Blade form (the core recursive entry).
+     *
+     * When the IR already carries a structured `ParsedExpr` tree, pass it as
+     * `preParsed` so the converter threads it straight through instead of
+     * re-parsing `expr`. With `preParsed` set, `expr` is unused for parsing
+     * (the converter derives any diagnostic text from the tree), so callers
+     * may pass `''`.
+     */
+    convertExpressionToBlade(expr: string, preParsed?: ParsedExpr): string;
+    /**
+     * Lower a JS expression to a Blade CONDITION (routes through `bf.truthy`
+     * unless the expression is structurally already boolean-shaped — see
+     * `boolean-result.ts`). Used for the conditional-spread ternary's test,
+     * which is a condition position, not a value position. Same `preParsed`
+     * contract as `convertExpressionToBlade`.
+     */
+    convertConditionToBlade(expr: string, preParsed?: ParsedExpr): string;
+}
+/**
+ * The contract the extracted in-template memo / context seeding
+ * (`memo/seed.ts`) depends on. The seed lowering recurses into the core
+ * expression lowering to compute a derived signal/memo value or a context
+ * default; that recursive entry is its only adapter coupling.
+ */
+export interface BladeMemoContext {
+    /**
+     * Lower a JS expression to its Blade form (the core recursive entry). See
+     * `BladeSpreadContext.convertExpressionToBlade` for the `preParsed` contract.
+     */
+    convertExpressionToBlade(expr: string, preParsed?: ParsedExpr): string;
+    /**
+     * Per-compile diagnostic list `convertExpressionToBlade` appends to on an
+     * unsupported shape (`_recordExprBF101`). `memo/seed.ts`'s
+     * `generateDerivedMemoSeed` is a SPECULATIVE "try this in-template
+     * recomputation, else fall back to the static ssrDefault seed" attempt per
+     * plan step — unlike every other `convertExpressionToBlade` call site, a
+     * failure here must NOT become a hard compile error, so it snapshots this
+     * array's length before calling in and truncates back to it on failure
+     * (discarding whatever `_recordExprBF101` appended) rather than letting
+     * the error escape.
+     */
+    readonly errors: CompilerError[];
+}
+//# sourceMappingURL=emit-context.d.ts.map

package/dist/adapter/emit-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-context.d.ts","sourceRoot":"","sources":["../../src/adapter/emit-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAE5E,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,QAAQ,CAAC,mBAAmB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAEzC;;;OAGG;IACH,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;IAEtD,oFAAoF;IACpF,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;IAEjD;;;OAGG;IACH,2BAA2B,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;IAE3E,wDAAwD;IACxD,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAExD,yEAAyE;IACzE,4BAA4B,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CACtE;AAED;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,uDAAuD;IACvD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAE9B,kEAAkE;IAClE,QAAQ,CAAC,MAAM,EAAE,aAAa,EAAE,CAAA;IAEhC,0EAA0E;IAC1E,QAAQ,CAAC,cAAc,EAAE,UAAU,CAAC,gBAAgB,CAAC,CAAA;IAErD,sEAAsE;IACtE,QAAQ,CAAC,WAAW,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IAExC;;;;;;;;OAQG;IACH,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,UAAU,GAAG,MAAM,CAAA;IAEtE;;;;;;OAMG;IACH,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,UAAU,GAAG,MAAM,CAAA;CACtE;AAED;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,UAAU,GAAG,MAAM,CAAA;IAEtE;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,MAAM,EAAE,aAAa,EAAE,CAAA;CACjC"}

package/dist/adapter/expr/array-method.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Array / string method lowering for the Blade template adapter.
+ *
+ * Ported from `packages/adapter-jinja/src/adapter/expr/array-method.ts`.
+ * Pure free functions shared by both the filter-context emitter and the
+ * top-level emitter — they take an `emit` callback for receiver / argument
+ * recursion and read no adapter instance state.
+ *
+ * The receiver/array helpers are the same runtime methods the Jinja adapter
+ * calls, invoked as `$bf->NAME(...)`.
+ */
+import type { ParsedExpr, ArrayMethod, SortComparator, FlatDepth } from '@barefootjs/jsx';
+export declare function renderArrayMethod(method: ArrayMethod, object: ParsedExpr, args: ParsedExpr[], emit: (e: ParsedExpr) => string): string;
+/**
+ * Emit a `.sort(cmp)` / `.toSorted(cmp)` via the runtime evaluator (#2018):
+ * the comparator body travels as serialized-ParsedExpr JSON, evaluated per
+ * comparison against `{paramA, paramB, …captured}`. Returns null when the
+ * body is outside the evaluator surface (e.g. a `localeCompare` comparator —
+ * `serializeParsedExpr` refuses it), so the caller falls back to the
+ * structured `$bf->sort`. `params` are the comparator arrow's two params
+ * (`[paramA, paramB]`).
+ */
+export declare function renderSortEval(recv: string, body: ParsedExpr, params: string[], emit: (e: ParsedExpr) => string): string | null;
+/**
+ * Emit a `.reduce(fn, init)` / `.reduceRight(fn, init)` via the runtime
+ * evaluator (#2018): the reducer body travels as serialized-ParsedExpr JSON,
+ * folded over the receiver from `init` in `direction` order. `params` are the
+ * reducer arrow's params (`[paramAcc, paramItem]`); `init` is the initial-value
+ * `ParsedExpr` from the call's trailing argument. Returns null when the body is
+ * outside the evaluator surface, or when `init` is not a literal string/number
+ * (→ caller refuses with BF101). A numeric seed passes through as a bare
+ * Blade number; a string seed as a single-quoted literal.
+ */
+export declare function renderReduceEval(recv: string, body: ParsedExpr, params: string[], init: ParsedExpr, direction: 'left' | 'right', emit: (e: ParsedExpr) => string): string | null;
+/**
+ * Emit a higher-order predicate call via the runtime evaluator (#2018, P2):
+ * `$bf->filter_eval` / `$bf->every_eval` / `$bf->some_eval` / `$bf->find_eval` /
+ * `$bf->find_index_eval`, carrying the serialized predicate body + captured env
+ * dict. Generalizes the lambda lowering to the same JS-faithful evaluator
+ * the Go/Jinja adapters use. Returns null when the predicate is outside the
+ * evaluator surface (e.g. a method-call predicate — `serializeParsedExpr`
+ * refuses it), so the caller falls back to the lambda form. `forward`
+ * (find / findIndex family only) selects the search direction — `false` =
+ * findLast / findLastIndex.
+ */
+export declare function renderPredicateEval(funcName: string, recv: string, predicate: ParsedExpr, param: string, emit: (e: ParsedExpr) => string, forward?: boolean): string | null;
+/**
+ * Emit a `.flatMap(proj)` via the runtime evaluator (#2018, P3): the projection
+ * body serializes to JSON and `$bf->flat_map_eval` projects + flattens one
+ * level. `param` is the projection arrow's single param. Returns null when the
+ * projection is outside the evaluator surface (→ caller refuses with BF101).
+ */
+export declare function renderFlatMapEval(recv: string, body: ParsedExpr, param: string, emit: (e: ParsedExpr) => string): string | null;
+/**
+ * Emit a value-producing `.map(cb)` via the runtime evaluator (#2073): the
+ * projection body serializes to JSON and `$bf->map_eval` projects each element,
+ * one result per element (no flatten — the JS `.map` contract). Composes
+ * through the array-method chain (`.map(cb).join(' ')`). Returns null when
+ * the projection is outside the evaluator surface (→ caller refuses with
+ * BF101). The JSX-returning `.map` is an IRLoop upstream and never reaches
+ * this emit.
+ */
+export declare function renderMapEval(recv: string, body: ParsedExpr, param: string, emit: (e: ParsedExpr) => string): string | null;
+/**
+ * Shared Blade emit for `.sort(cmp)` / `.toSorted(cmp)`. Used by both the
+ * filter-context emitter and the top-level emitter, plus the loop-array
+ * wrap in `renderLoop`. The runtime `$bf->sort` accepts an opts dict and
+ * returns a fresh list.
+ */
+export declare function renderSortMethod(recv: string, c: SortComparator): string;
+export declare function renderFlatMethod(recv: string, depth: FlatDepth | {
+    expr: ParsedExpr;
+}, emit: (e: ParsedExpr) => string): string;
+//# sourceMappingURL=array-method.d.ts.map

package/dist/adapter/expr/array-method.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-method.d.ts","sourceRoot":"","sources":["../../../src/adapter/expr/array-method.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH,OAAO,KAAK,EACV,UAAU,EACV,WAAW,EACX,cAAc,EACd,SAAS,EACV,MAAM,iBAAiB,CAAA;AAGxB,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,UAAU,EAAE,EAClB,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAC9B,MAAM,CA6HR;AAqBD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,MAAM,EAAE,EAChB,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAC9B,MAAM,GAAG,IAAI,CAUf;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,MAAM,EAAE,EAChB,IAAI,EAAE,UAAU,EAChB,SAAS,EAAE,MAAM,GAAG,OAAO,EAC3B,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAC9B,MAAM,GAAG,IAAI,CAkBf;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,UAAU,EACrB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,EAC/B,OAAO,CAAC,EAAE,OAAO,GAChB,MAAM,GAAG,IAAI,CAMf;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAC9B,MAAM,GAAG,IAAI,CAKf;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAC9B,MAAM,GAAG,IAAI,CAKf;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,cAAc,GAAG,MAAM,CASxE;AAGD,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS,GAAG;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,EACvC,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAC9B,MAAM,CAmBR"}

package/dist/adapter/expr/emitters.d.ts

@@ -0,0 +1,176 @@
+/**
+ * ParsedExpr → Blade emitters for the Blade template adapter.
+ *
+ * Ported from `packages/adapter-twig/src/adapter/expr/emitters.ts`
+ * (`TwigFilterEmitter` / `TwigTopLevelEmitter`), itself a port of the Jinja
+ * adapter's. Two `ParsedExprEmitter` implementations:
+ *
+ *   - `BladeFilterEmitter` — filter/predicate context (loop param + local
+ *     aliases + bare identifier signal fallback); self-contained, reads no
+ *     adapter state.
+ *   - `BladeTopLevelEmitter` — top-level / per-render-var context; depends on
+ *     the adapter only through the narrow `BladeEmitContext` seam.
+ *
+ * Divergences from the Twig port, documented at their definition site below:
+ *
+ *   1. **`$` sigil on every variable reference/read.** Twig has no sigil —
+ *      `twigIdent(name)` was both the mangled NAME and the value expression.
+ *      Blade compiles to raw PHP, so every read is `$name` — `bladeVar(name)`
+ *      (this adapter's helper, `lib/blade-naming.ts`) wraps `bladeIdent`
+ *      with the `$`. Every `identifier`/zero-arg-`call` (signal getter) site
+ *      below uses `bladeVar`, not `bladeIdent` alone.
+ *   2. **Member/index access lowers to `data_get(...)`, not `.`/`[]`.**
+ *      Twig's dot/bracket are polymorphic over {stdClass, array, null}; raw
+ *      PHP has no equivalent single operator. See `blade-naming.ts`'s file
+ *      header (divergence 3) for the full rationale — every `member`/
+ *      `indexAccess` call below routes through `bladeMemberAccess`/
+ *      `bladeIndexAccess` uniformly, including the `.length` special case
+ *      (still `$bf->length(...)`, unchanged mechanism, just `$bf->` syntax).
+ *   3. **Symbolic ternary, not word-based `if`/`else`** (unchanged from
+ *      Twig, still a Twig→Jinja divergence carried through) — Blade/PHP has
+ *      no `X if T else Y` inline-conditional form — `logical`'s `&&`/`||`
+ *      lowering and `conditional`'s ternary lowering both emit `(T ? A : B)`.
+ *   4. **JS-truthy condition wrapping** (`truthyTest`) — unchanged from the
+ *      Twig port: PHP truthiness diverges from JS (`'0'` is PHP-falsy,
+ *      JS-truthy; empty arrays are PHP-falsy, JS-truthy for both `[]` and
+ *      `{}`). Every condition-TEST position (`!x`, the left operand of
+ *      `&&`/`||`, a ternary's test) routes through the shared
+ *      `$bf->truthy(...)` runtime helper unless the operand is structurally
+ *      already boolean-shaped (`isBooleanResultParsed`). `&&`/`||` still
+ *      return the ORIGINAL operand VALUE (not a coerced bool) on the taken
+ *      branch — matching JS `a || b` returning `a` itself — only the BRANCH
+ *      TEST uses `$bf->truthy`. The left operand's rendered text is emitted
+ *      TWICE (once as the test, once as the value) — safe because every
+ *      operand reaching this pipeline is a pure, side-effect-free read.
+ *   5. **`??` is PHP-native**, covering undefined AND null in ONE operator —
+ *      PHP's `??` silences BOTH an undefined-variable/index notice and a
+ *      real `null` (`$missing ?? 'fb'` and `$x ?? 'fb'` with `$x = null`
+ *      both yield `'fb'`) — verified empirically, same as Twig's own native
+ *      `??` (this REPLACES Twig's `strict_variables: false` forgiveness with
+ *      a uniform per-use-site policy, since raw PHP has no engine-wide
+ *      "never warn on unset var" switch).
+ *   6. **`!` (bang), not `not`.** Blade/PHP's unary logical-not is `!`, not
+ *      Twig's word-form `not` — `unary`'s `op === '!'` branch emits
+ *      `!${truthyTest(...)}`; `truthyTest` already wraps its operand in a
+ *      function call (`$bf->truthy(...)`), which binds tighter than `!` in
+ *      PHP regardless of the surrounding expression, so no extra parens are
+ *      needed.
+ *   7. **`.` (dot) is PHP string concatenation, not member access.** Twig's
+ *      `~` operator becomes PHP's `.` in `templateLiteral`'s join — every
+ *      interpolated (non-string-literal) segment still routes through
+ *      `$bf->string(...)` first (PHP's own `(string)` cast, which `.`
+ *      invokes internally, diverges from JS `String(x)` — see
+ *      `blade-adapter.ts`'s file header, "Stringification").
+ *   8. **`===`/`!==` route through `$bf->eq`/`$bf->neq`, never PHP's own
+ *      `==`/`!=`/`===`/`!==`.** PHP's `==` is loose equality (`'1' == 1` is
+ *      `true` — wrong for JS strict equality), and PHP's OWN `===` is wrong
+ *      the other direction (`1 === 1.0` is `false` in PHP, but JS has one
+ *      number type — `1 === 1.0` is `true`). `$bf->eq`/`$bf->neq` are the
+ *      ONE shared JS-strict-equality implementation (mirrored by the
+ *      Evaluator's `_strict_eq`), so binary `===`/`!==` ALWAYS lower to a
+ *      method call here — same as the Twig port's divergence 4.
+ *   9. **No Blade lambda for the predicate-callback fallback** — unchanged
+ *      from Twig. `BladeTopLevelEmitter` uses ONE mechanism for every
+ *      higher-order callback (the evaluator-JSON `*_eval` payload). When
+ *      `serializeParsedExpr` refuses the body, the call surfaces `BF101`
+ *      instead of silently degrading — `.sort`/`.toSorted` is the one
+ *      exception, whose non-lambda STRUCTURED fallback (`$bf->sort` with a
+ *      `['keys' => […]]` descriptor) survives the port unchanged.
+ *      `BladeFilterEmitter` (the loop `.filter().map()` INLINE predicate,
+ *      rendered as a plain boolean expression, never a lambda) is otherwise
+ *      unaffected and still used for that path plus the filter-predicate
+ *      entry point `_renderBladeFilterExprPublic`.
+ */
+import { type ParsedExprEmitter, type ArrayMethod, type LiteralType, type ParsedExpr, type ObjectLiteralProperty, type FlatDepth, type TemplatePart } from '@barefootjs/jsx';
+import type { BladeEmitContext } from '../emit-context.ts';
+/**
+ * Route a condition-TEST position through `$bf->truthy(...)` unless the node
+ * is structurally already boolean-shaped. See the file header (divergence
+ * 4). Shared by both emitters below and reused by the adapter's top-level
+ * `convertConditionToBlade` for IR-level `if` / loop-filter conditions.
+ */
+export declare function truthyTest(node: ParsedExpr, rendered: string): string;
+/**
+ * Lowering for the predicate body of a filter / every / some / find, plus the
+ * same shape used by the loop-hoist `.filter().map()` inline condition.
+ * Higher-order predicates are emitted using PHP's own scalar comparison
+ * operators.
+ *
+ * NOTE: Blade/PHP has no `[x for x in … if …]`-as-expression form usable
+ * inline here (a comprehension is a value producer, not a boolean test), so
+ * a nested higher-order call (`x.tags.filter(...)`, `other.some(...)`)
+ * inside a predicate has no faithful scalar lowering here either — same
+ * BF101 surfacing as the Twig/Jinja ports (#2038) instead of silently
+ * degrading to the callback's receiver.
+ */
+export declare class BladeFilterEmitter implements ParsedExprEmitter {
+    private readonly param;
+    private readonly localVarMap;
+    private readonly isStringName;
+    private readonly onUnsupported?;
+    constructor(param: string, localVarMap: Map<string, string>, isStringName?: (n: string) => boolean, onUnsupported?: ((message: string, reason?: string) => void) | undefined);
+    identifier(name: string): string;
+    literal(value: string | number | boolean | null, literalType: LiteralType): string;
+    member(object: ParsedExpr, property: string, _computed: boolean, emit: (e: ParsedExpr) => string): string;
+    indexAccess(object: ParsedExpr, index: ParsedExpr, emit: (e: ParsedExpr) => string): string;
+    call(callee: ParsedExpr, args: ParsedExpr[], emit: (e: ParsedExpr) => string): string;
+    unary(op: string, argument: ParsedExpr, emit: (e: ParsedExpr) => string): string;
+    binary(op: string, left: ParsedExpr, right: ParsedExpr, emit: (e: ParsedExpr) => string): string;
+    logical(op: '&&' | '||' | '??', left: ParsedExpr, right: ParsedExpr, emit: (e: ParsedExpr) => string): string;
+    callbackMethod(method: string, object: ParsedExpr, _arrow: Extract<ParsedExpr, {
+        kind: 'arrow';
+    }>, _restArgs: ParsedExpr[], emit: (e: ParsedExpr) => string): string;
+    arrayLiteral(elements: ParsedExpr[], emit: (e: ParsedExpr) => string): string;
+    arrayMethod(method: ArrayMethod, object: ParsedExpr, args: ParsedExpr[], emit: (e: ParsedExpr) => string): string;
+    flatMethod(object: ParsedExpr, depth: FlatDepth | {
+        expr: ParsedExpr;
+    }, emit: (e: ParsedExpr) => string): string;
+    conditional(_test: ParsedExpr, _consequent: ParsedExpr, _alternate: ParsedExpr): string;
+    templateLiteral(_parts: TemplatePart[]): string;
+    arrow(_params: string[], _body: ParsedExpr): string;
+    regex(_raw: string): string;
+    unsupported(_raw: string, _reason: string): string;
+    objectLiteral(_properties: ObjectLiteralProperty[], _raw: string, _emit: (e: ParsedExpr) => string): string;
+}
+/**
+ * Lowering for top-level expressions whose identifiers resolve against the
+ * Blade template's per-render context vars (signals, props, locals
+ * introduced by `@php($x = …)`). Differs from the filter emitter mainly in
+ *   - `conditional` is supported (filter predicates can't return ternaries),
+ *   - higher-order methods route through `$bf->*` array/evaluator helpers,
+ *   - no lambda fallback exists (see the file header, divergence 9).
+ */
+export declare class BladeTopLevelEmitter implements ParsedExprEmitter {
+    private readonly ctx;
+    constructor(ctx: BladeEmitContext);
+    identifier(name: string): string;
+    literal(value: string | number | boolean | null, literalType: LiteralType): string;
+    member(object: ParsedExpr, property: string, _computed: boolean, emit: (e: ParsedExpr) => string): string;
+    indexAccess(object: ParsedExpr, index: ParsedExpr, emit: (e: ParsedExpr) => string): string;
+    call(callee: ParsedExpr, args: ParsedExpr[], emit: (e: ParsedExpr) => string): string;
+    unary(op: string, argument: ParsedExpr, emit: (e: ParsedExpr) => string): string;
+    binary(op: string, left: ParsedExpr, right: ParsedExpr, emit: (e: ParsedExpr) => string): string;
+    logical(op: '&&' | '||' | '??', left: ParsedExpr, right: ParsedExpr, emit: (e: ParsedExpr) => string): string;
+    callbackMethod(method: string, object: ParsedExpr, arrow: Extract<ParsedExpr, {
+        kind: 'arrow';
+    }>, restArgs: ParsedExpr[], emit: (e: ParsedExpr) => string): string;
+    /**
+     * Lower a boolean-predicate callback (`filter` / `find*` / `every` /
+     * `some`). See the file header, divergence 9: Blade has no lambda
+     * expression, so — unlike Kolon — there is no non-evaluator fallback here.
+     * A predicate the evaluator can't model surfaces `BF101`.
+     */
+    private _emitPredicateCallback;
+    arrayLiteral(elements: ParsedExpr[], emit: (e: ParsedExpr) => string): string;
+    arrayMethod(method: ArrayMethod, object: ParsedExpr, args: ParsedExpr[], emit: (e: ParsedExpr) => string): string;
+    flatMethod(object: ParsedExpr, depth: FlatDepth | {
+        expr: ParsedExpr;
+    }, emit: (e: ParsedExpr) => string): string;
+    conditional(test: ParsedExpr, consequent: ParsedExpr, alternate: ParsedExpr, emit: (e: ParsedExpr) => string): string;
+    templateLiteral(parts: TemplatePart[], emit: (e: ParsedExpr) => string): string;
+    arrow(_params: string[], _body: ParsedExpr): string;
+    regex(_raw: string): string;
+    unsupported(_raw: string, _reason: string): string;
+    objectLiteral(properties: ObjectLiteralProperty[], _raw: string, _emit: (e: ParsedExpr) => string): string;
+}
+//# sourceMappingURL=emitters.d.ts.map

package/dist/adapter/expr/emitters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitters.d.ts","sourceRoot":"","sources":["../../../src/adapter/expr/emitters.ts"],"names":[],"mappings":"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"}

package/dist/adapter/expr/operand.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Operand-type classification for the Blade template adapter.
+ *
+ * Ported from `packages/adapter-jinja/src/adapter/expr/operand.ts`. Pure
+ * function over `ParsedExpr` taking an `isStringName` predicate rather than
+ * reading adapter instance state.
+ *
+ * NOTE: unlike Kolon/Jinja, `===`/`!==` on this adapter ALWAYS route through
+ * `bf.eq`/`bf.neq` (see `blade-adapter.ts`'s file header, divergence 7) —
+ * Blade's own `==`/`!=` compile to PHP loose equality, which is wrong for JS
+ * strict-equality semantics regardless of operand type. This helper is
+ * therefore not consumed by the Blade lowering either — kept only as the
+ * parallel of the Jinja/Xslate/Mojo adapters' `expr/operand.ts` (groundwork
+ * for a future shared codegen surface).
+ */
+import type { ParsedExpr } from '@barefootjs/jsx';
+/**
+ * Whether a comparison operand is string-typed. In the Mojo adapter this
+ * selects Perl `eq`/`ne` over numeric `==`/`!=` for a `===`/`!==` against a
+ * string operand. Not consumed by the Blade emitters — `===`/`!==` always
+ * lowers to `bf.eq`/`bf.neq` regardless of operand type. Kept only as the
+ * parallel of the Jinja/Xslate/Mojo helper.
+ */
+export declare function isStringTypedOperand(expr: ParsedExpr, isStringName: (n: string) => boolean): boolean;
+//# sourceMappingURL=operand.d.ts.map

package/dist/adapter/expr/operand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operand.d.ts","sourceRoot":"","sources":["../../../src/adapter/expr/operand.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,OAAO,GAAG,OAAO,CASpG"}

package/dist/adapter/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Blade Template Adapter Exports
+ */
+export { BladeAdapter, bladeAdapter } from './blade-adapter.ts';
+export type { BladeAdapterOptions } from './blade-adapter.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/adapter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/adapter/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAC/D,YAAY,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA"}