@barefootjs/client 0.1.0

package/dist/reactive.js

@@ -0,0 +1,215 @@
+// src/reactive.ts
+var Owner = null;
+var Listener = null;
+var MAX_EFFECT_RUNS = 100;
+var BatchDepth = 0;
+var PendingEffects = new Set;
+function createSignal(initialValue) {
+  let value = initialValue;
+  const subscribers = new Set;
+  const get = () => {
+    if (Listener) {
+      subscribers.add(Listener);
+      Listener.dependencies.add(subscribers);
+    }
+    return value;
+  };
+  const set = (valueOrFn) => {
+    const newValue = typeof valueOrFn === "function" ? valueOrFn(value) : valueOrFn;
+    if (Object.is(value, newValue)) {
+      return;
+    }
+    value = newValue;
+    if (BatchDepth > 0) {
+      for (const effect of subscribers) {
+        PendingEffects.add(effect);
+      }
+    } else {
+      const effectsToRun = [...subscribers];
+      for (const effect of effectsToRun) {
+        runEffect(effect);
+      }
+    }
+  };
+  return [get, set];
+}
+function createEffect(fn) {
+  const effect = {
+    fn,
+    cleanup: null,
+    dependencies: new Set,
+    owner: Owner,
+    children: [],
+    disposed: false,
+    runCount: 0
+  };
+  if (Owner)
+    Owner.children.push(effect);
+  runEffect(effect);
+}
+function runEffect(effect) {
+  if (effect.disposed)
+    return;
+  effect.runCount++;
+  if (effect.runCount > MAX_EFFECT_RUNS) {
+    effect.runCount = 0;
+    throw new Error(`Circular dependency detected: effect re-entered itself ${MAX_EFFECT_RUNS} times.`);
+  }
+  if (effect.cleanup) {
+    effect.cleanup();
+    effect.cleanup = null;
+  }
+  for (const dep of effect.dependencies) {
+    dep.delete(effect);
+  }
+  effect.dependencies.clear();
+  const prevOwner = Owner;
+  const prevListener = Listener;
+  Owner = effect;
+  Listener = effect;
+  try {
+    const result = effect.fn();
+    if (typeof result === "function") {
+      effect.cleanup = result;
+    }
+  } finally {
+    Owner = prevOwner;
+    Listener = prevListener;
+    effect.runCount--;
+  }
+}
+function disposeSubtree(effect) {
+  if (effect.disposed)
+    return;
+  effect.disposed = true;
+  for (const child of effect.children) {
+    disposeSubtree(child);
+  }
+  effect.children.length = 0;
+  if (effect.cleanup) {
+    effect.cleanup();
+    effect.cleanup = null;
+  }
+  for (const dep of effect.dependencies) {
+    dep.delete(effect);
+  }
+  effect.dependencies.clear();
+  effect.owner = null;
+}
+function disposeEffect(effect) {
+  if (effect.disposed)
+    return;
+  if (effect.owner) {
+    const idx = effect.owner.children.indexOf(effect);
+    if (idx >= 0)
+      effect.owner.children.splice(idx, 1);
+  }
+  disposeSubtree(effect);
+}
+function createRoot(fn) {
+  const root = {
+    fn: () => {},
+    cleanup: null,
+    dependencies: new Set,
+    owner: Owner,
+    children: [],
+    disposed: false,
+    runCount: 0
+  };
+  if (Owner)
+    Owner.children.push(root);
+  const prevOwner = Owner;
+  const prevListener = Listener;
+  Owner = root;
+  Listener = null;
+  try {
+    return fn(() => disposeEffect(root));
+  } finally {
+    Owner = prevOwner;
+    Listener = prevListener;
+  }
+}
+function createDisposableEffect(fn) {
+  let disposed = false;
+  const effect = {
+    fn: () => {
+      if (disposed)
+        return;
+      return fn();
+    },
+    cleanup: null,
+    dependencies: new Set,
+    owner: Owner,
+    children: [],
+    disposed: false,
+    runCount: 0
+  };
+  if (Owner)
+    Owner.children.push(effect);
+  runEffect(effect);
+  return () => {
+    disposeEffect(effect);
+  };
+}
+function onCleanup(fn) {
+  if (Owner) {
+    const effect = Owner;
+    const prevCleanup = effect.cleanup;
+    effect.cleanup = () => {
+      if (prevCleanup)
+        prevCleanup();
+      fn();
+    };
+  }
+}
+function untrack(fn) {
+  const prevListener = Listener;
+  Listener = null;
+  try {
+    return fn();
+  } finally {
+    Listener = prevListener;
+  }
+}
+function batch(fn) {
+  BatchDepth++;
+  try {
+    return fn();
+  } finally {
+    BatchDepth--;
+    if (BatchDepth === 0) {
+      flushEffects();
+    }
+  }
+}
+function flushEffects() {
+  while (PendingEffects.size > 0) {
+    const effects = [...PendingEffects];
+    PendingEffects.clear();
+    for (const effect of effects) {
+      runEffect(effect);
+    }
+  }
+}
+function onMount(fn) {
+  createEffect(() => untrack(fn));
+}
+function createMemo(fn) {
+  const [value, setValue] = createSignal(undefined);
+  createEffect(() => {
+    const result = fn();
+    setValue(() => result);
+  });
+  return value;
+}
+export {
+  untrack,
+  onMount,
+  onCleanup,
+  createSignal,
+  createRoot,
+  createMemo,
+  createEffect,
+  createDisposableEffect,
+  batch
+};

