@barefootjs/erb 0.17.0

package/dist/adapter/lib/constants.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Compile-time constant tables for the ERB template adapter.
+ *
+ * Ported from the Mojolicious adapter's `lib/constants.ts`.
+ */
+import type { PrimitiveSpec } from './types.ts';
+/**
+ * Single source of truth for the ERB adapter's template-primitive
+ * surface. Each entry pairs the expected arity with the emit function.
+ * Adding / removing a primitive is a one-line change.
+ *
+ * The emit fn returns a Ruby expression (no surrounding `<%= %>`)
+ * suitable for embedding inside the ERB template action —
+ * `bf.json(val)`, `bf.floor(val)`, etc. Args arrive already
+ * Ruby-rendered via `convertExpressionToRuby` recursion, so a caller
+ * passing `props.config` reaches the emit fn as `v[:config]`.
+ */
+export declare const ERB_TEMPLATE_PRIMITIVES: Record<string, PrimitiveSpec>;
+/**
+ * Module-scope `templatePrimitives` map derived once from the spec
+ * record. Per-instance derivation would re-build the same Map on
+ * every `new ErbAdapter()` call.
+ */
+export declare const ERB_PRIMITIVE_EMIT_MAP: Record<string, (args: string[]) => string>;
+//# sourceMappingURL=constants.d.ts.map

package/dist/adapter/lib/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/adapter/lib/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE/C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAOjE,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,CAG3E,CAAA"}

package/dist/adapter/lib/ir-scope.d.ts

@@ -0,0 +1,27 @@
+/**
+ * IR traversal helpers for the ERB template adapter.
+ *
+ * Ported from the Mojolicious adapter's `lib/ir-scope.ts` (issue #2018
+ * track D lineage). Pure functions over the IR tree — no adapter instance
+ * state.
+ */
+import type { IRNode, IRProp } from '@barefootjs/jsx';
+/**
+ * Find the `children` prop's `jsx-children` payload (#1326). Narrowed
+ * via the AttrValue `kind` discriminator so adapter code stays type-
+ * safe if the IR shape evolves — adding a new AttrValue variant or
+ * renaming `children` to `jsxChildren` becomes a TS compile error
+ * here instead of silently dropping the children at runtime.
+ */
+export declare function resolveJsxChildrenProp(props: readonly IRProp[]): IRNode[];
+/**
+ * Collect the component's root scope element node(s) — the elements that
+ * become the rendered root and so carry `data-key` for a keyed loop item. A
+ * plain element root is itself; an `if-statement` (early-return) root
+ * contributes the top element of each branch (`consequent` + the `alternate`
+ * chain), since exactly one branch renders at runtime. Non-element branch
+ * tops (fragments / nested shapes) are walked one level so an
+ * `if (…) return <A/>` still resolves to `<A>`. (#1297)
+ */
+export declare function collectRootScopeNodes(node: IRNode): Set<IRNode>;
+//# sourceMappingURL=ir-scope.d.ts.map

package/dist/adapter/lib/ir-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir-scope.d.ts","sourceRoot":"","sources":["../../../src/adapter/lib/ir-scope.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAA6B,MAAM,iBAAiB,CAAA;AAEhF;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAKzE;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAiB/D"}

