@barefootjs/client 0.1.0

package/dist/runtime/insert.d.ts

@@ -0,0 +1,75 @@
+/**
+ * BarefootJS - Conditional Insert
+ *
+ * Handle conditional DOM updates using branch configurations.
+ * SolidJS-inspired replacement for legacy cond() that properly
+ * handles event binding for both branches.
+ */
+/**
+ * Result returned by a branch's `template()` when the template captures
+ * live DOM nodes via `__bfSlot` (#1213). `html` carries the marker-bearing
+ * HTML string; `slots[N]` is the actual `Node` referenced by the
+ * `<!--bf-slot:N-->` placeholder at the same index.
+ */
+export interface BranchTemplateResult {
+    html: string;
+    slots: Node[];
+}
+/**
+ * Branch configuration for conditional rendering.
+ * Contains template and event binding functions for each branch.
+ */
+export interface BranchConfig {
+    /**
+     * HTML template function for this branch. Returns either a plain HTML
+     * string (legacy) or a `{ html, slots }` pair for templates that
+     * captured live `Node` values via `__bfSlot`.
+     *
+     * ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+     *  INVARIANT — TEMPLATES RUN WITH REACTIVITY UNTRACKED.
+     * ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+     *
+     * Every call site goes through `evalBranchTemplate()` in this file,
+     * which wraps the invocation in `untrack()`. Signal reads inside
+     * the template are therefore NOT registered as effect dependencies.
+     *
+     * Consequences for authors of new branch shapes:
+     *
+     *  - `template()` must produce a function of state-at-call-time only.
+     *    Any reactive portion of the rendered fragment is wired up
+     *    afterwards by `bindEvents()` (events + per-binding effects) and
+     *    `__bfSlot` (live-Node splicing for slot-captured signals).
+     *
+     *  - A template such as `() => signalA() ? '<a>' : '<b>'` is a BUG:
+     *    later changes to `signalA` will not re-evaluate the template,
+     *    because the read was performed without tracking. Branch
+     *    selection belongs in the `conditionFn` argument of `insert()`,
+     *    not inside the template body.
+     */
+    template: () => string | BranchTemplateResult;
+    /**
+     * Bind events and reactive effects to elements within the branch.
+     * Called both during hydration (for SSR elements) and after DOM swaps.
+     * @param scope - The scope element to search within for event targets
+     * @returns Optional cleanup function, called when the branch is deactivated.
+     *          Used to dispose reactive effects scoped to this branch.
+     */
+    bindEvents: (scope: Element, opts?: {
+        isFirstRun?: boolean;
+    }) => (() => void) | void;
+}
+/**
+ * Handle conditional DOM updates using branch configurations.
+ *
+ * Key behaviors:
+ * - First run (hydration): Reuse SSR element, call branch.bindEvents() for current branch
+ * - Condition change: Create new element from template, call branch.bindEvents()
+ *
+ * @param scope - Component scope element
+ * @param id - Conditional slot ID (e.g., 's0')
+ * @param conditionFn - Function that returns current condition value
+ * @param whenTrue - Branch config for when condition is true
+ * @param whenFalse - Branch config for when condition is false
+ */
+export declare function insert(scope: Element | null, id: string, conditionFn: () => boolean, whenTrue: BranchConfig, whenFalse: BranchConfig): void;
+//# sourceMappingURL=insert.d.ts.map

package/dist/runtime/insert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert.d.ts","sourceRoot":"","sources":["../../src/runtime/insert.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAOH;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,IAAI,EAAE,CAAA;CACd;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,QAAQ,EAAE,MAAM,MAAM,GAAG,oBAAoB,CAAA;IAE7C;;;;;;OAMG;IACH,UAAU,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAA;CACrF;AAyBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,MAAM,CACpB,KAAK,EAAE,OAAO,GAAG,IAAI,EACrB,EAAE,EAAE,MAAM,EACV,WAAW,EAAE,MAAM,OAAO,EAC1B,QAAQ,EAAE,YAAY,EACtB,SAAS,EAAE,YAAY,GACtB,IAAI,CAsIN"}

package/dist/runtime/list.d.ts