package/dist/runtime/apply-rest-attrs.d.ts

@@ -0,0 +1,16 @@
+/**
+ * BarefootJS - Apply Rest Attributes Helper
+ *
+ * Applies spread attributes to HTML elements at hydration time.
+ * Used when spread props cannot be statically expanded (open types).
+ */
+/**
+ * Reactively apply rest attributes from a props source onto an HTML element.
+ * Runs inside a createEffect so attribute values update when props change.
+ *
+ * @param el - The target DOM element
+ * @param source - The props/rest object to read attributes from
+ * @param excludeKeys - Keys already handled statically (don't apply twice)
+ */
+export declare function applyRestAttrs(el: Element, source: Record<string, unknown>, excludeKeys: string[]): void;
+//# sourceMappingURL=apply-rest-attrs.d.ts.map

package/dist/runtime/apply-rest-attrs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-rest-attrs.d.ts","sourceRoot":"","sources":["../../src/runtime/apply-rest-attrs.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAyBH;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,EAAE,EAAE,OAAO,EACX,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,WAAW,EAAE,MAAM,EAAE,GACpB,IAAI,CAkEN"}

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

@@ -0,0 +1,22 @@
+/**
+ * Branch-template slot helper (#1213).
+ *
+ * Conditional `template()` arrows interpolate Child-position expressions
+ * via `${expr}`. When `expr` evaluates to a live `Node` (e.g. the result
+ * of `_p.renderNode(node())` returning an `HTMLElement` from
+ * `createComponent`), the surrounding template literal coerces it via
+ * `Object.prototype.toString`, producing `"[object HTMLDivElement]"` and
+ * destroying the live node identity on hydration.
+ *
+ * `__bfSlot` intercepts the value before stringification: if it's a
+ * `Node`, it stashes the node into the closure-scoped `slots` array and
+ * returns a unique marker comment. The `insert()` runtime then walks the
+ * parsed fragment for those markers and splices the original node back
+ * in by identity (no `cloneNode`), preserving event listeners and signal
+ * bindings.
+ *
+ * Non-node values fall through to `String(value)` for the existing
+ * inline-string path.
+ */
+export declare function __bfSlot(value: unknown, slots: Node[]): string;
+//# sourceMappingURL=branch-slot.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"branch-slot.d.ts","sourceRoot":"","sources":["../../src/runtime/branch-slot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,MAAM,CAW9D"}

package/dist/runtime/client-marker.d.ts

@@ -0,0 +1,21 @@
+/**
+ * BarefootJS - Client Marker
+ *
+ * Update text content for @client directive expressions
+ * that are evaluated only on the client side.
+ */
+/**
+ * Update text content for a client marker.
+ *
+ * Expects comment marker format: <!--bf-client:sX-->
+ * Both GoTemplateAdapter and HonoAdapter output this format for @client directives.
+ *
+ * A zero-width space (\u200B) is used as a prefix to mark text nodes managed by @client.
+ * This allows distinguishing managed text nodes from other content.
+ *
+ * @param scope - The component scope element to search within
+ * @param id - The slot ID (e.g., 's5')
+ * @param value - The value to display (will be converted to string)
+ */
+export declare function updateClientMarker(scope: Element | null, id: string, value: unknown): void;
+//# sourceMappingURL=client-marker.d.ts.map

