@barefootjs/erb 0.17.0

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

@@ -0,0 +1,24 @@
+/**
+ * Component-tree analysis for the ERB template adapter.
+ *
+ * Ported from the Mojolicious adapter's `analysis/component-tree.ts` (issue
+ * #2018 track D lineage). 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 /
+ * Mojo adapters' check — the ERB adapter has the same cross-template-
+ * registration constraint at request time. 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;;;;;;GAMG;AACH,wBAAgB,uCAAuC,CACrD,EAAE,EAAE,WAAW,EACf,aAAa,EAAE,MAAM,GACpB,aAAa,EAAE,CA0EjB"}

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

@@ -0,0 +1,66 @@
+/**
+ * Structural classifier for JS expressions whose result is a boolean
+ * value (or unambiguously stringifies to "true"/"false" in JS).
+ *
+ * Used by the ERB adapter's `emitExpression` to decide whether to
+ * route a reactive attribute binding through the `bf.bool_str` Ruby
+ * runtime helper (mirrors the Mojo/Xslate adapters' `bool_str` use).
+ * Ruby has no bare-comparison-to-string coercion either: `(count > 0)`
+ * evaluates to `true`/`false` objects, which `to_s` would render as
+ * the literal strings `"true"`/`"false"` — that part already matches
+ * JS `String(boolean)`. The wrapper still exists for parity with the
+ * Perl/Kolon family and for the cases below where the source
+ * expression is *opaque* (a bare call) but the attribute name
+ * witnesses a boolean value.
+ *
+ * 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 `convertExpressionToRuby` 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. Those
+ * carry their own (Ruby-coerced) value through unchanged, which
+ * stays correct for non-boolean shapes.
+ */
+export declare function isBooleanResultExpr(expr: string): boolean;
+export declare function isAriaBooleanAttr(name: string): boolean;
+/**
+ * True when `expr` is (structurally) a top-level `String(...)` call — the
+ * one JS shape that has ALREADY fully stringified its argument per JS
+ * `String(boolean)` semantics before the attribute emitter's `bool_str`
+ * wrap decision runs. `convertExpressionToRuby` lowers `String(x)` through
+ * the `ERB_TEMPLATE_PRIMITIVES` registry to `bf.string(x)`, which for a
+ * real Ruby `true`/`false` already returns the JS-correct `"true"` /
+ * `"false"` text (`Context#string`'s `TrueClass`/`FalseClass` branch).
+ * Piping that STRING through `bf.bool_str` again is a bug, not a harmless
+ * no-op: Ruby has no falsy-string (only `nil`/`false` are falsy), so
+ * `bf.bool_str("false")` unconditionally returns `"true"` — every
+ * `aria-checked={String(props.checked ?? false)}`-shaped binding would
+ * render `"true"` regardless of the underlying value. Perl doesn't share
+ * this bug (`"0"` — what `JSON::PP::false` stringifies to — IS Perl-falsy),
+ * which is why the Mojo/Xslate emitters don't need this guard; ERB's
+ * truthiness model requires it. Detected structurally off the parsed
+ * expression (not a text scan), so a user-defined helper merely NAMED
+ * `String` elsewhere can't false-positive: the aria-attr / boolean-result
+ * detectors already need real parse trees, and a bespoke `String` lookalike
+ * would need to be a genuinely zero-ambiguity call-to-`String` shape to
+ * match here in the first place.
+ */
+export declare function isExplicitStringCall(expr: 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAwCH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAIzD;AA2CD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAI1D"}

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

@@ -0,0 +1,107 @@
+/**
+ * The contract the extracted expression-emitter modules depend on instead of
+ * the concrete `ErbAdapter`.
+ *
+ * The ERB 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 `ErbTopLevelEmitter` still needs to call back into shared
+ * per-compile state and recursive entry points. `ErbEmitContext` is that
+ * seam: the emitter takes an `ErbEmitContext` 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 — matching
+ * the Mojo/Go adapters' `emitCtx`). The emitter depends on this narrow
+ * interface rather than the full adapter 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 ErbEmitContext {
+    /**
+     * 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 Ruby value, or null. */
+    resolveLiteralConst(name: string): string | null;
+    /**
+     * Resolve a static property access on a module object-literal const
+     * (`variantClasses.ghost`) to its Ruby value at compile time, or null.
+     */
+    resolveStaticRecordLiteral(objectName: string, key: string): string | null;
+    /**
+     * Whether `name` currently names a bare Ruby local bound by an enclosing
+     * loop/block (`todos().map(todo => ...)` → `|todo|`) — as opposed to a
+     * prop / signal / memo / module const, which always resolves through the
+     * `v[:name]` vars Hash. This is the ERB-specific branch point the Mojo/
+     * Kolon adapters don't need: Perl's `$name` sigil resolves a lexical
+     * loop var and a stash var identically, but ERB's two-locals variable
+     * model (`bf`, `v`) requires the identifier emitter to choose between a
+     * bare Ruby local and a `v[:name]` hash lookup.
+     */
+    isLoopBoundName(name: string): boolean;
+    /** Whether a getter/prop name resolves to a string-typed SSR value. */
+    _isStringValueName(name: string): boolean;
+    /** Record a BF101 unsupported-expression diagnostic. */
+    _recordExprBF101(message: string, reason?: string): void;
+    /** Lower a filter/predicate body to its Ruby form, bound to `param`. */
+    _renderRubyFilterExprPublic(expr: ParsedExpr, param: string): string;
+}
+/**
+ * The contract the extracted object-literal / conditional-spread lowering
+ * (`spread/spread-codegen.ts`) depends on. The spread lowering recurses into
+ * the core expression lowering and records its own BF101 diagnostics, so it
+ * needs the recursive entry point plus the per-compile bookkeeping the
+ * adapter owns. Declared separately from `ErbEmitContext` so each extracted
+ * module's real coupling is documented precisely.
+ */
+export interface ErbSpreadContext {
+    /** 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 Ruby 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` — mirrors go-template's
+     * `convertExpressionToGo(jsExpr, out?, preParsed?)`. With `preParsed` set,
+     * `expr` is unused for parsing (the converter derives any diagnostic text
+     * from the tree), so callers may pass `''`.
+     */
+    convertExpressionToRuby(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 ErbMemoContext {
+    /**
+     * Lower a JS expression to its Ruby 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` — mirrors go-template's
+     * `convertExpressionToGo(jsExpr, out?, preParsed?)`. With `preParsed` set,
+     * `expr` is unused for parsing (the converter derives any diagnostic text
+     * from the tree), so callers may pass `''`.
+     */
+    convertExpressionToRuby(expr: string, preParsed?: ParsedExpr): string;
+}
+//# 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,cAAc;IAC7B;;;OAGG;IACH,QAAQ,CAAC,mBAAmB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAEzC;;;OAGG;IACH,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;IAErD,mFAAmF;IACnF,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;IAEhD;;;OAGG;IACH,0BAA0B,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;IAE1E;;;;;;;;;OASG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAA;IAEtC,uEAAuE;IACvE,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAA;IAEzC,wDAAwD;IACxD,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAExD,wEAAwE;IACxE,2BAA2B,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CACrE;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B,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;;;;;;;;;OASG;IACH,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,UAAU,GAAG,MAAM,CAAA;CACtE;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;;;;;OASG;IACH,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,UAAU,GAAG,MAAM,CAAA;CACtE"}

package/dist/adapter/erb-adapter.d.ts

@@ -0,0 +1,374 @@
+/**
+ * BarefootJS ERB (Embedded Ruby) Template Adapter
+ *
+ * Generates ERB template files (.erb) from BarefootJS IR. Ported from the
+ * Mojolicious EP adapter (`@barefootjs/mojolicious`) — EP (Embedded Perl)
+ * maps 1:1 onto ERB (Embedded Ruby) for control flow and hydration-marker
+ * shape; the substantive divergences are:
+ *
+ *   - **Variable model.** Templates receive exactly two locals: `bf`
+ *     (runtime) and `v` (vars Hash, symbol keys). Every prop / signal /
+ *     memo / module-constant reference lowers to `v[:name]` — never a bare
+ *     Ruby local. Perl's uniform `$name` sigil doesn't need this split
+ *     (a lexical `my $name` and a stash `$name` render identically); Ruby's
+ *     bare-identifier ambiguity (reserved words, leading-uppercase =
+ *     constant) is why props/signals/consts move to a Hash instead.
+ *     Loop/block params are the one case that stays a bare Ruby local
+ *     (`lib/ruby-naming.ts::rubyLocal`).
+ *   - **Escaping.** Mojo's `<%= %>` auto-escapes; stdlib ERB does not — every
+ *     text/attribute-value interpolation that was a plain mojo `<%= %>`
+ *     becomes ERB `<%= bf.h(...) %>`. Every *raw* mojo `<%== %>` (runtime
+ *     helper output, already HTML) becomes a plain ERB `<%= %>` (no `bf.h`
+ *     — the plan's blanket EP→ERB mapping rule, applied mechanically
+ *     everywhere so there's exactly one place to audit for escaping bugs).
+ *   - **Ruby truthiness.** Ruby's falsy set is only `nil`/`false` — JS's is
+ *     `false, 0, NaN, "", null/undefined`. Every JS conditional TEST (`if`,
+ *     `&&`, `||`, `!`, `?:`) wraps in `bf.truthy?(...)`; ERB conditionals
+ *     wrap the same way. See `expr/emitters.ts`'s file docstring for the
+ *     `&&`/`||` operand-returning rewrite this forces.
+ *   - **Content capture.** Mojo's `begin %>…<% end` block-capture (for
+ *     forwarded JSX children / async fallback) has no ERB syntax analog;
+ *     ERB captures by slicing the shared output buffer around the nested
+ *     render (see `renderComponent` / `renderAsync`).
+ *
+ * See `expr/emitters.ts`, `expr/operand.ts`, and `lib/ruby-naming.ts` for
+ * the rest of the Perl→Ruby emission-contract detail.
+ */
+import type { ComponentIR, IRNode, IRElement, IRText, IRExpression, IRConditional, IRLoop, IRComponent, IRFragment, IRSlot, IRIfStatement, IRProvider, IRAsync, TemplatePrimitiveRegistry } from '@barefootjs/jsx';
+import { BaseAdapter, type AdapterOutput, type AdapterGenerateOptions, type IRNodeEmitter, type EmitIRNode } from '@barefootjs/jsx';
+import type { ErbRenderCtx } from './lib/types.ts';
+export type { ErbAdapterOptions } from './lib/types.ts';
+import type { ErbAdapterOptions } from './lib/types.ts';
+export declare class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCtx> {
+    name: string;
+    extension: string;
+    templatesPerComponent: boolean;
+    importMapInjection: 'html-snippet';
+    /**
+     * Identifier-path callees the ERB runtime can render in template scope.
+     * The relocate pass consults this map to mark matching calls as
+     * template-safe so the surrounding expression stays inlinable; the SSR
+     * template emitter substitutes the JS call with the registered Ruby
+     * helper invocation.
+     */
+    templatePrimitives: TemplatePrimitiveRegistry;
+    private componentName;
+    /** The component's root scope element(s) — each carries `data-key` for a
+     *  keyed loop item (set by the child renderer from the JSX `key` prop). A
+     *  plain element root is a single node; an `if-statement` (early-return)
+     *  root contributes the top element of every branch, since any one of
+     *  them can be the rendered root at runtime. */
+    private rootScopeNodes;
+    private options;
+    private errors;
+    private inLoop;
+    /**
+     * SolidJS-style props identifier (`function(props: P)`) and the
+     * analyzer-extracted prop names. Stashed at `generate()` entry so the
+     * per-attribute `emitSpread` callback can build a propsObject spread bag
+     * as an inline Ruby Hash literal without re-walking the IR.
+     */
+    private propsObjectName;
+    private propsParams;
+    private booleanTypedProps;
+    /**
+     * Names that resolve to a real SSR template var (via `v[:name]`) — prop
+     * param, signal getter, or memo. A `<Ctx.Provider value>` member
+     * referencing a name NOT in this set is a client-only function (a local
+     * handler const, or a signal setter) with no SSR value: it would read an
+     * un-seeded vars-Hash key, so it's lowered to `nil` instead.
+     */
+    private providerDataNames;
+    /**
+     * Names (signal getters + props) whose value is a string. Ruby's `==`
+     * doesn't drive equality-operator selection the way Perl's `eq`/`ne`
+     * split does (see `props/prop-classes.ts`), but this set still gates
+     * index-access Hash-vs-Array lowering (`expr/operand.ts`).
+     */
+    private stringValueNames;
+    /**
+     * Local binding names the request-scoped `searchParams()` env signal is
+     * imported under (handles `import { searchParams as sp }`). When
+     * non-empty the emitter lowers a `<binding>().get(k)` call to a real
+     * method call on the reserved `v[:search_params]` reader instead of the
+     * generic Hash lookup. Set at `generate()` entry from `ir.metadata.imports`;
+     * read by the top-level ParsedExpr emitter.
+     */
+    private _searchParamsLocals;
+    /**
+     * Call-lowering matchers active for this component. Bound at
+     * `generate()` entry via `prepareLoweringMatchers` and read by the
+     * top-level emitter. Covers both userland plugins and the compiler's
+     * built-in plugins (e.g. `queryHref` → `bf.query`) — one uniform path,
+     * no per-API branch.
+     */
+    private _loweringMatchers;
+    /**
+     * Module-scope pure string-literal constants (`const X = 'literal'` at
+     * file top-level), keyed by name → resolved literal value. Populated at
+     * `generate()` entry from `ir.metadata.localConstants`. When an
+     * identifier in an expression resolves to one of these, the adapter
+     * inlines the literal instead of emitting `v[:X]` against a vars-Hash key
+     * that is never seeded (a module const isn't a prop, signal, or local —
+     * the value would render empty).
+     */
+    private moduleStringConsts;
+    /**
+     * Full local-constant metadata from the entry IR, kept so spread
+     * lowering can resolve a bare-identifier spread (`{...sizeAttrs}`) to
+     * its initializer text and a `Record[propKey]` spread value to the
+     * module-const object literal it indexes. Populated at `generate()`
+     * entry alongside `moduleStringConsts`.
+     */
+    private localConstants;
+    /**
+     * Names currently bound by an enclosing loop body — the block-param
+     * locals `renderLoop` introduces (item, index, per-binding destructure
+     * fields) — ref-counted so nested loops compose. This is load-bearing
+     * for TWO things in the ERB adapter (more than the Mojo original, which
+     * only used it to guard const-inlining): it also decides the
+     * fundamental `v[:name]` vs bare-Ruby-local rendering choice in
+     * `ErbTopLevelEmitter.identifier` — see `emit-context.ts`'s
+     * `isLoopBoundName` docstring for why ERB's two-locals model needs this
+     * where Perl's uniform `$name` sigil does not.
+     */
+    private loopBoundNames;
+    /**
+     * Prop names whose value is `nil` in the template body when the caller
+     * omits them — so a bare-reference attribute should be dropped rather
+     * than rendered as `attr=""`. See `props/prop-classes.ts`'s
+     * `collectNullableOptionalProps` for the exact population criterion.
+     * Used by `elementAttrEmitter.emitExpression` to guard such an attribute
+     * with a Ruby nil-check (`<textarea>` omits `rows`), matching Hono's
+     * nullish-attribute omission.
+     */
+    private nullableOptionalProps;
+    constructor(options?: ErbAdapterOptions);
+    generate(ir: ComponentIR, options?: AdapterGenerateOptions): AdapterOutput;
+    /**
+     * Whether `expr` is a bare reference to a boolean-TYPED prop
+     * (`props.isActive` / destructured `isActive`) — used to route the
+     * binding through `bool_str` even though the expression itself is
+     * structurally opaque.
+     */
+    isBooleanTypedPropRef(expr: string): boolean;
+    /**
+     * Whether an attribute-value expression should route through
+     * `bf.bool_str` (single source of truth for all three attribute-emission
+     * call sites that make this decision). Three witnesses (any one
+     * suffices): the JS source structurally evaluates to a boolean
+     * (`isBooleanResultExpr`), the attribute name is one of the ARIA
+     * true/false(/mixed) names (`isAriaBooleanAttr` — the expression itself
+     * may be opaque, e.g. `accepted()`), or the expression is a bare
+     * reference to a boolean-TYPED prop (`isBooleanTypedPropRef`).
+     *
+     * EXCEPT when the expression is already a top-level `String(...)` call
+     * (`isExplicitStringCall`): `convertExpressionToRuby` lowers that to
+     * `bf.string(...)`, which for a real boolean already returns the
+     * JS-correct `"true"`/`"false"` text — wrapping that STRING in
+     * `bf.bool_str` again is a bug (Ruby has no falsy-string, so
+     * `bf.bool_str("false")` always returns `"true"`), not a harmless
+     * no-op. See `isExplicitStringCall`'s docstring for the full
+     * Perl-vs-Ruby truthiness contrast.
+     */
+    private shouldWrapBoolStr;
+    /**
+     * Parse `cond ? value : undefined` (or `: null`), returning the
+     * condition/consequent source spans, else `null`. Used for the
+     * attribute-omission rule; mirrors the Mojo/Xslate adapters.
+     */
+    parseUndefinedAlternateTernary(expr: string): {
+        condition: string;
+        consequent: string;
+    } | null;
+    /**
+     * Inline a const (any scope) whose initializer is a pure numeric or
+     * quoted string literal (`const totalPages = 5`) — function-scope
+     * consts never reach the per-render vars Hash, so a bare `v[:totalPages]`
+     * would read nil.
+     */
+    private resolveLiteralConst;
+    private resolveStaticRecordLiteral;
+    private resolveModuleStringConst;
+    /** Whether `name` currently names a loop-bound Ruby local. See
+     *  `ErbEmitContext.isLoopBoundName`'s docstring. */
+    private isLoopBoundName;
+    private generateScriptRegistrations;
+    /**
+     * Public entry point for node rendering. Delegates to the shared
+     * `IRNodeEmitter` dispatcher; per-kind logic lives in the
+     * `IRNodeEmitter` methods below.
+     */
+    renderNode(node: IRNode): string;
+    emitElement(node: IRElement, _ctx: ErbRenderCtx, _emit: EmitIRNode<ErbRenderCtx>): string;
+    emitText(node: IRText): string;
+    emitExpression(node: IRExpression): string;
+    emitConditional(node: IRConditional, _ctx: ErbRenderCtx, _emit: EmitIRNode<ErbRenderCtx>): string;
+    emitLoop(node: IRLoop, _ctx: ErbRenderCtx, _emit: EmitIRNode<ErbRenderCtx>): string;
+    emitComponent(node: IRComponent, _ctx: ErbRenderCtx, _emit: EmitIRNode<ErbRenderCtx>): string;
+    emitFragment(node: IRFragment, _ctx: ErbRenderCtx, _emit: EmitIRNode<ErbRenderCtx>): string;
+    emitSlot(node: IRSlot): string;
+    emitIfStatement(node: IRIfStatement, _ctx: ErbRenderCtx, _emit: EmitIRNode<ErbRenderCtx>): string;
+    emitProvider(node: IRProvider, _ctx: ErbRenderCtx, _emit: EmitIRNode<ErbRenderCtx>): string;
+    /** Lower a `<Ctx.Provider value>` value prop to a Ruby expression. */
+    private providerValueRuby;
+    /**
+     * Lower an object-literal provider value (`value={{ open: () => props.open
+     * ?? false, onOpenChange: … }}`) to a Ruby Hash. The SSR lowering is a
+     * per-member snapshot of what a consumer would READ during the same
+     * render:
+     *
+     * - zero-param expression-body arrows are getters — lower the body (the
+     *   value is fixed for the render, so the call-time indirection drops out)
+     * - `on[A-Z]`-named members and function-shaped values are client-only
+     *   behavior SSR never invokes — lower to `nil`
+     * - anything else lowers through the normal expression pipeline (so an
+     *   unsupported getter body still refuses loudly with BF101)
+     *
+     * Keys keep their JS names verbatim (as symbol keys) so a consumer-side
+     * `ctx.open` access maps onto the same key. Returns `null` when the
+     * expression is not a plain object literal (spread / computed key) — the
+     * caller falls back to the whole-expression path, which refuses those
+     * shapes with BF101.
+     */
+    private providerObjectLiteralRuby;
+    /**
+     * True when `src` is a bare identifier that doesn't resolve to a
+     * prop/signal/memo or an SSR-inlinable module string const — i.e. a
+     * client-only function reference in a context value (a local handler
+     * const like `scrollPrev`, or a signal setter like `setCanScrollPrev`).
+     * See `providerDataNames`. Module-scope string consts (`carouselClasses`)
+     * ARE SSR-resolvable via `moduleStringConsts`, so they're excluded here.
+     */
+    private isClientOnlyContextIdentifier;
+    emitAsync(node: IRAsync, _ctx: ErbRenderCtx, _emit: EmitIRNode<ErbRenderCtx>): string;
+    renderElement(element: IRElement): string;
+    renderExpression(expr: IRExpression): string;
+    /**
+     * True when `expr` is a structural read of the `children` prop: a bare
+     * `children` identifier, `props.children` / `<propsObjectName>.children`,
+     * or either of those on the left of a `?? fallback`. Prefers the IR's
+     * already-parsed `expr.parsed` tree (attached once during IR construction)
+     * and falls back to parsing `expr.expr` only when that's absent — never a
+     * regex/string scan of the source text.
+     */
+    private isChildrenValueExpr;
+    private isChildrenReferenceParsedExpr;
+    renderConditional(cond: IRConditional): string;
+    private renderNodeOrNull;
+    /**
+     * Add bf-c attribute to the first HTML element in a branch. If no element
+     * found, wrap with comment markers. Operates on already-emitted ERB
+     * template TEXT (not JS/TS source), matching the Mojo/Go adapters'
+     * identical marker-injection precedent.
+     */
+    private addCondMarkerToFirstElement;
+    renderLoop(loop: IRLoop): string;
+    /**
+     * AttrValue lowering for component invocation props (ERB / Ruby Hash
+     * literal form). Routed through the shared dispatcher so a new AttrValue
+     * kind becomes a TS compile error here.
+     *
+     * `jsx-children` returns empty — children are captured via the ERB
+     * output-buffer slice below, not threaded through the `render_child`
+     * props Hash.
+     */
+    private readonly componentPropEmitter;
+    renderComponent(comp: IRComponent): string;
+    private childrenCaptureCounter;
+    private toTemplateName;
+    private renderIfStatement;
+    private renderFragment;
+    private renderSlot;
+    renderAsync(node: IRAsync): string;
+    /**
+     * AttrValue lowering for intrinsic-element attributes (ERB template).
+     * Routed through the shared dispatcher.
+     */
+    private readonly elementAttrEmitter;
+    /**
+     * Uniquifies the `presenceOrUndefined` temp binding (`__bf_puN`) so two
+     *  presence-folded attrs in one template don't collide.
+     */
+    private presenceVarCounter;
+    /**
+     * Lower a `style={{ … }}` object literal to a CSS string with dynamic
+     * values interpolated as ERB tags, e.g. `{ backgroundColor: color,
+     * padding: '8px' }` → `background-color:<%= bf.h(v[:color]) %>;padding:8px`.
+     * Returns null when the shape is unsupported or any value can't be
+     * lowered (caller then falls through to the BF101 refusal).
+     */
+    private tryLowerStyleObject;
+    /** HTML-attribute escape for static text inlined into a `"..."` attribute. */
+    private escapeAttrText;
+    private renderAttributes;
+    renderScopeMarker(_instanceIdExpr: string): string;
+    renderSlotMarker(slotId: string): string;
+    renderCondMarker(condId: string): string;
+    /**
+     * Convert a ParsedExpr AST to Ruby expression string for filter
+     * predicates. Wraps the shared ParsedExpr dispatcher with an
+     * `ErbFilterEmitter` carrying the predicate's loop param and any
+     * block-body local var aliases.
+     */
+    private renderRubyFilterExpr;
+    private convertTemplateLiteralPartsToRuby;
+    /**
+     * Translate `${EXPR}` interpolations in a static template-part string
+     * into Ruby variable references and concatenate them with the
+     * surrounding literal text. Used by `convertTemplateLiteralPartsToRuby`
+     * when a `string` part still carries unresolved interpolations (e.g.
+     * `${className}` from a destructured prop the IR analyzer couldn't
+     * inline statically).
+     */
+    private substituteJsInterpolationsToRuby;
+    /**
+     * Refuse JS expression shapes that have no idiomatic ERB template
+     * representation. Currently catches:
+     *
+     *   - Object literals (`style={{ background: bg(), color: fg() }}`):
+     *     the regex pipeline strips signal calls but leaves the surrounding
+     *     `{ k: v, ... }` syntax intact, producing invalid Ruby inside
+     *     `<%= ... %>`.
+     *   - Tagged-template-literal call expressions
+     *     (`className={cn\`base \${tone()}\`}`): regex translation
+     *     produces malformed Ruby with no callable target.
+     *
+     * Records `BF101` with the same shape the Go/Mojo adapters emit, so
+     * cross-adapter diagnostics stay consistent. Returns `true` when the
+     * shape was rejected (caller should drop the attribute / skip the emit).
+     */
+    private refuseUnsupportedAttrExpression;
+    /**
+     * Build the EmitContext seam the top-level `ParsedExpr` emitter depends on.
+     * Built as a private object (the adapter does NOT `implements ErbEmitContext`)
+     * so the wrapped bookkeeping — `_searchParamsLocals`, the const/record
+     * resolvers, the loop-bound-name predicate, BF101 recording, the
+     * filter-predicate entry — stays private and off the exported adapter's
+     * public type, matching the Mojo/Go adapters' `emitCtx`.
+     */
+    private get emitCtx();
+    /**
+     * Build the narrow context the extracted spread lowering depends on.
+     * Passing a purpose-built object (rather than `this`) keeps the
+     * adapter's bookkeeping members private.
+     */
+    private get spreadCtx();
+    /** Build the narrow context the extracted memo seeding depends on. */
+    private get memoCtx();
+    private convertExpressionToRuby;
+    /**
+     * Render a full ParsedExpr tree to Ruby for top-level (non-filter)
+     * expressions where identifiers are signals / vars-Hash entries.
+     * Delegates to the shared ParsedExpr dispatcher with `ErbTopLevelEmitter`.
+     */
+    private renderParsedExprToRuby;
+    /** Whether `name` (a signal getter or prop) holds a string value — gates
+     *  index-access Hash-vs-Array lowering (see `expr/operand.ts`). */
+    private _isStringValueName;
+    private _recordExprBF101;
+    /** Internal hook for higher-order: predicate body re-uses the filter emitter. */
+    private _renderRubyFilterExprPublic;
+}
+export declare const erbAdapter: ErbAdapter;
+//# sourceMappingURL=erb-adapter.d.ts.map

package/dist/adapter/erb-adapter.d.ts.map

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