elements-kit 0.22.1 → 0.23.0

package/LICENSE

@@ -1,21 +1,201 @@
-MIT License
-
-Copyright (c) 2026 Wael Bettayeb
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -3,12 +3,12 @@
 **Universal reactive primitives for the web.** Signals, JSX, custom elements, and browser-API helpers. Import one at a time, compose them, or use any of them inside vanilla JS, React, Vue, or any framework.
 
 ```tsx
-import { signal, computed } from "elements-kit/signals";
+import { signal, computed, resolve } from "elements-kit/signals";
 import { render } from "elements-kit/render";
 import type { Props } from "elements-kit/jsx-runtime";
 
 function Counter(props: Props<{ initial?: number }>) {
-  const count = signal(props.initial() ?? 0);
+  const count = signal(resolve(props.initial) ?? 0);
   const doubled = computed(() => count() * 2);
 
   return (
@@ -60,13 +60,13 @@ Every feature is a separate subpath export — import only what you use.
 
 | Entry | Purpose |
 |-------|---------|
-| `elements-kit/signals` | `signal`, `computed`, `effect`, `effectScope`, `batch`, `untracked`, `trigger`, `onCleanup`, `MaybeReactive`, `resolve`, `resolveProps`, `@reactive` |
+| `elements-kit/signals` | `signal`, `computed`, `effect`, `effectScope`, `batch`, `untracked`, `trigger`, `onCleanup`, `MaybeReactive`, `resolve`, `computedProps`, `@reactive` |
 | `elements-kit/render` | `render(target, setup)` — mount a node with a scoped lifetime; returns `unmount` |
 | `elements-kit/attributes` | `@attributes` decorator + `ATTRIBUTES` symbol |
 | `elements-kit/slot` | `Slot` class + `@slot()` decorator + `SlotContent` type — comment-marker DOM regions as plain properties |
 | `elements-kit/custom-elements` | `defineElement`, `CustomElementRegistry`, `PropertiesOf`, `AttributesOf`, `EventsOf`, `PublicPropKeys` — raw framework-agnostic extractors for a custom element's properties/attributes/events |
 | `elements-kit/for` | `For` keyed-list component |
-| `elements-kit/jsx-runtime` | JSX factory + type helpers (`PropsOf`, `MaybeReactiveProps`, `RawProps`, `Props`, `Require`) — configure via `jsxImportSource` |
+| `elements-kit/jsx-runtime` | JSX factory + type helpers (`PropsOf`, `MaybeReactiveProps`, `Props`, `Require`) — configure via `jsxImportSource` |
 | `elements-kit/server` | `renderToStream`, `renderToString` — streaming HTML rendering in any JS runtime (Node, edge/Workers), no DOM required *(experimental)* |
 | `elements-kit/hydrate` | `hydrate(container, () => <App/>)` — adopt server-rendered DOM and make it interactive *(experimental)* |
 | `elements-kit/await` | `Await` — loading boundary (Suspense equivalent); code splitting = `async` + dynamic import *(experimental)* |
@@ -418,25 +418,41 @@ A small set of type helpers derives JSX prop shapes from your components — no
 | Helper | For |
 | ------ | --- |
 | `PropsOf<C>` | Unified — fn/class components give raw prop shapes; custom-element ctors give the full JSX surface (attrs, events, slots, children) |
-| `Props<P>` | Component-facing — every prop becomes a `Computed<T>` getter (what function components receive) |
-| `MaybeReactiveProps<P>` | Caller-facing — wrap every prop in `MaybeReactive` (e.g. a class component's constructor param) |
-| `RawProps<R>` | Recover the raw `P` from a branded `Props<P>` |
+| `Props<P>` | Every prop accepts a value *or* a reactive source — declare it on a function component that should take signals (alias of `MaybeReactiveProps<P>`) |
+| `MaybeReactiveProps<P>` | The same wrap under its descriptive name — used for class constructor params and the intrinsic-element surface |
+| `ComputedProps<P>` | The mirror of `Props<P>` — what a body *reads* after `computedProps`: every key a `Computed<T>`, optional keys included |
 | `MaybeReactive<T>` | Scalar value-or-getter (from `elements-kit/signals`) |
 | `Require<P, K>` | Promote optional keys to required |
 
-Callers never wrap anything by hand — at every JSX call site the runtime's `LibraryManagedAttributes` automatically lets parents pass each prop as a static value *or* a signal/computed.
+Intrinsic and custom-element attributes accept a static value *or* a signal at every JSX call site — the runtime's `LibraryManagedAttributes` handles that wrap for you.
 
-The JSX runtime auto-wraps function-component props — each key arrives as a callable getter that subscribes on read. Pair the signature with `Props<P>` and read `props.x()`:
+Function components are different: props arrive **exactly as the caller wrote them**, so the declared type is the contract on both sides. Declare plain types for static-only props; declare `Props<P>` (or `MaybeReactive<T>` per key) to accept signals, and read with `resolve` or by handing the prop to JSX:
 
 ```tsx