@@ -0,0 +1,21 @@
+/**
+ * BarefootJS - List Reconciliation
+ *
+ * Key-based DOM reconciliation for efficient list updates.
+ * Delegates to reconcileElements for element-based rendering.
+ */
+/**
+ * Render function type for list items.
+ * Returns an HTMLElement for each item.
+ */
+export type RenderItemFn<T> = (item: T, index: number) => HTMLElement;
+/**
+ * Reconcile a list container with new items using key-based matching.
+ *
+ * @param container - The parent element containing list items
+ * @param items - Array of items to render
+ * @param getKey - Function to extract a unique key from each item (or null to use index)
+ * @param renderItem - Function to render an item as HTMLElement
+ */
+export declare function reconcileList<T>(container: HTMLElement | null, items: T[], getKey: ((item: T, index: number) => string) | null, renderItem: RenderItemFn<T>): void;
+//# sourceMappingURL=list.d.ts.map

package/dist/runtime/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../src/runtime/list.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;;GAGG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,WAAW,CAAA;AAErE;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,SAAS,EAAE,WAAW,GAAG,IAAI,EAC7B,KAAK,EAAE,CAAC,EAAE,EACV,MAAM,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,GAAG,IAAI,EACnD,UAAU,EAAE,YAAY,CAAC,CAAC,CAAC,GAC1B,IAAI,CAkBN"}

package/dist/runtime/map-array.d.ts

@@ -0,0 +1,32 @@
+/**
+ * BarefootJS - Per-Item Reactive List Rendering
+ *
+ * Maps a reactive array to DOM elements with per-item scoping.
+ * Each item is rendered in its own createRoot with a per-item signal.
+ * When the array changes, same-key items UPDATE their signal instead of
+ * being disposed and recreated — fine-grained effects handle DOM updates.
+ *
+ * Unified CSR/SSR: renderItem receives an optional existing element.
+ * For SSR hydration, the existing DOM element is passed so renderItem
+ * can initialize it (initChild) instead of creating a new one (createComponent).
+ *
+ * Multi-root items (#1212): when the loop body is a JSX Fragment with two
+ * or more sibling elements, the compiler emits a `<!--bf-loop-i-->`
+ * comment before each item's roots. This module partitions the loop range
+ * by those markers so one logical item — the (startMarker, primaryEl,
+ * extras...) triple — moves, mounts, and unmounts as a single unit.
+ * Single-root loops continue to flow through the legacy path verbatim.
+ */
+/**
+ * Per-item scoped list rendering.
+ *
+ * @param accessor - Function returning the reactive array (signal/memo read)
+ * @param container - DOM container element
+ * @param getKey - Key extractor (null = use index). Receives plain item value.
+ * @param renderItem - Creates or initializes an HTMLElement for an item (runs in createRoot).
+ *                     Receives item as signal accessor: item() returns current value.
+ *                     When `existing` is passed, initializes the SSR-rendered element and returns it.
+ *                     When `existing` is undefined, creates a new element and returns it.
+ */
+export declare function mapArray<T>(accessor: () => T[], container: HTMLElement | null, getKey: ((item: T, index: number) => string) | null, renderItem: (item: () => T, index: number, existing?: HTMLElement) => HTMLElement, markerId?: string): void;
+//# sourceMappingURL=map-array.d.ts.map

package/dist/runtime/map-array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-array.d.ts","sourceRoot":"","sources":["../../src/runtime/map-array.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AA4LH;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACxB,QAAQ,EAAE,MAAM,CAAC,EAAE,EACnB,SAAS,EAAE,WAAW,GAAG,IAAI,EAC7B,MAAM,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,GAAG,IAAI,EACnD,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,WAAW,KAAK,WAAW,EACjF,QAAQ,CAAC,EAAE,MAAM,GAChB,IAAI,CA6JN"}

package/dist/runtime/portal.d.ts