package/dist/runtime/client-marker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-marker.d.ts","sourceRoot":"","sources":["../../src/runtime/client-marker.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAyB1F"}

package/dist/runtime/component.d.ts

@@ -0,0 +1,99 @@
+/**
+ * BarefootJS - Component Creation
+ *
+ * Functions for dynamically creating component instances at runtime.
+ * Used by reconcileList() when rendering components in loops.
+ */
+import type { ComponentDef } from './types';
+export declare function setParentScopeId(id: string | null): void;
+/**
+ * Create a component instance with DOM element and initialized state.
+ *
+ * This function:
+ * 1. Gets the template function for the component
+ * 2. Generates HTML from props using the template
+ * 3. Creates DOM element from HTML
+ * 4. Sets scope ID and key attributes
+ * 5. Initializes the component (attaches event handlers, sets up effects)
+ *
+ * @param name - Component name (e.g., 'TodoItem')
+ * @param props - Props to pass to the component
+ * @param key - Optional key for list reconciliation
+ * @returns Created DOM element
+ *
+ * @example
+ * const el = createComponent('TodoItem', {
+ *   todo: { id: 1, text: 'Buy milk', done: false },
+ *   onDelete: () => handleDelete(1)
+ * }, 1)
+ */
+/**
+ * Create a component instance from a string name (SSR mode, uses registry)
+ * or from a ComponentDef (CSR mode, no registry needed).
+ */
+/**
+ * Slot-relationship metadata stamped onto a freshly-created component as
+ * `bf-h` / `bf-m`. Top-level CSR mounts pass no `slot` — they own their
+ * own hydration lifecycle and `initChild` re-binds callbacks freely on
+ * each reconcile.
+ */
+export interface CreateComponentSlotInfo {
+    /** Host scope id (this child's `bf-h` value). */
+    parent: string;
+    /** Slot id in the host (this child's `bf-m` value). */
+    mount: string;
+}
+export declare function createComponent(nameOrDef: string | ComponentDef, props: Record<string, unknown>, key?: string | number, slot?: CreateComponentSlotInfo): HTMLElement;
+/**
+ * Get the props stored for a component element.
+ * Used by reconcileList to pass props to an existing element.
+ */
+export declare function getComponentProps(element: HTMLElement): Record<string, unknown> | undefined;
+/**
+ * Get the props update function for an element.
+ * Used by reconcileList to update props when reusing an element.
+ */
+export declare function getPropsUpdateFn(element: HTMLElement): ((props: Record<string, unknown>) => void) | undefined;
+/**
+ * Render a child component's template to an HTML string.
+ * Used by compiler-generated template functions when a stateless component
+ * appears inside a conditional branch or loop template.
+ *
+ * If the component has a registered template, it renders the HTML and injects
+ * a bf-s scope attribute. Otherwise, falls back to an empty placeholder.
+ *
+ * @param name - Component name (e.g., 'Spinner')
+ * @param props - Props to pass to the template
+ * @param key - Optional key for list reconciliation
+ * @returns HTML string with scope marker
+ */
+export declare function renderChild(name: string, props: Record<string, unknown>, key?: string | number, slotSuffix?: string): string;
+/**
+ * Escape ">" inside HTML attribute values to prevent broken parsing.
+ * UnoCSS classes like has-[>svg]:shrink-0 contain ">" which terminates
+ * the opening tag when parsed via innerHTML. The browser decodes &gt;
+ * back to ">" in the DOM attribute value, preserving CSS matching.
+ */
+/**
+ * Escape ">" inside HTML attribute values to prevent broken parsing.
+ * UnoCSS classes like has-[>svg]:shrink-0 contain ">" which terminates
+ * the opening tag when parsed via innerHTML. The browser decodes &gt;
+ * back to ">" in the DOM attribute value, preserving CSS matching.
+ */
+export declare function escapeAttrGt(html: string): string;
+/**
+ * Parse an HTML string into a DocumentFragment, safely escaping ">" in
+ * attribute values. All code that sets innerHTML on dynamic HTML should
+ * use this instead of raw innerHTML assignment.
+ *
+ * When `parent` is provided and lives in the SVG namespace, the markup
+ * is parsed under SVG foreign-content context by wrapping it in
+ * `<svg>...</svg>`; the wrapper's children are moved into the returned
+ * fragment so callers see the same shape as the HTML path. Without
+ * this, dynamically-inserted SVG elements (e.g., a `<path>` in a
+ * conditional drag preview) end up as `HTMLUnknownElement` in the
+ * xhtml namespace and the SVG renderer ignores them. Surfaced by the
+ * Graph/DAG Editor block (#135).
+ */
+export declare function parseHTML(html: string, parent?: Element | null): DocumentFragment;
+//# sourceMappingURL=component.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"component.d.ts","sourceRoot":"","sources":["../../src/runtime/component.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAS3C,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAExD;AAWD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;;;GAGG;AACH;;;;;GAKG;AACH,MAAM,WAAW,uBAAuB;IACtC,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAA;IACd,uDAAuD;IACvD,KAAK,EAAE,MAAM,CAAA;CACd;AAED,wBAAgB,eAAe,CAC7B,SAAS,EAAE,MAAM,GAAG,YAAY,EAChC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,EACrB,IAAI,CAAC,EAAE,uBAAuB,GAC7B,WAAW,CAyHb;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAE3F;AAuBD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,WAAW,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC,GAAG,SAAS,CAE7G;AAGD;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,EACrB,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,CAiDR;AA+DD;;;;;GAKG;AACH;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAID;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,GAAG,gBAAgB,CAcjF"}