package/dist/adapter/lib/ruby-naming.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Ruby identifier / literal / hash-key conventions for the ERB adapter.
+ *
+ * Pure helpers, ported from (and extending) the Mojolicious adapter's
+ * `lib/perl-naming.ts` for Ruby's syntax. None read adapter instance
+ * state, so they live at module scope as the single source of truth for
+ * Ruby-identifier quoting, literal escaping, and marker-id encoding.
+ *
+ * ## 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 — which sidesteps Ruby
+ * identifier-validity and reserved-word issues for that whole class of
+ * names (a prop literally named `class` or `Foo` is a non-issue: it's a
+ * *symbol* key, not a variable reference).
+ *
+ * The ONE place a bare Ruby local is still needed is a loop/block
+ * parameter (`todos().map(todo => ...)` → `|todo|`) — `rubyLocal` is the
+ * single naming rule for that case, matching the ERB adapter's binding
+ * architecture doc.
+ */
+/**
+ * Map a JS loop/block parameter name (`todo`, `index`, `class`, `Item`) to
+ * a safe bare Ruby local. Appends a trailing `_` when the name collides
+ * with a Ruby keyword; when the name isn't even a syntactically valid
+ * local (leading uppercase — parses as a constant — or another invalid
+ * leading character), prefixes `_` instead so the result still starts
+ * lowercase/underscore. Every loop-var / block-param emission site in the
+ * adapter goes through this one helper — no inline mangling.
+ */
+export declare function rubyLocal(name: string): string;
+/** Escape a string for a Ruby single-quoted literal: backslash first (so
+ *  it doesn't double-escape the quote we add next), then the quote. */
+export declare function escapeRubySingleQuoted(s: string): string;
+/** Wrap a raw string value as a Ruby single-quoted literal. */
+export declare function rubyStringLiteral(s: string): string;
+/**
+ * Render `name` as a Ruby Hash literal SYMBOL key in `key: value` position.
+ * A JSX attribute / prop name like `data-slot` isn't a valid bare Ruby
+ * identifier — Ruby's `"quoted": value` symbol-key syntax accepts an
+ * arbitrary string, so a non-identifier name still renders as a valid
+ * symbol key (`"data-slot": value` → `{:"data-slot" => value}`).
+ * Identifier-safe names (`className`, `size`, `_bf_slot`) pass through
+ * unquoted (`size: value`) for readability.
+ */
+export declare function rubySymbolKey(name: string): string;
+/**
+ * Render `name` as a Ruby symbol LITERAL (`:name` / `:"data-slot"`) — used
+ * for a compile-time-known Hash key read (`item[:field]`), as opposed to
+ * `rubySymbolKey`'s `key: value` Hash-literal position.
+ */
+export declare function rubySymbolLiteral(name: string): string;
+/**
+ * Encode an `IRLoop.markerId` into a Ruby-identifier-safe suffix for the
+ * `bf_iter_…` sort hoist local. Collision-free for marker ids that differ
+ * in any character — `-` and `_` map to distinct encodings (`_x2d` vs
+ * `__`) so `l-0` and `l_0` stay distinct.
+ *
+ * Today the IR only emits `l<digits>` so the encoding is mostly an
+ * identity, but pinning collision-freeness up front avoids a silent
+ * variable-shadow bug if a future marker generator widens the alphabet.
+ */
+export declare function rubyIdentifierFromMarkerId(markerId: string): string;
+//# sourceMappingURL=ruby-naming.d.ts.map

package/dist/adapter/lib/ruby-naming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ruby-naming.d.ts","sourceRoot":"","sources":["../../../src/adapter/lib/ruby-naming.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAoCH;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQ9C;AAED;uEACuE;AACvE,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,+DAA+D;AAC/D,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEnD;AAKD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAInE"}