@@ -0,0 +1,96 @@
+/**
+ * BarefootJS - Portal Utility
+ *
+ * Client-side utility to mount elements at arbitrary DOM positions.
+ * Typically used for modals, tooltips, and other overlay UI.
+ *
+ * API inspired by React's createPortal(children, domNode).
+ */
+export type Portal = {
+    /** The mounted element */
+    element: HTMLElement;
+    /** Remove the mounted element from the DOM */
+    unmount: () => void;
+};
+/**
+ * Options for createPortal
+ */
+export interface PortalOptions {
+    /**
+     * The scope element that owns this portal.
+     * When provided, the portal element will have a bf-po attribute
+     * set to the scope ID, allowing find() to locate elements inside the portal.
+     */
+    ownerScope?: Element;
+}
+/** Anything that can be converted to HTML string via toString() */
+export type Renderable = {
+    toString(): string;
+};
+/** Valid children types for createPortal */
+export type PortalChildren = HTMLElement | string | Renderable;
+/**
+ * Create a portal to mount an element at a specific container
+ *
+ * Similar to React's createPortal(children, domNode), this function
+ * mounts the given element/HTML to the specified container.
+ *
+ * @param children - Element to mount (HTMLElement, HTML string, or JSX.Element)
+ * @param container - Target container element (defaults to document.body)
+ * @param options - Optional configuration including ownerScope for scope-based find()
+ * @returns Portal object with element reference and unmount method
+ *
+ * @example
+ * // With HTML string
+ * const portal = createPortal(`
+ *   <div class="modal-overlay">
+ *     <div class="modal" role="dialog" aria-modal="true">
+ *       Modal content
+ *     </div>
+ *   </div>
+ * `, document.body)
+ *
+ * // With HTMLElement
+ * const modalEl = document.createElement('div')
+ * modalEl.className = 'modal'
+ * const portal = createPortal(modalEl, document.body)
+ *
+ * // With JSX.Element (Hono)
+ * const portal = createPortal(<Modal />, document.body)
+ *
+ * // With ownerScope for scope-based element detection
+ * const portal = createPortal(modalEl, document.body, { ownerScope: scopeElement })
+ *
+ * // Access the mounted element
+ * console.log(portal.element)
+ *
+ * // Later: unmount
+ * portal.unmount()
+ */
+/**
+ * Check if an element is inside an SSR-rendered portal.
+ * SSR portals are marked with bf-pi attribute.
+ *
+ * @param element - Element to check
+ * @returns true if element is inside an SSR portal
+ */
+export declare function isSSRPortal(element: HTMLElement): boolean;
+/**
+ * Remove a portal placeholder element (used after hydration).
+ * SSR Portal renders a <template bf-pp="..."> as a marker.
+ *
+ * @param portalId - The portal ID to find and remove
+ */
+/**
+ * Find a sibling slot element relative to the given element.
+ * Handles the SSR portal case where the element is inside a portal wrapper
+ * (bf-pi) instead of its original parent container.
+ *
+ * @param el - Element to search from
+ * @param slotSelector - CSS selector for the sibling slot (e.g., '[data-slot="popover-trigger"]')
+ * @returns The found element, or null
+ */
+export declare function findSiblingSlot(el: HTMLElement, slotSelector: string): HTMLElement | null;
+export declare function cleanupPortalPlaceholder(portalId: string): void;
+export declare function createPortal(children: PortalChildren, container?: HTMLElement, options?: PortalOptions): Portal;
+//# sourceMappingURL=portal.d.ts.map

package/dist/runtime/portal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"portal.d.ts","sourceRoot":"","sources":["../../src/runtime/portal.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,MAAM,MAAM,MAAM,GAAG;IACnB,0BAA0B;IAC1B,OAAO,EAAE,WAAW,CAAA;IACpB,8CAA8C;IAC9C,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB,CAAA;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB;AAED,mEAAmE;AACnE,MAAM,MAAM,UAAU,GAAG;IAAE,QAAQ,IAAI,MAAM,CAAA;CAAE,CAAA;AAE/C,4CAA4C;AAC5C,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,MAAM,GAAG,UAAU,CAAA;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAEzD;AAED;;;;;GAKG;AACH;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAiBzF;AAED,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAK/D;AAED,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,cAAc,EACxB,SAAS,GAAE,WAA2B,EACtC,OAAO,CAAC,EAAE,aAAa,GACtB,MAAM,CAyCR"}