package/dist/runtime/context.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Context API: DOM-bound runtime portion.
+ *
+ * `useContext` and `provideContext` walk the DOM (scope-based) to locate
+ * the nearest provider. Portal elements (with bf-po attribute) follow
+ * the logical owner chain.
+ *
+ * A global store is kept as a fallback for non-scoped usage.
+ */
+import type { Context } from '../context';
+export { createContext, type Context } from '../context';
+/**
+ * Set the current scope element for context operations.
+ * Called by initChild to scope provideContext/useContext to the correct element.
+ * Returns the previous scope for restoration.
+ */
+export declare function setCurrentScope(scope: Element | null): Element | null;
+/**
+ * Read the current value of a context.
+ *
+ * Walks up the DOM tree from the current scope element to find
+ * the nearest ancestor that provided this context. Falls back to
+ * the global store, then to the context's default value, then to
+ * `undefined`.
+ *
+ * Returning `undefined` (rather than throwing) when no provider is
+ * available lets templates evaluate safely before init has run
+ * `provideContext` — init's `createEffect` repaints once the
+ * provider is set up. See piconic-ai/barefootjs#1156.
+ */
+export declare function useContext<T>(context: Context<T>): T;
+/**
+ * Provide a value for a context.
+ *
+ * Stores the value on the current scope DOM element so that child
+ * components can find it via useContext's DOM ancestor walk.
+ * Also sets the global store as fallback.
+ */
+export declare function provideContext<T>(context: Context<T>, value: T): void;
+//# sourceMappingURL=context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/runtime/context.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AAEzC,OAAO,EAAE,aAAa,EAAE,KAAK,OAAO,EAAE,MAAM,YAAY,CAAA;AAWxD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,GAAG,OAAO,GAAG,IAAI,CAIrE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CA2BpD;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CA0BrE"}

package/dist/runtime/hydrate.d.ts