package/dist/adapter/lib/types.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared type aliases for the ERB template adapter.
+ *
+ * Ported from the Mojolicious adapter's `lib/types.ts`. Pure type
+ * declarations — no runtime behaviour — so the extracted emit modules and
+ * the main adapter share one definition rather than re-declaring the render
+ * context / options shape.
+ */
+/** A template-primitive spec: expected call arity + the emit fn. */
+export interface PrimitiveSpec {
+    arity: number;
+    emit: (args: string[]) => string;
+}
+/**
+ * ERB adapter's IRNode render context. The ERB lowering currently doesn't
+ * consume any render-position flags (`isRootOfClientComponent` is handled
+ * differently here than in Hono/Go), so the Ctx is empty. Kept as a named
+ * alias so future flags can extend it without changing the `IRNodeEmitter`
+ * interface.
+ */
+export type ErbRenderCtx = Record<string, never>;
+export interface ErbAdapterOptions {
+    /** Base path for client JS files (default: '/static/components/') */
+    clientJsBasePath?: string;
+    /** Path to barefoot.js runtime (default: '/static/components/barefoot.js') */
+    barefootJsPath?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/adapter/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/adapter/lib/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,oEAAoE;AACpE,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CACjC;AAED;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;AAEhD,MAAM,WAAW,iBAAiB;IAChC,qEAAqE;IACrE,gBAAgB,CAAC,EAAE,MAAM,CAAA;IAEzB,8EAA8E;IAC9E,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB"}

package/dist/adapter/memo/seed.d.ts

@@ -0,0 +1,35 @@
+/**
+ * In-template memo / context seeding for the ERB template adapter.
+ *
+ * Ported from the Mojolicious adapter's `memo/seed.ts` (issue #2018 track D
+ * lineage). Free functions taking an `ErbMemoContext` (built by the
+ * adapter's `memoCtx` getter) so the cluster depends only on the recursive
+ * expression entry, not the whole adapter class. These emit `<% v[:x] =
+ * ...; %>` seed lines that let the template body's `v[:x]` resolve to a
+ * derived signal/memo value or an active context value at SSR time. Mirror
+ * of the Go adapter's `memo/*`, retargeted to the vars-Hash variable model.
+ */
+import { type ComponentIR, type ContextConsumer } from '@barefootjs/jsx';
+import type { ErbMemoContext } from '../emit-context.ts';
+/** Ruby literal for a context-consumer's `createContext` default. */
+export declare function contextDefaultRuby(c: ContextConsumer): string;
+/**
+ * Emit one `<% v[:<local>] = bf.use_context(...) %>` seed line per context
+ * consumer so the template body's `v[:<local>]` resolves to the active
+ * provider value (or the `createContext` default).
+ */
+export declare function generateContextConsumerSeed(ir: ComponentIR): string;
+/**
+ * Emit `<% v[:<name>] = <ruby> %>` seed lines for every `derived` step of
+ * the backend-neutral SSR seed plan — the scope/availability/ordering
+ * analysis lives in `computeSsrSeedPlan` (packages/jsx/src/ssr-seed-plan.ts);
+ * this only lowers each step's expression to Ruby and applies the two
+ * backend-specific emit guards: skip an empty lowering, and skip a lowering
+ * that references no `v[:var]` at all (a constant init/body — e.g. a
+ * `derived` step with empty `frees` — keeps the existing static ssr-defaults
+ * seed instead). `env-reader` and `opaque` steps emit nothing (the runtime
+ * supplies the reader, or the adapter's ssr-defaults path already covers
+ * it). (#1297, #2075)
+ */
+export declare function generateDerivedMemoSeed(ctx: ErbMemoContext, ir: ComponentIR): string;
+//# sourceMappingURL=seed.d.ts.map

package/dist/adapter/memo/seed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed.d.ts","sourceRoot":"","sources":["../../../src/adapter/memo/seed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,eAAe,EAGrB,MAAM,iBAAiB,CAAA;AAExB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAGxD,qEAAqE;AACrE,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,eAAe,GAAG,MAAM,CAM7D;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,EAAE,EAAE,WAAW,GAAG,MAAM,CAWnE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,cAAc,EAAE,EAAE,EAAE,WAAW,GAAG,MAAM,CAapF"}

package/dist/adapter/props/prop-classes.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Prop classification for the ERB template adapter.
+ *
+ * Ported from the Mojolicious adapter's `props/prop-classes.ts` (issue #2018
+ * track D lineage). Pure functions over `ir.metadata` that derive the
+ * per-compile prop/name sets the adapter consults during lowering. No
+ * adapter instance state.
+ */
+import type { ComponentIR } from '@barefootjs/jsx';
+/**
+ * SSR-resolvable context-value names: props, signal getters, memos.
+ * A `<Ctx.Provider value>` member NOT in this set is a client-only function
+ * with no SSR value, lowered to `nil`.
+ */
+export declare function collectProviderDataNames(ir: ComponentIR): Set<string>;
+/**
+ * Props whose declared TS type is boolean — a bare binding of one
+ * (`data-active={props.isActive}`) must stringify as JS `String(boolean)`
+ * ("true"/"false"), matching the `bf.bool_str` helper's output.
+ */
+export declare function collectBooleanTypedProps(ir: ComponentIR): Set<string>;
+/**
+ * No-destructure-default props → `nil` when the caller omits them → guard
+ * their bare-reference attribute emission with a Ruby nil-check so the
+ * attribute drops instead of rendering `attr=""` (Hono-style nullish
+ * omission). A prop WITH a destructure default (`value = ''`) is never
+ * `nil` in the body and must stay unconditional, so it is excluded. Mirrors
+ * the Go adapter's nillable-field guard: there the witness is the resolved
+ * `interface{}` field type; here it is the absence of a default. Excludes
+ * concrete-primitive types (`string`/`number`/`boolean`) to match the Go
+ * adapter's scope, which guards only nillable fields and leaves concrete
+ * fields unconditional.
+ */
+export declare function collectNullableOptionalProps(ir: ComponentIR): Set<string>;
+/**
+ * String-typed signals and props. A signal is string-typed when its inferred
+ * type is `string` (the analyzer infers this from a string-literal initial
+ * value) or, defensively, when its initial value is a bare string literal; a
+ * prop when its annotated type is `string`.
+ *
+ * Ruby's `==`/`!=` don't coerce operand types the way Perl's numeric `==`
+ * does, so this set does NOT drive equality-operator selection in the ERB
+ * adapter (unlike Mojo's `eq`/`ne` split). It still matters for **index
+ * access**: `obj[index]` lowers a string-typed `index` to a Hash lookup
+ * (`obj[index.to_sym]`, JSON-shaped Ruby hashes use symbol keys) and any
+ * other type to an Array lookup (`obj[index]`) — see
+ * `expr/operand.ts::isStringTypedOperand`.
+ */
+export declare function collectStringValueNames(ir: ComponentIR): Set<string>;
+//# sourceMappingURL=prop-classes.d.ts.map

