@barefootjs/rust 0.1.0

package/README.md

@@ -0,0 +1,194 @@
+# @barefootjs/rust
+
+minijinja (Rust) adapter for BarefootJS: compiles the BarefootJS IR (JSX →
+IR, see `spec/compiler.md`) into `.j2` template files plus the client JS
+bundle every other adapter produces, and ships a Rust rendering runtime
+(`runtime/`, crate `barefootjs`) that renders those templates through a
+plain [`minijinja::Environment`](https://docs.rs/minijinja) — no framework
+is required (axum, actix-web, warp, bare `hyper`, etc. all work the same
+way).
+
+Near-verbatim port of `@barefootjs/jinja` (the Jinja2/Python adapter) to the
+`minijinja` Rust crate. **The emitted template syntax is IDENTICAL** to
+`@barefootjs/jinja`'s output — minijinja 2.21 is Jinja2-compatible for
+everything this adapter emits (verified by an orchestrator spike; see the
+Environment contract below). Only identity fields differ (`name: 'minijinja'`,
+`extension: '.j2'`, class `MinijinjaAdapter`) plus the render engine that
+interprets the syntax at request time (a Rust `minijinja::Environment`
+instead of Python's `jinja2.Environment`). See
+`src/adapter/minijinja-adapter.ts`'s header comment for the full
+Kolon↔Jinja2 syntax-mapping table (inherited unchanged from `@barefootjs/jinja`)
+and the JS-semantics divergences this port handles uniformly (truthiness,
+stringification, reserved-word identifier mangling, and the
+evaluator-only higher-order-callback lowering since Jinja has no lambda
+expression).
+
+## Template output shape
+
+- `name: 'minijinja'`, `extension: '.j2'`, `templatesPerComponent: true` —
+  one `.j2` file per component, named by snake-casing the PascalCase
+  component name (`UserCard` → `user_card.j2`).
+- Hydration markers (`bf-s`, `bf-h`/`bf-m`/`bf-r`, `bf-p`, slot/conditional
+  comment markers, loop boundary comments) use the SAME runtime method
+  names as every other adapter's `bf.*` calls (`bf.scope_attr()`,
+  `bf.hydration_attrs()`, `bf.text_start`/`text_end`, `bf.comment(...)`,
+  …) — see `spec/template-helpers.md` for the shared helper contract.
+- Every text/attribute interpolation of a possibly-non-string value is
+  routed through `bf.string(...)` (or `bf.bool_str(...)` for
+  boolean-shaped values); every non-comparison condition position is
+  routed through `bf.truthy(...)`. Both are pure Rust-runtime helpers —
+  see the Rust runtime pointer below.
+
+## The minijinja Environment contract
+
+This adapter's output assumes an `Environment` constructed exactly as
+follows (see `runtime/src/backend_minijinja.rs`):
+
+```rust
+let mut env = Environment::new();
+env.set_loader(minijinja::path_loader(templates_dir)); // .j2 files
+env.set_undefined_behavior(UndefinedBehavior::Chainable); // == Jinja2's ChainableUndefined; `missing.deep` renders '' — verified
+env.set_trim_blocks(true);
+env.set_lstrip_blocks(true);
+env.set_auto_escape_callback(|_| AutoEscape::Html); // REQUIRED: .j2 is not auto-escaped by default in minijinja
+env.set_formatter(<custom formatter>);
+```
+
+`trim_blocks`/`lstrip_blocks` are required because this adapter places
+`{% … %}` control tags on their own source line; without them every such
+line would leak a stray newline/indentation into the rendered HTML.
+
+The **custom formatter** is the uniform emit policy that absorbs the
+remaining JS/minijinja semantic differences (no per-fixture hacks anywhere —
+all divergence-absorption lives here plus in the `bf` runtime helpers):
+
+- `undefined`/`none` → print nothing
+- safe values → raw passthrough
+- strings → escape with MarkupSafe-compatible entities: `&` → `&amp;`, `<` →
+  `&lt;`, `>` → `&gt;`, `"` → `&quot;`, `'` → `&#39;` — **not** minijinja's
+  own default `&#x27;`; the conformance fixtures pin `&#39;` (matching
+  Python's MarkupSafe, which `@barefootjs/jinja`'s output also relies on)
+- numbers → JS `String(n)` formatting (`1.0` → `1`) via the centralized
+  `format_js_number` — this is a **fallback**; templates normally already
+  route a value through `bf.string(...)` before it reaches the formatter
+- bools → `true`/`false`
+
+### minijinja↔Jinja2 divergence record (orchestrator spike, minijinja 2.21.0)
+
+Verified compatible before committing to the near-verbatim port strategy:
+
+- `{{ missing }}` → `''`; `{% if missing.deep %}` → falsy, renders `''`
+  under `UndefinedBehavior::Chainable`
+- `(x if (x is defined and x is not none) else 'FB')` → `'FB'` for both
+  undefined AND `none`, the value otherwise ⇒ `@barefootjs/jinja`'s `??`
+  lowering ports verbatim
+- `{% set cap %}…{% endset %}` works; dict literals, `elif`, `loop.index0`,
+  `{% set %}` inside `{% for %}`, `~` concat, `| safe` all work identically
+  to Python's Jinja2
+- method calls on a custom `Object` (`bf.to_str(42)`) work via
+  `Object::call_method`
+- minijinja truthiness is Python-like (empty list/map/str are falsy) — same
+  as Python's Jinja2, and the reason JS truthiness MUST go through
+  `bf.truthy(...)` (the adapter already emits this, unchanged from the
+  Jinja2 port)
+
+No divergence found that required a per-fixture special case; every
+absorption point above is uniform (formatter, `bf` helper, or adapter emit
+rule).
+
+## Rust runtime
+
+`runtime/` is a self-contained Rust crate (`barefootjs`, deps: `minijinja`,
+`serde`, `serde_json`) implementing the engine-agnostic `bf` object every
+emitted template calls into: hydration markers, context propagation
+(`provide_context`/`use_context`), child-component rendering
+(`render_child`), script registration, and the JS-compatible helper library
+(`string`, `bool_str`, `truthy`, `number`, `floor`/`ceil`/`round`,
+array/string helpers, the `*_eval` evaluator helpers, `spread_attrs`,
+`query`, …). It mirrors the layering of `packages/adapter-jinja/python/barefootjs/`
+(an engine-agnostic core plus a thin per-engine backend) — see
+`spec/template-helpers.md` for the semantic contract each helper must
+satisfy, and the crate's own tests under `runtime/tests/`.
+
+The crate also ships a `bf-render` binary — a conformance renderer that
+reads a JSON payload (`templates_dir`, `entry`, `scope_id`, `vars`,
+`search_params?`, `children[]`) and writes the rendered HTML to stdout. It
+is what `src/test-render.ts` builds (once, memoized — `cargo build
+--manifest-path runtime/Cargo.toml --bin bf-render`) and spawns per
+conformance fixture; a production host would instead link the `barefootjs`
+library crate directly (see the axum sketch below) rather than shelling out
+to the binary.
+
+## Usage
+
+```ts
+// barefoot.config.ts
+import { createConfig } from '@barefootjs/rust/build'
+
+export default createConfig({
+  components: ['./src/components'],
+  outDir: './dist',
+})
+```
+
+`bf build` then emits `.j2` templates + client JS under `outDir`. A Rust
+host renders a component by constructing a `minijinja::Environment` (per
+the contract above) over `minijinja::path_loader` pointed at the emitted
+templates, wiring in the `barefootjs` crate's `backend_minijinja` module as
+the render backend:
+
+```rust
+use axum::{routing::get, Router};
+use barefootjs::{backend_minijinja::render_named, BarefootJS};
+
+async fn user_card() -> axum::response::Html<String> {
+    let mut bf = BarefootJS::new();
+    let html = render_named("user_card", &mut bf, /* vars */ Default::default());
+    axum::response::Html(html)
+}
+
+#[tokio::main]
+async fn main() {
+    let app = Router::new().route("/", get(user_card));
+    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
+    axum::serve(listener, app).await.unwrap();
+}
+```
+
+## Divergences from `@barefootjs/jinja`
+
+Beyond the identity fields (`name`, `extension`, class name) and the render
+engine itself, this is a near-verbatim port. One divergence DOES reach the
+emitted template syntax:
+
+- **Record/map lookup with a default.** Jinja2's dict has a `.get(k, d)`
+  method; `@barefootjs/jinja` emits `{'a': 'x', ...}.get(key, '')` for a
+  `Record<K, string>[key]` template-literal lookup. minijinja maps have no
+  `.get` method (`unknown method: map has no method named get`, verified).
+  This adapter instead emits `({'a': 'x', ...}[key] | default(''))`: a
+  missing-key index on a minijinja map returns `undefined` under
+  `UndefinedBehavior::Chainable`, and the builtin `default` filter supplies
+  the fallback inline (verified: `{{ {'a':'x'}[k] | default('DD') }}` →
+  `'DD'` on miss, `'x'` on hit, including nested in call args/string
+  concat). See `convertTemplateLiteralPartsToJinja`'s `lookup` branch in
+  `src/adapter/minijinja-adapter.ts`.
+
+The remaining divergences are all in the TypeScript side's places the
+conformance harness could not port byte-for-byte from `@barefootjs/jinja`,
+confined to `src/test-render.ts` (the conformance-render harness, not the
+adapter itself — the emitted template syntax is unaffected beyond the point
+above):
+
+- **Render invocation.** `@barefootjs/jinja` generates a throwaway Python
+  *script* per fixture (inline Python source building a props dict +
+  per-child renderer closures) and shells out to `python3`. This adapter
+  instead serializes the same information to a JSON *payload* and spawns
+  one long-lived compiled `bf-render` binary, built once per test run.
+- **Non-finite numbers.** JSON cannot represent `NaN`/`Infinity`/`-Infinity`
+  — the TS side recursively encodes them as `{"__bf_special": "nan" | "inf"
+  | "-inf"}` before `JSON.stringify`; `bf-render` decodes the sentinel back
+  to the corresponding `f64` after parsing.
+- **`vars` keys are unmangled.** Like `@barefootjs/jinja`'s Python props
+  dict, the JSON payload's `vars` keys are the RAW prop/signal/memo names;
+  reserved-word mangling happens in ONE place backend-side (the Rust
+  runtime's `render_named`, mirroring the Python runtime's `render_named`).

package/dist/adapter/analysis/component-tree.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Component-tree analysis for the minijinja template adapter.
+ *
+ * Ported from `packages/adapter-xslate/src/adapter/analysis/component-tree.ts`.
+ * Pure functions over the IR — they read no adapter instance state.
+ * `collectImportedLoopChildComponentErrors` returns its diagnostics instead
+ * of pushing onto the adapter's error list, so the adapter stays the sole
+ * owner of `errors`.
+ */
+import type { ComponentIR, CompilerError } from '@barefootjs/jsx';
+/**
+ * Whether the component needs the client runtime — it owns reactive state
+ * (signals / effects / onMount) or the analyzer flagged it as needing init.
+ */
+export declare function hasClientInteractivity(ir: ComponentIR): boolean;
+/**
+ * Build a `BF103` diagnostic for every component reference inside a loop body
+ * whose name is imported from a relative-path module. Mirror of the Go /
+ * Xslate / Jinja2 adapter's check — this adapter has the same
+ * cross-template-registration constraint at request time (each `.j2`
+ * component file must be registered with the shared `minijinja::Environment`
+ * loader alongside the parent). Returns the diagnostics so the caller pushes
+ * them onto its own error list.
+ */
+export declare function collectImportedLoopChildComponentErrors(ir: ComponentIR, componentName: string): CompilerError[];
+//# sourceMappingURL=component-tree.d.ts.map

package/dist/adapter/analysis/component-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-tree.d.ts","sourceRoot":"","sources":["../../../src/adapter/analysis/component-tree.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,WAAW,EAUX,aAAa,EACd,MAAM,iBAAiB,CAAA;AAExB;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO,CAO/D;AAED;;;;;;;;GAQG;AACH,wBAAgB,uCAAuC,CACrD,EAAE,EAAE,WAAW,EACf,aAAa,EAAE,MAAM,GACpB,aAAa,EAAE,CAqEjB"}

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

@@ -0,0 +1,85 @@
+/**
+ * Structural classifier for JS expressions whose result is a boolean value
+ * (or unambiguously stringifies to "true"/"false" in JS).
+ *
+ * Near-verbatim port of `packages/adapter-jinja/src/adapter/boolean-result.ts`
+ * (itself ported from `packages/adapter-xslate/src/adapter/boolean-result.ts`,
+ * which was ported from the Mojo adapter's `bf->bool_str` classifier). Used
+ * by this adapter for TWO purposes — one inherited from Xslate, one new:
+ *
+ * 1. **Attribute/text stringification** (inherited): route a boolean-shaped
+ *    reactive binding through the runtime `bf.bool_str` helper so the
+ *    serialised value matches JS `String(boolean)` ("true"/"false"). Python
+ *    has a real `bool` type (unlike Perl's `1`/`''`), but Python's own
+ *    `str(True)` == `"True"` (capitalised) — still wrong for HTML output —
+ *    so the same explicit routing is required.
+ * 2. **Condition-position truthy wrapping** (new — `isBooleanResultParsed` is
+ *    exported, not just the string-based `isBooleanResultExpr`): Python
+ *    truthiness diverges from JS specifically on empty containers (`[]` /
+ *    `{}` are JS-truthy, Python-falsy). Perl doesn't have this problem — a
+ *    Perl array/hash REFERENCE is always true, matching JS objects/arrays
+ *    being unconditionally truthy — which is why Xslate never needed a
+ *    truthy-routing layer for `if`/ternary/`&&`/`||` conditions. The Jinja
+ *    adapter's condition-emission call sites (see `minijinja-adapter.ts`'s
+ *    `convertConditionToJinja`) 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
+ * `convertExpressionToJinja` 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 (unlike Xslate's private equivalent) 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
+ * `minijinja-adapter.ts`'s `elementAttrEmitter`: `bf.string` and `bf.bool_str`
+ * produce IDENTICAL text for a real Python `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 Python-truthiness test over that STRING
+ * ("false" is a non-empty Python string, hence truthy, so
+ * `bf.bool_str(bf.string(false))` would wrongly render `"true"`). The Kolon
+ * port has the identical double-wrap shape and "works" only by an
+ * unrelated accident (`JSON::PP::Boolean` stringifies to `"0"`/`"1"`, and
+ * Perl specifically treats the STRING `"0"` as falsy) that doesn't hold in
+ * Python. An author who explicitly writes `String(...)` has already opted
+ * into JS `String()` semantics — `bf.string(x)` alone (which DOES special-
+ * case booleans, see `runtime.js_string`) 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAalE;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAuB/D;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAIzD;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;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,107 @@
+/**
+ * The contract the extracted expression-emitter modules depend on instead of
+ * the concrete `MinijinjaAdapter`.
+ *
+ * Near-verbatim port of `packages/adapter-jinja/src/adapter/emit-context.ts`
+ * (itself ported from `packages/adapter-xslate/src/adapter/emit-context.ts`).
+ * This 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 `JinjaTopLevelEmitter` still needs to call back
+ * into shared per-compile state and recursive entry points.
+ * `JinjaEmitContext` is that seam: the emitter takes a `JinjaEmitContext`
+ * 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 JinjaEmitContext {
+    /**
+     * (#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 Jinja value, or null. */
+    _resolveLiteralConst(name: string): string | null;
+    /**
+     * Resolve a static property access on a module object-literal const
+     * (`variantClasses.ghost`) to its Jinja 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 Jinja form, bound to `param`. */
+    _renderJinjaFilterExprPublic(expr: ParsedExpr, param: string): string;
+}
+/**
+ * The contract the extracted object-literal / conditional-spread lowering
+ * (`spread/spread-codegen.ts`) depends on. Declared separately from
+ * `JinjaEmitContext` so each extracted module's real coupling is documented
+ * precisely. Mirror of the Xslate adapter's `XslateSpreadContext`.
+ */
+export interface JinjaSpreadContext {
+    /** 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 Jinja 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 `''`.
+     */
+    convertExpressionToJinja(expr: string, preParsed?: ParsedExpr): string;
+    /**
+     * Lower a JS expression to a Jinja 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 `convertExpressionToJinja`.
+     */
+    convertConditionToJinja(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 JinjaMemoContext {
+    /**
+     * Lower a JS expression to its Jinja form (the core recursive entry). See
+     * `JinjaSpreadContext.convertExpressionToJinja` for the `preParsed` contract.
+     */
+    convertExpressionToJinja(expr: string, preParsed?: ParsedExpr): string;
+    /**
+     * Per-compile diagnostic list `convertExpressionToJinja` 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 `convertExpressionToJinja` 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;;;;;;;;;;;;;;;;;;;;GAoBG;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,75 @@
+/**
+ * Array / string method lowering for the minijinja template adapter.
+ *
+ * Ported from `packages/adapter-xslate/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 Xslate adapter
+ * calls, invoked as `bf.NAME(...)` (bare, no `$` sigil) instead of
+ * `$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
+ * Jinja 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/Xslate 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 Jinja 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;;;;;;;;;;;GAWG;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,143 @@
+/**
+ * ParsedExpr → Jinja2 emitters for the minijinja template adapter.
+ *
+ * Ported from `packages/adapter-xslate/src/adapter/expr/emitters.ts`
+ * (`XslateFilterEmitter` / `XslateTopLevelEmitter`). Two `ParsedExprEmitter`
+ * implementations:
+ *
+ *   - `JinjaFilterEmitter` — filter/predicate context (loop param + local
+ *     aliases + bare identifier signal fallback); self-contained, reads no
+ *     adapter state.
+ *   - `JinjaTopLevelEmitter` — top-level / per-render-var context; depends on
+ *     the adapter only through the narrow `JinjaEmitContext` seam.
+ *
+ * Two deliberate divergences from the Kolon port, both documented at their
+ * definition site below:
+ *
+ *   1. **JS-truthy condition wrapping** (`truthyTest`) — Python truthiness
+ *      diverges from JS on empty containers; Perl doesn't have this problem
+ *      (a Perl ref is always true), so Kolon never needed this. 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, not `true` — only the BRANCH TEST uses
+ *      `bf.truthy`. Because Jinja's `if/else` ternary has no way to reuse an
+ *      already-computed test value for both the test and (conditionally) the
+ *      result, 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 (a signal/prop lookup
+ *      or a call into a pure runtime helper), never a stateful expression.
+ *   2. **No Jinja lambda for the predicate-callback fallback.** Kolon's
+ *      `-> $x { … }` lambda is the Xslate top-level emitter's fallback when a
+ *      `.filter`/`.every`/`.some`/`.find*` predicate can't be serialized to
+ *      the runtime evaluator's JSON form (e.g. a nested method-call
+ *      predicate). Jinja has no lambda-expression syntax at all, so there is
+ *      no equivalent fallback to port. `JinjaTopLevelEmitter` therefore uses
+ *      ONE mechanism for every higher-order callback: the evaluator-JSON
+ *      `*_eval` payload (`bf.filter_eval`, `bf.sort_eval`, …). 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, no callback body at all) survives the port
+ *      unchanged since it was never lambda-shaped to begin with.
+ *      `JinjaFilterEmitter` (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 `_renderJinjaFilterExprPublic`.
+ */
+import { type ParsedExprEmitter, type ArrayMethod, type LiteralType, type ParsedExpr, type ObjectLiteralProperty, type FlatDepth, type TemplatePart } from '@barefootjs/jsx';
+import type { JinjaEmitContext } 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
+ * 1). Shared by both emitters below and reused by the adapter's top-level
+ * `convertConditionToJinja` 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 Jinja's own scalar comparison
+ * operators.
+ *
+ * NOTE: Jinja 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 Kolon (#2038) instead of silently degrading to the
+ * callback's receiver.
+ */
+export declare class JinjaFilterEmitter 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
+ * Jinja template's per-render context vars (signals, props, locals
+ * introduced by `{% set 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 2).
+ */
+export declare class JinjaTopLevelEmitter implements ParsedExprEmitter {
+    private readonly ctx;
+    constructor(ctx: JinjaEmitContext);
+    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 2: Jinja 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