@@ -0,0 +1,100 @@
+/**
+ * BarefootJS - Hydration
+ *
+ * Combined component registration + template registration + hydration.
+ * Single entry point for compiler-generated code.
+ *
+ * Design (post #1172):
+ *
+ *   1. `hydrate(name, def)` only **registers** the def + template +
+ *      component-registry entry, then schedules a walk.
+ *   2. The walk visits every scope in **true document order** — both
+ *      `[bf-s]` element scopes and `<!--bf-scope:Name_xxx-->` comment
+ *      scopes are interleaved by their actual DOM position. Parents
+ *      always init before descendants regardless of which kind of
+ *      scope each one is, so a comment-rooted parent that calls
+ *      `provideContext()` is visible to an element-rooted descendant
+ *      that calls `useContext()` on the very first hydrate pass.
+ *   3. Two scheduling phases, each capped to one in-flight callback:
+ *        - microtask: collapses every `hydrate()` call from the
+ *          bundled module body into a single walk on the next tick.
+ *        - rAF: catches scope elements that the streaming protocol
+ *          (Hono / `__bf_swap`) injects into the document *after*
+ *          the synchronous module body has finished.
+ *   4. `rehydrateAll()` and the comment-scope path both share this
+ *      walker, so streaming swaps and comment-rooted fragments enjoy
+ *      the same ordering guarantee.
+ *
+ * Same-name nesting (`<Counter>` inside `<Counter>`):
+ *   The walker's `hydratedScopes.has(el)` check is the *only* skip
+ *   guard. Parents that intentionally own their nested same-name
+ *   children call `initChild(...)` from their init body — initChild
+ *   marks the child scope as hydrated, so when the walker reaches it
+ *   later it short-circuits. Parents that *don't* call `initChild`
+ *   (the descendant is a coincidental same-name component, not a
+ *   structural child) get the descendant hydrated by the walker as a
+ *   normal top-level component. This makes nesting depth a non-issue
+ *   — the previous ancestor-walk guard is gone.
+ */
+import type { ComponentDef } from './types';
+/**
+ * Look up a registered component definition by name. Used by the CSR
+ * `createComponent` path to honour `comment: true` (transparent
+ * wrapper) components — without the def lookup, those components
+ * overwrite the inner element's `bf-s` and break child-scope
+ * resolution at hydration.
+ */
+export declare function getRegisteredDef(name: string): ComponentDef | undefined;
+/**
+ * Register a component and schedule a document-order hydration walk.
+ * Combines registration + template setup + hydration in a single call.
+ *
+ * **Scheduling semantics** (changed in #1172): the walk runs on the
+ * next microtask, then again on the next animation frame. The init
+ * functions for registered components are *not* invoked synchronously
+ * inside `hydrate()`. Code that needs to observe init effects on the
+ * same tick — typically tests, but also advanced consumers wiring
+ * imperative bridges — should either:
+ *
+ *   - `await Promise.resolve()` after a batch of `hydrate()` calls, or
+ *   - call `flushHydration()` (see below) to drain any pending walks
+ *     synchronously.
+ *
+ * The deferral is what lets the doc-order walker see a fully populated
+ * registry: every `hydrate()` call from the bundled module body lands
+ * in the registry *before* the microtask flush kicks off the single
+ * walk, so parents always init before their descendants regardless of
+ * which file the parent's `hydrate()` was emitted into.
+ *
+ * @param name - Component name
+ * @param def - Component definition (init function + optional template + comment flag)
+ */
+export declare function hydrate(name: string, def: ComponentDef): void;
+/**
+ * Re-hydrate all registered components.
+ *
+ * Called by the streaming resolver after swapping fallback content with
+ * resolved content. Goes through the same scheduler as `hydrate()` so
+ * back-to-back `__bf_swap` invocations or interleaved `hydrate()` calls
+ * collapse to a single walk per tick + per frame. Like `hydrate()` this
+ * is asynchronous — see `flushHydration()` if you need a synchronous
+ * drain.
+ */
+export declare function rehydrateAll(): void;
+/**
+ * Run any pending hydration walk synchronously, right now.
+ *
+ * The default scheduler is microtask + rAF — the right trade-off for
+ * production code (registry populates before the walk; back-to-back
+ * `hydrate()` calls coalesce). Tests and advanced consumers that need
+ * a deterministic completion point — e.g. imperative mounting code
+ * reading DOM state immediately after `render(...)` — call this
+ * helper instead of awaiting a microtask.
+ *
+ * @example
+ *   hydrate('Counter', def)
+ *   flushHydration()
+ *   // safe to read Counter's post-init DOM state
+ */
+export declare function flushHydration(): void;
+//# sourceMappingURL=hydrate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hydrate.d.ts","sourceRoot":"","sources":["../../src/runtime/hydrate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAQH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAS3C;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAEvE;AA8CD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,IAAI,CAgB7D;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,IAAI,IAAI,CAEnC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,IAAI,IAAI,CAKrC"}

package/dist/runtime/hydration-state.d.ts

