@ecopages/radiant 0.2.0 → 0.3.0-alpha.1

package/dist/core/radiant-component-ssr.d.ts

@@ -0,0 +1,29 @@
+import type { JsxRenderable } from '@ecopages/jsx';
+import type { RenderToStringOptions } from '@ecopages/jsx/server';
+import type { SsrSerializableContextProvider } from '../context/context-provider';
+import type { ReactiveProperty } from './radiant-element';
+import type { ReactivePropDefinition } from './reactive-prop-metadata';
+import type { SsrSerializableHydrationBinding } from './ssr-hydration-binding';
+type RadiantComponentSsrHost = {
+    constructor: CustomElementConstructor;
+    getAuthoredHydrationScriptMarkup?: () => string | undefined;
+    getContextProviders: () => SsrSerializableContextProvider[];
+    getHydrationBindings: () => SsrSerializableHydrationBinding[];
+    getSlotProjectionScriptTag?: () => string | undefined;
+    renderToString: (options?: RenderToStringOptions) => string;
+    getReactiveProperties: () => ReactiveProperty[];
+    getReactivePropDefinitions: () => ReactivePropDefinition[];
+    getPropertyValue: (name: string) => unknown;
+    listAttributeNames: () => string[];
+    getAttributeValue: (name: string) => string | null;
+};
+export declare class RadiantComponentSsrService {
+    private readonly host;
+    constructor(host: RadiantComponentSsrHost);
+    renderHost(): JsxRenderable;
+    renderHostToString(options?: RenderToStringOptions, attributes?: Record<string, string>): string;
+    private renderHostContent;
+    getHostAttributes(): Record<string, string>;
+    private getTagName;
+}
+export {};

package/dist/core/radiant-component-ssr.js

@@ -0,0 +1,3 @@
+import{g as a}from"../chunk-3ryr5wx2.js";import"../chunk-ssnnxzrj.js";import"../chunk-hztr86b4.js";import"../chunk-t8xtvgyg.js";import"../chunk-66e6s792.js";import"../chunk-vgtggzb6.js";export{a as RadiantComponentSsrService};
+
+//# debugId=F6B36BC49A26138E64756E2164756E21

package/dist/core/radiant-component-ssr.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "F6B36BC49A26138E64756E2164756E21",
+  "names": []
+}

package/dist/core/radiant-component.d.ts

@@ -0,0 +1,113 @@
+import { type JsxRenderable } from '@ecopages/jsx';
+import type { RenderToStringOptions } from '@ecopages/jsx/server';
+import { RadiantElement } from './radiant-element';
+import { type RadiantComponentRenderBridge } from './radiant-component-ssr-registry';
+/**
+ * A structured JSX-first Radiant base class.
+ * @typeParam Bindings - Explicit internal bindable shape. Include only the
+ * prop/state keys that JSX bindings should accept.
+ *
+ * Treat this as the component's internal reactive/bindable surface, not as the
+ * default public custom-element attribute contract. When a component exposes a
+ * narrower external API than its internal state, declare a separate public
+ * props type for the JSX intrinsic element and keep internal-only state out of
+ * that contract.
+ *
+ * Reusing the same type for both is fine only when the public props and the
+ * bindable reactive members are intentionally the same surface.
+ *
+ * - `render()` describes the view.
+ * - `update()` commits the current view into the host.
+ * - first render happens automatically on connect.
+ * - plain `@prop`, `@state`, and `@signal` reads performed during `render()`
+ *   participate in tracked rerender invalidation.
+ * - `update()` and `requestUpdate()` remain available when a rerender should be
+ *   scheduled from imperative work outside those tracked reads.
+ */
+export declare class RadiantComponent<Bindings extends object = {}> extends RadiantElement<Bindings> {
+    private isRendering;
+    private isFirstConnectPending;
+    private isRenderScheduled;
+    private needsRender;
+    private projectedSlotContent;
+    private renderSignal?;
+    private readonly renderWatcher;
+    private slotProjectionObserver?;
+    private slotProjectionVersion;
+    connectedCallback(): void;
+    /**
+     * Returns the current component view.
+     *
+     * The base implementation behaves like `<slot />`, so authored host children
+     * pass through unchanged when a subclass does not override `render()`.
+     */
+    render(): JsxRenderable;
+    /**
+     * Serializes the current component view into HTML.
+     */
+    renderToString(options?: RenderToStringOptions): string;
+    /**
+     * Returns the component host and current view as a JSX element.
+     */
+    renderHost(): JsxRenderable;
+    /**
+     * Serializes the component host and current view into HTML.
+     */
+    renderHostToString(options?: RenderToStringOptions): string;
+    /**
+     * Hydrates an SSR-rendered component view in place.
+     */
+    hydrate(): void;
+    /**
+     * Queues a component rerender and coalesces repeated requests into the same
+     * microtask.
+     *
+     * Use this when reactive state may change multiple times in the same turn and
+     * the current view should refresh once with the final values.
+     */
+    requestUpdate(): void;
+    /**
+     * Explicitly rerenders the component into its host.
+     */
+    update(): void;
+    disconnectedCallback(): void;
+    /**
+     * Returns the first projected element assigned to the default or named slot.
+     *
+     * Use this when component logic needs direct access to authored light-DOM
+     * content after projection.
+     *
+     * @param name Optional slot name. Omit for the default slot.
+     */
+    getSlotElement<T extends Element = Element>(name?: string): T | null;
+    /**
+     * Returns all projected elements assigned to the default or named slot.
+     *
+     * Text nodes are intentionally excluded so the result matches the element-
+     * oriented query semantics used by Radiant decorators.
+     *
+     * @param name Optional slot name. Omit for the default slot.
+     */
+    getSlotElements<T extends Element = Element>(name?: string): T[];
+    protected shouldAutoBindReactiveMembers(): boolean;
+    protected getHostSsrAttributes(): Record<string, string>;
+    /**
+     * Exposes the inherited SSR helper path to internal server renderers.
+     *
+     * The bridge is intentionally empty when a subclass overrides the host SSR
+     * methods so that custom host serialization remains the source of truth.
+     */
+    protected resolveSsrRenderBridge(): RadiantComponentRenderBridge;
+    private ensureSlotProjectionState;
+    private getHostChildNodeCount;
+    private getSlotProjectionScriptTag;
+    private getAuthoredHydrationScriptMarkup;
+    private handleSlotProjectionMutations;
+    private addProjectedSlotNode;
+    private removeProjectedSlotNode;
+    private observeSlotProjection;
+    private disconnectSlotProjectionObserver;
+    private disconnectRenderWatcher;
+    private resolveTrackedRenderOutput;
+    private resolveRenderOutput;
+}

