@openelement/core 0.41.0-alpha.1 → 0.41.0-alpha.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openelement/core",
-  "version": "0.41.0-alpha.1",
+  "version": "0.41.0-alpha.3",
   "type": "module",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",
@@ -118,7 +118,7 @@
     "deno"
   ],
   "dependencies": {
-    "@openelement/protocol": "^0.41.0-alpha.1",
-    "@openelement/signal": "^0.41.0-alpha.1"
+    "@openelement/protocol": "^0.41.0-alpha.3",
+    "@openelement/signal": "^0.41.0-alpha.3"
   }
 }

package/src/binding-activation.d.ts

@@ -1,2 +1,5 @@
-import type { BindingDescriptor, BindingDispose, BindingLifecycle } from "./binding-descriptor.js";
-/** Apply a single binding descriptor and return a dispose function. */ export declare function applyBindingDescriptor(desc: BindingDescriptor, lifecycle: BindingLifecycle): BindingDispose;
+import type { BindingDescriptor, BindingDispose, BindingLifecycle, BindingRenderer } from "./binding-descriptor.js";
+type ApplyFn = (desc: BindingDescriptor, lifecycle: BindingLifecycle, renderer?: BindingRenderer) => BindingDispose;
+/** Register a custom binding kind in the activation registry. */ export declare function registerBindingKind(kind: string, applyFn: ApplyFn): void;
+/** Apply a single binding descriptor and return a dispose function. */ export declare function applyBindingDescriptor(desc: BindingDescriptor, lifecycle: BindingLifecycle, renderer?: BindingRenderer): BindingDispose;
+/** Commit all binding descriptors against the activation layer in document order. */ export declare function commitBindings(descriptors: BindingDescriptor[], lifecycle: BindingLifecycle, renderer?: BindingRenderer): void;

package/src/binding-activation.js

@@ -6,53 +6,52 @@
  * @module @openelement/core/binding-activation
  */ import { effect, unwrapSignalLike } from '@openelement/signal';
 import { trustRenderHtml } from './security.js';
-import { renderToDom } from './jsx-render-dom.js';
 import { Fragment } from './jsx-runtime.js';
 import { createLogger } from './logger.js';
 import { formatError } from './errors.js';
 const bindingLog = createLogger('binding');
 const noop = ()=>{};
 /** Register a dispose function with the lifecycle. */ export function registerDispose(dispose, lifecycle) {
-  lifecycle.disposers?.add(dispose);
   if (lifecycle.signal) {
     lifecycle.signal.addEventListener('abort', dispose, {
       once: true
     });
+  } else {
+    lifecycle.disposers?.add(dispose);
   }
 }