+import { resolve } from "elements-kit/signals";
 import type { Props } from "elements-kit/jsx-runtime";
 
 function Greeting(props: Props<{ name: string }>) {
-  return <p>Hello, {props.name}</p>;
+  return <p>Hello, {props.name}</p>; // JSX accepts either form
+}
+
+function Plain(props: { name: string }) {
+  return <p>Hello, {props.name}</p>; // callers may not pass a signal
+}
+```
+
+To read one uniform shape instead, convert the props with `computedProps` — every key becomes a getter, so no read needs `resolve`. Defaults go on the call, since a getter is always truthy:
+
+```tsx
+import { computedProps } from "elements-kit/signals";
+
+function Chat(raw: Props<{ placeholder?: string }>) {
+  const props = computedProps(raw);
+  return <input placeholder={props.placeholder() ?? "Ask anything…"} />;
 }
 ```
 
-`resolveProps` stays exported for non-JSX call sites or nested prop bags.
+A prop that takes arguments (a render prop, a handler with parameters) is rejected there — a callable cannot be told apart from a getter, since `Computed<T>` *is* `() => T`. Read those off the raw props instead.
 
 ## `@reactive()` Decorator
 

package/dist/await.d.mts

@@ -1,4 +1,4 @@
-import { c as Props, t as Children } from "./children-s3nFjpLA.mjs";
+import { s as Props, t as Children } from "./children-BbHF-Dew.mjs";
 
 //#region src/await.d.ts
 /** @internal Metadata stamped on an Await region getter (see claim walk). */

package/dist/await.mjs

@@ -1,5 +1,4 @@
 import { f as effectsInert, t as ASYNC_REGION } from "./lib-DYypKhxk.mjs";
-import { isReactive } from "./signals/index.mjs";
 import { isReactivePromiseLike, promise } from "./utilities/promise.mjs";
 import { isAsyncLike } from "./utilities/async.mjs";
 //#region src/await.ts
@@ -14,16 +13,15 @@ function toAwaitables(value) {
 	return out;
 }
 function Await(props) {
-	const read = (value) => typeof value === "function" && !isReactive(value) ? value() : value;
-	const children = read(props.children);
-	const when = read(props.when);
+	const children = props.children;
+	const when = props.when;
 	const fromChildren = toAwaitables(children);
 	const awaitables = when != null ? toAwaitables(when) : fromChildren;
 	if (awaitables.length === 0) return children;
 	if (effectsInert()) return promise(Promise.all(awaitables).then(() => () => children));
 	const fallback = props.fallback;
 	const pending = () => awaitables.some((a) => a.state !== "fulfilled" && a.state !== "rejected");
-	const region = () => pending() ? read(fallback) : children;
+	const region = () => pending() ? fallback : children;
 	region[ASYNC_REGION] = {
 		ids: 1 + fromChildren.length,
 		pending

package/dist/children-BbHF-Dew.d.mts

@@ -0,0 +1,253 @@
+import { n as AttrChangeHandler, t as ATTRIBUTES } from "./attributes-DILeh3-s.mjs";
+import { i as PropertiesOf, n as CustomElementRegistry, r as EventsOf } from "./custom-elements-CdpilMDu.mjs";
+import { r as MaybeReactive } from "./index-BR8XVkck.mjs";
+import * as CSS from "csstype";
+import { JSX } from "dom-expressions/src/jsx";
+
+//#region src/jsx-runtime/element.d.ts
+type UnsupportedDomKeys = "ref" | "children" | "classList" | "$ServerOnly" | keyof JSX.CustomEventHandlersCamelCase<any> | keyof JSX.CustomEventHandlersLowerCase<any> | keyof JSX.DirectiveAttributes | keyof JSX.DirectiveFunctionAttributes<any> | keyof JSX.AttrAttributes | keyof JSX.BoolAttributes | keyof JSX.OnCaptureAttributes<any>;
+type DOMIntrinsicElements = { [K in keyof JSX.IntrinsicElements]: Omit<JSX.IntrinsicElements[K], UnsupportedDomKeys> };
+type DOMElements = { [K in keyof JSX.IntrinsicElements]: JSX.IntrinsicElements[K] extends {
+  ref?: infer R | undefined;
+} ? Extract<R, (el: any) => any> extends ((el: infer E) => any) ? E : Element : Element };
+declare function createElement(type: JSX$1.ElementType, allProps?: {
+  ref?: (el: Element) => void;
+} & Record<string, unknown>): JSX$1.Element | null;
+//#endregion
+//#region src/jsx-runtime/infer.d.ts
+/**
+ * Promote keys `K` of `P` to required; leave the rest unchanged.
+ *
+ * @template P — the prop object type.
+ * @template K — the keys to make required.
+ *
+ * @example
+ * ```ts
+ * type Optional = { a?: number; b?: string; c?: boolean };
+ * type AB = Require<Optional, "a" | "b">;
+ * // { a: number; b: string; c?: boolean }
+ * ```
+ */
+type Require<P, K extends keyof P> = { [X in K]-?: P[X] } & Omit<P, K>;
+/**
+ * Caller-facing wrap: each key accepts a plain value OR a reactive getter.
+ * Name it when typing a call-site shape by hand (e.g. a class component's
+ * constructor param, like `For`'s); the JSX checker applies it to intrinsic
+ * and custom-element props. Function-typed props are wrapped too
+ * (`Computed<F>` is zero-arg, so TS still picks the handler signature by
+ * arity for inline arrows). `Signal<F>` must never be added explicitly — its
+ * one-arg `Updater` half would collapse inline arrow params to implicit any.
+ */
+type MaybeReactiveProps<P> = { [K in keyof P]: undefined extends P[K] ? MaybeReactive<Exclude<P[K], undefined>> | undefined : MaybeReactive<P[K]> };
+/**
+ * Props of a function component that accepts reactive values — the same type
+ * as {@link MaybeReactiveProps}, under the name components reach for. Each key
+ * holds a plain value or a reactive source; the runtime hands the prop over
+ * exactly as the caller wrote it.
+ *
+ * Read a key with `resolve(props.x)`, or pass it straight into JSX, which
+ * accepts either form. Omit it and declare the plain value type when a
+ * component takes static props only — callers then cannot pass a signal.
+ *
+ * @example
+ * ```tsx
+ * function Greeting(props: Props<{ name: string; excited?: boolean }>) {
+ *   return <p>Hello, {props.name}{() => (resolve(props.excited) ? "!" : ".")}</p>;
+ * }
+ * ```
+ */
+type Props<P> = MaybeReactiveProps<P>;
+/**
+ * @internal Call-site prop resolution for `JSX.LibraryManagedAttributes`:
+ * - empty param (instance-field classes, no ctor) → wrap `PropsOf<C>`
+ * - any declared param → pass through verbatim
+ *
+ * Function components land in the pass-through branch: the runtime no longer
+ * transforms their props, so the declared type is the contract on both sides.
+ * A component opts into reactive props by declaring {@link Props} (or a
+ * per-key `MaybeReactive`) itself.
+ *
+ * Emptiness is checked FIRST so a no-ctor class still gets its instance fields
+ * wrapped; without that branch `<Toggle checked={x}/>` would have no prop type
+ * at all, since TS reads class attributes off the constructor parameter.
+ */
+type ResolveProps<C, P, NN = NonNullable<P>> = [keyof NN] extends [never] ? C extends JSX$1.ElementType | JSX$1.ElementClass ? MaybeReactiveProps<PropsOf<C>> : {} : NN;
+type PropKeysOf<C> = keyof PropertiesOf<C> & string;
+type AttrMap<C> = C extends {
+  [ATTRIBUTES]: infer M;
+} ? M : {};
+type HandlerValue<H> = H extends AttrChangeHandler<any> ? string | null : H;
+type AttrsOf<C> = AttrMap<C> extends infer M ? M extends Record<string, unknown> ? string extends keyof M ? {} : { [K in Exclude<keyof M & string, PropKeysOf<C>>]?: HandlerValue<M[K]> } : {} : {};
+type PropNamespacedOf<C> = { [K in PropKeysOf<C> as `prop:${K}`]?: NonNullable<PropertiesOf<C>[K]> };
+type JsxEventsOf<C> = { [K in keyof EventsOf<C> & string as `on:${K}`]?: (ev: EventsOf<C>[K]) => void };
+type ChildrenOf<C> = C extends {
+  children: never;
+} ? {} : {
+  children?: Children;
+};
+type BaseDOMAttrs = JSX.DOMAttributes<HTMLElement>;
+/**
+ * Full JSX prop type for a custom-element class (extends `HTMLElement`).
+ *
+ * Composes every surface the element can receive from JSX:
+ * - **Attributes** — keys from `static [ATTRIBUTES]` (typed `MaybeReactive<string | null>`).
+ *   Keys also present on the instance are dropped here so the flat key carries the property type.
+ * - **Flat properties** — public instance fields, wrapped in `MaybeReactive`.
+ * - **`prop:*`** — explicit property assignment for every field.
+ * - **Events** — keys from `declare static events: { ... }` produce
+ *   `on:${K}` typed handlers (the only event syntax the runtime attaches).
+ * - **Children** — `children?: Child` unless `static children: never`.
+ * - **DOM attrs** — the standard dom-expressions surface (`class`, `style`, `ref`, …).
+ *
+ * @template C — the custom-element class (constructor type).
+ *
+ * @example
+ * ```ts
+ * \@attributes
+ * class XRange extends HTMLElement {
+ *   static [ATTRIBUTES]: Attributes<XRange> = { min(v) { this.min = +v! } };
+ *   declare static events: { commit: CustomEvent<number> };
+ *   #slot = new Slot();
+ *   get label() { return this.#slot.get(); }
+ *   set label(value: Node) { this.#slot.set(value) }
+ *   \@reactive() min = 0;
+ * }
+ *
+ * type Props = ElementProps<typeof XRange>;
+ * // {
+ * //   min?: MaybeReactive<number>;
+ * //   "prop:min"?: number;
+ * //   "on:commit"?: (e: CustomEvent<number>) => void;
+ * //   label?: Node
+ * //   children?: Node;
+ * //   // …plus ref, class, class:*, style, style:*, standard DOM events
+ * // }
+ * ```
+ *
+ * @see {@link PropsOf} for class-components / function components (no attr/event synthesis).
+ */
+type ElementProps<C extends AnyElementCtor> = BaseDOMAttrs & AttrsOf<C> & PropertiesOf<C> & PropNamespacedOf<C> & JsxEventsOf<C> & ChildrenOf<C>;
+/**
+ * Props for any component — class or function.
+ *
+ * The combination of the two specialised helpers:
+ * - **Custom-element constructor** (`typeof Cls`, `Cls extends HTMLElement`)
+ *   → `ElementProps<Cls>` — the full JSX surface (attrs, `prop:*`, `on:*`,children).
+ * - **Everything else** (function component, class component ctor or
+ *   instance) → `ComponentProps<T>` — the raw prop shape.
+ *
+ * @template T — constructor, function, or instance.
+ *
+ * @example
+ * ```ts
+ * // 1. Class instance (lets a generic flow)
+ * class For<T> { each: T[] = []; render() { return null } }
+ * type ForProps<T> = PropsOf<For<T>>;
+ * //   ↑ { each?: T[] }
+ *
+ * // 2. Function component
+ * const Greeting = (_p: { name: string; excited?: boolean }) => null;
+ * type GreetingProps = PropsOf<typeof Greeting>;
+ * //   ↑ { name: string; excited?: boolean }
+ *
+ * // 3. Class constructor
+ * class Counter { count = 0; render() { return null } }
+ * type CounterProps = PropsOf<typeof Counter>;
+ * //   ↑ { count?: number }
+ * ```
+ */
+type PropsOf<T extends JSX$1.ElementType | JSX$1.ElementClass | AnyElementCtor> = T extends AnyElementCtor ? ElementProps<T> : T extends JSX$1.ElementType | JSX$1.ElementClass ? ComponentProps<T> : never;
+/**
+ * Props of a function or class COMPONENT (not a custom element): function
+ * components use the first parameter as declared; classes use their public
+ * instance fields. The custom-element half of `PropsOf` is `ElementProps`.
+ */
+type ComponentProps<T extends JSX$1.ElementType | JSX$1.ElementClass> = T extends ((props: infer P, ...rest: any[]) => any) ? P extends object ? P : {} : PropertiesOf<T>;
+type AnyElementCtor = abstract new (...args: any[]) => HTMLElement;
+//#endregion
+//#region src/jsx-runtime/fragment.d.ts
+/**
+ * Used by the JSX transform for `<>...</>` fragments.
+ *
+ * Each child is routed through `mountChild`, which handles Nodes, strings,
+ * numbers, arrays, and reactive getters — matching the behavior of any other
+ * JSX container. `mountChild` also wires each child's cleanup via its own
+ * `effectScope`, which links to the enclosing `effectScope` created by
+ * `createElement(Fragment, ...)` for disposal propagation.
+ *
+ * **Raw HTML mode** — `<Fragment html>{markup}</Fragment>`: the child is a
+ * `MaybeReactive<string>` rendered as markup inside a Slot region (comment
+ * markers), so the server renderer and the hydration claim pass share the
+ * region boundary. Reactive sources re-render the region on change. This is
+ * the library's only raw-HTML sink: the string is NOT escaped — sanitize
+ * untrusted input at the call site. `<script>` tags never execute.
+ */
+declare function Fragment(props: Props<{
+  children?: Children;
+}> | {
+  html: true;
+  children: MaybeReactive<string>;
+}): DocumentFragment;
+//#endregion
+//#region src/jsx-runtime/index.d.ts
+declare namespace JSX$1 {
+  export type Element = globalThis.Element | globalThis.DocumentFragment;
+  export type ElementClass = {
+    render(): JSX$1.Element | null;
+  };
+  export type ElementType = string | JSX$1.Element | (new (props: any) => JSX$1.ElementClass) | ((props: any) => JSX$1.Element | null);
+  export interface ElementChildrenAttribute {
+    children: {};
+  }
+  export interface IntrinsicAttributes {}
+  export type LibraryManagedAttributes<C, P> = ResolveProps<C, P>;
+  type RegisteredElements = { [K in keyof CustomElementRegistry]: CustomElementRegistry[K] extends infer C extends AnyElementCtor ? MaybeReactiveProps<WithJsxNamespaces<Omit<ElementProps<C>, "children" | "ref">, InstanceType<C>>> & {
+    ref?: (el: InstanceType<C>) => void;
+    children?: Children;
+  } : never };
+  export type IntrinsicElements = { [K in keyof DOMIntrinsicElements]: MaybeReactiveProps<WithJsxNamespaces<DOMIntrinsicElements[K], DOMElements[K]>> & {
+    ref?: (el: DOMElements[K]) => void;
+    children?: Children;
+  } & (DOMElements[K] extends SVGElement ? SvgNamespaceAttrs : {}) } & RegisteredElements;
+  export {};
+}
+/** A class whose constructor returns a ComponentInstance. */
+type ComponentClass<P extends Record<PropertyKey, unknown> = any> = new (props: P) => JSX$1.ElementClass;
+type ComponentFn<P extends Record<PropertyKey, unknown> = any> = (props: P) => JSX$1.Element | null;
+//#endregion
+//#region src/jsx-runtime/properties.d.ts
+interface CSSProperties extends CSS.PropertiesHyphen {
+  [key: `-${string}`]: string | number | undefined;
+}
+type CssStyleKey = Extract<keyof CSSProperties, string> extends infer K ? K extends `-${string}` ? never : K : never;
+type StyleNamespace = { [K in CssStyleKey as `style:${K}`]?: CSSProperties[K] | null };
+type PropNamespace<E> = { [K in keyof E as K extends string ? `prop:${K}` : never]?: E[K] };
+type XlinkAttrs = {
+  "xlink:href"?: string | undefined;
+  "xlink:title"?: string | undefined;
+  "xlink:show"?: "new" | "replace" | "embed" | "other" | "none" | undefined;
+  "xlink:role"?: string | undefined;
+  "xlink:type"?: "simple" | "extended" | "locator" | "arc" | "resource" | "title" | undefined;
+  "xlink:arcrole"?: string | undefined;
+  "xlink:actuate"?: "onLoad" | "onRequest" | "other" | "none" | undefined;
+};
+type ClassNamespace = { [K in `class:${string}`]?: boolean };
+type XmlAttrs = {
+  "xml:lang"?: string | undefined;
+  "xml:space"?: "default" | "preserve" | undefined;
+  "xml:base"?: string | undefined;
+};
+type SvgNamespaceAttrs = XlinkAttrs & XmlAttrs;
+interface StyleAttrObject extends CSS.Properties {}
+type JsxNamespaces<E extends Element = Element> = (E extends ElementCSSInlineStyle ? {
+  style?: string | StyleAttrObject;
+} & StyleNamespace : {}) & PropNamespace<Omit<E, "children">> & ClassNamespace;
+type JsxNamespaceKeys = "style" | `class:${string}` | `style:${string}` | `prop:${string}`;
+type WithJsxNamespaces<T, E extends Element = Element> = Omit<T, JsxNamespaceKeys> & JsxNamespaces<E>;
+//#endregion
+//#region src/jsx-runtime/children.d.ts
+type PrimitiveNodeType = Node | string | boolean | number | bigint | symbol | Date | RegExp | null | undefined;
+type AnyFn = (...args: any[]) => Children;
+type Children = PrimitiveNodeType | AnyFn | Element | DocumentFragment | Children[];
+//#endregion
+export { Fragment as a, PropsOf as c, JSX$1 as i, Require as l, ComponentClass as n, MaybeReactiveProps as o, ComponentFn as r, Props as s, Children as t, createElement as u };

package/dist/{element-Di0PYFX1.mjs → element-w3nDE2S5.mjs}

@@ -1,6 +1,6 @@
 import { C as untracked, _ as onCleanup, d as effectScope, u as effect } from "./lib-DYypKhxk.mjs";
 import "./polyfill-CdZVCxdo.mjs";
-import { isReactive, resolveProps } from "./signals/index.mjs";
+import { isReactive } from "./signals/index.mjs";
 import { on } from "./utilities/event-listener.mjs";
 import { Slot } from "./slot.mjs";
 //#region src/jsx-runtime/constants.ts
@@ -540,7 +540,7 @@ function createFunctionElement(type, props, ref) {
 	let dispose;
 	untracked(() => {
 		dispose = effectScope(() => {
-			el = type(resolveProps(props));
+			el = type(props);
 			if (typeof ref === "function" && el instanceof Element) ref(el);
 		});
 	});

package/dist/for.d.mts

@@ -1,4 +1,4 @@
-import { s as MaybeReactiveProps } from "./children-s3nFjpLA.mjs";
+import { o as MaybeReactiveProps } from "./children-BbHF-Dew.mjs";
 
 //#region src/for.d.ts
 type KeyFn<T> = (item: T, index: number) => string | number;

package/dist/for.mjs

@@ -1,6 +1,6 @@
 import { C as untracked, S as trigger, _ as onCleanup, d as effectScope, u as effect, x as signal } from "./lib-DYypKhxk.mjs";
 import "./signals/index.mjs";
-import { n as disposeElement } from "./element-Di0PYFX1.mjs";
+import { n as disposeElement } from "./element-w3nDE2S5.mjs";
 //#region src/for.ts
 /**
 * Keyed list renderer. See {@link ForProps} for prop details.

package/dist/{fragment-Bvs1sGu1.mjs → fragment-DEhI5x0f.mjs}

@@ -1,6 +1,6 @@
 import { _ as onCleanup, u as effect } from "./lib-DYypKhxk.mjs";
 import "./signals/index.mjs";
-import { a as mountChild } from "./element-Di0PYFX1.mjs";
+import { a as mountChild } from "./element-w3nDE2S5.mjs";
 import { Slot } from "./slot.mjs";
 //#region src/jsx-runtime/fragment.ts
 /**
@@ -44,8 +44,7 @@ function Fragment(props) {
 		} else if (source != null) slot.set(parseHtml(String(source)));
 		return fragment;
 	}
-	const children = props.children;
-	const raw = typeof children === "function" ? children() : children;
+	const raw = props.children;
 	if (raw == null) return fragment;
 	const nodes = Array.isArray(raw) ? raw.flat(Infinity) : [raw];
 	for (const child of nodes) mountChild(fragment, child);

package/dist/hydrate/index.mjs

@@ -1,2 +1,2 @@
-import { t as hydrate } from "../hydrate-DvWdnV-e.mjs";
+import { t as hydrate } from "../hydrate-CrVzu88K.mjs";
 export { hydrate };