package/dist/core/radiant-component.js

@@ -0,0 +1,3 @@
+import{P as a}from"../chunk-s5p5z3z4.js";import"../chunk-gdkte2vd.js";import"../chunk-eyw14d6y.js";import"../chunk-cnyxrh9r.js";import"../chunk-gg74gdpv.js";import"../chunk-e0r6ca2g.js";import"../chunk-66e6s792.js";import"../chunk-3xxvmd5c.js";import"../chunk-hpzgnxgq.js";import"../chunk-nssj2x13.js";import"../chunk-vgtggzb6.js";export{a as RadiantComponent};
+
+//# debugId=51A938E8D704D2E664756E2164756E21

package/dist/core/radiant-component.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "51A938E8D704D2E664756E2164756E21",
+  "names": []
+}

package/dist/core/radiant-element.d.ts

@@ -1,6 +1,14 @@
 import type { EventEmitter } from '../tools';
+import { type JsxRenderable, type SubscribableJsxValue } from '@ecopages/jsx';
+import type { SsrSerializableContextProvider } from '../context/context-provider';
 import type { UnknownContext } from '../context/types';
+import type { SsrSerializableHydrationBinding } from './ssr-hydration-binding';
 import { type AttributeTypeConstant, type ReadAttributeValueReturnType, type WriteAttributeValueReturnType } from '../utils/attribute-utils';
+declare const RadiantElementBase: {
+    new (): HTMLElement;
+    prototype: HTMLElement;
+};
+type ReactiveDependencyReader = () => unknown;
 /**
  * Possible positions to insert a rendered template.
  */
@@ -36,16 +44,74 @@ export type ReactivePropertyOptions<T> = {
     reflect?: boolean;
     attribute?: string;
     defaultValue?: T;
+    /**
+     * Exposes a JSX binding companion for the reactive property.
+     *
+     * - `true` creates a `$propertyName` accessor.
+     * - a string creates a custom accessor with that name.
+     * - `undefined` defers to the host default.
+     *
+     * The generated accessor returns a subscribable JSX child value so JSX can
+     * patch only the affected child part when the property changes.
+     */
+    bind?: boolean | string;
+};
+export type ReactiveBindingOption = boolean | string;
+export type ReactiveFieldOptions = {
+    /**
+     * Exposes a JSX binding companion for the reactive field.
+     *
+     * - `true` creates a `$fieldName` accessor.
+     * - a string creates a custom accessor with that name.
+     * - `undefined` defers to the host default.
+     */
+    bind?: ReactiveBindingOption;
 };
 export type ReactiveField<T = unknown> = {
     name: string;
     value: T;
     initialValue: T;
 };
+type StringPropertyKey<Value> = Extract<keyof Value, string>;
+/**
+ * Value type produced by a JSX binding for a selected reactive member.
+ *
+ * Bindings preserve the original property type when it is already renderable by
+ * the Ecopages JSX runtime. For non-renderable values, the binding falls back
+ * to the broader `JsxRenderable` contract consumed by the renderer.
+ */
+export type ReactiveBindingValue<Host extends object, Property extends StringPropertyKey<Host>> = Host[Property] extends JsxRenderable ? Host[Property] : JsxRenderable;
+/**
+ * Namespace of cached JSX bindings keyed by the explicit bindable shape.
+ *
+ * Radiant exposes this namespace twice on every host:
+ *
+ * - `host.bindings.key` for the explicit form
+ * - `host.$.key` for the short form
+ *
+ * Both aliases resolve through the same cached binding objects as
+ * `host.bind('key')`.
+ */
+export type ReactiveBindings<Bindings extends object> = {
+    readonly [Property in StringPropertyKey<Bindings>]: SubscribableJsxValue<ReactiveBindingValue<Bindings, Property>>;
+};
 /**
  * Represents an interface for a Radiant element.
+ * @typeParam Bindings - Explicit internal bindable shape used to type `bind()` and `getReactiveBinding()`.
+ *
+ * This shape describes which reactive members are exposed through `bindings`,
+ * `$`, and `bind(...)`. It does not automatically define the public JSX
+ * attribute contract for the custom element.
  */
