@barefootjs/jinja 0.1.0

package/README.md

@@ -0,0 +1,66 @@
+# @barefootjs/jinja
+
+Jinja2 adapter for BarefootJS: compiles the BarefootJS IR (JSX → IR, see
+`spec/compiler.md`) into `.jinja` template files plus the client JS bundle
+every other adapter produces, and ships a Python rendering runtime
+(`python/barefootjs/`) that renders those templates through a plain
+`jinja2.Environment` — no framework is required (Flask, Django, bare WSGI,
+etc. all work the same way).
+
+Near-mechanical port of `@barefootjs/xslate` (the Text::Xslate/Kolon
+adapter) to Jinja2 syntax. See `src/adapter/jinja-adapter.ts`'s header
+comment for the full Kolon↔Jinja syntax-mapping table and the JS/Python
+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: 'jinja'`, `extension: '.jinja'`, `templatesPerComponent: true` —
+  one `.jinja` file per component, named by snake-casing the PascalCase
+  component name (`UserCard` → `user_card.jinja`).
+- 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 Python-runtime helpers —
+  see the Python runtime pointer below.
+
+## Python runtime
+
+`python/barefootjs/` is a self-contained Python package (only dependency:
+`jinja2`) 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-perl/lib/` (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 package's own tests under `python/tests/`.
+
+## Usage
+
+```ts
+// barefoot.config.ts
+import { createConfig } from '@barefootjs/jinja/build'
+
+export default createConfig({
+  components: ['./src/components'],
+  outDir: './dist',
+})
+```
+
+`bf build` then emits `.jinja` templates + client JS under `outDir`. A
+Python host renders a component by constructing a `jinja2.Environment`
+(with `autoescape=True`, `undefined=jinja2.ChainableUndefined`,
+`trim_blocks=True`, `lstrip_blocks=True` — see the adapter header comment
+for why the last two are required) over a `FileSystemLoader` pointed at
+the emitted templates, wiring in `barefootjs.backend_jinja` as the render
+backend.

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

@@ -0,0 +1,26 @@
+/**
+ * Component-tree analysis for the Jinja2 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 adapter's check — the Jinja adapter has the same
+ * cross-template-registration constraint at request time (each `.jinja`
+ * component file must be registered with the shared `jinja2.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,84 @@
+/**
+ * Structural classifier for JS expressions whose result is a boolean value
+ * (or unambiguously stringifies to "true"/"false" in JS).
+ *
+ * Ported from `packages/adapter-xslate/src/adapter/boolean-result.ts`
+ * (itself ported from the Mojo adapter's `bf->bool_str` classifier). Used by
+ * the Jinja 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 `jinja-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
+ * `jinja-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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;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,106 @@
+/**
+ * The contract the extracted expression-emitter modules depend on instead of
+ * the concrete `JinjaAdapter`.
+ *
+ * Ported from `packages/adapter-xslate/src/adapter/emit-context.ts`. The
+ * Jinja 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;;;;;;;;;;;;;;;;;;;GAmBG;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 Jinja2 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 Jinja 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

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":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEH,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,qBAAqB,EAC1B,KAAK,SAAS,EACd,KAAK,YAAY,EAIlB,MAAM,iBAAiB,CAAA;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AA+B1D;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAErE;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,kBAAmB,YAAW,iBAAiB;IAExD,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,YAAY;IAI7B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC;IAPjC,YACmB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,YAAY,GAAE,CAAC,CAAC,EAAE,MAAM,KAAK,OAAqB,EAIlD,aAAa,CAAC,GAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,aAAA,EACzE;IAEJ,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAK/B;IAED,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,EAAE,WAAW,EAAE,WAAW,GAAG,MAAM,CAKjF;IAED,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAAG,MAAM,CAUxG;IAED,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAAG,MAAM,CAK1F;IAED,IAAI,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAAG,MAAM,CAMpF;IAED,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAAG,MAAM,CAI/E;IAED,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAAG,MAAM,CAW/F;IAED,OAAO,CAAC,EAAE,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAAG,MAAM,CAoB5G;IAED,cAAc,CACZ,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,OAAO,CAAC,UAAU,EAAE;QAAE,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC,EAC9C,SAAS,EAAE,UAAU,EAAE,EACvB,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAC9B,MAAM,CASR;IAED,YAAY,CAAC,QAAQ,EAAE,UAAU,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAAG,MAAM,CAE5E;IAED,WAAW,CACT,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,UAAU,EAAE,EAClB,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAC9B,MAAM,CAER;IAED,UAAU,CACR,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,SAAS,GAAG;QAAE,IAAI,EAAE,UAAU,CAAA;KAAE,EACvC,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAC9B,MAAM,CAER;IAED,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,GAAG,MAAM,CAEtF;IAED,eAAe,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,MAAM,CAE9C;IAED,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,UAAU,GAAG,MAAM,CAElD;IAED,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE1B;IAED,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAEjD;IAED,aAAa,CAAC,WAAW,EAAE,qBAAqB,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAAG,MAAM,CAK1G;CACF;AAED;;;;;;;;GAQG;AACH,qBAAa,oBAAqB,YAAW,iBAAiB;IAChD,OAAO,CAAC,QAAQ,CAAC,GAAG;IAAhC,YAA6B,GAAG,EAAE,gBAAgB,EAAI;IAEtD,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAc/B;IAED,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,EAAE,WAAW,EAAE,WAAW,GAAG,MAAM,CAKjF;IAED,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAAG,MAAM,CAoBxG;IAED,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAAG,MAAM,CAI1F;IAED,IAAI,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAAG,MAAM,CA+BpF;IAED,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAAG,MAAM,CAI/E;IAED,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAAG,MAAM,CAU/F;IAED,OAAO,CAAC,EAAE,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAAG,MAAM,CAW5G;IAED,cAAc,CACZ,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,OAAO,CAAC,UAAU,EAAE;QAAE,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC,EAC7C,QAAQ,EAAE,UAAU,EAAE,EACtB,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAC9B,MAAM,CA2ER;IAED;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IA6B9B,YAAY,CAAC,QAAQ,EAAE,UAAU,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAAG,MAAM,CAE5E;IAED,WAAW,CACT,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,UAAU,EAAE,EAClB,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAC9B,MAAM,CAER;IAED,UAAU,CACR,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,SAAS,GAAG;QAAE,IAAI,EAAE,UAAU,CAAA;KAAE,EACvC,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAC9B,MAAM,CAER;IAED,WAAW,CACT,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,UAAU,EACrB,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAC9B,MAAM,CAER;IAED,eAAe,CAAC,KAAK,EAAE,YAAY,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAAG,MAAM,CAwB9E;IAED,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,UAAU,GAAG,MAAM,CAMlD;IAED,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAG1B;IAED,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAEjD;IAED,aAAa,CAAC,UAAU,EAAE,qBAAqB,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAAG,MAAM,CAWzG;CACF"}

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

@@ -0,0 +1,25 @@
+/**
+ * Operand-type classification for the Jinja2 template adapter.
+ *
+ * Ported from `packages/adapter-xslate/src/adapter/expr/operand.ts`. Pure
+ * function over `ParsedExpr` taking an `isStringName` predicate rather than
+ * reading adapter instance state.
+ *
+ * NOTE: like Kolon's `==`/`!=`, Jinja/Python's `==`/`!=` are value-equality
+ * operators that compare strings and numbers correctly, so the Jinja
+ * emitters never need to steer string comparisons onto a different operator
+ * family. This helper is therefore not consumed by the Jinja lowering
+ * today either — kept only as the parallel of the 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. Neither the Kolon nor the Jinja emitters consume it —
+ * both languages' `==`/`!=` compare strings and numbers correctly, so
+ * `===`/`!==` always map to `==`/`!=`. Kept only as the parallel of the
+ * 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;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD;;;;;;;GAOG;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 @@
+/**
+ * Jinja2 Template Adapter Exports
+ */
+export { JinjaAdapter, jinjaAdapter } from './jinja-adapter.ts';
+export type { JinjaAdapterOptions } from './jinja-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"}