-/** Apply a single binding descriptor and return a dispose function. */ export function applyBindingDescriptor(desc, lifecycle) {
-  switch(desc.kind){
-    case 'static-attr':
-      return applyStaticAttr(desc, lifecycle);
-    case 'static-prop':
-      return applyStaticProp(desc, lifecycle);
-    case 'static-boolean':
-      return applyStaticBoolean(desc, lifecycle);
-    case 'static-style':
-      return applyStaticStyle(desc, lifecycle);
-    case 'signal-text':
-      return applySignalText(desc, lifecycle);
-    case 'signal-class':
-      return applySignalClass(desc, lifecycle);
-    case 'signal-attr':
-      return applySignalAttr(desc, lifecycle);
-    case 'signal-html':
-      return applySignalHtml(desc, lifecycle);
-    case 'signal-render':
-      return applySignalRender(desc, lifecycle);
-    case 'event':
-      return applyEvent(desc, lifecycle);
-    case 'ref':
-      return applyRef(desc, lifecycle);
-    default:
-      {
-        // Exhaustiveness guard: unknown descriptor kinds are no-ops.
-        const _exhaustive = desc;
-        void _exhaustive;
-        return noop;
-      }
+const registry = new Map();
+/** Register a custom binding kind in the activation registry. */ export function registerBindingKind(kind, applyFn) {
+  if (registry.has(kind)) {
+    bindingLog.warn(`Overwriting registered binding kind: ${kind}`);
+  }
+  registry.set(kind, applyFn);
+}
+/** Apply a single binding descriptor and return a dispose function. */ export function applyBindingDescriptor(desc, lifecycle, renderer) {
+  const apply = registry.get(desc.kind);
+  if (apply) {
+    return apply(desc, lifecycle, renderer);
+  }
+  return noop;
+}
+/** Commit all binding descriptors against the activation layer in document order. */ export function commitBindings(descriptors, lifecycle, renderer) {
+  for (const desc of descriptors){
+    applyBindingDescriptor(desc, lifecycle, renderer);
   }
 }
+registry.set('static-attr', (desc, lifecycle)=>applyStaticAttr(desc, lifecycle));
+registry.set('static-prop', (desc, lifecycle)=>applyStaticProp(desc, lifecycle));
+registry.set('static-boolean', (desc, lifecycle)=>applyStaticBoolean(desc, lifecycle));
+registry.set('static-style', (desc, lifecycle)=>applyStaticStyle(desc, lifecycle));
+registry.set('signal-text', (desc, lifecycle)=>applySignalText(desc, lifecycle));
+registry.set('signal-class', (desc, lifecycle)=>applySignalClass(desc, lifecycle));
+registry.set('signal-attr', (desc, lifecycle)=>applySignalAttr(desc, lifecycle));
+registry.set('signal-html', (desc, lifecycle)=>applySignalHtml(desc, lifecycle));
+registry.set('signal-render', (desc, lifecycle, renderer)=>applySignalRender(desc, lifecycle, renderer));
+registry.set('conditional', (desc, lifecycle, renderer)=>applyConditional(desc, lifecycle, renderer));
+registry.set('list', (desc, lifecycle, renderer)=>applyList(desc, lifecycle, renderer));
+registry.set('event', (desc, lifecycle)=>applyEvent(desc, lifecycle));
+registry.set('ref', (desc, lifecycle)=>applyRef(desc, lifecycle));
 function applyStaticAttr(desc, _lifecycle) {
   if (desc.value == null) {
     desc.el.removeAttribute(desc.attrName);
@@ -159,8 +158,9 @@ function applySignalHtml(desc, lifecycle) {
   registerDispose(dispose, lifecycle);
   return dispose;
 }
-function applySignalRender(desc, lifecycle) {
+function applySignalRender(desc, lifecycle, renderer) {
   const { el, signal } = desc;
+  const descLifecycle = desc.lifecycle ?? {};
   let currentChildren = [];
   const currentNestedDisposers = new Set();
   const clearRender = ()=>{
@@ -181,13 +181,16 @@ function applySignalRender(desc, lifecycle) {
     clearRender();
     const raw = unwrapSignalLike(signal.value);
     if (raw == null) return;
+    if (!renderer) {
+      throw new Error('signal-render binding requires a renderer');
+    }
     // Render into a fresh child lifecycle so nested signal effects can be
     // disposed per render without leaking into previous renders.
     const renderLifecycle = {
       disposers: currentNestedDisposers
     };
-    if (lifecycle.signal) {
-      renderLifecycle.signal = lifecycle.signal;
+    if (descLifecycle.signal ?? lifecycle.signal) {
+      renderLifecycle.signal = descLifecycle.signal ?? lifecycle.signal;
     }
     // Normalize VNode[] into a Fragment so multiple rendered nodes can be
     // tracked and replaced together across updates.
@@ -196,8 +199,8 @@ function applySignalRender(desc, lifecycle) {
       props: {},
       children: raw
     } : raw;
-    const result = renderToDom(node, renderLifecycle);
-    if (result.nodeType === 11 || result.nodeType === 0) {
+    const result = renderer.render(node, renderLifecycle);
+    if (result.nodeType === 11) {
       const fragChildren = [];
       while(result.firstChild){
         const child = result.firstChild;
@@ -227,6 +230,148 @@ function applySignalRender(desc, lifecycle) {
   registerDispose(fullDispose, lifecycle);
   return fullDispose;
 }
+function applyConditional(desc, lifecycle, renderer) {
+  const { anchor, condition, renderTruthy, renderFalsy } = desc;
+  let currentChildren = [];
+  const currentNestedDisposers = new Set();
+  const clearRender = ()=>{
+    for (const dispose of currentNestedDisposers){
+      try {
+        dispose();
+      } catch (err) {
+        bindingLog.error(`conditional nested dispose failed: ${formatError(err)}`);
+      }
+    }
+    currentNestedDisposers.clear();
+    for (const child of currentChildren){
+      child.remove();
+    }
+    currentChildren = [];
+  };
+  const render = ()=>{
+    clearRender();
+    const show = Boolean(unwrapSignalLike(condition));
+    const target = show ? renderTruthy() : renderFalsy?.();
+    if (target == null) return;
+    if (!renderer) {
+      throw new Error('conditional binding requires a renderer');
+    }
+    const renderLifecycle = {
+      disposers: currentNestedDisposers
+    };
+    if (lifecycle.signal) {
+      renderLifecycle.signal = lifecycle.signal;
+    }
+    const node = Array.isArray(target) ? {
+      tag: Fragment,
+      props: {},
+      children: target
+    } : target;
+    const result = renderer.render(node, renderLifecycle);
+    if (result.nodeType === 11) {
+      const fragChildren = [];
+      while(result.firstChild){
+        fragChildren.push(result.firstChild);
+      }
+      const ref = anchor.nextSibling;
+      for(let i = fragChildren.length - 1; i >= 0; i--){
+        anchor.parentNode?.insertBefore(fragChildren[i], ref);
+      }
+      currentChildren = fragChildren;
+    } else {
+      const child = result;
+      anchor.parentNode?.insertBefore(child, anchor.nextSibling);
+      currentChildren = [
+        child
+      ];
+    }
+  };
+  const dispose = effect(()=>{
+    try {
+      render();
+    } catch (err) {
+      bindingLog.error(`conditional binding failed: ${formatError(err)}`);
+    }
+  });
+  const fullDispose = ()=>{
+    clearRender();
+    dispose();
+  };
+  registerDispose(fullDispose, lifecycle);
+  return fullDispose;
+}
+function applyList(desc, lifecycle, renderer) {
+  const { anchor, items, renderItem } = desc;
+  let anchors = [];
+  const currentNestedDisposers = new Set();
+  const clearRender = ()=>{
+    for (const dispose of currentNestedDisposers){
+      try {
+        dispose();
+      } catch (err) {
+        bindingLog.error(`list nested dispose failed: ${formatError(err)}`);
+      }
+    }
+    currentNestedDisposers.clear();
+    for (const a of anchors){
+      a.remove();
+    }
+    anchors = [];
+  };
+  const render = ()=>{
+    clearRender();
+    const list = unwrapSignalLike(items);
+    if (!Array.isArray(list)) return;
+    if (!renderer) {
+      throw new Error('list binding requires a renderer');
+    }
+    const ref = anchor.nextSibling;
+    const rendered = [];
+    for(let i = 0; i < list.length; i++){
+      const renderLifecycle = {
+        disposers: currentNestedDisposers
+      };
+      if (lifecycle.signal) {
+        renderLifecycle.signal = lifecycle.signal;
+      }
+      const vn = renderItem(list[i], i);
+      const node = Array.isArray(vn) ? {
+        tag: Fragment,
+        props: {},
+        children: vn
+      } : vn;
+      const dom = renderer.render(node, renderLifecycle);
+      if (dom.nodeType === 11) {
+        const fragChildren = [];
+        while(dom.firstChild){
+          fragChildren.push(dom.firstChild);
+        }
+        for(let j = fragChildren.length - 1; j >= 0; j--){
+          anchor.parentNode?.insertBefore(fragChildren[j], ref);
+        }
+        rendered.push(...fragChildren);
+      } else {
+        const child = dom;
+        anchor.parentNode?.insertBefore(child, ref);
+        rendered.push(child);
+      }
+    }
+    anchors = rendered;
+  };
+  const dispose = effect(()=>{
+    try {
+      render();
+    } catch (err) {
+      bindingLog.error(`list binding failed: ${formatError(err)}`);
+    }
+  });
+  const fullDispose = ()=>{
+    clearRender();
+    dispose();
+  };
+  registerDispose(fullDispose, lifecycle);
+  return fullDispose;
+}
 function applyEvent(desc, lifecycle) {
   const { el, type, handler, options } = desc;
   const listenerOptions = lifecycle.signal ? {
@@ -251,4 +396,4 @@ function applyRef(desc, _lifecycle) {
   }
   return noop;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/core/src/binding-activation.ts"],"sourcesContent":["/**\n * @openelement/core - Unified binding activation (ADR-0109 Phase 1).\n *\n * Applies a declarative BindingDescriptor to a host element.\n *\n * @module @openelement/core/binding-activation\n */\n\nimport { effect, unwrapSignalLike } from '@openelement/signal';\nimport { trustRenderHtml } from './security.js';\nimport { renderToDom } from './jsx-render-dom.js';\nimport { Fragment } from './jsx-runtime.js';\nimport { createLogger } from './logger.js';\nimport { formatError } from './errors.js';\nimport type { BindingDescriptor, BindingDispose, BindingLifecycle } from './binding-descriptor.js';\n\nconst bindingLog = createLogger('binding');\n\nconst noop: BindingDispose = () => {};\n\n/** Register a dispose function with the lifecycle. */\nexport function registerDispose(dispose: BindingDispose, lifecycle: BindingLifecycle): void {\n  lifecycle.disposers?.add(dispose);\n  if (lifecycle.signal) {\n    lifecycle.signal.addEventListener('abort', dispose, { once: true });\n  }\n}\n\n/** Apply a single binding descriptor and return a dispose function. */\nexport function applyBindingDescriptor(\n  desc: BindingDescriptor,\n  lifecycle: BindingLifecycle,\n): BindingDispose {\n  switch (desc.kind) {\n    case 'static-attr':\n      return applyStaticAttr(desc, lifecycle);\n    case 'static-prop':\n      return applyStaticProp(desc, lifecycle);\n    case 'static-boolean':\n      return applyStaticBoolean(desc, lifecycle);\n    case 'static-style':\n      return applyStaticStyle(desc, lifecycle);\n    case 'signal-text':\n      return applySignalText(desc, lifecycle);\n    case 'signal-class':\n      return applySignalClass(desc, lifecycle);\n    case 'signal-attr':\n      return applySignalAttr(desc, lifecycle);\n    case 'signal-html':\n      return applySignalHtml(desc, lifecycle);\n    case 'signal-render':\n      return applySignalRender(desc, lifecycle);\n    case 'event':\n      return applyEvent(desc, lifecycle);\n    case 'ref':\n      return applyRef(desc, lifecycle);\n    default: {\n      // Exhaustiveness guard: unknown descriptor kinds are no-ops.\n      const _exhaustive: never = desc;\n      void _exhaustive;\n      return noop;\n    }\n  }\n}\n\nfunction applyStaticAttr(\n  desc: Extract<BindingDescriptor, { kind: 'static-attr' }>,\n  _lifecycle: BindingLifecycle,\n): BindingDispose {\n  if (desc.value == null) {\n    desc.el.removeAttribute(desc.attrName);\n  } else {\n    desc.el.setAttribute(desc.attrName, String(desc.value));\n  }\n  return noop;\n}\n\nfunction applyStaticProp(\n  desc: Extract<BindingDescriptor, { kind: 'static-prop' }>,\n  _lifecycle: BindingLifecycle,\n): BindingDispose {\n  (desc.el as unknown as Record<string, unknown>)[desc.propName] = desc.value;\n  return noop;\n}\n\nfunction applyStaticBoolean(\n  desc: Extract<BindingDescriptor, { kind: 'static-boolean' }>,\n  _lifecycle: BindingLifecycle,\n): BindingDispose {\n  if (desc.value) {\n    desc.el.setAttribute(desc.attrName, '');\n  } else {\n    desc.el.removeAttribute(desc.attrName);\n  }\n  return noop;\n}\n\nfunction applyStaticStyle(\n  desc: Extract<BindingDescriptor, { kind: 'static-style' }>,\n  _lifecycle: BindingLifecycle,\n): BindingDispose {\n  const target = desc.el as HTMLElement;\n  for (const [k, v] of Object.entries(desc.value)) {\n    target.style.setProperty(k, String(v));\n  }\n  return noop;\n}\n\nfunction applySignalText(\n  desc: Extract<BindingDescriptor, { kind: 'signal-text' }>,\n  lifecycle: BindingLifecycle,\n): BindingDispose {\n  const target = desc.el as Text | Element;\n  const sig = desc.signal;\n\n  const update = () => {\n    const value = unwrapSignalLike(sig.value);\n    const text = value == null ? '' : String(value);\n    target.textContent = text;\n  };\n\n  const dispose = effect(() => {\n    try {\n      update();\n    } catch (err) {\n      bindingLog.error(`signal-text binding failed: ${formatError(err)}`);\n    }\n  });\n  registerDispose(dispose, lifecycle);\n  return dispose;\n}\n\nfunction applySignalClass(\n  desc: Extract<BindingDescriptor, { kind: 'signal-class' }>,\n  lifecycle: BindingLifecycle,\n): BindingDispose {\n  const { el, className, signal } = desc;\n\n  const update = () => {\n    const value = Boolean(unwrapSignalLike(signal.value));\n    el.classList.toggle(className, value);\n  };\n\n  const dispose = effect(() => {\n    try {\n      update();\n    } catch (err) {\n      bindingLog.error(`signal-class binding failed: ${formatError(err)}`);\n    }\n  });\n  registerDispose(dispose, lifecycle);\n  return dispose;\n}\n\nfunction applySignalAttr(\n  desc: Extract<BindingDescriptor, { kind: 'signal-attr' }>,\n  lifecycle: BindingLifecycle,\n): BindingDispose {\n  const { el, attrNames, signal } = desc;\n\n  const update = () => {\n    const value = unwrapSignalLike(signal.value);\n    for (const attrName of attrNames) {\n      if (value == null || value === false) {\n        el.removeAttribute(attrName);\n      } else if (value === true) {\n        el.setAttribute(attrName, '');\n      } else {\n        el.setAttribute(attrName, String(value));\n      }\n    }\n  };\n\n  const dispose = effect(() => {\n    try {\n      update();\n    } catch (err) {\n      bindingLog.error(`signal-attr binding failed: ${formatError(err)}`);\n    }\n  });\n  registerDispose(dispose, lifecycle);\n  return dispose;\n}\n\nfunction applySignalHtml(\n  desc: Extract<BindingDescriptor, { kind: 'signal-html' }>,\n  lifecycle: BindingLifecycle,\n): BindingDispose {\n  const { el, signal, trusted } = desc;\n\n  const update = () => {\n    const raw = unwrapSignalLike(signal.value);\n    const str = raw == null ? '' : String(raw);\n    if (trusted) {\n      el.innerHTML = trustRenderHtml(str);\n    } else {\n      el.textContent = str;\n    }\n  };\n\n  const dispose = effect(() => {\n    try {\n      update();\n    } catch (err) {\n      bindingLog.error(`signal-html binding failed: ${formatError(err)}`);\n    }\n  });\n  registerDispose(dispose, lifecycle);\n  return dispose;\n}\n\nfunction applySignalRender(\n  desc: Extract<BindingDescriptor, { kind: 'signal-render' }>,\n  lifecycle: BindingLifecycle,\n): BindingDispose {\n  const { el, signal } = desc;\n\n  let currentChildren: ChildNode[] = [];\n  const currentNestedDisposers = new Set<() => void>();\n\n  const clearRender = () => {\n    for (const dispose of currentNestedDisposers) {\n      try {\n        dispose();\n      } catch (err) {\n        bindingLog.error(`signal-render nested dispose failed: ${formatError(err)}`);\n      }\n    }\n    currentNestedDisposers.clear();\n    for (const child of currentChildren) {\n      child.remove();\n    }\n    currentChildren = [];\n  };\n\n  const render = () => {\n    clearRender();\n    const raw = unwrapSignalLike(signal.value);\n    if (raw == null) return;\n\n    // Render into a fresh child lifecycle so nested signal effects can be\n    // disposed per render without leaking into previous renders.\n    const renderLifecycle: BindingLifecycle = {\n      disposers: currentNestedDisposers,\n    };\n    if (lifecycle.signal) {\n      renderLifecycle.signal = lifecycle.signal;\n    }\n\n    // Normalize VNode[] into a Fragment so multiple rendered nodes can be\n    // tracked and replaced together across updates.\n    const node = Array.isArray(raw) ? { tag: Fragment, props: {}, children: raw } : raw;\n    const result = renderToDom(node, renderLifecycle);\n\n    if (result.nodeType === 11 || result.nodeType === 0) {\n      const fragChildren: ChildNode[] = [];\n      while (result.firstChild) {\n        const child = result.firstChild as ChildNode;\n        fragChildren.push(child);\n        el.appendChild(child);\n      }\n      currentChildren = fragChildren;\n    } else {\n      const child = result as ChildNode;\n      el.appendChild(child);\n      currentChildren = [child];\n    }\n  };\n\n  const dispose = effect(() => {\n    try {\n      render();\n    } catch (err) {\n      bindingLog.error(`signal-render binding failed: ${formatError(err)}`);\n    }\n  });\n\n  const fullDispose: BindingDispose = () => {\n    clearRender();\n    dispose();\n  };\n  registerDispose(fullDispose, lifecycle);\n  return fullDispose;\n}\n\nfunction applyEvent(\n  desc: Extract<BindingDescriptor, { kind: 'event' }>,\n  lifecycle: BindingLifecycle,\n): BindingDispose {\n  const { el, type, handler, options } = desc;\n\n  const listenerOptions: AddEventListenerOptions | boolean = lifecycle.signal\n    ? {\n      ...(typeof options === 'object' && options !== null ? options : {}),\n      signal: lifecycle.signal,\n    }\n    : (options ?? {});\n\n  el.addEventListener(type, handler, listenerOptions);\n\n  const dispose: BindingDispose = () => {\n    el.removeEventListener(type, handler, listenerOptions);\n  };\n\n  // When no AbortSignal was provided we still want an explicit dispose path.\n  if (!lifecycle.signal) {\n    registerDispose(dispose, lifecycle);\n  }\n  return dispose;\n}\n\nfunction applyRef(\n  desc: Extract<BindingDescriptor, { kind: 'ref' }>,\n  _lifecycle: BindingLifecycle,\n): BindingDispose {\n  try {\n    desc.callback(desc.el);\n  } catch (err) {\n    bindingLog.error(`ref binding failed: ${formatError(err)}`);\n  }\n  return noop;\n}\n"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/core/src/binding-activation.ts"],"sourcesContent":["/**\n * @openelement/core - Unified binding activation (ADR-0109 Phase 1).\n *\n * Applies a declarative BindingDescriptor to a host element.\n *\n * @module @openelement/core/binding-activation\n */\n\nimport { effect, unwrapSignalLike } from '@openelement/signal';\nimport { trustRenderHtml } from './security.js';\nimport { Fragment } from './jsx-runtime.js';\nimport { createLogger } from './logger.js';\nimport { formatError } from './errors.js';\nimport type {\n  BindingDescriptor,\n  BindingDispose,\n  BindingLifecycle,\n  BindingRenderer,\n} from './binding-descriptor.js';\n\nconst bindingLog = createLogger('binding');\n\nconst noop: BindingDispose = () => {};\n\n/** Register a dispose function with the lifecycle. */\nexport function registerDispose(dispose: BindingDispose, lifecycle: BindingLifecycle): void {\n  if (lifecycle.signal) {\n    lifecycle.signal.addEventListener('abort', dispose, { once: true });\n  } else {\n    lifecycle.disposers?.add(dispose);\n  }\n}\n\ntype ApplyFn = (\n  desc: BindingDescriptor,\n  lifecycle: BindingLifecycle,\n  renderer?: BindingRenderer,\n) => BindingDispose;\n\nconst registry = new Map<string, ApplyFn>();\n\n/** Register a custom binding kind in the activation registry. */\nexport function registerBindingKind(kind: string, applyFn: ApplyFn): void {\n  if (registry.has(kind)) {\n    bindingLog.warn(`Overwriting registered binding kind: ${kind}`);\n  }\n  registry.set(kind, applyFn);\n}\n\n/** Apply a single binding descriptor and return a dispose function. */\nexport function applyBindingDescriptor(\n  desc: BindingDescriptor,\n  lifecycle: BindingLifecycle,\n  renderer?: BindingRenderer,\n): BindingDispose {\n  const apply = registry.get(desc.kind);\n  if (apply) {\n    return apply(desc, lifecycle, renderer);\n  }\n  return noop;\n}\n\n/** Commit all binding descriptors against the activation layer in document order. */\nexport function commitBindings(\n  descriptors: BindingDescriptor[],\n  lifecycle: BindingLifecycle,\n  renderer?: BindingRenderer,\n): void {\n  for (const desc of descriptors) {\n    applyBindingDescriptor(desc, lifecycle, renderer);\n  }\n}\n\nregistry.set(\n  'static-attr',\n  (desc, lifecycle) =>\n    applyStaticAttr(desc as Extract<BindingDescriptor, { kind: 'static-attr' }>, lifecycle),\n);\nregistry.set(\n  'static-prop',\n  (desc, lifecycle) =>\n    applyStaticProp(desc as Extract<BindingDescriptor, { kind: 'static-prop' }>, lifecycle),\n);\nregistry.set(\n  'static-boolean',\n  (desc, lifecycle) =>\n    applyStaticBoolean(desc as Extract<BindingDescriptor, { kind: 'static-boolean' }>, lifecycle),\n);\nregistry.set(\n  'static-style',\n  (desc, lifecycle) =>\n    applyStaticStyle(desc as Extract<BindingDescriptor, { kind: 'static-style' }>, lifecycle),\n);\nregistry.set(\n  'signal-text',\n  (desc, lifecycle) =>\n    applySignalText(desc as Extract<BindingDescriptor, { kind: 'signal-text' }>, lifecycle),\n);\nregistry.set(\n  'signal-class',\n  (desc, lifecycle) =>\n    applySignalClass(desc as Extract<BindingDescriptor, { kind: 'signal-class' }>, lifecycle),\n);\nregistry.set(\n  'signal-attr',\n  (desc, lifecycle) =>\n    applySignalAttr(desc as Extract<BindingDescriptor, { kind: 'signal-attr' }>, lifecycle),\n);\nregistry.set(\n  'signal-html',\n  (desc, lifecycle) =>\n    applySignalHtml(desc as Extract<BindingDescriptor, { kind: 'signal-html' }>, lifecycle),\n);\nregistry.set('signal-render', (desc, lifecycle, renderer) =>\n  applySignalRender(\n    desc as Extract<BindingDescriptor, { kind: 'signal-render' }>,\n    lifecycle,\n    renderer,\n  ));\nregistry.set('conditional', (desc, lifecycle, renderer) =>\n  applyConditional(\n    desc as Extract<BindingDescriptor, { kind: 'conditional' }>,\n    lifecycle,\n    renderer,\n  ));\nregistry.set(\n  'list',\n  (desc, lifecycle, renderer) =>\n    applyList(desc as Extract<BindingDescriptor, { kind: 'list' }>, lifecycle, renderer),\n);\nregistry.set(\n  'event',\n  (desc, lifecycle) => applyEvent(desc as Extract<BindingDescriptor, { kind: 'event' }>, lifecycle),\n);\nregistry.set(\n  'ref',\n  (desc, lifecycle) => applyRef(desc as Extract<BindingDescriptor, { kind: 'ref' }>, lifecycle),\n);\n\nfunction applyStaticAttr(\n  desc: Extract<BindingDescriptor, { kind: 'static-attr' }>,\n  _lifecycle: BindingLifecycle,\n): BindingDispose {\n  if (desc.value == null) {\n    desc.el.removeAttribute(desc.attrName);\n  } else {\n    desc.el.setAttribute(desc.attrName, String(desc.value));\n  }\n  return noop;\n}\n\nfunction applyStaticProp(\n  desc: Extract<BindingDescriptor, { kind: 'static-prop' }>,\n  _lifecycle: BindingLifecycle,\n): BindingDispose {\n  (desc.el as unknown as Record<string, unknown>)[desc.propName] = desc.value;\n  return noop;\n}\n\nfunction applyStaticBoolean(\n  desc: Extract<BindingDescriptor, { kind: 'static-boolean' }>,\n  _lifecycle: BindingLifecycle,\n): BindingDispose {\n  if (desc.value) {\n    desc.el.setAttribute(desc.attrName, '');\n  } else {\n    desc.el.removeAttribute(desc.attrName);\n  }\n  return noop;\n}\n\nfunction applyStaticStyle(\n  desc: Extract<BindingDescriptor, { kind: 'static-style' }>,\n  _lifecycle: BindingLifecycle,\n): BindingDispose {\n  const target = desc.el as HTMLElement;\n  for (const [k, v] of Object.entries(desc.value)) {\n    target.style.setProperty(k, String(v));\n  }\n  return noop;\n}\n\nfunction applySignalText(\n  desc: Extract<BindingDescriptor, { kind: 'signal-text' }>,\n  lifecycle: BindingLifecycle,\n): BindingDispose {\n  const target = desc.el as Text | Element;\n  const sig = desc.signal;\n\n  const update = () => {\n    const value = unwrapSignalLike(sig.value);\n    const text = value == null ? '' : String(value);\n    target.textContent = text;\n  };\n\n  const dispose = effect(() => {\n    try {\n      update();\n    } catch (err) {\n      bindingLog.error(`signal-text binding failed: ${formatError(err)}`);\n    }\n  });\n  registerDispose(dispose, lifecycle);\n  return dispose;\n}\n\nfunction applySignalClass(\n  desc: Extract<BindingDescriptor, { kind: 'signal-class' }>,\n  lifecycle: BindingLifecycle,\n): BindingDispose {\n  const { el, className, signal } = desc;\n\n  const update = () => {\n    const value = Boolean(unwrapSignalLike(signal.value));\n    el.classList.toggle(className, value);\n  };\n\n  const dispose = effect(() => {\n    try {\n      update();\n    } catch (err) {\n      bindingLog.error(`signal-class binding failed: ${formatError(err)}`);\n    }\n  });\n  registerDispose(dispose, lifecycle);\n  return dispose;\n}\n\nfunction applySignalAttr(\n  desc: Extract<BindingDescriptor, { kind: 'signal-attr' }>,\n  lifecycle: BindingLifecycle,\n): BindingDispose {\n  const { el, attrNames, signal } = desc;\n\n  const update = () => {\n    const value = unwrapSignalLike(signal.value);\n    for (const attrName of attrNames) {\n      if (value == null || value === false) {\n        el.removeAttribute(attrName);\n      } else if (value === true) {\n        el.setAttribute(attrName, '');\n      } else {\n        el.setAttribute(attrName, String(value));\n      }\n    }\n  };\n\n  const dispose = effect(() => {\n    try {\n      update();\n    } catch (err) {\n      bindingLog.error(`signal-attr binding failed: ${formatError(err)}`);\n    }\n  });\n  registerDispose(dispose, lifecycle);\n  return dispose;\n}\n\nfunction applySignalHtml(\n  desc: Extract<BindingDescriptor, { kind: 'signal-html' }>,\n  lifecycle: BindingLifecycle,\n): BindingDispose {\n  const { el, signal, trusted } = desc;\n\n  const update = () => {\n    const raw = unwrapSignalLike(signal.value);\n    const str = raw == null ? '' : String(raw);\n    if (trusted) {\n      el.innerHTML = trustRenderHtml(str);\n    } else {\n      el.textContent = str;\n    }\n  };\n\n  const dispose = effect(() => {\n    try {\n      update();\n    } catch (err) {\n      bindingLog.error(`signal-html binding failed: ${formatError(err)}`);\n    }\n  });\n  registerDispose(dispose, lifecycle);\n  return dispose;\n}\n\nfunction applySignalRender(\n  desc: Extract<BindingDescriptor, { kind: 'signal-render' }>,\n  lifecycle: BindingLifecycle,\n  renderer?: BindingRenderer,\n): BindingDispose {\n  const { el, signal } = desc;\n  const descLifecycle = desc.lifecycle ?? {};\n\n  let currentChildren: ChildNode[] = [];\n  const currentNestedDisposers = new Set<() => void>();\n\n  const clearRender = () => {\n    for (const dispose of currentNestedDisposers) {\n      try {\n        dispose();\n      } catch (err) {\n        bindingLog.error(`signal-render nested dispose failed: ${formatError(err)}`);\n      }\n    }\n    currentNestedDisposers.clear();\n    for (const child of currentChildren) {\n      child.remove();\n    }\n    currentChildren = [];\n  };\n\n  const render = () => {\n    clearRender();\n    const raw = unwrapSignalLike(signal.value);\n    if (raw == null) return;\n    if (!renderer) {\n      throw new Error('signal-render binding requires a renderer');\n    }\n\n    // Render into a fresh child lifecycle so nested signal effects can be\n    // disposed per render without leaking into previous renders.\n    const renderLifecycle: BindingLifecycle = {\n      disposers: currentNestedDisposers,\n    };\n    if (descLifecycle.signal ?? lifecycle.signal) {\n      renderLifecycle.signal = descLifecycle.signal ?? lifecycle.signal;\n    }\n\n    // Normalize VNode[] into a Fragment so multiple rendered nodes can be\n    // tracked and replaced together across updates.\n    const node = Array.isArray(raw) ? { tag: Fragment, props: {}, children: raw } : raw;\n    const result = renderer.render(node, renderLifecycle);\n\n    if (result.nodeType === 11) {\n      const fragChildren: ChildNode[] = [];\n      while (result.firstChild) {\n        const child = result.firstChild as ChildNode;\n        fragChildren.push(child);\n        el.appendChild(child);\n      }\n      currentChildren = fragChildren;\n    } else {\n      const child = result as ChildNode;\n      el.appendChild(child);\n      currentChildren = [child];\n    }\n  };\n\n  const dispose = effect(() => {\n    try {\n      render();\n    } catch (err) {\n      bindingLog.error(`signal-render binding failed: ${formatError(err)}`);\n    }\n  });\n\n  const fullDispose: BindingDispose = () => {\n    clearRender();\n    dispose();\n  };\n  registerDispose(fullDispose, lifecycle);\n  return fullDispose;\n}\n\nfunction applyConditional(\n  desc: Extract<BindingDescriptor, { kind: 'conditional' }>,\n  lifecycle: BindingLifecycle,\n  renderer?: BindingRenderer,\n): BindingDispose {\n  const { anchor, condition, renderTruthy, renderFalsy } = desc;\n\n  let currentChildren: ChildNode[] = [];\n  const currentNestedDisposers = new Set<() => void>();\n\n  const clearRender = () => {\n    for (const dispose of currentNestedDisposers) {\n      try {\n        dispose();\n      } catch (err) {\n        bindingLog.error(`conditional nested dispose failed: ${formatError(err)}`);\n      }\n    }\n    currentNestedDisposers.clear();\n    for (const child of currentChildren) {\n      child.remove();\n    }\n    currentChildren = [];\n  };\n\n  const render = () => {\n    clearRender();\n    const show = Boolean(unwrapSignalLike(condition));\n    const target = show ? renderTruthy() : renderFalsy?.();\n    if (target == null) return;\n    if (!renderer) {\n      throw new Error('conditional binding requires a renderer');\n    }\n\n    const renderLifecycle: BindingLifecycle = {\n      disposers: currentNestedDisposers,\n    };\n    if (lifecycle.signal) {\n      renderLifecycle.signal = lifecycle.signal;\n    }\n\n    const node = Array.isArray(target) ? { tag: Fragment, props: {}, children: target } : target;\n    const result = renderer.render(node, renderLifecycle);\n\n    if (result.nodeType === 11) {\n      const fragChildren: ChildNode[] = [];\n      while (result.firstChild) {\n        fragChildren.push(result.firstChild as ChildNode);\n      }\n      const ref = anchor.nextSibling;\n      for (let i = fragChildren.length - 1; i >= 0; i--) {\n        anchor.parentNode?.insertBefore(fragChildren[i], ref);\n      }\n      currentChildren = fragChildren;\n    } else {\n      const child = result as ChildNode;\n      anchor.parentNode?.insertBefore(child, anchor.nextSibling);\n      currentChildren = [child];\n    }\n  };\n\n  const dispose = effect(() => {\n    try {\n      render();\n    } catch (err) {\n      bindingLog.error(`conditional binding failed: ${formatError(err)}`);\n    }\n  });\n\n  const fullDispose: BindingDispose = () => {\n    clearRender();\n    dispose();\n  };\n  registerDispose(fullDispose, lifecycle);\n  return fullDispose;\n}\n\nfunction applyList(\n  desc: Extract<BindingDescriptor, { kind: 'list' }>,\n  lifecycle: BindingLifecycle,\n  renderer?: BindingRenderer,\n): BindingDispose {\n  const { anchor, items, renderItem } = desc;\n\n  let anchors: ChildNode[] = [];\n  const currentNestedDisposers = new Set<() => void>();\n\n  const clearRender = () => {\n    for (const dispose of currentNestedDisposers) {\n      try {\n        dispose();\n      } catch (err) {\n        bindingLog.error(`list nested dispose failed: ${formatError(err)}`);\n      }\n    }\n    currentNestedDisposers.clear();\n    for (const a of anchors) {\n      a.remove();\n    }\n    anchors = [];\n  };\n\n  const render = () => {\n    clearRender();\n    const list = unwrapSignalLike(items);\n    if (!Array.isArray(list)) return;\n    if (!renderer) {\n      throw new Error('list binding requires a renderer');\n    }\n\n    const ref: ChildNode | null = anchor.nextSibling;\n    const rendered: ChildNode[] = [];\n\n    for (let i = 0; i < list.length; i++) {\n      const renderLifecycle: BindingLifecycle = {\n        disposers: currentNestedDisposers,\n      };\n      if (lifecycle.signal) {\n        renderLifecycle.signal = lifecycle.signal;\n      }\n\n      const vn = renderItem(list[i], i);\n      const node = Array.isArray(vn) ? { tag: Fragment, props: {}, children: vn } : vn;\n      const dom = renderer.render(node, renderLifecycle);\n\n      if (dom.nodeType === 11) {\n        const fragChildren: ChildNode[] = [];\n        while (dom.firstChild) {\n          fragChildren.push(dom.firstChild as ChildNode);\n        }\n        for (let j = fragChildren.length - 1; j >= 0; j--) {\n          anchor.parentNode?.insertBefore(fragChildren[j], ref);\n        }\n        rendered.push(...fragChildren);\n      } else {\n        const child = dom as ChildNode;\n        anchor.parentNode?.insertBefore(child, ref);\n        rendered.push(child);\n      }\n    }\n\n    anchors = rendered;\n  };\n\n  const dispose = effect(() => {\n    try {\n      render();\n    } catch (err) {\n      bindingLog.error(`list binding failed: ${formatError(err)}`);\n    }\n  });\n\n  const fullDispose: BindingDispose = () => {\n    clearRender();\n    dispose();\n  };\n  registerDispose(fullDispose, lifecycle);\n  return fullDispose;\n}\n\nfunction applyEvent(\n  desc: Extract<BindingDescriptor, { kind: 'event' }>,\n  lifecycle: BindingLifecycle,\n): BindingDispose {\n  const { el, type, handler, options } = desc;\n\n  const listenerOptions: AddEventListenerOptions | boolean = lifecycle.signal\n    ? {\n      ...(typeof options === 'object' && options !== null ? options : {}),\n      signal: lifecycle.signal,\n    }\n    : (options ?? {});\n\n  el.addEventListener(type, handler, listenerOptions);\n\n  const dispose: BindingDispose = () => {\n    el.removeEventListener(type, handler, listenerOptions);\n  };\n\n  // When no AbortSignal was provided we still want an explicit dispose path.\n  if (!lifecycle.signal) {\n    registerDispose(dispose, lifecycle);\n  }\n  return dispose;\n}\n\nfunction applyRef(\n  desc: Extract<BindingDescriptor, { kind: 'ref' }>,\n  _lifecycle: BindingLifecycle,\n): BindingDispose {\n  try {\n    desc.callback(desc.el);\n  } catch (err) {\n    bindingLog.error(`ref binding failed: ${formatError(err)}`);\n  }\n  return noop;\n}\n"],"names":[],"mappings":"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"}

package/src/binding-descriptor.d.ts

@@ -10,11 +10,13 @@
   /** AbortSignal that triggers automatic disposal when aborted. */ signal?: AbortSignal;
   /** Explicit disposers collected for batch cleanup. */ disposers?: Set<() => void>;
 }
+/** Renderer contract injected to avoid a core intra-package cycle. */ export interface BindingRenderer {
+  /** Render a VNode tree (or primitive) to a DOM node under the given lifecycle. */ render(node: unknown, lifecycle: BindingLifecycle): Node;
+}
 /** Dispose function returned by bindings and registered into lifecycle. */ export type BindingDispose = () => void;
 export interface StaticAttrBindingDescriptor {
   kind: 'static-attr';
   el: Element;
-  key: string;
   attrName: string;
   value: unknown;
 }
@@ -40,7 +42,7 @@ export interface SignalTextBindingDescriptor {
   el: Element | Text;
   signal: Signal<unknown>;
 }
-export interface SignalClassBindingDescriptor {
+/** @internal DSD-only descriptor emitted by hydration-scope, never by CSR collectPropBindings. */ export interface SignalClassBindingDescriptor {
   kind: 'signal-class';
   el: Element;
   className: string;
@@ -62,7 +64,20 @@ export interface SignalRenderBindingDescriptor {
   kind: 'signal-render';
   el: Element;
   signal: Signal<unknown>;
-  lifecycle: BindingLifecycle;
+  lifecycle?: BindingLifecycle;
+}
+export interface ConditionalBindingDescriptor {
+  kind: 'conditional';
+  anchor: ChildNode;
+  condition: Signal<unknown> | unknown;
+  renderTruthy: () => unknown;
+  renderFalsy?: () => unknown;
+}
+export interface ListBindingDescriptor {
+  kind: 'list';
+  anchor: ChildNode;
+  items: Signal<unknown> | unknown;
+  renderItem: (item: unknown, index: number) => unknown;
 }
 export interface EventBindingDescriptor {
   kind: 'event';
@@ -76,4 +91,17 @@ export interface RefBindingDescriptor {
   el: Element;
   callback: (el: Element) => void;
 }
-/** Union of all supported binding descriptors. */ export type BindingDescriptor = StaticAttrBindingDescriptor | StaticPropBindingDescriptor | StaticBooleanBindingDescriptor | StaticStyleBindingDescriptor | SignalTextBindingDescriptor | SignalClassBindingDescriptor | SignalAttrBindingDescriptor | SignalHtmlBindingDescriptor | SignalRenderBindingDescriptor | EventBindingDescriptor | RefBindingDescriptor;
+/** Union of all supported binding descriptors. */ export type BindingDescriptor = StaticAttrBindingDescriptor | StaticPropBindingDescriptor | StaticBooleanBindingDescriptor | StaticStyleBindingDescriptor | SignalTextBindingDescriptor | SignalClassBindingDescriptor | SignalAttrBindingDescriptor | SignalHtmlBindingDescriptor | SignalRenderBindingDescriptor | ConditionalBindingDescriptor | ListBindingDescriptor | EventBindingDescriptor | RefBindingDescriptor;
+/** Create a signal-text binding descriptor. */ export declare function bindText(node: Text | Element, signal: Signal<unknown>): SignalTextBindingDescriptor;
+/** Create a signal-attribute binding descriptor. */ export declare function bindAttr(element: Element, names: string[], signal: Signal<unknown>): SignalAttrBindingDescriptor;
+/** Create a signal-class binding descriptor. */ export declare function bindClass(element: Element, className: string, signal: Signal<unknown>): SignalClassBindingDescriptor;
+/** Create a signal-html binding descriptor. */ export declare function bindHtml(element: Element, signal: Signal<unknown>, trusted: boolean): SignalHtmlBindingDescriptor;
+/** Create an event binding descriptor. */ export declare function bindEvent(element: EventTarget, event: string, listener: EventListenerOrEventListenerObject, options?: AddEventListenerOptions | boolean): EventBindingDescriptor;
+/** Create a signal-render binding descriptor. */ export declare function bindRender(element: Element, signal: Signal<unknown>, lifecycle: BindingLifecycle): SignalRenderBindingDescriptor;
+/** Create a conditional ({@link Show}) binding descriptor. */ export declare function bindConditional(anchor: ChildNode, condition: Signal<unknown> | unknown, renderTruthy: () => unknown, renderFalsy?: () => unknown): ConditionalBindingDescriptor;
+/** Create a list ({@link For}) binding descriptor. */ export declare function bindList(anchor: ChildNode, items: Signal<unknown> | unknown, renderItem: (item: unknown, index: number) => unknown): ListBindingDescriptor;
+/** Create a static attribute binding descriptor. */ export declare function bindStaticAttr(element: Element, attrName: string, value: unknown): StaticAttrBindingDescriptor;
+/** Create a static DOM property binding descriptor. */ export declare function bindStaticProp(element: Element, propName: string, value: unknown): StaticPropBindingDescriptor;
+/** Create a static boolean attribute binding descriptor. */ export declare function bindStaticBoolean(element: Element, attrName: string, value: boolean): StaticBooleanBindingDescriptor;
+/** Create a static inline style binding descriptor. */ export declare function bindStaticStyle(element: Element, value: Record<string, string | number>): StaticStyleBindingDescriptor;
+/** Create a ref callback binding descriptor. */ export declare function bindRef(element: Element, callback: (el: Element) => void): RefBindingDescriptor;

package/src/binding-descriptor.js

@@ -5,5 +5,108 @@
  * Each descriptor captures one side effect to apply to a host element.
  *
  * @module @openelement/core/binding-descriptor
- */ 
-//# sourceMappingURL=data:application/json;base64,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
+ */ // ─── Factory constructors ───────────────────────────────────────────────────
+/** Create a signal-text binding descriptor. */ export function bindText(node, signal) {
+  return {
+    kind: 'signal-text',
+    el: node,
+    signal
+  };
+}
+/** Create a signal-attribute binding descriptor. */ export function bindAttr(element, names, signal) {
+  return {
+    kind: 'signal-attr',
+    el: element,
+    attrNames: names,
+    signal
+  };
+}
+/** Create a signal-class binding descriptor. */ export function bindClass(element, className, signal) {
+  return {
+    kind: 'signal-class',
+    el: element,
+    className,
+    signal
+  };
+}
+/** Create a signal-html binding descriptor. */ export function bindHtml(element, signal, trusted) {
+  return {
+    kind: 'signal-html',
+    el: element,
+    signal,
+    trusted
+  };
+}
+/** Create an event binding descriptor. */ export function bindEvent(element, event, listener, options) {
+  return {
+    kind: 'event',
+    el: element,
+    type: event,
+    handler: listener,
+    options
+  };
+}
+/** Create a signal-render binding descriptor. */ export function bindRender(element, signal, lifecycle) {
+  return {
+    kind: 'signal-render',
+    el: element,
+    signal,
+    lifecycle
+  };
+}
+/** Create a conditional ({@link Show}) binding descriptor. */ export function bindConditional(anchor, condition, renderTruthy, renderFalsy) {
+  return {
+    kind: 'conditional',
+    anchor,
+    condition,
+    renderTruthy,
+    renderFalsy
+  };
+}
+/** Create a list ({@link For}) binding descriptor. */ export function bindList(anchor, items, renderItem) {
+  return {
+    kind: 'list',
+    anchor,
+    items,
+    renderItem
+  };
+}
+/** Create a static attribute binding descriptor. */ export function bindStaticAttr(element, attrName, value) {
+  return {
+    kind: 'static-attr',
+    el: element,
+    attrName,
+    value
+  };
+}
+/** Create a static DOM property binding descriptor. */ export function bindStaticProp(element, propName, value) {
+  return {
+    kind: 'static-prop',
+    el: element,
+    propName,
+    value
+  };
+}
+/** Create a static boolean attribute binding descriptor. */ export function bindStaticBoolean(element, attrName, value) {
+  return {
+    kind: 'static-boolean',
+    el: element,
+    attrName,
+    value
+  };
+}
+/** Create a static inline style binding descriptor. */ export function bindStaticStyle(element, value) {
+  return {
+    kind: 'static-style',
+    el: element,
+    value
+  };
+}
+/** Create a ref callback binding descriptor. */ export function bindRef(element, callback) {
+  return {
+    kind: 'ref',
+    el: element,
+    callback
+  };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/core/src/binding-descriptor.ts"],"sourcesContent":["/**\n * @openelement/core - Unified binding descriptor types (ADR-0109 Phase 1).\n *\n * Declarative DOM binding contracts used by the runtime and hydration layers.\n * Each descriptor captures one side effect to apply to a host element.\n *\n * @module @openelement/core/binding-descriptor\n */\n\nimport type { Signal } from '@openelement/protocol/signal';\n\n/** Shared lifecycle context for a set of bindings. */\nexport interface BindingLifecycle {\n  /** AbortSignal that triggers automatic disposal when aborted. */\n  signal?: AbortSignal;\n  /** Explicit disposers collected for batch cleanup. */\n  disposers?: Set<() => void>;\n}\n\n/** Renderer contract injected to avoid a core intra-package cycle. */\nexport interface BindingRenderer {\n  /** Render a VNode tree (or primitive) to a DOM node under the given lifecycle. */\n  render(node: unknown, lifecycle: BindingLifecycle): Node;\n}\n\n/** Dispose function returned by bindings and registered into lifecycle. */\nexport type BindingDispose = () => void;\n\n// ─── Static descriptors ─────────────────────────────────────────────────────\n\nexport interface StaticAttrBindingDescriptor {\n  kind: 'static-attr';\n  el: Element;\n  attrName: string;\n  value: unknown;\n}\n\nexport interface StaticPropBindingDescriptor {\n  kind: 'static-prop';\n  el: Element;\n  propName: string;\n  value: unknown;\n}\n\nexport interface StaticBooleanBindingDescriptor {\n  kind: 'static-boolean';\n  el: Element;\n  attrName: string;\n  value: boolean;\n}\n\nexport interface StaticStyleBindingDescriptor {\n  kind: 'static-style';\n  el: Element;\n  value: Record<string, string | number>;\n}\n\n// ─── Signal descriptors ─────────────────────────────────────────────────────\n\nexport interface SignalTextBindingDescriptor {\n  kind: 'signal-text';\n  el: Element | Text;\n  signal: Signal<unknown>;\n}\n\n/** @internal DSD-only descriptor emitted by hydration-scope, never by CSR collectPropBindings. */\nexport interface SignalClassBindingDescriptor {\n  kind: 'signal-class';\n  el: Element;\n  className: string;\n  signal: Signal<unknown>;\n}\n\nexport interface SignalAttrBindingDescriptor {\n  kind: 'signal-attr';\n  el: Element;\n  attrNames: string[];\n  signal: Signal<unknown>;\n}\n\nexport interface SignalHtmlBindingDescriptor {\n  kind: 'signal-html';\n  el: Element;\n  signal: Signal<unknown>;\n  trusted: boolean;\n}\n\nexport interface SignalRenderBindingDescriptor {\n  kind: 'signal-render';\n  el: Element;\n  signal: Signal<unknown>;\n  lifecycle?: BindingLifecycle;\n}\n\nexport interface ConditionalBindingDescriptor {\n  kind: 'conditional';\n  anchor: ChildNode;\n  condition: Signal<unknown> | unknown;\n  renderTruthy: () => unknown;\n  renderFalsy?: () => unknown;\n}\n\nexport interface ListBindingDescriptor {\n  kind: 'list';\n  anchor: ChildNode;\n  items: Signal<unknown> | unknown;\n  renderItem: (item: unknown, index: number) => unknown;\n}\n\n// ─── Event / ref descriptors ──────────────────────────────────────────────────\n\nexport interface EventBindingDescriptor {\n  kind: 'event';\n  el: EventTarget;\n  type: string;\n  handler: EventListenerOrEventListenerObject;\n  options?: AddEventListenerOptions | boolean;\n}\n\nexport interface RefBindingDescriptor {\n  kind: 'ref';\n  el: Element;\n  callback: (el: Element) => void;\n}\n\n/** Union of all supported binding descriptors. */\nexport type BindingDescriptor =\n  | StaticAttrBindingDescriptor\n  | StaticPropBindingDescriptor\n  | StaticBooleanBindingDescriptor\n  | StaticStyleBindingDescriptor\n  | SignalTextBindingDescriptor\n  | SignalClassBindingDescriptor\n  | SignalAttrBindingDescriptor\n  | SignalHtmlBindingDescriptor\n  | SignalRenderBindingDescriptor\n  | ConditionalBindingDescriptor\n  | ListBindingDescriptor\n  | EventBindingDescriptor\n  | RefBindingDescriptor;\n\n// ─── Factory constructors ───────────────────────────────────────────────────\n\n/** Create a signal-text binding descriptor. */\nexport function bindText(\n  node: Text | Element,\n  signal: Signal<unknown>,\n): SignalTextBindingDescriptor {\n  return { kind: 'signal-text', el: node, signal };\n}\n\n/** Create a signal-attribute binding descriptor. */\nexport function bindAttr(\n  element: Element,\n  names: string[],\n  signal: Signal<unknown>,\n): SignalAttrBindingDescriptor {\n  return { kind: 'signal-attr', el: element, attrNames: names, signal };\n}\n\n/** Create a signal-class binding descriptor. */\nexport function bindClass(\n  element: Element,\n  className: string,\n  signal: Signal<unknown>,\n): SignalClassBindingDescriptor {\n  return { kind: 'signal-class', el: element, className, signal };\n}\n\n/** Create a signal-html binding descriptor. */\nexport function bindHtml(\n  element: Element,\n  signal: Signal<unknown>,\n  trusted: boolean,\n): SignalHtmlBindingDescriptor {\n  return { kind: 'signal-html', el: element, signal, trusted };\n}\n\n/** Create an event binding descriptor. */\nexport function bindEvent(\n  element: EventTarget,\n  event: string,\n  listener: EventListenerOrEventListenerObject,\n  options?: AddEventListenerOptions | boolean,\n): EventBindingDescriptor {\n  return { kind: 'event', el: element, type: event, handler: listener, options };\n}\n\n/** Create a signal-render binding descriptor. */\nexport function bindRender(\n  element: Element,\n  signal: Signal<unknown>,\n  lifecycle: BindingLifecycle,\n): SignalRenderBindingDescriptor {\n  return { kind: 'signal-render', el: element, signal, lifecycle };\n}\n\n/** Create a conditional ({@link Show}) binding descriptor. */\nexport function bindConditional(\n  anchor: ChildNode,\n  condition: Signal<unknown> | unknown,\n  renderTruthy: () => unknown,\n  renderFalsy?: () => unknown,\n): ConditionalBindingDescriptor {\n  return { kind: 'conditional', anchor, condition, renderTruthy, renderFalsy };\n}\n\n/** Create a list ({@link For}) binding descriptor. */\nexport function bindList(\n  anchor: ChildNode,\n  items: Signal<unknown> | unknown,\n  renderItem: (item: unknown, index: number) => unknown,\n): ListBindingDescriptor {\n  return { kind: 'list', anchor, items, renderItem };\n}\n\n/** Create a static attribute binding descriptor. */\nexport function bindStaticAttr(\n  element: Element,\n  attrName: string,\n  value: unknown,\n): StaticAttrBindingDescriptor {\n  return { kind: 'static-attr', el: element, attrName, value };\n}\n\n/** Create a static DOM property binding descriptor. */\nexport function bindStaticProp(\n  element: Element,\n  propName: string,\n  value: unknown,\n): StaticPropBindingDescriptor {\n  return { kind: 'static-prop', el: element, propName, value };\n}\n\n/** Create a static boolean attribute binding descriptor. */\nexport function bindStaticBoolean(\n  element: Element,\n  attrName: string,\n  value: boolean,\n): StaticBooleanBindingDescriptor {\n  return { kind: 'static-boolean', el: element, attrName, value };\n}\n\n/** Create a static inline style binding descriptor. */\nexport function bindStaticStyle(\n  element: Element,\n  value: Record<string, string | number>,\n): StaticStyleBindingDescriptor {\n  return { kind: 'static-style', el: element, value };\n}\n\n/** Create a ref callback binding descriptor. */\nexport function bindRef(\n  element: Element,\n  callback: (el: Element) => void,\n): RefBindingDescriptor {\n  return { kind: 'ref', el: element, callback };\n}\n"],"names":[],"mappings":"AAAA;;;;;;;CAOC,GAsID,+EAA+E;AAE/E,6CAA6C,GAC7C,OAAO,SAAS,SACd,IAAoB,EACpB,MAAuB;EAEvB,OAAO;IAAE,MAAM;IAAe,IAAI;IAAM;EAAO;AACjD;AAEA,kDAAkD,GAClD,OAAO,SAAS,SACd,OAAgB,EAChB,KAAe,EACf,MAAuB;EAEvB,OAAO;IAAE,MAAM;IAAe,IAAI;IAAS,WAAW;IAAO;EAAO;AACtE;AAEA,8CAA8C,GAC9C,OAAO,SAAS,UACd,OAAgB,EAChB,SAAiB,EACjB,MAAuB;EAEvB,OAAO;IAAE,MAAM;IAAgB,IAAI;IAAS;IAAW;EAAO;AAChE;AAEA,6CAA6C,GAC7C,OAAO,SAAS,SACd,OAAgB,EAChB,MAAuB,EACvB,OAAgB;EAEhB,OAAO;IAAE,MAAM;IAAe,IAAI;IAAS;IAAQ;EAAQ;AAC7D;AAEA,wCAAwC,GACxC,OAAO,SAAS,UACd,OAAoB,EACpB,KAAa,EACb,QAA4C,EAC5C,OAA2C;EAE3C,OAAO;IAAE,MAAM;IAAS,IAAI;IAAS,MAAM;IAAO,SAAS;IAAU;EAAQ;AAC/E;AAEA,+CAA+C,GAC/C,OAAO,SAAS,WACd,OAAgB,EAChB,MAAuB,EACvB,SAA2B;EAE3B,OAAO;IAAE,MAAM;IAAiB,IAAI;IAAS;IAAQ;EAAU;AACjE;AAEA,4DAA4D,GAC5D,OAAO,SAAS,gBACd,MAAiB,EACjB,SAAoC,EACpC,YAA2B,EAC3B,WAA2B;EAE3B,OAAO;IAAE,MAAM;IAAe;IAAQ;IAAW;IAAc;EAAY;AAC7E;AAEA,oDAAoD,GACpD,OAAO,SAAS,SACd,MAAiB,EACjB,KAAgC,EAChC,UAAqD;EAErD,OAAO;IAAE,MAAM;IAAQ;IAAQ;IAAO;EAAW;AACnD;AAEA,kDAAkD,GAClD,OAAO,SAAS,eACd,OAAgB,EAChB,QAAgB,EAChB,KAAc;EAEd,OAAO;IAAE,MAAM;IAAe,IAAI;IAAS;IAAU;EAAM;AAC7D;AAEA,qDAAqD,GACrD,OAAO,SAAS,eACd,OAAgB,EAChB,QAAgB,EAChB,KAAc;EAEd,OAAO;IAAE,MAAM;IAAe,IAAI;IAAS;IAAU;EAAM;AAC7D;AAEA,0DAA0D,GAC1D,OAAO,SAAS,kBACd,OAAgB,EAChB,QAAgB,EAChB,KAAc;EAEd,OAAO;IAAE,MAAM;IAAkB,IAAI;IAAS;IAAU;EAAM;AAChE;AAEA,qDAAqD,GACrD,OAAO,SAAS,gBACd,OAAgB,EAChB,KAAsC;EAEtC,OAAO;IAAE,MAAM;IAAgB,IAAI;IAAS;EAAM;AACpD;AAEA,8CAA8C,GAC9C,OAAO,SAAS,QACd,OAAgB,EAChB,QAA+B;EAE/B,OAAO;IAAE,MAAM;IAAO,IAAI;IAAS;EAAS;AAC9C"}

package/src/csr.d.ts

@@ -6,8 +6,9 @@
  *
  * ADR-0109 Phase 1: split @openelement/core into static, hydrate, and csr.
  */ export * from "./static.js";
-export type { BindingDescriptor, BindingDispose, BindingLifecycle } from "./binding-descriptor.js";
-export { applyBindingDescriptor } from "./binding-activation.js";
+export type { BindingDescriptor, BindingDispose, BindingLifecycle, BindingRenderer } from "./binding-descriptor.js";
+export { bindAttr, bindClass, bindConditional, bindEvent, bindHtml, bindList, bindRef, bindRender, bindStaticAttr, bindStaticBoolean, bindStaticProp, bindStaticStyle, bindText } from "./binding-descriptor.js";
+export { applyBindingDescriptor, commitBindings, registerBindingKind } from "./binding-activation.js";
 export { applyProps, collectPropBindings, renderToDom } from "./jsx-render-dom.js";
 export { collectEventBindings, eventRecordsToDescriptors, hydrateEventMarkers } from "./event-hydration.js";
 export type { EventBinding, EventBindingRecord } from "./event-hydration.js";