@@ -0,0 +1,13 @@
+/**
+ * BarefootJS - Hydration State
+ *
+ * Tracks which scope elements have been hydrated using a WeakSet
+ * instead of a DOM attribute. This avoids polluting the DOM and
+ * enables tree-shaking.
+ */
+/**
+ * Set of scope elements that have been initialized/hydrated.
+ * Used to prevent duplicate initialization.
+ */
+export declare const hydratedScopes: WeakSet<Element>;
+//# sourceMappingURL=hydration-state.d.ts.map

package/dist/runtime/hydration-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydration-state.d.ts","sourceRoot":"","sources":["../../src/runtime/hydration-state.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;GAGG;AACH,eAAO,MAAM,cAAc,kBAAyB,CAAA"}

package/dist/runtime/index.d.ts

@@ -0,0 +1,27 @@
+export { createSignal, createEffect, createDisposableEffect, createMemo, createRoot, onCleanup, onMount, untrack, batch, type Reactive, type Signal, type Memo, type CleanupFn, type EffectFn, } from '@barefootjs/client/reactive';
+export { splitProps } from '../split-props';
+export { __slot, type SlotMarker } from '../slot';
+export { forwardProps } from '../forward-props';
+export { unwrap } from '../unwrap';
+export { createContext, useContext, provideContext, setCurrentScope, type Context, } from './context';
+export { createPortal, isSSRPortal, findSiblingSlot, cleanupPortalPlaceholder, type Portal, type PortalOptions, type Renderable, type PortalChildren, } from './portal';
+export { reconcileList, type RenderItemFn } from './list';
+export { reconcileElements, getLoopChildren, getLoopNodes } from './reconcile-elements';
+export { qsaItem, upsertChildItem } from './qsa-item';
+export { mapArray } from './map-array';
+export { registerTemplate, getTemplate, hasTemplate, type TemplateFn } from './template';
+export { createComponent, renderChild, getPropsUpdateFn, getComponentProps, parseHTML, } from './component';
+export { applyRestAttrs } from './apply-rest-attrs';
+export { spreadAttrs } from './spread-attrs';
+export { styleToCss } from './style';
+export { findScope, find, $, $c, $t, qsa, qsaChildScope, qsaChildScopes, cssEscape } from './query';
+export { hydrate, rehydrateAll, flushHydration, getRegisteredDef } from './hydrate';
+export { registerComponent, getComponentInit, initChild, upsertChild } from './registry';
+export { insert, type BranchConfig, type BranchTemplateResult } from './insert';
+export { __bfSlot } from './branch-slot';
+export { updateClientMarker } from './client-marker';
+export { hydratedScopes } from './hydration-state';
+export { render } from './render';
+export { __bf_swap, setupStreaming } from './streaming';
+export type { InitFn, ComponentDef } from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,sBAAsB,EACtB,UAAU,EACV,UAAU,EACV,SAAS,EACT,OAAO,EACP,OAAO,EACP,KAAK,EACL,KAAK,QAAQ,EACb,KAAK,MAAM,EACX,KAAK,IAAI,EACT,KAAK,SAAS,EACd,KAAK,QAAQ,GACd,MAAM,6BAA6B,CAAA;AAEpC,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,EAAE,MAAM,EAAE,KAAK,UAAU,EAAE,MAAM,SAAS,CAAA;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC/C,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AAIlC,OAAO,EACL,aAAa,EACb,UAAU,EACV,cAAc,EACd,eAAe,EACf,KAAK,OAAO,GACb,MAAM,WAAW,CAAA;AAGlB,OAAO,EACL,YAAY,EACZ,WAAW,EACX,eAAe,EACf,wBAAwB,EACxB,KAAK,MAAM,EACX,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,cAAc,GACpB,MAAM,UAAU,CAAA;AAGjB,OAAO,EAAE,aAAa,EAAE,KAAK,YAAY,EAAE,MAAM,QAAQ,CAAA;AACzD,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AACvF,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAGtC,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAA;AAGxF,OAAO,EACL,eAAe,EACf,WAAW,EACX,gBAAgB,EAChB,iBAAiB,EACjB,SAAS,GACV,MAAM,aAAa,CAAA;AAGpB,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAGpC,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,aAAa,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AACnG,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AACnF,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AACxF,OAAO,EAAE,MAAM,EAAE,KAAK,YAAY,EAAE,KAAK,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAC/E,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAGpD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAGlD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAGjC,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAGvD,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA"}