package/dist/runtime/qsa-item.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Multi-root-aware slot lookup + child upsert for `mapArray` items whose
+ * body is a JSX Fragment with two or more sibling elements (#1212).
+ *
+ * In a single-root loop, every reactive slot inside a renderItem body is a
+ * descendant of `__el`, so plain `qsa(__el, ...)` finds it. With a
+ * multi-root Fragment item the second / third / Nth root are *siblings* of
+ * `__el` rather than descendants — `__el.querySelector(...)` will silently
+ * miss them, leaving reactive attributes / event handlers unbound, and
+ * `upsertChild(__el, ...)` will fail to find child component scope
+ * elements that live on a sibling root.
+ *
+ * The compiler emits `qsaItem` / `upsertChildItem` for these cases. Both
+ * iterate the same set of "item root elements":
+ *
+ *   1. The primary element itself.
+ *   2. Sibling roots that follow it in the DOM, until a loop boundary
+ *      Comment is reached (`<!--bf-loop-i-->`, `<!--bf-loop:*-->`,
+ *      `<!--bf-/loop:*-->`). These bound the item's range so a lookup
+ *      cannot escape into a neighbouring item or into nodes outside the
+ *      loop.
+ *   3. The CSR-only `__bfExtras` stash. During renderItem-body setup
+ *      (between the template clone and the function's return), the
+ *      primary and extras are still detached nodes — `__el.nextSibling`
+ *      is `null` and step 2 yields nothing. Reading `__bfExtras` lets
+ *      lookups reach the still-pending extras before `mapArray` inserts
+ *      them into the DOM.
+ */
+/**
+ * Find an element matching `selector` within an item's range. Searches
+ * the primary's descendants first, then walks each root in
+ * `itemRootElements`, returning the first match.
+ */
+export declare function qsaItem(primaryEl: Element | null, selector: string): Element | null;
+/**
+ * Multi-root-aware variant of `upsertChild`. Looks for the SSR scope
+ * element (or CSR placeholder) anywhere within the item's range —
+ * descendants of the primary root, sibling Fragment roots in the DOM,
+ * or the pre-insertion `__bfExtras` stash — so a child component
+ * carried by any root of a multi-root loop body is initialised
+ * correctly (#1212).
+ *
+ * Uses `qsaItem`-style search (root-or-descendant per element) so it
+ * also matches when a sibling root *is* the component scope element
+ * itself, not just a parent of it.
+ *
+ * Mirrors `upsertChild`'s #1220 collision skip: slotId-suffix candidates
+ * with a deeper `_sN_sN` shape (a synthesized child's nested scope path)
+ * are ignored so `initChild` doesn't fire on the wrong element.
+ */
+export declare function upsertChildItem(primaryEl: Element, name: string, slotId: string | null, props: Record<string, unknown>, key?: string | number, anchorScope?: Element | null): HTMLElement | null;
+//# sourceMappingURL=qsa-item.d.ts.map

package/dist/runtime/qsa-item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qsa-item.d.ts","sourceRoot":"","sources":["../../src/runtime/qsa-item.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAsCH;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,SAAS,EAAE,OAAO,GAAG,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAQnF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,OAAO,EAClB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,EACrB,WAAW,CAAC,EAAE,OAAO,GAAG,IAAI,GAC3B,WAAW,GAAG,IAAI,CAwBpB"}

package/dist/runtime/query.d.ts

@@ -0,0 +1,86 @@
+/**
+ * BarefootJS - DOM Query Helpers
+ *
+ * Scope-aware DOM query utilities for compiler-generated ClientJS.
+ * These helpers find elements within component scopes, respecting
+ * nested scope boundaries and comment-based scopes.
+ */
+/** CSS attribute-value escape with a fallback for environments lacking CSS.escape. */
+export declare const cssEscape: (s: string) => string;
+/**
+ * Find component scope element for hydration.
+ * Supports unique instance IDs (e.g., ComponentName_abc123).
+ *
+ * @param name - Component name prefix to search for
+ * @param idx - Instance index (for multiple instances)
+ * @param parent - Parent element or scope element to search within
+ * @param comment - When true, fall back to comment-based scope search (fragment roots only)
+ * @returns The scope element or null if not found
+ */
+export declare function findScope(name: string, idx: number, parent: Element | Document | null, comment?: boolean): Element | null;
+/**
+ * Find an element within a scope.
+ * Enumerates candidates via candidatesInScope generator, then applies
+ * context-specific filtering (scope-aware, ignoreScope, or comment-scope).
+ * Portals are searched as a final fallback via findInPortals.
+ *
+ * @param scope - The scope element to search within
+ * @param selector - CSS selector to match
+ * @param ignoreScope - Skip scope boundary checks (for parent-owned ^-prefixed slots)
+ * @returns The matching element or null
+ */
+export declare function find(scope: Element | null, selector: string, ignoreScope?: boolean): Element | null;
+/**
+ * Find an element matching a selector, checking the element itself first,
+ * then its descendants. Unlike querySelector() which only searches descendants,
+ * this also matches the root element.
+ *
+ * Used by compiler-generated code for event binding and attribute updates
+ * on loop items where the target may be the loop item's root element itself.
+ */
+export declare function qsa(el: Element | null, selector: string): Element | null;
+/**
+ * `querySelector` variant that skips #1220 cross-binding candidates: any
+ * descendant whose bf-s already carries a deeper nested-slot path is
+ * ignored. Falls back to the standalone match-or-descendant semantics
+ * (mirrors `qsa`'s self-match) when no candidate qualifies.
+ *
+ * Compiler-generated static-array child-init code calls this in place of
+ * a bare `containerVar.querySelector(...)` so the filter runs even on
+ * paths that don't pass through `qsa` (#1220 review feedback).
+ */
+export declare function qsaChildScope(scope: Element, selector: string): Element | null;
+/**
+ * `querySelectorAll` variant with the same #1220 filter. Returns the
+ * matching descendants in document order, with nested-slot collisions
+ * dropped so the caller's `forEach((el, idx) => …)` pairs scope
+ * elements with array items by position correctly.
+ */
+export declare function qsaChildScopes(scope: Element, selector: string): Element[];
+/**
+ * Find elements within a scope by slot IDs.
+ * Used by compiler-generated code for regular slot element references.
+ * Always returns an array — callers use destructuring.
+ *
+ * For parent-owned slots (^-prefixed IDs like '^s3'), searches all descendants
+ * ignoring scope boundaries. This handles elements passed as children to child
+ * components — they are owned by the parent but rendered inside the child's scope.
+ */
+export declare function $(scope: Element | null, ...ids: string[]): (Element | null)[];
+/**
+ * Find child component scope elements by slot ID or component name.
+ * - Slot ID (e.g., 's1'): uses suffix match [bf-s$="_s1"]
+ * - Component name (e.g., 'Counter'): uses prefix match [bf-s^="Counter_"]
+ * Always returns an array — callers use destructuring.
+ */
+export declare function $c(scope: Element | null, ...ids: string[]): (Element | null)[];
+/**
+ * Find Text nodes for reactive text expressions marked by comment nodes.
+ * Expects marker format: <!--bf:sX-->text<!--/-->
+ * Always returns an array — callers use destructuring.
+ *
+ * Uses a single TreeWalker pass to find all markers at once,
+ * with early exit when all are found.
+ */
+export declare function $t(scope: Element | null, ...ids: string[]): (Text | null)[];
+//# sourceMappingURL=query.d.ts.map

package/dist/runtime/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/runtime/query.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,sFAAsF;AACtF,eAAO,MAAM,SAAS,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAGJ,CAAA;AAqCnC;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,OAAO,GAAG,QAAQ,GAAG,IAAI,EACjC,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,GAAG,IAAI,CAoDhB;AA6HD;;;;;;;;;;GAUG;AACH,wBAAgB,IAAI,CAClB,KAAK,EAAE,OAAO,GAAG,IAAI,EACrB,QAAQ,EAAE,MAAM,EAChB,WAAW,CAAC,EAAE,OAAO,GACpB,OAAO,GAAG,IAAI,CA2BhB;AAuBD;;;;;;;GAOG;AACH,wBAAgB,GAAG,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CA0BxE;AA+CD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAU9E;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,EAAE,CAO1E;AAED;;;;;;;;GAQG;AACH,wBAAgB,CAAC,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,EAAE,GAAG,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC,EAAE,CAO7E;AAED;;;;;GAKG;AACH,wBAAgB,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,EAAE,GAAG,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC,EAAE,CAE9E;AA+FD;;;;;;;GAOG;AACH,wBAAgB,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,EAAE,GAAG,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,EAAE,CAkC3E"}

package/dist/runtime/reconcile-elements.d.ts

@@ -0,0 +1,44 @@
+/**
+ * BarefootJS - Element-based List Reconciliation
+ *
+ * Key-based DOM reconciliation for component-based list rendering.
+ * Used when renderItem returns HTMLElement (via createComponent).
+ */
+/**
+ * Get loop children from a container, respecting bf-loop boundary markers.
+ * When markers are present, returns only elements between them.
+ * When absent, returns all children (backward compatible).
+ * Exported for use by compiler-generated hydration code.
+ */
+export declare function getLoopChildren(container: HTMLElement, markerId?: string): HTMLElement[];
+/**
+ * Like {@link getLoopChildren}, but returns every node between the loop
+ * boundary markers — Comments (per-item `<!--bf-loop-i-->` markers) and
+ * text included. The branch-clearing path needs to remove the per-item
+ * marker comments alongside elements; otherwise stale markers would
+ * accumulate when a branch swap forces mapArray to start over (#1212).
+ */
+export declare function getLoopNodes(container: HTMLElement, markerId?: string): Node[];
+/**
+ * Ensure loop boundary markers exist in a container for SSR-rendered content.
+ * SSR HTML doesn't include markers, so we insert them during hydration.
+ * Uses itemCount to identify the last N children as loop items (rest are siblings).
+ */
+export declare function ensureLoopMarkers(container: HTMLElement, itemCount: number, markerId?: string): void;
+/**
+ * Reconcile a list container using HTMLElement mode (for createComponent).
+ * Reuses existing elements by key, creates new elements as needed.
+ *
+ * @param container - The parent element containing list items
+ * @param items - Array of items to render
+ * @param getKey - Function to extract a unique key from each item (or null to use index)
+ * @param renderItem - Function that returns an HTMLElement for each item
+ * @param firstElement - Pre-created element for first item (avoids duplicate creation when caller already rendered item 0)
+ */
+export declare function reconcileElements<T>(container: HTMLElement | null, items: T[], getKey: ((item: T, index: number) => string) | null, renderItem: (item: T, index: number) => HTMLElement, firstElement?: HTMLElement, markerId?: string): void;
+/**
+ * Sync reactive DOM state from a source element to a target element.
+ * Copies class names, replaces conditional elements, and syncs text content.
+ */
+export declare function syncElementState(target: HTMLElement, source: HTMLElement): void;
+//# sourceMappingURL=reconcile-elements.d.ts.map

package/dist/runtime/reconcile-elements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile-elements.d.ts","sourceRoot":"","sources":["../../src/runtime/reconcile-elements.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAoEH;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,WAAW,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,WAAW,EAAE,CAMxF;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,WAAW,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,EAAE,CAY9E;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAgBpG;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,SAAS,EAAE,WAAW,GAAG,IAAI,EAC7B,KAAK,EAAE,CAAC,EAAE,EACV,MAAM,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,GAAG,IAAI,EACnD,UAAU,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,WAAW,EACnD,YAAY,CAAC,EAAE,WAAW,EAC1B,QAAQ,CAAC,EAAE,MAAM,GAChB,IAAI,CA2JN;AAkCD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI,CAiD/E"}

package/dist/runtime/registry.d.ts

@@ -0,0 +1,53 @@
+/**
+ * BarefootJS - Component Registry
+ *
+ * Component registry for parent-child communication.
+ * Each component registers its init function so parents can initialize children with props.
+ */
+import type { InitFn } from './types';
+/**
+ * Register a component's init function for parent initialization.
+ * Also processes any pending child initializations for this component.
+ *
+ * @param name - Component name (e.g., 'Counter', 'AddTodoForm')
+ * @param init - Init function that takes (scope, props)
+ */
+export declare function registerComponent(name: string, init: InitFn): void;
+/**
+ * Get a component's init function from the registry.
+ * Used by createComponent() to initialize dynamically created components.
+ *
+ * @param name - Component name
+ * @returns Init function or undefined if not registered
+ */
+export declare function getComponentInit(name: string): InitFn | undefined;
+/**
+ * Initialize a child component with props from parent.
+ * Used by parent components to pass function props (like onAdd) to children.
+ *
+ * If the child component's script hasn't loaded yet (component not registered),
+ * queues the initialization request. When the component registers via
+ * registerComponent(), pending initializations are processed synchronously.
+ *
+ * @param name - Child component name
+ * @param childScope - The child's scope element (found by parent)
+ * @param props - Props to pass to the child (including function props)
+ */
+export declare function initChild(name: string, childScope: Element | null, props?: Record<string, unknown>): void;
+/**
+ * Upsert a child component at a slot inside `parent`. Resolves the SSR vs
+ * CSR shape at runtime in one place — so the compiler doesn't need a
+ * `mode: 'csr' | 'ssr'` argument for child component emission.
+ *
+ *   1. SSR: a `[bf-h][bf-m]` element exists for this (parent,
+ *      slot). Initialise it via initChild and return it.
+ *   2. CSR: a `[data-bf-ph="<slotId|name>"]` placeholder exists. Replace it
+ *      with `createComponent(name, props, key)` and return the new element.
+ *   3. Neither matches (already initialised on a previous reconcile pass) —
+ *      no-op, return null.
+ *
+ * The returned element is the live component scope element — callers can
+ * use it for follow-up effects (e.g. a children-textContent createEffect).
+ */
+export declare function upsertChild(parent: Element, name: string, slotId: string | null, props: Record<string, unknown>, key?: string | number, anchorScope?: Element | null): HTMLElement | null;
+//# sourceMappingURL=registry.d.ts.map

package/dist/runtime/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/runtime/registry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAarC;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAclE;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEjE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,OAAO,GAAG,IAAI,EAC1B,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAClC,IAAI,CAoCN;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,OAAO,EACf,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,EACrB,WAAW,CAAC,EAAE,OAAO,GAAG,IAAI,GAC3B,WAAW,GAAG,IAAI,CAwBpB"}

package/dist/runtime/render.d.ts

@@ -0,0 +1,35 @@
+/**
+ * BarefootJS - Client-Side Rendering
+ *
+ * CSR entry point for rendering components directly in the browser
+ * without server-side rendering. Tree-shakeable: SSR-only apps
+ * never import this module.
+ */
+import type { ComponentDef } from './types';
+/**
+ * Render a component into a container element (CSR mode).
+ *
+ * Accepts either:
+ * - A registered component name (string) — looks up `init` and `template` from the registry
+ *   (the component must be registered first by importing its `.client.js` file).
+ * - A `ComponentDef` — uses the def's `init` and `template` directly, bypassing the registry.
+ *
+ * Generates DOM from the template, mounts it into the container, and initializes it
+ * with the given props. Unlike hydrate(), no pre-rendered HTML is required; the
+ * container's content is replaced entirely.
+ *
+ * @param container - Target DOM element to render into
+ * @param nameOrDef - Registered component name or a ComponentDef
+ * @param props - Props to pass to the component
+ *
+ * @example
+ * // By name (registry-based)
+ * await import('/static/components/Counter.client.js')
+ * render(document.getElementById('app')!, 'Counter', { initialCount: 0 })
+ *
+ * @example
+ * // By ComponentDef (registry-free)
+ * render(container, { name: 'MyNode', init, template }, { id: 'n1' })
+ */
+export declare function render(container: HTMLElement, nameOrDef: string | ComponentDef, props?: Record<string, unknown>): void;
+//# sourceMappingURL=render.d.ts.map

package/dist/runtime/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../src/runtime/render.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAOH,OAAO,KAAK,EAAE,YAAY,EAAU,MAAM,SAAS,CAAA;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,MAAM,CACpB,SAAS,EAAE,WAAW,EACtB,SAAS,EAAE,MAAM,GAAG,YAAY,EAChC,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAClC,IAAI,CA4DN"}

package/dist/runtime/scope.d.ts

@@ -0,0 +1,28 @@
+/**
+ * BarefootJS - Comment Scope Registry
+ *
+ * Registry for elements that serve as scope proxies for comment-based scopes.
+ * Maps an element to its comment node and the sibling range boundary.
+ */
+/**
+ * Information about a comment-based scope.
+ */
+export interface CommentScopeInfo {
+    commentNode: Comment;
+    scopeId: string;
+}
+/**
+ * Registry mapping elements to their comment scope info.
+ */
+export declare const commentScopeRegistry: WeakMap<Element, CommentScopeInfo>;
+/**
+ * Get the scope ID for an element from the comment scope registry.
+ * Used by createPortal to resolve scope IDs for comment-based scopes.
+ */
+export declare function getPortalScopeId(element: Element): string | null;
+/**
+ * Find the end boundary for a comment-based scope.
+ * The boundary is the next bf-scope: comment or the end of the parent's children.
+ */
+export declare function getCommentScopeBoundary(commentNode: Comment): Node | null;
+//# sourceMappingURL=scope.d.ts.map

package/dist/runtime/scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope.d.ts","sourceRoot":"","sources":["../../src/runtime/scope.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,OAAO,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;GAEG;AACH,eAAO,MAAM,oBAAoB,oCAA2C,CAAA;AAE5E;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAGhE;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,OAAO,GAAG,IAAI,GAAG,IAAI,CAUzE"}

package/dist/runtime/slot-resolver.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Shared slot-relationship resolver: identifies the SSR scope of a child
+ * component mounted at slot `<sN>` inside its parent.
+ *
+ * Both single-root (`registry.ts::upsertChild`) and multi-root loop-body
+ * (`qsa-item.ts::upsertChildItem`) paths consume this. They differ only
+ * in whether they search a single `parent` element or walk a sequence of
+ * loop-item root elements; the lookup logic is identical.
+ *
+ * See `spec/compiler.md` "Slot identity" for the marker contract.
+ */
+/** Resolve the host scope id for a slot lookup. Prefers the explicit
+ *  `anchorScope` because the immediate `parent` element may be a freshly-
+ *  created detached fragment whose `closest()` returns null. */
+export declare function parentScopeOf(parent: Element, anchorScope?: Element | null): string;
+/** Build the (host, slot) metadata for a fresh component about to be
+ *  mounted at `slotId`. `createComponent` stamps these onto the new
+ *  element so subsequent `upsertChild` lookups can find it. `parent`
+ *  defaults to the empty string when no surrounding scope is resolvable
+ *  (top-level CSR mount). */
+export declare function buildSlotInfo(parent: Element, slotId: string, anchorScope?: Element | null): {
+    parent: string;
+    mount: string;
+};
+/**
+ * Find the SSR scope element for a child component at `slotId` inside
+ * `parent`. Primary lookup is `(BF_HOST, BF_AT)`; the suffix fallback
+ * covers `renderChild` paths that emit a parent-anchored `bf-s` without
+ * stamping host metadata.
+ *
+ * `selfMatch` lets the multi-root loop-body caller include the root
+ * element itself in the search (the loop-item primary may be the scope
+ * element, not just a parent of it).
+ */
+export declare function findSsrScopeBySlotIn(parent: Element, slotId: string, anchorScope: Element | null | undefined, selfMatch: boolean): HTMLElement | null;
+//# sourceMappingURL=slot-resolver.d.ts.map

package/dist/runtime/slot-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slot-resolver.d.ts","sourceRoot":"","sources":["../../src/runtime/slot-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH;;gEAEgE;AAChE,wBAAgB,aAAa,CAAC,MAAM,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,OAAO,GAAG,IAAI,GAAG,MAAM,CAInF;AAED;;;;6BAI6B;AAC7B,wBAAgB,aAAa,CAC3B,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,EACd,WAAW,CAAC,EAAE,OAAO,GAAG,IAAI,GAC3B;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAEnC;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,EACvC,SAAS,EAAE,OAAO,GACjB,WAAW,GAAG,IAAI,CAapB"}

package/dist/runtime/spread-attrs.d.ts

@@ -0,0 +1,19 @@
+/**
+ * BarefootJS - Spread Attributes Helper (Template Mode)
+ *
+ * Converts an object to an HTML attribute string for use inside template literals.
+ * Unlike applyRestAttrs (which manipulates DOM elements reactively), this produces
+ * a static string for server/template rendering of computed local spreads.
+ */
+/**
+ * Convert an object to an HTML attribute string.
+ * Aligned with applyRestAttrs conventions: skips null/undefined/false,
+ * event handlers, maps className→class and htmlFor→for. The `style`
+ * prop is routed through `styleToCss` so object literals serialize to
+ * a real CSS string (matching the reactive `applyRestAttrs` path).
+ *
+ * SVG attributes listed in `SVG_CAMEL_CASE_ATTRS` are preserved
+ * verbatim — the SVG XML spec is case-sensitive for those names.
+ */
+export declare function spreadAttrs(obj: Record<string, unknown>): string;
+//# sourceMappingURL=spread-attrs.d.ts.map

package/dist/runtime/spread-attrs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spread-attrs.d.ts","sourceRoot":"","sources":["../../src/runtime/spread-attrs.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA+CH;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAwBhE"}