@barefootjs/mojolicious 0.16.0 → 0.17.1

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

@@ -0,0 +1,30 @@
+/**
+ * Component-tree analysis for the Mojolicious EP template adapter.
+ *
+ * Extracted from `mojo-adapter.ts` (domain-module refactor, issue #2018
+ * track D). 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`.
+ *
+ * SHARED CANDIDATE: `hasClientInteractivity` is byte-identical to the Xslate
+ * adapter's copy and adapter-agnostic; the BF103 loop-child check is the same
+ * structural walk in both, differing only in the Perl/Kolon diagnostic text —
+ * both are groundwork for a shared Perl-family codegen module (issue #2018
+ * track D).
+ */
+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
+ * adapter's check — the Mojo 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;;;;;;;;;;;;;;GAcG;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/emit-context.d.ts

@@ -0,0 +1,96 @@
+/**
+ * The contract the extracted expression-emitter modules depend on instead of
+ * the concrete `MojoAdapter`.
+ *
+ * The Mojo 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 `MojoTopLevelEmitter` still needs to call back into shared
+ * per-compile state and recursive entry points. `MojoEmitContext` is that
+ * seam: the emitter takes a `MojoEmitContext` 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
+ * Go adapter's `emitCtx`). The emitter depends on this narrow interface rather
+ * than the full ~3k-line 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 MojoEmitContext {
+    /**
+     * (#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 Perl value, or null. */
+    resolveLiteralConst(name: string): string | null;
+    /**
+     * Resolve a static property access on a module object-literal const
+     * (`variantClasses.ghost`) to its Perl value at compile time, or null.
+     */
+    resolveStaticRecordLiteral(objectName: string, key: string): string | null;
+    /** 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 Perl form, bound to `param`. */
+    _renderPerlFilterExprPublic(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 `MojoEmitContext` so each extracted
+ * module's real coupling is documented precisely.
+ */
+export interface MojoSpreadContext {
+    /** 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 Perl 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 `''`.
+     */
+    convertExpressionToPerl(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 MojoMemoContext {
+    /**
+     * Lower a JS expression to its Perl 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 `''`.
+     */
+    convertExpressionToPerl(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,eAAe;IAC9B;;;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,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,iBAAiB;IAChC,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,eAAe;IAC9B;;;;;;;;;OASG;IACH,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,UAAU,GAAG,MAAM,CAAA;CACtE"}

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

@@ -0,0 +1,85 @@
+/**
+ * Array / string method lowering for the Mojolicious EP template adapter.
+ *
+ * Extracted from `mojo-adapter.ts` (domain-module refactor, issue #2018
+ * track D). 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.
+ */
+import type { ParsedExpr, ArrayMethod, SortComparator, FlatDepth } from '@barefootjs/jsx';
+/**
+ * Lower an `arr.<method>(...)` / `str.<method>(...)` value-builtin call to
+ * its Perl form. The IR lifts these into the dedicated `array-method` kind at
+ * parse time (see the `arrayMethod` emitter arms), so this is the single
+ * place every adapter-supported array/string method is mapped. An unhandled
+ * `ArrayMethod` variant throws rather than emitting a silent no-op — the
+ * drift defence we already apply to `ParsedExpr.kind` extended to its
+ * sub-discriminator.
+ */
+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 can't be evaluated (e.g. a `localeCompare` comparator —
+ * `serializeParsedExpr` refuses it), so the caller falls back to the
+ * structured `bf->sort`. A `||`-chained multi-key comparator needs no
+ * special handling — JS `0 || next` is exactly the tie-break semantics.
+ */
+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. Returns null when
+ * the body can't be evaluated (→ caller falls back to `bf->reduce`). A numeric
+ * seed passes through as a bare Perl number; a concat seed as a single-quoted
+ * string.
+ */
+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
+ * hashref. Generalizes the inline `grep` / `bf->find` lowering to the same
+ * JS-faithful evaluator the Go adapter uses (cross-adapter isomorphism).
+ * 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 `grep` / `bf->find` 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/P5): the
+ * projection `body` serializes to JSON and `bf->flat_map_eval` projects +
+ * flattens one level. The sole flatMap lowering now (the structured
+ * `bf->flat_map` / `bf->flat_map_tuple` fallback was retired with the
+ * `ParsedExpr` collapse); returns null when the projection is outside the
+ * evaluator surface, and the caller records 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, and the caller
+ * records 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 Mojo emit for `.sort(cmp)` / `.toSorted(cmp)` (#1448 Tier B).
+ * Used by both the filter-context emitter and the top-level emitter,
+ * plus the loop-hoist path in `renderLoop` — same emit shape across
+ * all three so a regression in any one path surfaces consistently.
+ *
+ * The Perl helper accepts a hash-ref opts bag whose `keys` entry is
+ * an ordered list of per-key hashes (room for a future `nulls` knob
+ * without arity churn), and returns a fresh ARRAY ref so downstream
+ * composition (`@{bf->sort(...)}` in `join(...)`, etc.) stays
+ * straightforward.
+ */
+export declare function renderSortMethod(recv: string, c: SortComparator): string;
+export declare function renderFlatMethod(recv: string, depth: FlatDepth): 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;;;;;;;GAOG;AAMH,OAAO,KAAK,EACV,UAAU,EACV,WAAW,EACX,cAAc,EACd,SAAS,EACV,MAAM,iBAAiB,CAAA;AAExB;;;;;;;;GAQG;AACH,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,CA6MR;AA6BD;;;;;;;;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,CAOf;AAED;;;;;;;GAOG;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,CAmBf;AAED;;;;;;;;;;;GAWG;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;;;;;;;GAOG;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;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,cAAc,GAAG,MAAM,CAaxE;AAKD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAGvE"}

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

@@ -0,0 +1,78 @@
+/**
+ * ParsedExpr → Perl emitters for the Mojolicious EP template adapter.
+ *
+ * Extracted from `mojo-adapter.ts` (domain-module refactor, issue #2018
+ * track D). Two `ParsedExprEmitter` implementations:
+ *
+ *   - `MojoFilterEmitter` — filter/predicate context (loop param + local
+ *     aliases + bare `$name` signal fallback); self-contained, reads no
+ *     adapter state.
+ *   - `MojoTopLevelEmitter` — top-level / stash context; depends on the
+ *     adapter only through the narrow `MojoEmitContext` seam.
+ */
+import { type ParsedExprEmitter, type ArrayMethod, type LiteralType, type ParsedExpr, type ObjectLiteralProperty, type FlatDepth, type TemplatePart } from '@barefootjs/jsx';
+import type { MojoEmitContext } from '../emit-context.ts';
+export declare class MojoFilterEmitter 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, emit: (e: ParsedExpr) => string): string;
+    conditional(_test: ParsedExpr, _consequent: ParsedExpr, _alternate: ParsedExpr): string;
+    templateLiteral(_parts: TemplatePart[]): string;
+    arrow(_params: string[], _body: ParsedExpr, _emit: (e: ParsedExpr) => string): 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 Mojo template's stash (signals, props, locals introduced by
+ * `% my $x = ...;` lines). Differs from the filter emitter mainly in
+ *   - `.length` → `scalar(@{...})` (filter contexts never see arrays
+ *     in lvalue position),
+ *   - `conditional` is supported (filter predicates can't return
+ *     ternaries),
+ *   - the `unsupported` fallback drops to the regex pipeline so legacy
+ *     shapes the AST can't classify still emit something coherent.
+ */
+export declare class MojoTopLevelEmitter implements ParsedExprEmitter {
+    private readonly ctx;
+    constructor(ctx: MojoEmitContext);
+    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;
+    private renderPredicate;
+    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, 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, _emit: (e: ParsedExpr) => string): string;
+    regex(_raw: string): string;
+    unsupported(_raw: string, _reason: string): string;
+    objectLiteral(_properties: ObjectLiteralProperty[], _raw: string, _emit: (e: ParsedExpr) => string): string;
+}
+//# sourceMappingURL=emitters.d.ts.map

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

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

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

@@ -0,0 +1,34 @@
+/**
+ * Operand-type classification + index-access lowering for the Mojolicious
+ * EP template adapter.
+ *
+ * Extracted from `mojo-adapter.ts` (domain-module refactor, issue #2018
+ * track D). Pure functions over `ParsedExpr` — they take an `isStringName`
+ * predicate (supplied by the emitter from adapter state) rather than reading
+ * adapter instance state directly.
+ *
+ * SHARED CANDIDATE: `isStringTypedOperand` is byte-identical to the Xslate
+ * adapter's copy and is adapter-agnostic — an extraction candidate for a
+ * shared Perl-family codegen module (groundwork for the future Perl evaluator
+ * integration, issue #2018 track D). `emitIndexAccessPerl` stays Mojo-specific
+ * (Perl's `->[]` vs `->{}` split has no Kolon equivalent).
+ */
+import type { ParsedExpr } from '@barefootjs/jsx';
+/**
+ * Whether a comparison operand is string-typed, so JS `===`/`!==` against it
+ * must lower to Perl `eq`/`ne` instead of numeric `==`/`!=` (#1672). Covers a
+ * string literal, a string-signal getter call (`sel()`), and a string prop
+ * access (`props.x`). `isStringName` reports whether a getter/prop name is
+ * known-string. Loop-element fields (`t.id`) on untyped arrays have no known
+ * type and stay undetected — a separate, narrower gap.
+ */
+export declare function isStringTypedOperand(expr: ParsedExpr, isStringName: (n: string) => boolean): boolean;
+/**
+ * Lower `arr[index]` to a Perl deref. Perl distinguishes array
+ * (`->[$i]`) from hash (`->{$k}`) access, which JS's single `[]` does
+ * not — so we pick by the index expression's type: a string-typed key
+ * derefs the hash, anything else (the common loop-index / arithmetic
+ * case, e.g. `selected()[index]`) derefs the array. #1897.
+ */
+export declare function emitIndexAccessPerl(object: ParsedExpr, index: ParsedExpr, emit: (e: ParsedExpr) => string, isStringName: (n: string) => boolean): string;
+//# sourceMappingURL=operand.d.ts.map

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

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