package/dist/adapter/props/prop-classes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prop-classes.d.ts","sourceRoot":"","sources":["../../../src/adapter/props/prop-classes.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAGlD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,WAAW,GAAG,GAAG,CAAC,MAAM,CAAC,CAMrE;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,WAAW,GAAG,GAAG,CAAC,MAAM,CAAC,CAMrE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,4BAA4B,CAAC,EAAE,EAAE,WAAW,GAAG,GAAG,CAAC,MAAM,CAAC,CAWzE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,WAAW,GAAG,GAAG,CAAC,MAAM,CAAC,CAWpE"}

package/dist/adapter/spread/spread-codegen.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Object-literal / conditional-spread → Ruby Hash lowering for the ERB
+ * template adapter.
+ *
+ * Ported from the Mojolicious adapter's `spread/spread-codegen.ts` (issue
+ * #2018 track D lineage). Free functions taking an `ErbSpreadContext` (built
+ * by the adapter's `spreadCtx` getter) so the cluster depends on the narrow
+ * seam — the recursive expression entry plus per-compile bookkeeping —
+ * rather than the whole adapter class. Mirror of the Go adapter's
+ * `spread/spread-codegen.ts`.
+ *
+ * The conditional-spread / object-literal entries read the IR-carried
+ * structured `ParsedExpr` tree instead of re-parsing the source with
+ * `ts.createSourceFile`. The condition and scalar values are threaded
+ * straight into `ctx.convertExpressionToRuby` as its `preParsed` argument
+ * (cf. go-template's `convertExpressionToGo(jsExpr, out?, preParsed?)`), so
+ * no stringify→re-parse round-trip occurs. The `ts.factory` rebuild in
+ * `recordIndexAccessToRuby` only reconstructs the `IDENT[KEY]` node the
+ * shared `parseRecordIndexAccess` parser accepts; no source-text re-parse.
+ * `stringifyParsedExpr` is retained solely for the BF101 diagnostic message
+ * (display purposes).
+ */
+import type { ParsedExpr } from '@barefootjs/jsx';
+import type { ErbSpreadContext } from '../emit-context.ts';
+/**
+ * Lower a `cond ? {…} : {…}` conditional-spread expression — carried as the
+ * IR's structured `ParsedExpr` tree — to a Ruby ternary over two Hashes, or
+ * null when it isn't that shape. `parseExpression` already strips redundant
+ * parentheses, so the conditional / object-literal shapes surface directly.
+ */
+export declare function conditionalSpreadToRuby(ctx: ErbSpreadContext, expr: ParsedExpr | undefined): string | null;
+/**
+ * Lower a bare object-literal expression (`{ align: 'start' }`), carried as
+ * the IR's structured `ParsedExpr` tree, to a Ruby Hash via
+ * `objectLiteralToRubyHash`, or null when it isn't a plain object literal.
+ * Used for inline object-literal child props (carousel `opts`).
+ */
+export declare function objectLiteralExprToRubyHash(ctx: ErbSpreadContext, expr: ParsedExpr | undefined): string | null;
+/**
+ * Convert a static object literal into a Ruby Hash string for a conditional
+ * spread. Only static string/identifier keys are allowed; values resolve
+ * via `convertExpressionToRuby`. Returns null for any computed/spread/
+ * dynamic key. Empty object → `{}`.
+ */
+export declare function objectLiteralToRubyHash(ctx: ErbSpreadContext, obj: Extract<ParsedExpr, {
+    kind: 'object-literal';
+}>): string | null;
+/**
+ * Lower a spread-object VALUE of the form `IDENT[KEY]` where:
+ *   - `IDENT` resolves via `localConstants` to a MODULE-scope object
+ *     literal whose property values are all scalar (number/string)
+ *     literals under static (string-literal or identifier) keys
+ *     (a `Record<staticKeys, scalar>` map like `sizeMap`), AND
+ *   - `KEY` is a bare identifier that is a prop.
+ * Emits an inline indexed Ruby Hash:
+ *   `{ sm: 16, md: 20 }[v[:size].to_sym]`
+ *
+ * Returns the Ruby string when convertible, else `null` so the caller falls
+ * back to its normal value lowering (which records BF101 for an unsupported
+ * shape). Mirror of the Go adapter's `recordIndexAccessToGoMap`.
+ */
+export declare function recordIndexAccessToRuby(ctx: ErbSpreadContext, val: ParsedExpr): string | null;
+//# sourceMappingURL=spread-codegen.d.ts.map

package/dist/adapter/spread/spread-codegen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spread-codegen.d.ts","sourceRoot":"","sources":["../../../src/adapter/spread/spread-codegen.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAG1D;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,gBAAgB,EACrB,IAAI,EAAE,UAAU,GAAG,SAAS,GAC3B,MAAM,GAAG,IAAI,CAiBf;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,GAAG,EAAE,gBAAgB,EACrB,IAAI,EAAE,UAAU,GAAG,SAAS,GAC3B,MAAM,GAAG,IAAI,CAGf;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,gBAAgB,EACrB,GAAG,EAAE,OAAO,CAAC,UAAU,EAAE;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC,GACnD,MAAM,GAAG,IAAI,CA0Cf;AAUD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,gBAAgB,EAAE,GAAG,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI,CA4B7F"}

package/dist/adapter/value/parsed-literal.d.ts

@@ -0,0 +1,21 @@
+/**
+ * String-type value helpers for the ERB template adapter.
+ *
+ * Ported from the Mojolicious adapter's `value/parsed-literal.ts`
+ * (issue #2018 track D lineage). Pure functions over analyzer type info /
+ * const-initializer text — no adapter instance state.
+ *
+ * SHARED CANDIDATE: `isStringTypeInfo` and `isBareStringLiteral` are
+ * byte-identical to the Mojo/Xslate adapters' copies and adapter-agnostic.
+ *
+ * Module-scope pure-string-const inlining is owned by the shared
+ * `collectModuleStringConsts` in `@barefootjs/jsx` (consumed via
+ * `moduleStringConsts`), so no adapter-local source re-parse lives here.
+ */
+import type { TypeInfo } from '@barefootjs/jsx';
+/** True when `type` is the `string` primitive. */
+export declare function isStringTypeInfo(type: TypeInfo | undefined): boolean;
+/** True when `initialValue` is a bare string-literal expression (`'x'` /
+ *  `"x"`), used as a fallback for signals whose type wasn't inferred. */
+export declare function isBareStringLiteral(initialValue: string | undefined): boolean;
+//# sourceMappingURL=parsed-literal.d.ts.map

package/dist/adapter/value/parsed-literal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsed-literal.d.ts","sourceRoot":"","sources":["../../../src/adapter/value/parsed-literal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAE/C,kDAAkD;AAClD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,OAAO,CAEpE;AAED;yEACyE;AACzE,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAI7E"}

package/dist/build.d.ts

@@ -0,0 +1,28 @@
+import type { BuildOptions } from '@barefootjs/jsx';
+import { ErbAdapter } from './adapter/index.ts';
+import type { ErbAdapterOptions } from './adapter/index.ts';
+export interface ErbBuildOptions extends BuildOptions {
+    /** Adapter-specific options passed to ErbAdapter */
+    adapterOptions?: ErbAdapterOptions;
+}
+/**
+ * Create a BarefootBuildConfig for ERB (Embedded Ruby) template projects.
+ *
+ * Uses structural typing — does not import BarefootBuildConfig to avoid a
+ * circular dependency between @barefootjs/erb and @barefootjs/cli.
+ */
+export declare function createConfig(options?: ErbBuildOptions): {
+    adapter: ErbAdapter;
+    paths: import("@barefootjs/jsx").BarefootPaths | undefined;
+    components: string[] | undefined;
+    outDir: string | undefined;
+    minify: boolean | undefined;
+    contentHash: boolean | undefined;
+    externals: Record<string, import("@barefootjs/jsx").ExternalSpec> | undefined;
+    externalsBasePath: string | undefined;
+    bundleEntries: import("@barefootjs/jsx").BundleEntry[] | undefined;
+    localImportPrefixes: string[] | undefined;
+    outputLayout: import("@barefootjs/jsx").OutputLayout;
+    postBuild: ((ctx: import("@barefootjs/jsx").PostBuildContext) => Promise<void> | void) | undefined;
+};
+//# sourceMappingURL=build.d.ts.map

package/dist/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../src/build.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAC/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAE3D,MAAM,WAAW,eAAgB,SAAQ,YAAY;IACnD,oDAAoD;IACpD,cAAc,CAAC,EAAE,iBAAiB,CAAA;CACnC;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,GAAE,eAAoB;IAEtD,OAAO;IACP,KAAK;IACL,UAAU;IACV,MAAM;IACN,MAAM;IACN,WAAW;IACX,SAAS;IACT,iBAAiB;IACjB,aAAa;IACb,mBAAmB;IACnB,YAAY;IAKZ,SAAS;EAEZ"}