-export interface IRadiantElement {
+export interface IRadiantElement<Bindings extends object = {}> {
+    /**
+     * Namespace of cached JSX bindings keyed by the explicit bindable shape.
+     */
+    readonly bindings: ReactiveBindings<Bindings>;
+    /**
+     * Short alias for {@link bindings}.
+     */
+    readonly $: ReactiveBindings<Bindings>;
     /**
      * Called when a property of the element is updated.
      * @param changedProperty - The name of the changed property.
@@ -58,6 +124,33 @@ export interface IRadiantElement {
      * @param event - The event listener to subscribe to.
      */
     subscribeEvent(event: RadiantElementEventListener): void;
+    /**
+     * Registers a callback to be invoked when a reactive property or field changes.
+     *
+     * @returns A cleanup function that unregisters the callback.
+     */
+    registerUpdateCallback(property: string, update: (...rest: any[]) => any): () => void;
+    /**
+     * Returns a subscribable JSX child binding for a reactive property or field.
+     *
+     * Prefer `this.bindings.key` or `this.$.key` in JSX render code when you want
+     * property access syntax without string literals.
+     */
+    bind<Property extends StringPropertyKey<Bindings>>(property: Property): SubscribableJsxValue<ReactiveBindingValue<Bindings, Property>>;
+    /**
+     * Returns a subscribable JSX child binding for a reactive property or field.
+     *
+     * This is the primitive lookup used by `bind()`, `bindings.key`, and `$.key`.
+     */
+    getReactiveBinding<Property extends StringPropertyKey<Bindings>>(property: Property): SubscribableJsxValue<ReactiveBindingValue<Bindings, Property>>;
+    /**
+     * Defines a stable JSX binding companion accessor for a reactive member.
+     *
+     * Companion bindings create properties such as `$count` directly on the host.
+     * Prefer the `bindings` or `$` namespace for new code when you want typed,
+     * explicit access to the configured bindable shape.
+     */
+    defineReactiveBinding(property: string, bind?: ReactiveBindingOption): void;
     /**
      * Subscribes to multiple Radiant element events.
      * @param events - The array of event listeners to subscribe to.
@@ -68,16 +161,42 @@ export interface IRadiantElement {
      */
     registerCleanupCallback(callback: () => void): void;
     /**
-     * Renders a template into the specified target element.
+     * Registers a callback to run on each future host connection.
+     *
+     * The callback is only invoked from `connectedCallback()`. Registering it
+     * after the host is already connected does not invoke it immediately.
+     */
+    registerConnectedCallback(callback: () => void): void;
+    /**
+     * Registers a raw value reader for a reactive member so that tracked render
+     * dependencies can read the underlying value without triggering the public
+     * getter's dependency tracking.
+     */
+    registerReactiveDependencyReader(property: string, read: () => unknown): void;
+    /**
+     * Records a tracked read of a reactive member during a component render,
+     * allowing the signals runtime to re-render only the affected parts.
+     */
+    trackReactiveRead(property: string): void;
+    /**
+     * Renders a trusted HTML template string into the specified target element.
+     *
+     * **Security:** The `template` string is written to the DOM via `innerHTML`
+     * or `insertAdjacentHTML` without built-in sanitization. Callers are
+     * responsible for ensuring the input is trusted. Supply a `sanitize`
+     * function to transform the template before insertion.
+     *
      * @param options - The rendering options.
      * @param options.target - The target element to render the template into.
      * @param options.template - The template string to render.
      * @param options.insert - The position to insert the rendered template. (optional)
+     * @param options.sanitize - An optional function that transforms the template string before insertion.
      */
     renderTemplate(options: {
         target: HTMLElement;
         template: string;
         insert?: RenderInsertPosition;
+        sanitize?: (html: string) => string;
     }): void;
     /**
      * Called when the Radiant element is connected to a context.
@@ -90,14 +209,24 @@ export interface IRadiantElement {
      * @param all - Whether to get all elements with the specified data-ref attribute value.
      * @returns The element with the specified data-ref attribute value, an array of elements or null if no element was found.
      */
-    getRef<T extends Element = Element>(ref: string, all: boolean): T | T[];
+    getRef<T extends Element = Element>(ref: string, all: true): T[];
+    getRef<T extends Element = Element>(ref: string, all?: false): T | null;
 }
 /**
  * A base class for creating custom elements with reactive properties and event subscriptions.
+ * @typeParam Bindings - Explicit internal bindable shape. Include only the
+ * prop/state keys that JSX bindings should accept.
+ *
+ * Prefer a separate public props type for custom-element JSX declarations when
+ * the external attribute contract differs from the component's internal
+ * reactive state. Reuse the same type only when the public props and bindable
+ * members are intentionally identical.
  * @extends HTMLElement
- * @implements IRadiantElement
+ * @implements IRadiantElement<Bindings>
  */
-export declare class RadiantElement extends HTMLElement implements IRadiantElement {
+export declare class RadiantElement<Bindings extends object = {}> extends RadiantElementBase implements IRadiantElement<Bindings> {
+    readonly bindings: ReactiveBindings<Bindings>;
+    readonly $: ReactiveBindings<Bindings>;
     /**
      * A map of property metadata objects, it contains useful information about the properties configured via decorators.
      */
@@ -106,6 +235,28 @@ export declare class RadiantElement extends HTMLElement implements IRadiantEleme
      * A map of reactive fields, it contains the reactive fields configured via decorators.
      */
     private reactiveFields;
+    /**
+     * Stable dependency nodes used when plain reactive member reads participate
+     * in tracked component renders.
+     */
+    private reactiveDependencies;
+    /**
+     * Raw value readers for reactive members whose public getter should also
+     * register tracked render dependencies.
+     */
+    private reactiveDependencyReaders;
+    /**
+     * Stable subscribable JSX bindings keyed by reactive property name.
+     */
+    private reactiveBindings;
+    /**
+     * Registered context providers keyed by decorated property name.
+     */
+    private contextProviders;
+    /**
+     * Registered keyed hydration payload producers appended to SSR host output.
+     */
+    private hydrationBindings;
     /**
      * A map of property update callbacks. These callbacks are called when a property is updated.
      */
@@ -118,6 +269,10 @@ export declare class RadiantElement extends HTMLElement implements IRadiantEleme
      * A map for event emitters
      */
     private eventEmitters;
+    /**
+     * Callbacks executed whenever the Radiant element is connected to the DOM.
+     */
+    private onConnectedCallbacks;
     /**
      * An array of cleanup callbacks to be executed when the Radiant element is disconnected from the DOM.
      */
@@ -126,28 +281,81 @@ export declare class RadiantElement extends HTMLElement implements IRadiantEleme
      * A flag indicating whether the element has been connected to the DOM.
      */
     private elementReady;
+    constructor();
+    private createReactiveBindingNamespace;
     connectedCallback(): void;
     connectedContextCallback(_contextName: UnknownContext): void;
     disconnectedCallback(): void;
     notifyUpdate(changedProperty: string, oldValue: unknown, value: unknown): void;
     private transformAttributeValue;
     attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
-    renderTemplate({ target, template, insert, }: {
+    /**
+     * Renders a trusted HTML template string into the specified target element.
+     *
+     * **Security:** The `template` string is written to the DOM via `innerHTML`
+     * or `insertAdjacentHTML` without built-in sanitization. Callers are
+     * responsible for ensuring the input is trusted. Supply a `sanitize`
+     * function to transform the template before insertion.
+     */
+    renderTemplate({ target, template, insert, sanitize, }: {
         target: HTMLElement;
         template: string;
         insert?: RenderInsertPosition;
+        sanitize?: (html: string) => string;
     }): void;
     registerReactiveProperty(config: ReactiveProperty): void;
+    protected getReactiveProperties(): ReactiveProperty[];
     registerReactiveField<T>(config: ReactiveField<T>): void;
-    registerUpdateCallback(property: string, update: (...rest: any[]) => any): void;
+    registerReactiveDependencyReader(property: string, read: ReactiveDependencyReader): void;
+    registerContextProvider(name: string, provider: SsrSerializableContextProvider): void;
+    registerHydrationBinding(name: string, binding: SsrSerializableHydrationBinding): void;
+    protected getContextProviders(): SsrSerializableContextProvider[];
+    protected getHydrationBindings(): SsrSerializableHydrationBinding[];
+    /**
+     * Flushes any deferred SSR-only preparation work before the host is
+     * serialized.
+     *
+     * Radiant uses this to reapply SSR consumer state after construction so the
+     * first server render sees finalized fields, props, and authored content.
+     */
+    protected prepareForSsr(): void;
+    /**
+     * Returns the default JSX binding policy for reactive members on this host.
+     *
+     * Plain `RadiantElement` instances keep binding opt-in. JSX-first hosts such
+     * as `RadiantComponent` override this hook to opt into automatic bindings for
+     * `@prop`, `@state`, and direct `createReactiveProp`/`createReactiveField`
+     * calls when no explicit `bind` option is supplied.
+     */
+    protected shouldAutoBindReactiveMembers(): boolean;
+    registerUpdateCallback(property: string, update: (...rest: any[]) => any): () => void;
+    getReactiveBinding<Property extends StringPropertyKey<Bindings>>(property: Property): SubscribableJsxValue<ReactiveBindingValue<Bindings, Property>>;
+    bind<Property extends StringPropertyKey<Bindings>>(property: Property): SubscribableJsxValue<ReactiveBindingValue<Bindings, Property>>;
+    defineReactiveBinding(property: string, bind?: ReactiveBindingOption): void;
+    private getReactiveDependency;
+    trackReactiveRead(property: string): void;
+    private readReactiveDependencyValue;
+    private readReactiveBindingValue;
     subscribeEvents(events: RadiantElementEventListener[]): Array<() => void>;
     subscribeEvent(eventConfig: RadiantElementEventListener): () => void;
     private unsubscribeEvent;
     private removeAllSubscribedEvents;
+    /**
+     * Registers a callback that runs on every future disconnect.
+     */
     registerCleanupCallback(callback: () => void): void;
+    /**
+     * Registers a callback that runs from `connectedCallback()` on future host
+     * connections.
+     *
+     * Registering after the host is already connected does not invoke the
+     * callback immediately.
+     */
+    registerConnectedCallback(callback: () => void): void;
     registerEventEmitter(name: string, emitter: EventEmitter): void;
     getRef<T extends Element = Element>(ref: string, all: true): T[];
-    getRef<T extends Element = Element>(ref: string, all?: false): T;
-    createReactiveField<T>(propertyName: string, initialValue: T): void;
+    getRef<T extends Element = Element>(ref: string, all?: false): T | null;
+    createReactiveField<T>(propertyName: string, initialValue: T, options?: ReactiveFieldOptions): void;
     createReactiveProp<T = unknown>(propertyName: string, options: ReactivePropertyOptions<T>): void;
 }
+export {};

package/dist/core/radiant-element.js

@@ -1,4 +1,3 @@
-import{J as Z,K as _,L as $,M as D}from"../utils/attribute-utils.js";class T extends HTMLElement{reactiveProperties=new Map;reactiveFields=new Map;updateCallbacks=new Map;eventSubscriptions=new Map;eventEmitters=new Map;onDisconnectedCallback=[];elementReady=!1;connectedCallback(){this.elementReady=!0}connectedContextCallback(j){}disconnectedCallback(){this.removeAllSubscribedEvents();for(let j of this.onDisconnectedCallback)j()}notifyUpdate(j,x,B){if(!this.updateCallbacks||x===B)return;const z=this.updateCallbacks.get(j);if(z)for(let G of z)G()}transformAttributeValue(j,x){return j?x?.converter.fromAttribute(j):j}attributeChangedCallback(j,x,B){if(x===B||!this.elementReady)return;if(this.reactiveProperties.has(j)){const z=this.reactiveProperties.get(j),G=this.transformAttributeValue(B,z),J=this.transformAttributeValue(x,z),Q=z?z.attribute:j;this[Q]=G,this.notifyUpdate(j,J,G)}}renderTemplate({target:j=this,template:x,insert:B="replace"}){switch(B){case"replace":j.innerHTML=x;break;case"beforeend":j.insertAdjacentHTML("beforeend",x);break;case"afterbegin":j.insertAdjacentHTML("afterbegin",x);break}}registerReactiveProperty(j){this.reactiveProperties.set(j.name,j)}registerReactiveField(j){this.reactiveFields.set(j.name,j)}registerUpdateCallback(j,x){if(!this.updateCallbacks.has(j))this.updateCallbacks.set(j,new Set);this.updateCallbacks.get(j)?.add(x)}subscribeEvents(j){const x=[];for(let B of j)x.push(this.subscribeEvent(B));return x}subscribeEvent(j){const x=(z)=>{if(z.target&&z.target.matches(j.selector))j.listener.call(this,z)},B=`${j.type}:${j.selector}`;return this.addEventListener(j.type,x,j.options),this.eventSubscriptions.set(B,{...j,listener:x}),this.unsubscribeEvent.bind(this,B)}unsubscribeEvent(j){const x=this.eventSubscriptions.get(j);if(x)this.removeEventListener(x.type,x.listener,x.options),this.eventSubscriptions.delete(j)}removeAllSubscribedEvents(){for(let j of this.eventSubscriptions.values())this.removeEventListener(j.type,j.listener,j.options);this.eventSubscriptions.clear()}registerCleanupCallback(j){this.onDisconnectedCallback.push(j)}registerEventEmitter(j,x){this.eventEmitters.set(j,x)}getRef(j,x=!1){const B=`[data-ref="${j}"]`;let z;if(x){if(z=Array.from(this.querySelectorAll(B)),z.length===0)z=[]}else if(z=this.querySelector(B),!z)z=document.createDocumentFragment();return z}createReactiveField(j,x){const B={name:j,value:x,initialValue:x};this.registerReactiveField(B),Object.defineProperty(this,j,{get(){return this.reactiveFields.get(j)?.value??void 0},set(z){const G=this.reactiveFields.get(j)?.value;if(G!==z)this.reactiveFields.set(j,{...B,value:z}),this.notifyUpdate(j,G,z)},enumerable:!0,configurable:!0}),this.notifyUpdate(j,void 0,x)}createReactiveProp(j,x){const{type:B,attribute:z,reflect:G,defaultValue:J}=x,Q=z??j;if(J!==void 0&&!$(B,J))throw new Error(`defaultValue does not match the expected type for ${B.name}`);const U=D(this,B,Q,J),X={type:B,name:j,value:U,initialValue:U,attribute:Q,converter:{fromAttribute:(H)=>Z(H,B),toAttribute:(H)=>_(H,B)}};this.registerReactiveProperty(X);const Y=(H)=>{if(G){const W=X.converter.toAttribute(H);this.setAttribute(Q,W)}};if(Object.defineProperty(this,j,{get:function(){return this.reactiveProperties.get(j)?.value??void 0},set:function(H){const W=this.reactiveProperties.get(j)?.value;if(W!==H)this.reactiveProperties.set(j,{...X,value:H}),Y(H),this.notifyUpdate(j,W,H)},enumerable:!0,configurable:!0}),U!==void 0)Y(U),queueMicrotask(()=>{this.notifyUpdate(j,void 0,U)})}}export{T as RadiantElement};
-export{T as s};
+import{Y as a}from"../chunk-gdkte2vd.js";import"../chunk-eyw14d6y.js";import"../chunk-cnyxrh9r.js";import"../chunk-66e6s792.js";import"../chunk-vgtggzb6.js";export{a as RadiantElement};
 
-//# debugId=02C394B602FFC5B564756E2164756E21
+//# debugId=AFB01FEC1FA2614F64756E2164756E21

package/dist/core/radiant-element.js.map

@@ -1,10 +1,9 @@
 {
   "version": 3,
-  "sources": ["../src/core/radiant-element.ts"],
+  "sources": [],
   "sourcesContent": [
-    "import type { EventEmitter } from '@/tools';\nimport type { UnknownContext } from '../context/types';\nimport {\n  type AttributeTypeConstant,\n  type ReadAttributeValueReturnType,\n  type WriteAttributeValueReturnType,\n  getInitialValue,\n  isValueOfType,\n  readAttributeValue,\n  writeAttributeValue,\n} from '../utils/attribute-utils';\n\n/**\n * Possible positions to insert a rendered template.\n */\nexport type RenderInsertPosition = 'replace' | 'beforebegin' | 'afterbegin' | 'beforeend' | 'afterend';\n\n/**\n * Represents a Radiant element event listener.\n */\nexport type RadiantElementEventListener = {\n  selector: string;\n  type: string;\n  listener: EventListener;\n  options?: AddEventListenerOptions;\n};\n\n/**\n * Represents a property metadata object.\n */\nexport interface ReactiveProperty<T = unknown> {\n  type: AttributeTypeConstant;\n  value?: T;\n  initialValue?: T;\n  name: string;\n  attribute: string;\n  converter: {\n    fromAttribute: (value: string) => ReadAttributeValueReturnType;\n    toAttribute: (value: any) => WriteAttributeValueReturnType;\n  };\n}\n\n/**\n * Represents the options for a reactive property.\n */\nexport type ReactivePropertyOptions<T> = {\n  type: AttributeTypeConstant;\n  reflect?: boolean;\n  attribute?: string;\n  defaultValue?: T;\n};\n\nexport type ReactiveField<T = unknown> = {\n  name: string;\n  value: T;\n  initialValue: T;\n};\n\n/**\n * Represents an interface for a Radiant element.\n */\nexport interface IRadiantElement {\n  /**\n   * Called when a property of the element is updated.\n   * @param changedProperty - The name of the changed property.\n   * @param oldValue - The old value of the property.\n   * @param newValue - The new value of the property.\n   */\n  notifyUpdate(changedProperty: string, oldValue: unknown, newValue: unknown): void;\n\n  /**\n   * Subscribes to a Radiant element event.\n   * @param event - The event listener to subscribe to.\n   */\n  subscribeEvent(event: RadiantElementEventListener): void;\n\n  /**\n   * Subscribes to multiple Radiant element events.\n   * @param events - The array of event listeners to subscribe to.\n   */\n  subscribeEvents(events: RadiantElementEventListener[]): void;\n\n  /**\n   * It adds a callback to be executed when the Radiant element is disconnected from the DOM.\n   */\n  registerCleanupCallback(callback: () => void): void;\n\n  /**\n   * Renders a template into the specified target element.\n   * @param options - The rendering options.\n   * @param options.target - The target element to render the template into.\n   * @param options.template - The template string to render.\n   * @param options.insert - The position to insert the rendered template. (optional)\n   */\n  renderTemplate(options: {\n    target: HTMLElement;\n    template: string;\n    insert?: RenderInsertPosition;\n  }): void;\n\n  /**\n   * Called when the Radiant element is connected to a context.\n   * @param context - The connected context.\n   */\n  connectedContextCallback(context: UnknownContext): void;\n\n  /**\n   * Gets a reference to a child element by its data-ref attribute.\n   * @param ref - The data-ref attribute value of the element to get.\n   * @param all - Whether to get all elements with the specified data-ref attribute value.\n   * @returns The element with the specified data-ref attribute value, an array of elements or null if no element was found.\n   */\n  getRef<T extends Element = Element>(ref: string, all: boolean): T | T[];\n}\n\n/**\n * A base class for creating custom elements with reactive properties and event subscriptions.\n * @extends HTMLElement\n * @implements IRadiantElement\n */\nexport class RadiantElement extends HTMLElement implements IRadiantElement {\n  /**\n   * A map of property metadata objects, it contains useful information about the properties configured via decorators.\n   */\n  private reactiveProperties = new Map<string, ReactiveProperty>();\n\n  /**\n   * A map of reactive fields, it contains the reactive fields configured via decorators.\n   */\n  private reactiveFields = new Map<string, ReactiveField>();\n\n  /**\n   * A map of property update callbacks. These callbacks are called when a property is updated.\n   */\n  private updateCallbacks = new Map<string, Set<(...rest: any[]) => any>>();\n\n  /**\n   * A map of event subscriptions used to manage event listeners on the Radiant element.\n   */\n  private eventSubscriptions = new Map<string, RadiantElementEventListener>();\n\n  /**\n   * A map for event emitters\n   */\n  private eventEmitters = new Map<string, EventEmitter>();\n\n  /**\n   * An array of cleanup callbacks to be executed when the Radiant element is disconnected from the DOM.\n   */\n  private onDisconnectedCallback: (() => void)[] = [];\n\n  /**\n   * A flag indicating whether the element has been connected to the DOM.\n   */\n  private elementReady = false;\n\n  connectedCallback() {\n    this.elementReady = true;\n  }\n\n  connectedContextCallback(_contextName: UnknownContext): void {}\n\n  disconnectedCallback() {\n    this.removeAllSubscribedEvents();\n    for (const cleanup of this.onDisconnectedCallback) {\n      cleanup();\n    }\n  }\n\n  public notifyUpdate(changedProperty: string, oldValue: unknown, value: unknown) {\n    if (!this.updateCallbacks || oldValue === value) return;\n    const updates = this.updateCallbacks.get(changedProperty);\n\n    if (updates) {\n      for (const update of updates) {\n        update();\n      }\n    }\n  }\n\n  private transformAttributeValue(value: string | null, config: any): unknown {\n    return value ? config?.converter.fromAttribute(value) : value;\n  }\n\n  attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null) {\n    if (oldValue === newValue || !this.elementReady) return;\n\n    if (this.reactiveProperties.has(name)) {\n      const config = this.reactiveProperties.get(name);\n\n      const transformedValue = this.transformAttributeValue(newValue, config);\n      const transformedOldValue = this.transformAttributeValue(oldValue, config);\n\n      const key = config ? config.attribute : name;\n      (this as any)[key] = transformedValue;\n      this.notifyUpdate(name, transformedOldValue, transformedValue);\n    }\n  }\n\n  public renderTemplate({\n    target = this,\n    template,\n    insert = 'replace',\n  }: {\n    target: HTMLElement;\n    template: string;\n    insert?: RenderInsertPosition;\n  }) {\n    switch (insert) {\n      case 'replace':\n        target.innerHTML = template;\n        break;\n      case 'beforeend':\n        target.insertAdjacentHTML('beforeend', template);\n        break;\n      case 'afterbegin':\n        target.insertAdjacentHTML('afterbegin', template);\n        break;\n    }\n  }\n\n  public registerReactiveProperty(config: ReactiveProperty) {\n    this.reactiveProperties.set(config.name, config);\n  }\n\n  public registerReactiveField<T>(config: ReactiveField<T>) {\n    this.reactiveFields.set(config.name, config);\n  }\n\n  public registerUpdateCallback(property: string, update: (...rest: any[]) => any) {\n    if (!this.updateCallbacks.has(property)) {\n      this.updateCallbacks.set(property, new Set());\n    }\n    this.updateCallbacks.get(property)?.add(update);\n  }\n\n  public subscribeEvents(events: RadiantElementEventListener[]): Array<() => void> {\n    const unsubscribers: Array<() => void> = [];\n    for (const event of events) {\n      unsubscribers.push(this.subscribeEvent(event));\n    }\n    return unsubscribers;\n  }\n\n  public subscribeEvent(eventConfig: RadiantElementEventListener): () => void {\n    const delegatedListener = (delegatedEvent: Event) => {\n      if (delegatedEvent.target && (delegatedEvent.target as Element).matches(eventConfig.selector)) {\n        eventConfig.listener.call(this, delegatedEvent);\n      }\n    };\n    const subscriptionId = `${eventConfig.type}:${eventConfig.selector}`;\n    this.addEventListener(eventConfig.type, delegatedListener, eventConfig.options);\n    this.eventSubscriptions.set(subscriptionId, {\n      ...eventConfig,\n      listener: delegatedListener,\n    });\n\n    return this.unsubscribeEvent.bind(this, subscriptionId);\n  }\n\n  private unsubscribeEvent(id: string): void {\n    const eventSubscription = this.eventSubscriptions.get(id);\n    if (eventSubscription) {\n      this.removeEventListener(eventSubscription.type, eventSubscription.listener, eventSubscription.options);\n      this.eventSubscriptions.delete(id);\n    }\n  }\n\n  private removeAllSubscribedEvents(): void {\n    for (const eventSubscription of this.eventSubscriptions.values()) {\n      this.removeEventListener(eventSubscription.type, eventSubscription.listener, eventSubscription.options);\n    }\n    this.eventSubscriptions.clear();\n  }\n\n  public registerCleanupCallback(callback: () => void): void {\n    this.onDisconnectedCallback.push(callback);\n  }\n\n  public registerEventEmitter(name: string, emitter: EventEmitter) {\n    this.eventEmitters.set(name, emitter);\n  }\n\n  public getRef<T extends Element = Element>(ref: string, all: true): T[];\n  public getRef<T extends Element = Element>(ref: string, all?: false): T;\n  public getRef<T extends Element = Element>(ref: string, all = false): T | T[] {\n    const selector = `[data-ref=\"${ref}\"]`;\n    let result: T | T[];\n    if (all) {\n      result = Array.from(this.querySelectorAll(selector)) as T[];\n      if (result.length === 0) result = [];\n    } else {\n      result = this.querySelector(selector) as T;\n      if (!result) {\n        const fragment = document.createDocumentFragment();\n        result = fragment as unknown as T;\n      }\n    }\n    return result;\n  }\n\n  public createReactiveField<T>(propertyName: string, initialValue: T): void {\n    const reactiveField: ReactiveField<T> = {\n      name: propertyName,\n      value: initialValue,\n      initialValue: initialValue,\n    };\n\n    this.registerReactiveField(reactiveField);\n\n    Object.defineProperty(this, propertyName, {\n      get(this: RadiantElement) {\n        return this.reactiveFields.get(propertyName)?.value ?? undefined;\n      },\n      set(this: RadiantElement, newValue: T) {\n        const oldValue = this.reactiveFields.get(propertyName)?.value;\n        if (oldValue !== newValue) {\n          this.reactiveFields.set(propertyName, { ...reactiveField, value: newValue });\n          this.notifyUpdate(propertyName, oldValue, newValue);\n        }\n      },\n      enumerable: true,\n      configurable: true,\n    });\n\n    this.notifyUpdate(propertyName, undefined, initialValue);\n  }\n\n  public createReactiveProp<T = unknown>(propertyName: string, options: ReactivePropertyOptions<T>): void {\n    const { type, attribute, reflect, defaultValue } = options;\n    const attributeKey = attribute ?? propertyName;\n\n    if (defaultValue !== undefined && !isValueOfType(type, defaultValue)) {\n      throw new Error(`defaultValue does not match the expected type for ${type.name}`);\n    }\n\n    const initialValue: T | undefined = getInitialValue(this, type, attributeKey, defaultValue) as T;\n\n    const propertyMapping: ReactiveProperty<T> = {\n      type,\n      name: propertyName,\n      value: initialValue,\n      initialValue,\n      attribute: attributeKey,\n      converter: {\n        fromAttribute: (value) => readAttributeValue(value, type),\n        toAttribute: (value) => writeAttributeValue(value, type),\n      },\n    };\n\n    this.registerReactiveProperty(propertyMapping);\n\n    const handleReflectRequest = (value: T) => {\n      if (reflect) {\n        const attributeValue = propertyMapping.converter.toAttribute(value);\n        this.setAttribute(attributeKey, attributeValue);\n      }\n    };\n\n    Object.defineProperty(this, propertyName, {\n      get: function (this: RadiantElement) {\n        return this.reactiveProperties.get(propertyName)?.value ?? undefined;\n      },\n      set: function (this: RadiantElement, newValue: T) {\n        const oldValue = this.reactiveProperties.get(propertyName)?.value;\n        if (oldValue !== newValue) {\n          this.reactiveProperties.set(propertyName, { ...propertyMapping, value: newValue });\n          handleReflectRequest(newValue);\n          this.notifyUpdate(propertyName, oldValue, newValue);\n        }\n      },\n      enumerable: true,\n      configurable: true,\n    });\n\n    if (initialValue !== undefined) {\n      handleReflectRequest(initialValue as T);\n      queueMicrotask(() => {\n        this.notifyUpdate(propertyName, undefined, initialValue);\n      });\n    }\n  }\n}\n"
   ],
-  "mappings": "qEAwHO,MAAM,UAAuB,WAAuC,CAIjE,mBAAqB,IAAI,IAKzB,eAAiB,IAAI,IAKrB,gBAAkB,IAAI,IAKtB,mBAAqB,IAAI,IAKzB,cAAgB,IAAI,IAKpB,uBAAyC,CAAC,EAK1C,aAAe,GAEvB,iBAAiB,EAAG,CAClB,KAAK,aAAe,GAGtB,wBAAwB,CAAC,EAAoC,EAE7D,oBAAoB,EAAG,CACrB,KAAK,0BAA0B,EAC/B,QAAW,KAAW,KAAK,uBACzB,EAAQ,EAIL,YAAY,CAAC,EAAyB,EAAmB,EAAgB,CAC9E,IAAK,KAAK,iBAAmB,IAAa,EAAO,OACjD,MAAM,EAAU,KAAK,gBAAgB,IAAI,CAAe,EAExD,GAAI,EACF,QAAW,KAAU,EACnB,EAAO,EAKL,uBAAuB,CAAC,EAAsB,EAAsB,CAC1E,OAAO,EAAQ,GAAQ,UAAU,cAAc,CAAK,EAAI,EAG1D,wBAAwB,CAAC,EAAc,EAAyB,EAAyB,CACvF,GAAI,IAAa,IAAa,KAAK,aAAc,OAEjD,GAAI,KAAK,mBAAmB,IAAI,CAAI,EAAG,CACrC,MAAM,EAAS,KAAK,mBAAmB,IAAI,CAAI,EAEzC,EAAmB,KAAK,wBAAwB,EAAU,CAAM,EAChE,EAAsB,KAAK,wBAAwB,EAAU,CAAM,EAEnE,EAAM,EAAS,EAAO,UAAY,EACxC,AAAC,KAAa,GAAO,EACrB,KAAK,aAAa,EAAM,EAAqB,CAAgB,GAI1D,cAAc,EACnB,SAAS,KACT,WACA,SAAS,WAKR,CACD,OAAQ,OACD,UACH,EAAO,UAAY,EACnB,UACG,YACH,EAAO,mBAAmB,YAAa,CAAQ,EAC/C,UACG,aACH,EAAO,mBAAmB,aAAc,CAAQ,EAChD,OAIC,wBAAwB,CAAC,EAA0B,CACxD,KAAK,mBAAmB,IAAI,EAAO,KAAM,CAAM,EAG1C,qBAAwB,CAAC,EAA0B,CACxD,KAAK,eAAe,IAAI,EAAO,KAAM,CAAM,EAGtC,sBAAsB,CAAC,EAAkB,EAAiC,CAC/E,IAAK,KAAK,gBAAgB,IAAI,CAAQ,EACpC,KAAK,gBAAgB,IAAI,EAAU,IAAI,GAAK,EAE9C,KAAK,gBAAgB,IAAI,CAAQ,GAAG,IAAI,CAAM,EAGzC,eAAe,CAAC,EAA0D,CAC/E,MAAM,EAAmC,CAAC,EAC1C,QAAW,KAAS,EAClB,EAAc,KAAK,KAAK,eAAe,CAAK,CAAC,EAE/C,OAAO,EAGF,cAAc,CAAC,EAAsD,CAC1E,MAAM,EAAoB,CAAC,IAA0B,CACnD,GAAI,EAAe,QAAW,EAAe,OAAmB,QAAQ,EAAY,QAAQ,EAC1F,EAAY,SAAS,KAAK,KAAM,CAAc,GAG5C,EAAiB,GAAG,EAAY,QAAQ,EAAY,WAO1D,OANA,KAAK,iBAAiB,EAAY,KAAM,EAAmB,EAAY,OAAO,EAC9E,KAAK,mBAAmB,IAAI,EAAgB,IACvC,EACH,SAAU,CACZ,CAAC,EAEM,KAAK,iBAAiB,KAAK,KAAM,CAAc,EAGhD,gBAAgB,CAAC,EAAkB,CACzC,MAAM,EAAoB,KAAK,mBAAmB,IAAI,CAAE,EACxD,GAAI,EACF,KAAK,oBAAoB,EAAkB,KAAM,EAAkB,SAAU,EAAkB,OAAO,EACtG,KAAK,mBAAmB,OAAO,CAAE,EAI7B,yBAAyB,EAAS,CACxC,QAAW,KAAqB,KAAK,mBAAmB,OAAO,EAC7D,KAAK,oBAAoB,EAAkB,KAAM,EAAkB,SAAU,EAAkB,OAAO,EAExG,KAAK,mBAAmB,MAAM,EAGzB,uBAAuB,CAAC,EAA4B,CACzD,KAAK,uBAAuB,KAAK,CAAQ,EAGpC,oBAAoB,CAAC,EAAc,EAAuB,CAC/D,KAAK,cAAc,IAAI,EAAM,CAAO,EAK/B,MAAmC,CAAC,EAAa,EAAM,GAAgB,CAC5E,MAAM,EAAW,cAAc,MAC/B,IAAI,EACJ,GAAI,GAEF,GADA,EAAS,MAAM,KAAK,KAAK,iBAAiB,CAAQ,CAAC,EAC/C,EAAO,SAAW,EAAG,EAAS,CAAC,UAEnC,EAAS,KAAK,cAAc,CAAQ,GAC/B,EAEH,EADiB,SAAS,uBAAuB,EAIrD,OAAO,EAGF,mBAAsB,CAAC,EAAsB,EAAuB,CACzE,MAAM,EAAkC,CACtC,KAAM,EACN,MAAO,EACP,aAAc,CAChB,EAEA,KAAK,sBAAsB,CAAa,EAExC,OAAO,eAAe,KAAM,EAAc,CACxC,GAAG,EAAuB,CACxB,OAAO,KAAK,eAAe,IAAI,CAAY,GAAG,OAAS,QAEzD,GAAG,CAAuB,EAAa,CACrC,MAAM,EAAW,KAAK,eAAe,IAAI,CAAY,GAAG,MACxD,GAAI,IAAa,EACf,KAAK,eAAe,IAAI,EAAc,IAAK,EAAe,MAAO,CAAS,CAAC,EAC3E,KAAK,aAAa,EAAc,EAAU,CAAQ,GAGtD,WAAY,GACZ,aAAc,EAChB,CAAC,EAED,KAAK,aAAa,EAAc,OAAW,CAAY,EAGlD,kBAA+B,CAAC,EAAsB,EAA2C,CACtG,MAAQ,OAAM,YAAW,UAAS,gBAAiB,EAC7C,EAAe,GAAa,EAElC,GAAI,IAAiB,SAAc,EAAc,EAAM,CAAY,EACjE,MAAM,IAAI,MAAM,qDAAqD,EAAK,MAAM,EAGlF,MAAM,EAA8B,EAAgB,KAAM,EAAM,EAAc,CAAY,EAEpF,EAAuC,CAC3C,OACA,KAAM,EACN,MAAO,EACP,eACA,UAAW,EACX,UAAW,CACT,cAAe,CAAC,IAAU,EAAmB,EAAO,CAAI,EACxD,YAAa,CAAC,IAAU,EAAoB,EAAO,CAAI,CACzD,CACF,EAEA,KAAK,yBAAyB,CAAe,EAE7C,MAAM,EAAuB,CAAC,IAAa,CACzC,GAAI,EAAS,CACX,MAAM,EAAiB,EAAgB,UAAU,YAAY,CAAK,EAClE,KAAK,aAAa,EAAc,CAAc,IAoBlD,GAhBA,OAAO,eAAe,KAAM,EAAc,CACxC,YAAc,EAAuB,CACnC,OAAO,KAAK,mBAAmB,IAAI,CAAY,GAAG,OAAS,QAE7D,YAAc,CAAuB,EAAa,CAChD,MAAM,EAAW,KAAK,mBAAmB,IAAI,CAAY,GAAG,MAC5D,GAAI,IAAa,EACf,KAAK,mBAAmB,IAAI,EAAc,IAAK,EAAiB,MAAO,CAAS,CAAC,EACjF,EAAqB,CAAQ,EAC7B,KAAK,aAAa,EAAc,EAAU,CAAQ,GAGtD,WAAY,GACZ,aAAc,EAChB,CAAC,EAEG,IAAiB,OACnB,EAAqB,CAAiB,EACtC,eAAe,IAAM,CACnB,KAAK,aAAa,EAAc,OAAW,CAAY,EACxD,EAGP",
-  "debugId": "02C394B602FFC5B564756E2164756E21",
+  "mappings": "",
+  "debugId": "AFB01FEC1FA2614F64756E2164756E21",
   "names": []
 }

package/dist/core/radiant-hydrator-state.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Marks the current JavaScript environment as hydration-enabled for first
+ * custom-element connect.
+ *
+ * `RadiantComponent` reads this flag before deciding whether SSR markup should
+ * hydrate in place or be replaced by a fresh client render.
+ */
+export declare function installRadiantHydratorState(): void;
+/**
+ * Clears the explicit hydration-enabled flag from `globalThis`.
+ *
+ * This is mainly used by tests so they can assert both hydrated and non-
+ * hydrated first-connect behavior deterministically.
+ */
+export declare function uninstallRadiantHydratorState(): void;
+/**
+ * Returns whether first-connect hydration is currently enabled for this
+ * JavaScript environment.
+ */
+export declare function isRadiantHydratorInstalled(): boolean;

package/dist/core/radiant-hydrator-state.js

@@ -0,0 +1,3 @@
+import{Qa as a,Ra as b,Sa as c}from"../chunk-gg74gdpv.js";import"../chunk-vgtggzb6.js";export{b as uninstallRadiantHydratorState,c as isRadiantHydratorInstalled,a as installRadiantHydratorState};
+
+//# debugId=C0B4DFA976E463CA64756E2164756E21

package/dist/core/radiant-hydrator-state.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "C0B4DFA976E463CA64756E2164756E21",
+  "names": []
+}

package/dist/core/reactive-jsx-value.d.ts

@@ -0,0 +1,10 @@
+import type { SubscribableJsxValue } from '@ecopages/jsx';
+import type { RadiantElement, ReactiveBindingValue } from './radiant-element';
+/**
+ * Creates a stable JSX child binding backed by a Radiant reactive property or field.
+ *
+ * The returned value resolves eagerly on the server and subscribes to the host's
+ * update callbacks on the client so the mounted child range can patch directly
+ * when the selected property changes.
+ */
+export declare function bindReactiveValue<Bindings extends object, Host extends RadiantElement<Bindings>, Property extends Extract<keyof Bindings, string>>(host: Host, property: Property): SubscribableJsxValue<ReactiveBindingValue<Bindings, Property>>;

package/dist/core/reactive-jsx-value.js

@@ -0,0 +1,3 @@
+import{Q as a}from"../chunk-z9kxfckm.js";import"../chunk-vgtggzb6.js";export{a as bindReactiveValue};
+
+//# debugId=F7E9554439ABF24664756E2164756E21

package/dist/core/reactive-jsx-value.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "F7E9554439ABF24664756E2164756E21",
+  "names": []
+}

package/dist/core/reactive-prop-metadata.d.ts

@@ -0,0 +1,7 @@
+import type { ReactivePropertyOptions } from './radiant-element';
+export type ReactivePropDefinition = {
+    name: string;
+    options: ReactivePropertyOptions<unknown>;
+};
+export declare function registerReactivePropDefinition(target: object, propertyName: string, options: ReactivePropertyOptions<unknown>): void;
+export declare function getReactivePropDefinitions(target: object): ReactivePropDefinition[];

package/dist/core/reactive-prop-metadata.js

@@ -0,0 +1,3 @@
+import{Ya as a,Za as b}from"../chunk-9mqtp3js.js";import"../chunk-vgtggzb6.js";export{a as registerReactivePropDefinition,b as getReactivePropDefinitions};
+
+//# debugId=A9F67D3FDEFF6A6464756E2164756E21

package/dist/core/reactive-prop-metadata.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "A9F67D3FDEFF6A6464756E2164756E21",
+  "names": []
+}