@openelement/core 0.41.0-alpha.1

package/src/jsx-render-dom.js

@@ -0,0 +1,376 @@
+/**
+ * Converts a VNode tree to real DOM nodes for client-side rendering and hydration.
+ *
+ * Design (ADR-0057 / ADR-0109 Phase 2):
+ * - Props are translated into BindingDescriptor objects
+ * - Binding descriptors are applied via applyBindingDescriptor()
+ * - Signal names are resolved through an optional signalRegistry and emitted as
+ *   data-signal markers for DSD hydration consistency.
+ *
+ * @module @openelement/core/jsx-render-dom
+ */ import { isComponentCtor, isComponentFn, isVNode } from './vnode.js';
+import { FOR_TAG, Fragment, HTML_TAG, SHOW_TAG } from './jsx-runtime.js';
+import { isSignalLike, unwrapSignalLike } from '@openelement/signal';
+import { eventTypeFromProp } from './event-hydration.js';
+import { trustRenderHtml } from './security.js';
+import { effect } from '@openelement/signal';
+import { createLogger } from './logger.js';
+import { formatError } from './errors.js';
+import { applyBindingDescriptor } from './binding-activation.js';
+import { DATA_SIGNAL } from '@openelement/protocol/hydration-markers';
+const SVG_NS = 'http://www.w3.org/2000/svg';
+/**
+ * Elements that MUST be created with createElementNS(SVG_NS, tag) to render
+ * correctly. Using createElement() puts them in the HTML namespace where
+ * browsers won't render them as SVG shapes.
+ */ const SVG_TAGS = new Set([
+  'svg',
+  'circle',
+  'ellipse',
+  'line',
+  'path',
+  'polygon',
+  'polyline',
+  'rect',
+  'g',
+  'defs',
+  'clipPath',
+  'mask',
+  'pattern',
+  'use',
+  'symbol',
+  'image',
+  'text',
+  'tspan',
+  'textPath',
+  'linearGradient',
+  'radialGradient',
+  'stop',
+  'animate',
+  'animateTransform',
+  'animateMotion',
+  'foreignObject',
+  'title',
+  'desc',
+  'feBlend',
+  'feColorMatrix',
+  'feComponentTransfer',
+  'feComposite',
+  'feConvolveMatrix',
+  'feDiffuseLighting',
+  'feDisplacementMap',
+  'feDistantLight',
+  'feDropShadow',
+  'feFlood',
+  'feFuncA',
+  'feFuncB',
+  'feFuncG',
+  'feFuncR',
+  'feGaussianBlur',
+  'feImage',
+  'feMerge',
+  'feMergeNode',
+  'feMorphology',
+  'feOffset',
+  'fePointLight',
+  'feSpecularLighting',
+  'feSpotLight',
+  'feTile',
+  'feTurbulence'
+]);
+function createElementForTag(tag) {
+  if (SVG_TAGS.has(tag)) {
+    return document.createElementNS(SVG_NS, tag);
+  }
+  return document.createElement(tag);
+}
+/** Resolve a signal object to its registered name, if any. */ function signalNameFor(value, signalRegistry) {
+  if (!signalRegistry || !isSignalLike(value)) return undefined;
+  for (const [name, sig] of signalRegistry.entries()){
+    if (sig === value) return name;
+  }
+  return undefined;
+}
+/**
+ * Collect BindingDescriptor objects from a JSX props object.
+ *
+ * @param el - Target element the descriptors will apply to.
+ * @param props - VNode props.
+ * @param signalRegistry - Optional registry used to name signals for hydration markers.
+ * @returns Array of binding descriptors.
+ */ export function collectPropBindings(el, props, signalRegistry) {
+  const descriptors = [];
+  const trustedHtml = props.trustedHtml === true;
+  for (const [key, value] of Object.entries(props)){
+    if (key === 'children' || key === 'key' || key === 'trustedHtml') continue;
+    // ref callback
+    if (key === 'ref' && typeof value === 'function') {
+      descriptors.push({
+        kind: 'ref',
+        el,
+        callback: value
+      });
+      continue;
+    }
+    // Event handlers
+    if (key.startsWith('on') && typeof value === 'function') {
+      const eventType = eventTypeFromProp(key);
+      if (!eventType) continue;
+      descriptors.push({
+        kind: 'event',
+        el,
+        type: eventType,
+        handler: value
+      });
+      continue;
+    }
+    if (value == null) continue;
+    // innerHTML maps to signal-html / static text injection.
+    if (key === 'innerHTML') {
+      if (isSignalLike(value)) {
+        descriptors.push({
+          kind: 'signal-html',
+          el,
+          signal: value,
+          trusted: trustedHtml
+        });
+      } else {
+        const resolved = String(unwrapSignalLike(value));
+        if (trustedHtml) {
+          el.innerHTML = trustRenderHtml(resolved);
+        } else {
+          el.textContent = resolved;
+        }
+      }
+      continue;
+    }
+    // Signal binding — emit data-signal marker when we can resolve a name.
+    if (isSignalLike(value)) {
+      const sig = value;
+      const name = signalNameFor(sig, signalRegistry);
+      const attrName = key === 'className' ? 'class' : key === 'htmlFor' ? 'for' : key;
+      if (name) {
+        el.setAttribute(DATA_SIGNAL, name);
+      }
+      if (key === 'className' || key === 'class') {
+        // ponytail: CSR signal-class only supports a single toggle class today;
+        // the string-prop branch below is unreachable because this block is gated
+        // by isSignalLike. Use explicit data-signal-class markers for arbitrary
+        // class names; revisit when signal-class accepts a class-name accessor.
+        const className = attrName === 'class' ? '' : attrName;
+        descriptors.push({
+          kind: 'signal-class',
+          el,
+          className,
+          signal: sig
+        });
+      } else {
+        descriptors.push({
+          kind: 'signal-attr',
+          el,
+          attrNames: [
+            attrName
+          ],
+          signal: sig
+        });
+      }
+      continue;
+    }
+    const resolved = unwrapSignalLike(value);
+    if (key === 'style' && typeof resolved === 'object' && resolved !== null) {
+      const styleObj = {};
+      for (const [sk, sv] of Object.entries(resolved)){
+        styleObj[sk] = unwrapSignalLike(sv);
+      }
+      descriptors.push({
+        kind: 'static-style',
+        el,
+        value: styleObj
+      });
+      continue;
+    }
+    // DOM properties that are NOT HTML attributes
+    if (key === 'textContent') {
+      descriptors.push({
+        kind: 'static-prop',
+        el,
+        propName: 'textContent',
+        value: resolved
+      });
+      continue;
+    }
+    const attrName = key === 'className' ? 'class' : key === 'htmlFor' ? 'for' : key;
+    if (typeof resolved === 'boolean') {
+      descriptors.push({
+        kind: 'static-boolean',
+        el,
+        attrName,
+        value: resolved
+      });
+      continue;
+    }
+    descriptors.push({
+      kind: 'static-attr',
+      el,
+      key,
+      attrName,
+      value: resolved
+    });
+  }
+  return descriptors;
+}
+/**
+ * Apply a props object to a real DOM element.
+ */ export function applyProps(el, props, lifecycle, signalRegistry) {
+  const descriptors = collectPropBindings(el, props, signalRegistry);
+  for (const desc of descriptors){
+    applyBindingDescriptor(desc, lifecycle ?? {});
+  }
+}
+/**
+ * Render a VNode tree to a real DOM node.
+ *
+ * @param node - VNode, string, number, or null/undefined
+ * @param lifecycle - Optional BindingLifecycle for automatic cleanup
+ * @param disposers - Optional Set to collect effect dispose fns (backward compat)
+ * @param signalRegistry - Optional registry used to resolve signal names for markers
+ * @returns DOM Node (Element, Text, or DocumentFragment)
+ */ export function renderToDom(node, lifecycle, disposers, signalRegistry) {
+  const fullLifecycle = lifecycle ?? (disposers ? {
+    disposers
+  } : {});
+  if (disposers && !lifecycle?.disposers) {
+    fullLifecycle.disposers = disposers;
+  }
+  if (node == null || node === false) {
+    return document.createTextNode('');
+  }
+  if (typeof node === 'string') {
+    return document.createTextNode(node);
+  }
+  if (typeof node === 'number' || typeof node === 'boolean') {
+    return document.createTextNode(String(node));
+  }
+  // Signal-to-TextNode reactive binding (ADR-0058/0059).
+  if (isSignalLike(node)) {
+    const sig = node;
+    const textNode = document.createTextNode(String(sig.value ?? ''));
+    applyBindingDescriptor({
+      kind: 'signal-text',
+      el: textNode,
+      signal: sig
+    }, fullLifecycle);
+    return textNode;
+  }
+  if (!isVNode(node)) {
+    return document.createTextNode(String(node));
+  }
+  const { tag, props, children } = node;
+  if (tag === Fragment || typeof tag === 'symbol' && String(tag) === 'Symbol(openelement.fragment)') {
+    const frag = document.createDocumentFragment();
+    for (const child of children){
+      frag.appendChild(renderToDom(child, fullLifecycle, undefined, signalRegistry));
+    }
+    return frag;
+  }
+  // Trusted HTML — parse raw HTML string into real DOM nodes
+  if (tag === HTML_TAG) {
+    const container = document.createElement('div');
+    const html = props?.html ?? '';
+    container.innerHTML = trustRenderHtml(String(html));
+    const frag = document.createDocumentFragment();
+    while(container.firstChild){
+      frag.appendChild(container.firstChild);
+    }
+    return frag;
+  }
+  if (tag === SHOW_TAG || tag === 'show') {
+    const whenSig = props?.when;
+    const ch = children;
+    const truthy = ch[0];
+    const falsy = ch[1];
+    const marker = document.createComment('show');
+    let anchor = null;
+    const swap = ()=>{
+      const show = Boolean(isSignalLike(whenSig) ? whenSig.value : whenSig);
+      const target = show ? truthy : falsy;
+      if (anchor) anchor.remove();
+      if (target != null) {
+        anchor = renderToDom(target, fullLifecycle, undefined, signalRegistry);
+        marker.parentNode?.insertBefore(anchor, marker.nextSibling);
+      } else {
+        anchor = null;
+      }
+    };
+    const dispose = effect(()=>swap());
+    if (fullLifecycle.signal) {
+      fullLifecycle.signal.addEventListener('abort', dispose, {
+        once: true
+      });
+    }
+    fullLifecycle.disposers?.add(dispose);
+    swap();
+    return marker;
+  }
+  if (tag === FOR_TAG || tag === 'fore') {
+    const eachSig = props?.each;
+    const renderFn = children[0] ?? (()=>document.createTextNode(''));
+    const marker = document.createComment('for');
+    let anchors = [];
+    const reconcile = ()=>{
+      const items = isSignalLike(eachSig) ? eachSig.value : eachSig;
+      if (!Array.isArray(items)) return;
+      // Remove old
+      for (const a of anchors)a.remove();
+      anchors = [];
+      // Render new
+      for(let i = 0; i < items.length; i++){
+        const vn = renderFn(items[i], i);
+        const dom = renderToDom(vn, fullLifecycle, undefined, signalRegistry);
+        marker.parentNode?.insertBefore(dom, marker.nextSibling);
+        anchors.push(dom);
+      }
+    };
+    const dispose = effect(()=>reconcile());
+    if (fullLifecycle.signal) {
+      fullLifecycle.signal.addEventListener('abort', dispose, {
+        once: true
+      });
+    }
+    fullLifecycle.disposers?.add(dispose);
+    reconcile();
+    return marker;
+  }
+  if (isComponentCtor(tag)) {
+    try {
+      const instance = new tag();
+      for (const [k, v] of Object.entries(props)){
+        instance[k] = v;
+      }
+      const result = instance.render();
+      return renderToDom(result, fullLifecycle, undefined, signalRegistry);
+    } catch (err) {
+      createLogger('dom-render').error(`renderToDom() failed for <${String(tag)}>: ${formatError(err)}`);
+      return document.createTextNode('');
+    }
+  }
+  if (isComponentFn(tag)) {
+    try {
+      const result = tag({
+        ...props,
+        children
+      });
+      return renderToDom(result, fullLifecycle, undefined, signalRegistry);
+    } catch (err) {
+      createLogger('dom-render').error(`renderToDom() failed for <${String(tag)}>: ${formatError(err)}`);
+      return document.createTextNode('');
+    }
+  }
+  const el = createElementForTag(tag);
+  applyProps(el, props, fullLifecycle, signalRegistry);
+  for (const child of children){
+    el.appendChild(renderToDom(child, fullLifecycle, undefined, signalRegistry));
+  }
+  return el;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/core/src/jsx-render-dom.ts"],"sourcesContent":["/**\n * Converts a VNode tree to real DOM nodes for client-side rendering and hydration.\n *\n * Design (ADR-0057 / ADR-0109 Phase 2):\n * - Props are translated into BindingDescriptor objects\n * - Binding descriptors are applied via applyBindingDescriptor()\n * - Signal names are resolved through an optional signalRegistry and emitted as\n *   data-signal markers for DSD hydration consistency.\n *\n * @module @openelement/core/jsx-render-dom\n */\n\nimport { isComponentCtor, isComponentFn, isVNode } from './vnode.js';\nimport type { RenderFn, VNode } from '@openelement/protocol/vnode';\nimport type { Signal } from '@openelement/protocol/signal';\nimport { FOR_TAG, Fragment, HTML_TAG, SHOW_TAG } from './jsx-runtime.js';\nimport { isSignalLike, unwrapSignalLike } from '@openelement/signal';\nimport { eventTypeFromProp } from './event-hydration.js';\nimport { trustRenderHtml } from './security.js';\nimport { effect } from '@openelement/signal';\nimport { createLogger } from './logger.js';\nimport { formatError } from './errors.js';\nimport { applyBindingDescriptor } from './binding-activation.js';\nimport type { BindingDescriptor, BindingLifecycle } from './binding-descriptor.js';\nimport { DATA_SIGNAL } from '@openelement/protocol/hydration-markers';\n\nconst SVG_NS = 'http://www.w3.org/2000/svg';\n\n/**\n * Elements that MUST be created with createElementNS(SVG_NS, tag) to render\n * correctly. Using createElement() puts them in the HTML namespace where\n * browsers won't render them as SVG shapes.\n */\nconst SVG_TAGS = new Set([\n  'svg',\n  'circle',\n  'ellipse',\n  'line',\n  'path',\n  'polygon',\n  'polyline',\n  'rect',\n  'g',\n  'defs',\n  'clipPath',\n  'mask',\n  'pattern',\n  'use',\n  'symbol',\n  'image',\n  'text',\n  'tspan',\n  'textPath',\n  'linearGradient',\n  'radialGradient',\n  'stop',\n  'animate',\n  'animateTransform',\n  'animateMotion',\n  'foreignObject',\n  'title',\n  'desc',\n  'feBlend',\n  'feColorMatrix',\n  'feComponentTransfer',\n  'feComposite',\n  'feConvolveMatrix',\n  'feDiffuseLighting',\n  'feDisplacementMap',\n  'feDistantLight',\n  'feDropShadow',\n  'feFlood',\n  'feFuncA',\n  'feFuncB',\n  'feFuncG',\n  'feFuncR',\n  'feGaussianBlur',\n  'feImage',\n  'feMerge',\n  'feMergeNode',\n  'feMorphology',\n  'feOffset',\n  'fePointLight',\n  'feSpecularLighting',\n  'feSpotLight',\n  'feTile',\n  'feTurbulence',\n]);\n\nfunction createElementForTag(tag: string): Element {\n  if (SVG_TAGS.has(tag)) {\n    return document.createElementNS(SVG_NS, tag);\n  }\n  return document.createElement(tag);\n}\n\n/** Resolve a signal object to its registered name, if any. */\nfunction signalNameFor(\n  value: unknown,\n  signalRegistry?: Map<string, Signal<unknown>>,\n): string | undefined {\n  if (!signalRegistry || !isSignalLike(value)) return undefined;\n  for (const [name, sig] of signalRegistry.entries()) {\n    if (sig === value) return name;\n  }\n  return undefined;\n}\n\n/**\n * Collect BindingDescriptor objects from a JSX props object.\n *\n * @param el - Target element the descriptors will apply to.\n * @param props - VNode props.\n * @param signalRegistry - Optional registry used to name signals for hydration markers.\n * @returns Array of binding descriptors.\n */\nexport function collectPropBindings(\n  el: Element,\n  props: Record<string, unknown>,\n  signalRegistry?: Map<string, Signal<unknown>>,\n): BindingDescriptor[] {\n  const descriptors: BindingDescriptor[] = [];\n  const trustedHtml = props.trustedHtml === true;\n\n  for (const [key, value] of Object.entries(props)) {\n    if (key === 'children' || key === 'key' || key === 'trustedHtml') continue;\n\n    // ref callback\n    if (key === 'ref' && typeof value === 'function') {\n      descriptors.push({ kind: 'ref', el, callback: value as (el: Element) => void });\n      continue;\n    }\n\n    // Event handlers\n    if (key.startsWith('on') && typeof value === 'function') {\n      const eventType = eventTypeFromProp(key);\n      if (!eventType) continue;\n      descriptors.push({ kind: 'event', el, type: eventType, handler: value as EventListener });\n      continue;\n    }\n\n    if (value == null) continue;\n\n    // innerHTML maps to signal-html / static text injection.\n    if (key === 'innerHTML') {\n      if (isSignalLike(value)) {\n        descriptors.push({\n          kind: 'signal-html',\n          el,\n          signal: value as Signal<unknown>,\n          trusted: trustedHtml,\n        });\n      } else {\n        const resolved = String(unwrapSignalLike(value));\n        if (trustedHtml) {\n          (el as HTMLElement).innerHTML = trustRenderHtml(resolved);\n        } else {\n          (el as HTMLElement).textContent = resolved;\n        }\n      }\n      continue;\n    }\n\n    // Signal binding — emit data-signal marker when we can resolve a name.\n    if (isSignalLike(value)) {\n      const sig = value as Signal<unknown>;\n      const name = signalNameFor(sig, signalRegistry);\n      const attrName = key === 'className' ? 'class' : key === 'htmlFor' ? 'for' : key;\n\n      if (name) {\n        el.setAttribute(DATA_SIGNAL, name);\n      }\n\n      if (key === 'className' || key === 'class') {\n        // ponytail: CSR signal-class only supports a single toggle class today;\n        // the string-prop branch below is unreachable because this block is gated\n        // by isSignalLike. Use explicit data-signal-class markers for arbitrary\n        // class names; revisit when signal-class accepts a class-name accessor.\n        const className = attrName === 'class' ? '' : attrName;\n        descriptors.push({\n          kind: 'signal-class',\n          el,\n          className,\n          signal: sig,\n        });\n      } else {\n        descriptors.push({ kind: 'signal-attr', el, attrNames: [attrName], signal: sig });\n      }\n      continue;\n    }\n\n    const resolved = unwrapSignalLike(value);\n\n    if (key === 'style' && typeof resolved === 'object' && resolved !== null) {\n      const styleObj: Record<string, string | number> = {};\n      for (const [sk, sv] of Object.entries(resolved as Record<string, unknown>)) {\n        styleObj[sk] = unwrapSignalLike(sv) as string | number;\n      }\n      descriptors.push({ kind: 'static-style', el, value: styleObj });\n      continue;\n    }\n\n    // DOM properties that are NOT HTML attributes\n    if (key === 'textContent') {\n      descriptors.push({ kind: 'static-prop', el, propName: 'textContent', value: resolved });\n      continue;\n    }\n\n    const attrName = key === 'className' ? 'class' : key === 'htmlFor' ? 'for' : key;\n\n    if (typeof resolved === 'boolean') {\n      descriptors.push({ kind: 'static-boolean', el, attrName, value: resolved });\n      continue;\n    }\n\n    descriptors.push({ kind: 'static-attr', el, key, attrName, value: resolved });\n  }\n\n  return descriptors;\n}\n\n/**\n * Apply a props object to a real DOM element.\n */\nexport function applyProps(\n  el: Element,\n  props: Record<string, unknown>,\n  lifecycle?: BindingLifecycle,\n  signalRegistry?: Map<string, Signal<unknown>>,\n): void {\n  const descriptors = collectPropBindings(el, props, signalRegistry);\n  for (const desc of descriptors) {\n    applyBindingDescriptor(desc, lifecycle ?? {});\n  }\n}\n\n/**\n * Render a VNode tree to a real DOM node.\n *\n * @param node - VNode, string, number, or null/undefined\n * @param lifecycle - Optional BindingLifecycle for automatic cleanup\n * @param disposers - Optional Set to collect effect dispose fns (backward compat)\n * @param signalRegistry - Optional registry used to resolve signal names for markers\n * @returns DOM Node (Element, Text, or DocumentFragment)\n */\nexport function renderToDom(\n  node: unknown,\n  lifecycle?: BindingLifecycle,\n  disposers?: Set<() => void>,\n  signalRegistry?: Map<string, Signal<unknown>>,\n): Node {\n  const fullLifecycle: BindingLifecycle = lifecycle ?? (disposers ? { disposers } : {});\n  if (disposers && !lifecycle?.disposers) {\n    fullLifecycle.disposers = disposers;\n  }\n\n  if (node == null || node === false) {\n    return document.createTextNode('');\n  }\n  if (typeof node === 'string') {\n    return document.createTextNode(node);\n  }\n  if (typeof node === 'number' || typeof node === 'boolean') {\n    return document.createTextNode(String(node));\n  }\n\n  // Signal-to-TextNode reactive binding (ADR-0058/0059).\n  if (isSignalLike(node)) {\n    const sig = node as Signal<unknown>;\n    const textNode = document.createTextNode(String(sig.value ?? ''));\n    applyBindingDescriptor({ kind: 'signal-text', el: textNode, signal: sig }, fullLifecycle);\n    return textNode;\n  }\n\n  if (!isVNode(node)) {\n    return document.createTextNode(String(node));\n  }\n\n  const { tag, props, children } = node as VNode;\n\n  if (\n    tag === Fragment || (typeof tag === 'symbol' && String(tag) === 'Symbol(openelement.fragment)')\n  ) {\n    const frag = document.createDocumentFragment();\n    for (const child of children) {\n      frag.appendChild(renderToDom(child, fullLifecycle, undefined, signalRegistry));\n    }\n    return frag;\n  }\n\n  // Trusted HTML — parse raw HTML string into real DOM nodes\n  if (tag === HTML_TAG) {\n    const container = document.createElement('div');\n    const html = props?.html ?? '';\n    container.innerHTML = trustRenderHtml(String(html));\n    const frag = document.createDocumentFragment();\n    while (container.firstChild) {\n      frag.appendChild(container.firstChild);\n    }\n    return frag;\n  }\n\n  if (tag === SHOW_TAG || tag === 'show') {\n    const whenSig = props?.when;\n    const ch = children as VNode[];\n    const truthy: unknown = ch[0];\n    const falsy: unknown = ch[1];\n    const marker = document.createComment('show');\n\n    let anchor: ChildNode | null = null;\n    const swap = () => {\n      const show = Boolean(\n        isSignalLike(whenSig) ? (whenSig as { value: unknown }).value : whenSig,\n      );\n      const target = show ? truthy : falsy;\n      if (anchor) anchor.remove();\n      if (target != null) {\n        anchor = renderToDom(target, fullLifecycle, undefined, signalRegistry) as ChildNode;\n        marker.parentNode?.insertBefore(anchor, marker.nextSibling);\n      } else {\n        anchor = null;\n      }\n    };\n    const dispose = effect(() => swap());\n    if (fullLifecycle.signal) {\n      fullLifecycle.signal.addEventListener('abort', dispose, { once: true });\n    }\n    fullLifecycle.disposers?.add(dispose);\n    swap();\n    return marker;\n  }\n\n  if (tag === FOR_TAG || tag === 'fore') {\n    const eachSig = props?.each;\n    const renderFn = (children[0] as RenderFn) ??\n      ((() => document.createTextNode('') as unknown) as RenderFn);\n\n    const marker = document.createComment('for');\n    let anchors: ChildNode[] = [];\n\n    const reconcile = () => {\n      const items =\n        (isSignalLike(eachSig) ? (eachSig as { value: unknown }).value : eachSig) as unknown[];\n      if (!Array.isArray(items)) return;\n\n      // Remove old\n      for (const a of anchors) a.remove();\n      anchors = [];\n\n      // Render new\n      for (let i = 0; i < items.length; i++) {\n        const vn = renderFn(items[i], i);\n        const dom = renderToDom(vn, fullLifecycle, undefined, signalRegistry) as ChildNode;\n        marker.parentNode?.insertBefore(dom, marker.nextSibling);\n        anchors.push(dom);\n      }\n    };\n    const dispose = effect(() => reconcile());\n    if (fullLifecycle.signal) {\n      fullLifecycle.signal.addEventListener('abort', dispose, { once: true });\n    }\n    fullLifecycle.disposers?.add(dispose);\n    reconcile();\n    return marker;\n  }\n\n  if (isComponentCtor(tag)) {\n    try {\n      const instance = new tag();\n      for (const [k, v] of Object.entries(props)) {\n        (instance as Record<string, unknown>)[k] = v;\n      }\n      const result = instance.render();\n      return renderToDom(result, fullLifecycle, undefined, signalRegistry);\n    } catch (err) {\n      createLogger('dom-render').error(\n        `renderToDom() failed for <${String(tag)}>: ${formatError(err)}`,\n      );\n      return document.createTextNode('');\n    }\n  }\n  if (isComponentFn(tag)) {\n    try {\n      const result = tag({ ...props, children });\n      return renderToDom(result, fullLifecycle, undefined, signalRegistry);\n    } catch (err) {\n      createLogger('dom-render').error(\n        `renderToDom() failed for <${String(tag)}>: ${formatError(err)}`,\n      );\n      return document.createTextNode('');\n    }\n  }\n\n  const el = createElementForTag(tag as string);\n  applyProps(el, props, fullLifecycle, signalRegistry);\n  for (const child of children) {\n    el.appendChild(renderToDom(child, fullLifecycle, undefined, signalRegistry));\n  }\n\n  return el;\n}\n"],"names":[],"mappings":"AAAA;;;;;;;;;;CAUC,GAED,SAAS,eAAe,EAAE,aAAa,EAAE,OAAO,QAAQ,aAAa;AAGrE,SAAS,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,QAAQ,mBAAmB;AACzE,SAAS,YAAY,EAAE,gBAAgB,QAAQ,sBAAsB;AACrE,SAAS,iBAAiB,QAAQ,uBAAuB;AACzD,SAAS,eAAe,QAAQ,gBAAgB;AAChD,SAAS,MAAM,QAAQ,sBAAsB;AAC7C,SAAS,YAAY,QAAQ,cAAc;AAC3C,SAAS,WAAW,QAAQ,cAAc;AAC1C,SAAS,sBAAsB,QAAQ,0BAA0B;AAEjE,SAAS,WAAW,QAAQ,0CAA0C;AAEtE,MAAM,SAAS;AAEf;;;;CAIC,GACD,MAAM,WAAW,IAAI,IAAI;EACvB;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACD;AAED,SAAS,oBAAoB,GAAW;EACtC,IAAI,SAAS,GAAG,CAAC,MAAM;IACrB,OAAO,SAAS,eAAe,CAAC,QAAQ;EAC1C;EACA,OAAO,SAAS,aAAa,CAAC;AAChC;AAEA,4DAA4D,GAC5D,SAAS,cACP,KAAc,EACd,cAA6C;EAE7C,IAAI,CAAC,kBAAkB,CAAC,aAAa,QAAQ,OAAO;EACpD,KAAK,MAAM,CAAC,MAAM,IAAI,IAAI,eAAe,OAAO,GAAI;IAClD,IAAI,QAAQ,OAAO,OAAO;EAC5B;EACA,OAAO;AACT;AAEA;;;;;;;CAOC,GACD,OAAO,SAAS,oBACd,EAAW,EACX,KAA8B,EAC9B,cAA6C;EAE7C,MAAM,cAAmC,EAAE;EAC3C,MAAM,cAAc,MAAM,WAAW,KAAK;EAE1C,KAAK,MAAM,CAAC,KAAK,MAAM,IAAI,OAAO,OAAO,CAAC,OAAQ;IAChD,IAAI,QAAQ,cAAc,QAAQ,SAAS,QAAQ,eAAe;IAElE,eAAe;IACf,IAAI,QAAQ,SAAS,OAAO,UAAU,YAAY;MAChD,YAAY,IAAI,CAAC;QAAE,MAAM;QAAO;QAAI,UAAU;MAA+B;MAC7E;IACF;IAEA,iBAAiB;IACjB,IAAI,IAAI,UAAU,CAAC,SAAS,OAAO,UAAU,YAAY;MACvD,MAAM,YAAY,kBAAkB;MACpC,IAAI,CAAC,WAAW;MAChB,YAAY,IAAI,CAAC;QAAE,MAAM;QAAS;QAAI,MAAM;QAAW,SAAS;MAAuB;MACvF;IACF;IAEA,IAAI,SAAS,MAAM;IAEnB,yDAAyD;IACzD,IAAI,QAAQ,aAAa;MACvB,IAAI,aAAa,QAAQ;QACvB,YAAY,IAAI,CAAC;UACf,MAAM;UACN;UACA,QAAQ;UACR,SAAS;QACX;MACF,OAAO;QACL,MAAM,WAAW,OAAO,iBAAiB;QACzC,IAAI,aAAa;UACd,GAAmB,SAAS,GAAG,gBAAgB;QAClD,OAAO;UACJ,GAAmB,WAAW,GAAG;QACpC;MACF;MACA;IACF;IAEA,uEAAuE;IACvE,IAAI,aAAa,QAAQ;MACvB,MAAM,MAAM;MACZ,MAAM,OAAO,cAAc,KAAK;MAChC,MAAM,WAAW,QAAQ,cAAc,UAAU,QAAQ,YAAY,QAAQ;MAE7E,IAAI,MAAM;QACR,GAAG,YAAY,CAAC,aAAa;MAC/B;MAEA,IAAI,QAAQ,eAAe,QAAQ,SAAS;QAC1C,wEAAwE;QACxE,0EAA0E;QAC1E,wEAAwE;QACxE,wEAAwE;QACxE,MAAM,YAAY,aAAa,UAAU,KAAK;QAC9C,YAAY,IAAI,CAAC;UACf,MAAM;UACN;UACA;UACA,QAAQ;QACV;MACF,OAAO;QACL,YAAY,IAAI,CAAC;UAAE,MAAM;UAAe;UAAI,WAAW;YAAC;WAAS;UAAE,QAAQ;QAAI;MACjF;MACA;IACF;IAEA,MAAM,WAAW,iBAAiB;IAElC,IAAI,QAAQ,WAAW,OAAO,aAAa,YAAY,aAAa,MAAM;MACxE,MAAM,WAA4C,CAAC;MACnD,KAAK,MAAM,CAAC,IAAI,GAAG,IAAI,OAAO,OAAO,CAAC,UAAsC;QAC1E,QAAQ,CAAC,GAAG,GAAG,iBAAiB;MAClC;MACA,YAAY,IAAI,CAAC;QAAE,MAAM;QAAgB;QAAI,OAAO;MAAS;MAC7D;IACF;IAEA,8CAA8C;IAC9C,IAAI,QAAQ,eAAe;MACzB,YAAY,IAAI,CAAC;QAAE,MAAM;QAAe;QAAI,UAAU;QAAe,OAAO;MAAS;MACrF;IACF;IAEA,MAAM,WAAW,QAAQ,cAAc,UAAU,QAAQ,YAAY,QAAQ;IAE7E,IAAI,OAAO,aAAa,WAAW;MACjC,YAAY,IAAI,CAAC;QAAE,MAAM;QAAkB;QAAI;QAAU,OAAO;MAAS;MACzE;IACF;IAEA,YAAY,IAAI,CAAC;MAAE,MAAM;MAAe;MAAI;MAAK;MAAU,OAAO;IAAS;EAC7E;EAEA,OAAO;AACT;AAEA;;CAEC,GACD,OAAO,SAAS,WACd,EAAW,EACX,KAA8B,EAC9B,SAA4B,EAC5B,cAA6C;EAE7C,MAAM,cAAc,oBAAoB,IAAI,OAAO;EACnD,KAAK,MAAM,QAAQ,YAAa;IAC9B,uBAAuB,MAAM,aAAa,CAAC;EAC7C;AACF;AAEA;;;;;;;;CAQC,GACD,OAAO,SAAS,YACd,IAAa,EACb,SAA4B,EAC5B,SAA2B,EAC3B,cAA6C;EAE7C,MAAM,gBAAkC,aAAa,CAAC,YAAY;IAAE;EAAU,IAAI,CAAC,CAAC;EACpF,IAAI,aAAa,CAAC,WAAW,WAAW;IACtC,cAAc,SAAS,GAAG;EAC5B;EAEA,IAAI,QAAQ,QAAQ,SAAS,OAAO;IAClC,OAAO,SAAS,cAAc,CAAC;EACjC;EACA,IAAI,OAAO,SAAS,UAAU;IAC5B,OAAO,SAAS,cAAc,CAAC;EACjC;EACA,IAAI,OAAO,SAAS,YAAY,OAAO,SAAS,WAAW;IACzD,OAAO,SAAS,cAAc,CAAC,OAAO;EACxC;EAEA,uDAAuD;EACvD,IAAI,aAAa,OAAO;IACtB,MAAM,MAAM;IACZ,MAAM,WAAW,SAAS,cAAc,CAAC,OAAO,IAAI,KAAK,IAAI;IAC7D,uBAAuB;MAAE,MAAM;MAAe,IAAI;MAAU,QAAQ;IAAI,GAAG;IAC3E,OAAO;EACT;EAEA,IAAI,CAAC,QAAQ,OAAO;IAClB,OAAO,SAAS,cAAc,CAAC,OAAO;EACxC;EAEA,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG;EAEjC,IACE,QAAQ,YAAa,OAAO,QAAQ,YAAY,OAAO,SAAS,gCAChE;IACA,MAAM,OAAO,SAAS,sBAAsB;IAC5C,KAAK,MAAM,SAAS,SAAU;MAC5B,KAAK,WAAW,CAAC,YAAY,OAAO,eAAe,WAAW;IAChE;IACA,OAAO;EACT;EAEA,2DAA2D;EAC3D,IAAI,QAAQ,UAAU;IACpB,MAAM,YAAY,SAAS,aAAa,CAAC;IACzC,MAAM,OAAO,OAAO,QAAQ;IAC5B,UAAU,SAAS,GAAG,gBAAgB,OAAO;IAC7C,MAAM,OAAO,SAAS,sBAAsB;IAC5C,MAAO,UAAU,UAAU,CAAE;MAC3B,KAAK,WAAW,CAAC,UAAU,UAAU;IACvC;IACA,OAAO;EACT;EAEA,IAAI,QAAQ,YAAY,QAAQ,QAAQ;IACtC,MAAM,UAAU,OAAO;IACvB,MAAM,KAAK;IACX,MAAM,SAAkB,EAAE,CAAC,EAAE;IAC7B,MAAM,QAAiB,EAAE,CAAC,EAAE;IAC5B,MAAM,SAAS,SAAS,aAAa,CAAC;IAEtC,IAAI,SAA2B;IAC/B,MAAM,OAAO;MACX,MAAM,OAAO,QACX,aAAa,WAAW,AAAC,QAA+B,KAAK,GAAG;MAElE,MAAM,SAAS,OAAO,SAAS;MAC/B,IAAI,QAAQ,OAAO,MAAM;MACzB,IAAI,UAAU,MAAM;QAClB,SAAS,YAAY,QAAQ,eAAe,WAAW;QACvD,OAAO,UAAU,EAAE,aAAa,QAAQ,OAAO,WAAW;MAC5D,OAAO;QACL,SAAS;MACX;IACF;IACA,MAAM,UAAU,OAAO,IAAM;IAC7B,IAAI,cAAc,MAAM,EAAE;MACxB,cAAc,MAAM,CAAC,gBAAgB,CAAC,SAAS,SAAS;QAAE,MAAM;MAAK;IACvE;IACA,cAAc,SAAS,EAAE,IAAI;IAC7B;IACA,OAAO;EACT;EAEA,IAAI,QAAQ,WAAW,QAAQ,QAAQ;IACrC,MAAM,UAAU,OAAO;IACvB,MAAM,WAAW,AAAC,QAAQ,CAAC,EAAE,IAC1B,CAAC,IAAM,SAAS,cAAc,CAAC,GAAc;IAEhD,MAAM,SAAS,SAAS,aAAa,CAAC;IACtC,IAAI,UAAuB,EAAE;IAE7B,MAAM,YAAY;MAChB,MAAM,QACH,aAAa,WAAW,AAAC,QAA+B,KAAK,GAAG;MACnE,IAAI,CAAC,MAAM,OAAO,CAAC,QAAQ;MAE3B,aAAa;MACb,KAAK,MAAM,KAAK,QAAS,EAAE,MAAM;MACjC,UAAU,EAAE;MAEZ,aAAa;MACb,IAAK,IAAI,IAAI,GAAG,IAAI,MAAM,MAAM,EAAE,IAAK;QACrC,MAAM,KAAK,SAAS,KAAK,CAAC,EAAE,EAAE;QAC9B,MAAM,MAAM,YAAY,IAAI,eAAe,WAAW;QACtD,OAAO,UAAU,EAAE,aAAa,KAAK,OAAO,WAAW;QACvD,QAAQ,IAAI,CAAC;MACf;IACF;IACA,MAAM,UAAU,OAAO,IAAM;IAC7B,IAAI,cAAc,MAAM,EAAE;MACxB,cAAc,MAAM,CAAC,gBAAgB,CAAC,SAAS,SAAS;QAAE,MAAM;MAAK;IACvE;IACA,cAAc,SAAS,EAAE,IAAI;IAC7B;IACA,OAAO;EACT;EAEA,IAAI,gBAAgB,MAAM;IACxB,IAAI;MACF,MAAM,WAAW,IAAI;MACrB,KAAK,MAAM,CAAC,GAAG,EAAE,IAAI,OAAO,OAAO,CAAC,OAAQ;QACzC,QAAoC,CAAC,EAAE,GAAG;MAC7C;MACA,MAAM,SAAS,SAAS,MAAM;MAC9B,OAAO,YAAY,QAAQ,eAAe,WAAW;IACvD,EAAE,OAAO,KAAK;MACZ,aAAa,cAAc,KAAK,CAC9B,CAAC,0BAA0B,EAAE,OAAO,KAAK,GAAG,EAAE,YAAY,MAAM;MAElE,OAAO,SAAS,cAAc,CAAC;IACjC;EACF;EACA,IAAI,cAAc,MAAM;IACtB,IAAI;MACF,MAAM,SAAS,IAAI;QAAE,GAAG,KAAK;QAAE;MAAS;MACxC,OAAO,YAAY,QAAQ,eAAe,WAAW;IACvD,EAAE,OAAO,KAAK;MACZ,aAAa,cAAc,KAAK,CAC9B,CAAC,0BAA0B,EAAE,OAAO,KAAK,GAAG,EAAE,YAAY,MAAM;MAElE,OAAO,SAAS,cAAc,CAAC;IACjC;EACF;EAEA,MAAM,KAAK,oBAAoB;EAC/B,WAAW,IAAI,OAAO,eAAe;EACrC,KAAK,MAAM,SAAS,SAAU;IAC5B,GAAG,WAAW,CAAC,YAAY,OAAO,eAAe,WAAW;EAC9D;EAEA,OAAO;AACT"}

package/src/jsx-runtime.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @openelement/core - JSX Runtime.
+ *
+ * Implements the React-compatible jsx/jsxs/jsxDEV/Fragment interface.
+ * Consumed by TypeScript/esbuild JSX transform when `jsxImportSource: "@openelement/core"`.
+ *
+ * Design (ADR-0057):
+ * - Fragment groups multiple children without a wrapping element
+ * - jsxDEV adds source-map information in development builds
+ *
+ * @module @openelement/core/jsx-runtime
+ */ import type { ComponentCtor, ComponentFn, VNode } from '@openelement/protocol/vnode';
+/**
+ * Usage in TSX:
+ *   return <><div>a</div><div>b</div></>;
+ */ export declare const Fragment: unique symbol;
+/** @internal Symbol for <Show> tag matching in renderToDom */ export declare const SHOW_TAG: unique symbol;
+/** @internal Symbol for <For> tag matching in renderToDom */ export declare const FOR_TAG: unique symbol;
+/** @internal Symbol for raw HTML insertion (trustedHtml helper) */ export declare const HTML_TAG: unique symbol;
+/**
+ * Create a VNode that renders as raw trusted HTML.
+ *
+ * During SSR the HTML string is emitted verbatim; on the client it is parsed
+ * into real DOM nodes via innerHTML. The caller is responsible for sanitizing
+ * the input — this is a trust boundary, not a sanitizer.
+ *
+ * @param html - The raw HTML string to render.
+ * @returns A VNode that the render pipeline treats as trusted HTML.
+ */ export declare function trustedHtml(html: string): VNode;
+/**
+ * Show conditional rendering factory (ADR-0059).
+ *
+ * Returns a VNode with the internal SHOW_TAG symbol so renderToDom
+ * can intercept it as a control flow directive. Exported as a
+ * function (not a Symbol) for TypeScript JSX compatibility.
+ *
+ * Usage: <Show when={this.#loading}><Spinner/><Content/></Show>
+ */ export declare function Show(props: Record<string, unknown>): VNode;
+/**
+ * For list rendering factory (ADR-0059).
+ *
+ * Usage: <For each={this.#items}>{(item) => <li>{item.name}</li>}</For>
+ */ export declare function For(props: Record<string, unknown>): VNode;
+type ComponentTag = string | ComponentFn | ComponentCtor | symbol;
+/**
+ * Called by the TypeScript JSX transform for elements with a single child.
+ */ export declare function jsx(tag: ComponentTag | typeof Fragment, props: Record<string, unknown>, key?: string | number): VNode;
+/**
+ * Called by the TypeScript JSX transform for elements with multiple children.
+ */ export declare function jsxs(tag: ComponentTag | typeof Fragment, props: Record<string, unknown>, key?: string | number): VNode;
+/**
+ * JSX factory for development mode.
+ * Same as `jsx` but receives source-map information for better error messages.
+ */ export declare function jsxDEV(tag: ComponentTag | typeof Fragment, props: Record<string, unknown>, key?: string | number, _isStaticChildren?: boolean, source?: {
+  fileName: string;
+  lineNumber: number;
+  columnNumber: number;
+}, _self?: unknown): VNode;

package/src/jsx-runtime.js

@@ -0,0 +1,99 @@
+/**
+ * @openelement/core - JSX Runtime.
+ *
+ * Implements the React-compatible jsx/jsxs/jsxDEV/Fragment interface.
+ * Consumed by TypeScript/esbuild JSX transform when `jsxImportSource: "@openelement/core"`.
+ *
+ * Design (ADR-0057):
+ * - Fragment groups multiple children without a wrapping element
+ * - jsxDEV adds source-map information in development builds
+ *
+ * @module @openelement/core/jsx-runtime
+ */ /// <reference path="./jsx-types.d.ts" />
+/**
+ * Usage in TSX:
+ *   return <><div>a</div><div>b</div></>;
+ */ export const Fragment = Symbol.for('openelement.fragment');
+/** @internal Symbol for <Show> tag matching in renderToDom */ export const SHOW_TAG = Symbol.for('openelement.show');
+/** @internal Symbol for <For> tag matching in renderToDom */ export const FOR_TAG = Symbol.for('openelement.for');
+/** @internal Symbol for raw HTML insertion (trustedHtml helper) */ export const HTML_TAG = Symbol.for('openelement.html');
+/**
+ * Create a VNode that renders as raw trusted HTML.
+ *
+ * During SSR the HTML string is emitted verbatim; on the client it is parsed
+ * into real DOM nodes via innerHTML. The caller is responsible for sanitizing
+ * the input — this is a trust boundary, not a sanitizer.
+ *
+ * @param html - The raw HTML string to render.
+ * @returns A VNode that the render pipeline treats as trusted HTML.
+ */ export function trustedHtml(html) {
+  return {
+    tag: HTML_TAG,
+    props: {
+      html
+    },
+    children: []
+  };
+}
+/**
+ * Show conditional rendering factory (ADR-0059).
+ *
+ * Returns a VNode with the internal SHOW_TAG symbol so renderToDom
+ * can intercept it as a control flow directive. Exported as a
+ * function (not a Symbol) for TypeScript JSX compatibility.
+ *
+ * Usage: <Show when={this.#loading}><Spinner/><Content/></Show>
+ */ export function Show(props) {
+  return createVNode(SHOW_TAG, props);
+}
+/**
+ * For list rendering factory (ADR-0059).
+ *
+ * Usage: <For each={this.#items}>{(item) => <li>{item.name}</li>}</For>
+ */ export function For(props) {
+  return createVNode(FOR_TAG, props);
+}
+function normaliseChildren(raw) {
+  if (raw == null) return [];
+  if (Array.isArray(raw)) {
+    return raw.flat(Infinity).filter((c)=>c != null && c !== false && c !== true);
+  }
+  if (raw === false || raw === true) return [];
+  return [
+    raw
+  ];
+}
+function createVNode(tag, props, key) {
+  const { children, ref, ...rest } = props;
+  const childArray = normaliseChildren(children);
+  const vnode = {
+    tag,
+    props: rest,
+    children: childArray
+  };
+  if (key !== undefined) vnode.key = key;
+  if (ref !== undefined) vnode.ref = ref;
+  return vnode;
+}
+/**
+ * Called by the TypeScript JSX transform for elements with a single child.
+ */ export function jsx(tag, props, key) {
+  return createVNode(tag, props, key);
+}
+/**
+ * Called by the TypeScript JSX transform for elements with multiple children.
+ */ export function jsxs(tag, props, key) {
+  return createVNode(tag, props, key);
+}
+/**
+ * JSX factory for development mode.
+ * Same as `jsx` but receives source-map information for better error messages.
+ */ export function jsxDEV(tag, props, key, _isStaticChildren, source, _self) {
+  const vnode = createVNode(tag, props, key);
+  if (source) {
+    vnode.__source = source;
+  }
+  return vnode;
+} // augmentations in published packages. The ambient declarations in
+ // jsx-types.d.ts provide the same TypeScript JSX type-checking.
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/core/src/jsx-runtime.ts"],"sourcesContent":["/**\n * @openelement/core - JSX Runtime.\n *\n * Implements the React-compatible jsx/jsxs/jsxDEV/Fragment interface.\n * Consumed by TypeScript/esbuild JSX transform when `jsxImportSource: \"@openelement/core\"`.\n *\n * Design (ADR-0057):\n * - Fragment groups multiple children without a wrapping element\n * - jsxDEV adds source-map information in development builds\n *\n * @module @openelement/core/jsx-runtime\n */\n\n/// <reference path=\"./jsx-types.d.ts\" />\n\nimport type { ComponentCtor, ComponentFn, VNode } from '@openelement/protocol/vnode';\n\n/**\n * Usage in TSX:\n *   return <><div>a</div><div>b</div></>;\n */\nexport const Fragment: unique symbol = Symbol.for('openelement.fragment');\n\n/** @internal Symbol for <Show> tag matching in renderToDom */\nexport const SHOW_TAG: unique symbol = Symbol.for('openelement.show');\n/** @internal Symbol for <For> tag matching in renderToDom */\nexport const FOR_TAG: unique symbol = Symbol.for('openelement.for');\n/** @internal Symbol for raw HTML insertion (trustedHtml helper) */\nexport const HTML_TAG: unique symbol = Symbol.for('openelement.html');\n\n/**\n * Create a VNode that renders as raw trusted HTML.\n *\n * During SSR the HTML string is emitted verbatim; on the client it is parsed\n * into real DOM nodes via innerHTML. The caller is responsible for sanitizing\n * the input — this is a trust boundary, not a sanitizer.\n *\n * @param html - The raw HTML string to render.\n * @returns A VNode that the render pipeline treats as trusted HTML.\n */\nexport function trustedHtml(html: string): VNode {\n  return { tag: HTML_TAG, props: { html }, children: [] };\n}\n\n/**\n * Show conditional rendering factory (ADR-0059).\n *\n * Returns a VNode with the internal SHOW_TAG symbol so renderToDom\n * can intercept it as a control flow directive. Exported as a\n * function (not a Symbol) for TypeScript JSX compatibility.\n *\n * Usage: <Show when={this.#loading}><Spinner/><Content/></Show>\n */\nexport function Show(props: Record<string, unknown>): VNode {\n  return createVNode(SHOW_TAG, props);\n}\n\n/**\n * For list rendering factory (ADR-0059).\n *\n * Usage: <For each={this.#items}>{(item) => <li>{item.name}</li>}</For>\n */\nexport function For(props: Record<string, unknown>): VNode {\n  return createVNode(FOR_TAG, props);\n}\n\nfunction normaliseChildren(raw: unknown): (VNode | string)[] {\n  if (raw == null) return [];\n  if (Array.isArray(raw)) {\n    return raw.flat(Infinity).filter((c) => c != null && c !== false && c !== true) as (\n      | VNode\n      | string\n    )[];\n  }\n  if (raw === false || raw === true) return [];\n  return [raw as VNode | string];\n}\n\ntype ComponentTag = string | ComponentFn | ComponentCtor | symbol;\n\nfunction createVNode(\n  tag: ComponentTag | typeof Fragment,\n  props: Record<string, unknown>,\n  key?: string | number,\n): VNode {\n  const { children, ref, ...rest } = props as Record<string, unknown> & {\n    children?: unknown;\n    ref?: (el: Element) => void;\n  };\n  const childArray = normaliseChildren(children);\n  const vnode: VNode = { tag, props: rest, children: childArray };\n  if (key !== undefined) vnode.key = key;\n  if (ref !== undefined) vnode.ref = ref as (el: Element) => void;\n  return vnode;\n}\n\n/**\n * Called by the TypeScript JSX transform for elements with a single child.\n */\nexport function jsx(\n  tag: ComponentTag | typeof Fragment,\n  props: Record<string, unknown>,\n  key?: string | number,\n): VNode {\n  return createVNode(tag, props, key);\n}\n\n/**\n * Called by the TypeScript JSX transform for elements with multiple children.\n */\nexport function jsxs(\n  tag: ComponentTag | typeof Fragment,\n  props: Record<string, unknown>,\n  key?: string | number,\n): VNode {\n  return createVNode(tag, props, key);\n}\n\n/**\n * JSX factory for development mode.\n * Same as `jsx` but receives source-map information for better error messages.\n */\nexport function jsxDEV(\n  tag: ComponentTag | typeof Fragment,\n  props: Record<string, unknown>,\n  key?: string | number,\n  _isStaticChildren?: boolean,\n  source?: { fileName: string; lineNumber: number; columnNumber: number },\n  _self?: unknown,\n): VNode {\n  const vnode = createVNode(tag, props, key);\n  if (source) {\n    (vnode as VNode & { __source?: unknown }).__source = source;\n  }\n  return vnode;\n}\n\n// augmentations in published packages. The ambient declarations in\n// jsx-types.d.ts provide the same TypeScript JSX type-checking.\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;CAWC,GAED,yCAAyC;AAIzC;;;CAGC,GACD,OAAO,MAAM,WAA0B,OAAO,GAAG,CAAC,wBAAwB;AAE1E,4DAA4D,GAC5D,OAAO,MAAM,WAA0B,OAAO,GAAG,CAAC,oBAAoB;AACtE,2DAA2D,GAC3D,OAAO,MAAM,UAAyB,OAAO,GAAG,CAAC,mBAAmB;AACpE,iEAAiE,GACjE,OAAO,MAAM,WAA0B,OAAO,GAAG,CAAC,oBAAoB;AAEtE;;;;;;;;;CASC,GACD,OAAO,SAAS,YAAY,IAAY;EACtC,OAAO;IAAE,KAAK;IAAU,OAAO;MAAE;IAAK;IAAG,UAAU,EAAE;EAAC;AACxD;AAEA;;;;;;;;CAQC,GACD,OAAO,SAAS,KAAK,KAA8B;EACjD,OAAO,YAAY,UAAU;AAC/B;AAEA;;;;CAIC,GACD,OAAO,SAAS,IAAI,KAA8B;EAChD,OAAO,YAAY,SAAS;AAC9B;AAEA,SAAS,kBAAkB,GAAY;EACrC,IAAI,OAAO,MAAM,OAAO,EAAE;EAC1B,IAAI,MAAM,OAAO,CAAC,MAAM;IACtB,OAAO,IAAI,IAAI,CAAC,UAAU,MAAM,CAAC,CAAC,IAAM,KAAK,QAAQ,MAAM,SAAS,MAAM;EAI5E;EACA,IAAI,QAAQ,SAAS,QAAQ,MAAM,OAAO,EAAE;EAC5C,OAAO;IAAC;GAAsB;AAChC;AAIA,SAAS,YACP,GAAmC,EACnC,KAA8B,EAC9B,GAAqB;EAErB,MAAM,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,MAAM,GAAG;EAInC,MAAM,aAAa,kBAAkB;EACrC,MAAM,QAAe;IAAE;IAAK,OAAO;IAAM,UAAU;EAAW;EAC9D,IAAI,QAAQ,WAAW,MAAM,GAAG,GAAG;EACnC,IAAI,QAAQ,WAAW,MAAM,GAAG,GAAG;EACnC,OAAO;AACT;AAEA;;CAEC,GACD,OAAO,SAAS,IACd,GAAmC,EACnC,KAA8B,EAC9B,GAAqB;EAErB,OAAO,YAAY,KAAK,OAAO;AACjC;AAEA;;CAEC,GACD,OAAO,SAAS,KACd,GAAmC,EACnC,KAA8B,EAC9B,GAAqB;EAErB,OAAO,YAAY,KAAK,OAAO;AACjC;AAEA;;;CAGC,GACD,OAAO,SAAS,OACd,GAAmC,EACnC,KAA8B,EAC9B,GAAqB,EACrB,iBAA2B,EAC3B,MAAuE,EACvE,KAAe;EAEf,MAAM,QAAQ,YAAY,KAAK,OAAO;EACtC,IAAI,QAAQ;IACT,MAAyC,QAAQ,GAAG;EACvD;EACA,OAAO;AACT,EAEA,mEAAmE;CACnE,gEAAgE"}

package/src/jsx-types.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @openelement/core - JSX type declarations.
+ *
+ * Required by TypeScript's `jsx: "react-jsx"` mode.
+ * Defines JSX.Element as VNode so function components returning VNode
+ * are recognized as valid JSX component types.
+ *
+ * @module @openelement/core/jsx-types
+ */
+
+declare namespace JSX {
+  /**
+   * JSX expression result — structurally compatible with VNode.
+   *
+   * children must match VNode.children: (VNode | string)[] to satisfy
+   * TypeScript's structural assignability check when a JSX expression
+   * is returned from DsdElement.render(): VNode | null.
+   */
+  interface Element {
+    tag:
+      | string
+      | import('@openelement/protocol/vnode').ComponentFn
+      | import('@openelement/protocol/vnode').ComponentCtor
+      | symbol;
+    props: Record<string, unknown>;
+    children: (string | import('@openelement/protocol/vnode').VNode)[];
+    key?: string | number;
+    ref?: (el: globalThis.Element) => void;
+  }
+
+  interface ElementClass {
+    render(): unknown;
+  }
+
+  interface IntrinsicElements {
+    [elemName: string]: Record<string, unknown>;
+  }
+
+  interface ElementAttributesProperty {
+    props: Record<string, unknown>;
+  }
+
+  interface ElementChildrenAttribute {
+    children: unknown;
+  }
+}

package/src/logger.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @openelement/core - Tagged console logger.
+ *
+ * Lightweight scoped logger. Returns plain functions so it is tree-shakable
+ * and has zero class overhead.
+ *
+ * @module @openelement/core/logger
+ */ export interface Logger {
+  debug: (msg: string, ...args: unknown[]) => void;
+  info: (msg: string, ...args: unknown[]) => void;
+  warn: (msg: string, ...args: unknown[]) => void;
+  error: (msg: string, ...args: unknown[]) => void;
+}
+export declare function createLogger(tag: string): Logger;
+export declare function warnOnce(key: string, logger: Logger, msg: string): void;