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

package/src/csr.js

@@ -6,9 +6,10 @@
  *
  * ADR-0109 Phase 1: split @openelement/core into static, hydrate, and csr.
  */ export * from './static.js';
-export { applyBindingDescriptor } from './binding-activation.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';
 // Full DOM renderer
 export { applyProps, collectPropBindings, renderToDom } from './jsx-render-dom.js';
 // Event hydration (DOM-specific parts not already in static.ts)
 export { collectEventBindings, eventRecordsToDescriptors, hydrateEventMarkers } from './event-hydration.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vaG9tZS9ydW5uZXIvd29yay9vcGVuZWxlbWVudC9vcGVuZWxlbWVudC9wYWNrYWdlcy9jb3JlL3NyYy9jc3IudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAb3BlbmVsZW1lbnQvY29yZS9jc3IgLSBDbGllbnQtc2lkZSByZW5kZXJpbmcgcnVudGltZSBzdXJmYWNlLlxuICpcbiAqIEluY2x1ZGVzIHRoZSBzdGF0aWMgcmVuZGVyaW5nIHN1cmZhY2UgcGx1cyB0aGUgZnVsbCBET00gcmVuZGVyZXIgYW5kIGV2ZW50XG4gKiBoeWRyYXRpb24gaGVscGVycy4gVXNlZCBmb3IgQ1NSIGZhbGxiYWNrcyBhbmQgcHVyZSBpc2xhbmRzLlxuICpcbiAqIEFEUi0wMTA5IFBoYXNlIDE6IHNwbGl0IEBvcGVuZWxlbWVudC9jb3JlIGludG8gc3RhdGljLCBoeWRyYXRlLCBhbmQgY3NyLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vc3RhdGljLmpzJztcblxuLy8gQmluZGluZyBsYXllclxuZXhwb3J0IHR5cGUgeyBCaW5kaW5nRGVzY3JpcHRvciwgQmluZGluZ0Rpc3Bvc2UsIEJpbmRpbmdMaWZlY3ljbGUgfSBmcm9tICcuL2JpbmRpbmctZGVzY3JpcHRvci5qcyc7XG5leHBvcnQgeyBhcHBseUJpbmRpbmdEZXNjcmlwdG9yIH0gZnJvbSAnLi9iaW5kaW5nLWFjdGl2YXRpb24uanMnO1xuXG4vLyBGdWxsIERPTSByZW5kZXJlclxuZXhwb3J0IHsgYXBwbHlQcm9wcywgY29sbGVjdFByb3BCaW5kaW5ncywgcmVuZGVyVG9Eb20gfSBmcm9tICcuL2pzeC1yZW5kZXItZG9tLmpzJztcblxuLy8gRXZlbnQgaHlkcmF0aW9uIChET00tc3BlY2lmaWMgcGFydHMgbm90IGFscmVhZHkgaW4gc3RhdGljLnRzKVxuZXhwb3J0IHtcbiAgY29sbGVjdEV2ZW50QmluZGluZ3MsXG4gIGV2ZW50UmVjb3Jkc1RvRGVzY3JpcHRvcnMsXG4gIGh5ZHJhdGVFdmVudE1hcmtlcnMsXG59IGZyb20gJy4vZXZlbnQtaHlkcmF0aW9uLmpzJztcbmV4cG9ydCB0eXBlIHsgRXZlbnRCaW5kaW5nLCBFdmVudEJpbmRpbmdSZWNvcmQgfSBmcm9tICcuL2V2ZW50LWh5ZHJhdGlvbi5qcyc7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Q0FPQyxHQUVELGNBQWMsY0FBYztBQUk1QixTQUFTLHNCQUFzQixRQUFRLDBCQUEwQjtBQUVqRSxvQkFBb0I7QUFDcEIsU0FBUyxVQUFVLEVBQUUsbUJBQW1CLEVBQUUsV0FBVyxRQUFRLHNCQUFzQjtBQUVuRixnRUFBZ0U7QUFDaEUsU0FDRSxvQkFBb0IsRUFDcEIseUJBQXlCLEVBQ3pCLG1CQUFtQixRQUNkLHVCQUF1QiJ9
+//# sourceMappingURL=data:application/json;base64,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

package/src/event-hydration.js

@@ -10,6 +10,7 @@ import { isSignalLike } from '@openelement/signal';
 import { isComponentCtor, isVNode } from './vnode.js';
 import { DATA_EID } from '@openelement/protocol/hydration-markers';
 import { applyBindingDescriptor } from './binding-activation.js';
+import { bindEvent } from './binding-descriptor.js';
 import { eventMarkerId, eventTypeFromProp } from './event-marker.js';
 // Re-export pure marker helpers so existing consumers keep working.
 export { createEventMarkerContext, eventMarkerId, eventTypeFromProp, serializeEventMarkers } from './event-marker.js';
@@ -95,12 +96,7 @@ export function collectEventBindings(node) {
 export function eventRecordsToDescriptors(el, records, owner) {
   return records.map((record)=>{
     const handler = owner && typeof record.handler === 'function' ? record.handler.bind(owner) : record.handler;
-    return {
-      kind: 'event',
-      el,
-      type: record.type,
-      handler
-    };
+    return bindEvent(el, record.type, handler);
   });
 }
 export function hydrateEventMarkers(root, bindings, cleanupBag, owner) {
@@ -115,4 +111,4 @@ export function hydrateEventMarkers(root, bindings, cleanupBag, owner) {
     }
   }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/core/src/event-hydration.ts"],"sourcesContent":["/**\n * Marker-based event hydration for SSR VNode output.\n *\n * SSR emits deterministic `data-eid` markers. During DSD upgrade,\n * DsdElement renders the same VNode tree in memory, collects event handlers in\n * the same traversal order, and binds them to matching DOM markers without\n * replacing the existing DSD DOM.\n */\n\nimport { FOR_TAG, Fragment, SHOW_TAG } from './jsx-runtime.js';\nimport { isSignalLike } from '@openelement/signal';\nimport { isComponentCtor, isVNode } from './vnode.js';\nimport type { RenderFn, VNode } from '@openelement/protocol/vnode';\nimport { DATA_EID } from '@openelement/protocol/hydration-markers';\nimport { applyBindingDescriptor } from './binding-activation.js';\nimport type { EventBindingDescriptor } from './binding-descriptor.js';\nimport { eventMarkerId, eventTypeFromProp } from './event-marker.js';\n\n// Re-export pure marker helpers so existing consumers keep working.\nexport {\n  createEventMarkerContext,\n  eventMarkerId,\n  eventTypeFromProp,\n  serializeEventMarkers,\n} from './event-marker.js';\nexport type { EventMarkerContext } from './event-marker.js';\n\nexport interface EventBindingRecord {\n  id: string;\n  type: string;\n  handler: EventListener;\n}\n\n/** Hydration-time event binding contract (mirrors BindingDescriptor). */\nexport type EventBinding = EventBindingDescriptor;\n\nexport function collectEventBindings(node: unknown): Map<string, EventBindingRecord[]> {\n  const bindings = new Map<string, EventBindingRecord[]>();\n  let count = 0;\n\n  const visit = (value: unknown): void => {\n    if (\n      value == null || value === false || typeof value === 'string' || typeof value === 'number'\n    ) {\n      return;\n    }\n    if (isSignalLike(value)) {\n      visit((value as { value: unknown }).value);\n      return;\n    }\n    if (!isVNode(value)) return;\n\n    const { tag, props, children } = value as VNode;\n\n    if (\n      tag === Fragment ||\n      (typeof tag === 'symbol' && String(tag) === 'Symbol(openelement.fragment)')\n    ) {\n      for (const child of children) visit(child);\n      return;\n    }\n\n    if (tag === SHOW_TAG || tag === 'show') {\n      const whenVal = isSignalLike(props?.when)\n        ? (props!.when as { value: unknown }).value\n        : props?.when;\n      const target = whenVal ? children[0] : children[1];\n      visit(target);\n      return;\n    }\n\n    if (tag === FOR_TAG || tag === 'fore') {\n      const items = (isSignalLike(props?.each)\n        ? (props!.each as { value: unknown }).value\n        : props?.each) as unknown[];\n      const renderFn = children[0] as RenderFn;\n      if (Array.isArray(items) && typeof renderFn === 'function') {\n        items.forEach((item, i) =>\n          visit(renderFn(item, i))\n        );\n      }\n      return;\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        visit(instance.render());\n      } catch {\n        return;\n      }\n      return;\n    }\n\n    if (typeof tag === 'function') {\n      try {\n        visit((tag as (props: Record<string, unknown>) => unknown)({ ...props, children }));\n      } catch {\n        return;\n      }\n      return;\n    }\n\n    const records: EventBindingRecord[] = [];\n    for (const [key, value] of Object.entries(props ?? {})) {\n      const type = eventTypeFromProp(key);\n      if (type && typeof value === 'function') {\n        records.push({\n          id: '',\n          type,\n          handler: value as EventListener,\n        });\n      }\n    }\n\n    // Visit children before assigning an ID to this element so the order\n    // matches SSR (renderToNode serializes children first).\n    for (const child of children) visit(child);\n\n    if (records.length > 0) {\n      const id = eventMarkerId(count++);\n      bindings.set(id, records.map((record) => ({ ...record, id })));\n    }\n  };\n\n  visit(node);\n  return bindings;\n}\n\nexport function eventRecordsToDescriptors(\n  el: Element,\n  records: EventBindingRecord[],\n  owner?: unknown,\n): EventBinding[] {\n  return records.map((record) => {\n    const handler = owner && typeof record.handler === 'function'\n      ? (record.handler as EventListener).bind(owner)\n      : record.handler as EventListener;\n    return {\n      kind: 'event',\n      el,\n      type: record.type,\n      handler,\n    };\n  });\n}\n\nexport function hydrateEventMarkers(\n  root: Element | ShadowRoot,\n  bindings: Map<string, EventBindingRecord[]>,\n  cleanupBag: Array<() => void>,\n  owner?: unknown,\n): void {\n  for (const el of root.querySelectorAll(`[${DATA_EID}]`)) {\n    const id = el.getAttribute(DATA_EID);\n    if (!id) continue;\n    const records = bindings.get(id);\n    if (!records) continue;\n    for (const desc of eventRecordsToDescriptors(el, records, owner)) {\n      const dispose = applyBindingDescriptor(desc, {});\n      cleanupBag.push(dispose);\n    }\n  }\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/event-hydration.ts"],"sourcesContent":["/**\n * Marker-based event hydration for SSR VNode output.\n *\n * SSR emits deterministic `data-eid` markers. During DSD upgrade,\n * DsdElement renders the same VNode tree in memory, collects event handlers in\n * the same traversal order, and binds them to matching DOM markers without\n * replacing the existing DSD DOM.\n */\n\nimport { FOR_TAG, Fragment, SHOW_TAG } from './jsx-runtime.js';\nimport { isSignalLike } from '@openelement/signal';\nimport { isComponentCtor, isVNode } from './vnode.js';\nimport type { RenderFn, VNode } from '@openelement/protocol/vnode';\nimport { DATA_EID } from '@openelement/protocol/hydration-markers';\nimport { applyBindingDescriptor } from './binding-activation.js';\nimport { bindEvent } from './binding-descriptor.js';\nimport type { EventBindingDescriptor } from './binding-descriptor.js';\nimport { eventMarkerId, eventTypeFromProp } from './event-marker.js';\n\n// Re-export pure marker helpers so existing consumers keep working.\nexport {\n  createEventMarkerContext,\n  eventMarkerId,\n  eventTypeFromProp,\n  serializeEventMarkers,\n} from './event-marker.js';\nexport type { EventMarkerContext } from './event-marker.js';\n\nexport interface EventBindingRecord {\n  id: string;\n  type: string;\n  handler: EventListener;\n}\n\n/** Hydration-time event binding contract (mirrors BindingDescriptor). */\nexport type EventBinding = EventBindingDescriptor;\n\nexport function collectEventBindings(node: unknown): Map<string, EventBindingRecord[]> {\n  const bindings = new Map<string, EventBindingRecord[]>();\n  let count = 0;\n\n  const visit = (value: unknown): void => {\n    if (\n      value == null || value === false || typeof value === 'string' || typeof value === 'number'\n    ) {\n      return;\n    }\n    if (isSignalLike(value)) {\n      visit((value as { value: unknown }).value);\n      return;\n    }\n    if (!isVNode(value)) return;\n\n    const { tag, props, children } = value as VNode;\n\n    if (\n      tag === Fragment ||\n      (typeof tag === 'symbol' && String(tag) === 'Symbol(openelement.fragment)')\n    ) {\n      for (const child of children) visit(child);\n      return;\n    }\n\n    if (tag === SHOW_TAG || tag === 'show') {\n      const whenVal = isSignalLike(props?.when)\n        ? (props!.when as { value: unknown }).value\n        : props?.when;\n      const target = whenVal ? children[0] : children[1];\n      visit(target);\n      return;\n    }\n\n    if (tag === FOR_TAG || tag === 'fore') {\n      const items = (isSignalLike(props?.each)\n        ? (props!.each as { value: unknown }).value\n        : props?.each) as unknown[];\n      const renderFn = children[0] as RenderFn;\n      if (Array.isArray(items) && typeof renderFn === 'function') {\n        items.forEach((item, i) =>\n          visit(renderFn(item, i))\n        );\n      }\n      return;\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        visit(instance.render());\n      } catch {\n        return;\n      }\n      return;\n    }\n\n    if (typeof tag === 'function') {\n      try {\n        visit((tag as (props: Record<string, unknown>) => unknown)({ ...props, children }));\n      } catch {\n        return;\n      }\n      return;\n    }\n\n    const records: EventBindingRecord[] = [];\n    for (const [key, value] of Object.entries(props ?? {})) {\n      const type = eventTypeFromProp(key);\n      if (type && typeof value === 'function') {\n        records.push({\n          id: '',\n          type,\n          handler: value as EventListener,\n        });\n      }\n    }\n\n    // Visit children before assigning an ID to this element so the order\n    // matches SSR (renderToNode serializes children first).\n    for (const child of children) visit(child);\n\n    if (records.length > 0) {\n      const id = eventMarkerId(count++);\n      bindings.set(id, records.map((record) => ({ ...record, id })));\n    }\n  };\n\n  visit(node);\n  return bindings;\n}\n\nexport function eventRecordsToDescriptors(\n  el: Element,\n  records: EventBindingRecord[],\n  owner?: unknown,\n): EventBinding[] {\n  return records.map((record) => {\n    const handler = owner && typeof record.handler === 'function'\n      ? (record.handler as EventListener).bind(owner)\n      : record.handler as EventListener;\n    return bindEvent(el, record.type, handler);\n  });\n}\n\nexport function hydrateEventMarkers(\n  root: Element | ShadowRoot,\n  bindings: Map<string, EventBindingRecord[]>,\n  cleanupBag: Array<() => void>,\n  owner?: unknown,\n): void {\n  for (const el of root.querySelectorAll(`[${DATA_EID}]`)) {\n    const id = el.getAttribute(DATA_EID);\n    if (!id) continue;\n    const records = bindings.get(id);\n    if (!records) continue;\n    for (const desc of eventRecordsToDescriptors(el, records, owner)) {\n      const dispose = applyBindingDescriptor(desc, {});\n      cleanupBag.push(dispose);\n    }\n  }\n}\n"],"names":[],"mappings":"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"}

package/src/hydrate.d.ts

@@ -6,10 +6,12 @@
  *
  * 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 { HydrationScope } from "./hydration-scope.js";
+export type { HydrationScopeDebug, HydrationScopeOptions } from "./hydration-scope.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 { collectEventBindings, eventRecordsToDescriptors, hydrateEventMarkers } from "./event-hydration.js";
 export type { EventBinding, EventBindingRecord } from "./event-hydration.js";
 export { createDsdRenderRoot, hydrateDsdEvents } from "./dsd-hydration.js";
 export type { Constructor, DsdHydration } from "./dsd-hydration.js";
-export { bindHydrateEvents } from "./dsd-hydration-events.js";

package/src/hydrate.js

@@ -6,10 +6,12 @@
  *
  * ADR-0109 Phase 1: split @openelement/core into static, hydrate, and csr.
  */ export * from './static.js';
-export { applyBindingDescriptor } from './binding-activation.js';
+// Hydration scope
+export { HydrationScope } from './hydration-scope.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';
 // Marker-based event hydration (DOM-specific parts not in static.ts)
 export { collectEventBindings, eventRecordsToDescriptors, hydrateEventMarkers } from './event-hydration.js';
 // DSD hydration contract
 export { createDsdRenderRoot, hydrateDsdEvents } from './dsd-hydration.js';
-export { bindHydrateEvents } from './dsd-hydration-events.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vaG9tZS9ydW5uZXIvd29yay9vcGVuZWxlbWVudC9vcGVuZWxlbWVudC9wYWNrYWdlcy9jb3JlL3NyYy9oeWRyYXRlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQG9wZW5lbGVtZW50L2NvcmUvaHlkcmF0ZSAtIERTRCBpbnRlcmFjdGl2ZSBydW50aW1lIHN1cmZhY2UuXG4gKlxuICogSW5jbHVkZXMgdGhlIHN0YXRpYyByZW5kZXJpbmcgc3VyZmFjZSBwbHVzIG1hcmtlci1iYXNlZCBldmVudCBoeWRyYXRpb25cbiAqIGFuZCBEU0Qgc2hhZG93LXJvb3QgaHlkcmF0aW9uIGhlbHBlcnMuIFVzZWQgYnkgRFNEIGludGVyYWN0aXZlIGlzbGFuZHMuXG4gKlxuICogQURSLTAxMDkgUGhhc2UgMTogc3BsaXQgQG9wZW5lbGVtZW50L2NvcmUgaW50byBzdGF0aWMsIGh5ZHJhdGUsIGFuZCBjc3IuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9zdGF0aWMuanMnO1xuXG4vLyBCaW5kaW5nIGxheWVyXG5leHBvcnQgdHlwZSB7IEJpbmRpbmdEZXNjcmlwdG9yLCBCaW5kaW5nRGlzcG9zZSwgQmluZGluZ0xpZmVjeWNsZSB9IGZyb20gJy4vYmluZGluZy1kZXNjcmlwdG9yLmpzJztcbmV4cG9ydCB7IGFwcGx5QmluZGluZ0Rlc2NyaXB0b3IgfSBmcm9tICcuL2JpbmRpbmctYWN0aXZhdGlvbi5qcyc7XG5cbi8vIE1hcmtlci1iYXNlZCBldmVudCBoeWRyYXRpb24gKERPTS1zcGVjaWZpYyBwYXJ0cyBub3QgaW4gc3RhdGljLnRzKVxuZXhwb3J0IHtcbiAgY29sbGVjdEV2ZW50QmluZGluZ3MsXG4gIGV2ZW50UmVjb3Jkc1RvRGVzY3JpcHRvcnMsXG4gIGh5ZHJhdGVFdmVudE1hcmtlcnMsXG59IGZyb20gJy4vZXZlbnQtaHlkcmF0aW9uLmpzJztcbmV4cG9ydCB0eXBlIHsgRXZlbnRCaW5kaW5nLCBFdmVudEJpbmRpbmdSZWNvcmQgfSBmcm9tICcuL2V2ZW50LWh5ZHJhdGlvbi5qcyc7XG5cbi8vIERTRCBoeWRyYXRpb24gY29udHJhY3RcbmV4cG9ydCB7IGNyZWF0ZURzZFJlbmRlclJvb3QsIGh5ZHJhdGVEc2RFdmVudHMgfSBmcm9tICcuL2RzZC1oeWRyYXRpb24uanMnO1xuZXhwb3J0IHR5cGUgeyBDb25zdHJ1Y3RvciwgRHNkSHlkcmF0aW9uIH0gZnJvbSAnLi9kc2QtaHlkcmF0aW9uLmpzJztcbmV4cG9ydCB7IGJpbmRIeWRyYXRlRXZlbnRzIH0gZnJvbSAnLi9kc2QtaHlkcmF0aW9uLWV2ZW50cy5qcyc7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Q0FPQyxHQUVELGNBQWMsY0FBYztBQUk1QixTQUFTLHNCQUFzQixRQUFRLDBCQUEwQjtBQUVqRSxxRUFBcUU7QUFDckUsU0FDRSxvQkFBb0IsRUFDcEIseUJBQXlCLEVBQ3pCLG1CQUFtQixRQUNkLHVCQUF1QjtBQUc5Qix5QkFBeUI7QUFDekIsU0FBUyxtQkFBbUIsRUFBRSxnQkFBZ0IsUUFBUSxxQkFBcUI7QUFFM0UsU0FBUyxpQkFBaUIsUUFBUSw0QkFBNEIifQ==
+//# sourceMappingURL=data:application/json;base64,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

package/src/hydration-scope.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @openelement/core/hydrate - HydrationScope value object.
+ *
+ * Standalone container for the lifecycle state of a hydrated shadow root.
+ * Owns effect disposers, event cleanups, and the cached VNode used for
+ * declarative event marker binding. Designed to be usable without an
+ * OpenElement instance so third-party framework runtimes can hydrate the
+ * same DSD shadow root later.
+ *
+ * @module @openelement/core/hydrate
+ */ import type { Signal } from '@openelement/protocol/signal';
+import type { BindingLifecycle, BindingRenderer } from "./binding-descriptor.js";
+/** Options for creating a HydrationScope. */ export interface HydrationScopeOptions {
+  /** Signal registry used to resolve data-signal markers. */ signalRegistry?: Map<string, Signal<unknown>>;
+  /** Renderer used for signal-render and event-marker VNode rendering. */ renderer?: BindingRenderer;
+  /** Render function that produces the VNode used for event-marker hydration. */ render?: () => unknown;
+}
+/** Read-only observables exposed for debugging. */ export interface HydrationScopeDebug {
+  isActive: boolean;
+  effectCount: number;
+  eventCleanupCount: number;
+}
+/**
+ * Lifecycle scope for a hydrated shadow root.
+ *
+ * Keeps effect disposers, event listener cleanups, and the cached VNode in one
+ * place so they can be disposed as a unit. The scope does not depend on
+ * OpenElement; callers provide the signal registry and optional render function.
+ */ export declare class HydrationScope {
+  constructor(options?: HydrationScopeOptions);
+  /** Create a BindingLifecycle backed by this scope's effect disposers. */ createLifecycle(): BindingLifecycle;
+  /** Set the cached VNode for event-marker hydration. */ setCachedVNode(vnode: unknown): void;
+  /** Resolve data-signal markers in a shadow root and activate bindings. */ hydrate(shadowRoot: ShadowRoot, signalRegistry?: Map<string, Signal<unknown>>): void;
+  /** Dispose all effects and event listeners tracked by this scope. */ dispose(): void;
+  /**
+   * Clear effects and event listeners without deactivating the scope.
+   *
+   * Used before re-rendering or re-hydrating an existing shadow root so the
+   * scope can accept a fresh set of bindings. Does not gate on #active so
+   * that a disconnected-then-reconnected element can be re-hydrated.
+   */ reset(): void;
+  /** Debug observables for testing and devtools. */ get debug(): HydrationScopeDebug;
+}

package/src/hydration-scope.js

@@ -0,0 +1,160 @@
+/**
+ * @openelement/core/hydrate - HydrationScope value object.
+ *
+ * Standalone container for the lifecycle state of a hydrated shadow root.
+ * Owns effect disposers, event cleanups, and the cached VNode used for
+ * declarative event marker binding. Designed to be usable without an
+ * OpenElement instance so third-party framework runtimes can hydrate the
+ * same DSD shadow root later.
+ *
+ * @module @openelement/core/hydrate
+ */ import { applyBindingDescriptor } from './binding-activation.js';
+import { collectEventBindings, hydrateEventMarkers } from './event-hydration.js';
+import { renderToDom } from './jsx-render-dom.js';
+import { isVNode } from './vnode.js';
+import { bindAttr, bindClass, bindRender, bindText } from './binding-descriptor.js';
+import { DATA_SIGNAL, DATA_SIGNAL_ATTR, DATA_SIGNAL_CLASS, DATA_SIGNAL_RENDER, parseSignalAttrSpec } from '@openelement/protocol/hydration-markers';
+/** Collect binding descriptors from data-signal markers in a shadow root. */ function collectHydrationBindings(shadowRoot, signalRegistry, lifecycle) {
+  const descriptors = [];
+  for (const el of shadowRoot.querySelectorAll(`[${DATA_SIGNAL}]`)){
+    const name = el.getAttribute(DATA_SIGNAL);
+    if (!name) continue;
+    const sig = signalRegistry.get(name);
+    if (!sig) continue;
+    const hasClass = el.hasAttribute(DATA_SIGNAL_CLASS);
+    const hasAttr = el.hasAttribute(DATA_SIGNAL_ATTR);
+    if (hasClass) {
+      const className = el.getAttribute(DATA_SIGNAL_CLASS);
+      if (className) {
+        descriptors.push(bindClass(el, className, sig));
+      }
+    }
+    if (hasAttr) {
+      const attrSpec = el.getAttribute(DATA_SIGNAL_ATTR);
+      if (attrSpec) {
+        const attrNames = parseSignalAttrSpec(attrSpec);
+        if (attrNames.length > 0) {
+          descriptors.push(bindAttr(el, attrNames, sig));
+        }
+      }
+    }
+    if (!hasClass && !hasAttr) {
+      descriptors.push(bindText(el, sig));
+    }
+  }
+  for (const el of shadowRoot.querySelectorAll(`[${DATA_SIGNAL_RENDER}]`)){
+    const name = el.getAttribute(DATA_SIGNAL_RENDER);
+    if (!name) continue;
+    const sig = signalRegistry.get(name);
+    if (!sig) continue;
+    descriptors.push(bindRender(el, sig, lifecycle));
+  }
+  return descriptors;
+}
+/**
+ * Lifecycle scope for a hydrated shadow root.
+ *
+ * Keeps effect disposers, event listener cleanups, and the cached VNode in one
+ * place so they can be disposed as a unit. The scope does not depend on
+ * OpenElement; callers provide the signal registry and optional render function.
+ */ export class HydrationScope {
+  #effectDisposers = new Set();
+  #eventCleanups = [];
+  #signalRegistry;
+  #renderer;
+  #render;
+  #cachedVNode = undefined;
+  #cacheValid = false;
+  #active = true;
+  constructor(options = {}){
+    this.#signalRegistry = options.signalRegistry ?? new Map();
+    this.#renderer = options.renderer ?? {
+      render: (node, lifecycle)=>renderToDom(node, lifecycle)
+    };
+    this.#render = options.render;
+  }
+  /** Create a BindingLifecycle backed by this scope's effect disposers. */ createLifecycle() {
+    return {
+      disposers: this.#effectDisposers
+    };
+  }
+  /** Set the cached VNode for event-marker hydration. */ setCachedVNode(vnode) {
+    this.#cachedVNode = vnode;
+    this.#cacheValid = true;
+  }
+  /** Resolve data-signal markers in a shadow root and activate bindings. */ hydrate(shadowRoot, signalRegistry) {
+    if (!this.#active) return;
+    const registry = signalRegistry ?? this.#signalRegistry;
+    const lifecycle = {
+      disposers: this.#effectDisposers
+    };
+    const descriptors = collectHydrationBindings(shadowRoot, registry, lifecycle);
+    for (const desc of descriptors){
+      if (desc.kind === 'signal-render') {
+        // Preserve the original DSD hydration contract: replace any SSR content
+        // with the client-rendered VNode tree on first activation.
+        while(desc.el.firstChild)desc.el.removeChild(desc.el.firstChild);
+      }
+      applyBindingDescriptor(desc, lifecycle, this.#renderer);
+    }
+    // Bind declarative event markers from the cached or freshly-rendered VNode.
+    const vnode = this.#resolveVNode();
+    if (isVNode(vnode)) {
+      const eventBindings = collectEventBindings(vnode);
+      hydrateEventMarkers(shadowRoot, eventBindings, this.#eventCleanups, shadowRoot.host ?? undefined);
+    }
+    // Chromium DSD layout fix: force reflow without DOM rebuild.
+    requestAnimationFrame(()=>{
+      void shadowRoot.host?.offsetHeight;
+    });
+  }
+  /** Dispose all effects and event listeners tracked by this scope. */ dispose() {
+    if (!this.#active) return;
+    this.#active = false;
+    this.#clearBindings();
+  }
+  /**
+   * Clear effects and event listeners without deactivating the scope.
+   *
+   * Used before re-rendering or re-hydrating an existing shadow root so the
+   * scope can accept a fresh set of bindings. Does not gate on #active so
+   * that a disconnected-then-reconnected element can be re-hydrated.
+   */ reset() {
+    this.#clearBindings();
+    this.#active = true;
+  }
+  #clearBindings() {
+    for (const d of this.#effectDisposers){
+      try {
+        d();
+      } catch  {}
+    }
+    this.#effectDisposers.clear();
+    for (const f of this.#eventCleanups){
+      try {
+        f();
+      } catch  {}
+    }
+    this.#eventCleanups = [];
+    this.#cachedVNode = undefined;
+    this.#cacheValid = false;
+  }
+  /** Debug observables for testing and devtools. */ get debug() {
+    return {
+      isActive: this.#active,
+      effectCount: this.#effectDisposers.size,
+      eventCleanupCount: this.#eventCleanups.length
+    };
+  }
+  #resolveVNode() {
+    if (this.#cacheValid) return this.#cachedVNode;
+    if (this.#render) {
+      const vnode = this.#render();
+      this.#cachedVNode = vnode;
+      this.#cacheValid = true;
+      return vnode;
+    }
+    return undefined;
+  }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/core/src/hydration-scope.ts"],"sourcesContent":["/**\n * @openelement/core/hydrate - HydrationScope value object.\n *\n * Standalone container for the lifecycle state of a hydrated shadow root.\n * Owns effect disposers, event cleanups, and the cached VNode used for\n * declarative event marker binding. Designed to be usable without an\n * OpenElement instance so third-party framework runtimes can hydrate the\n * same DSD shadow root later.\n *\n * @module @openelement/core/hydrate\n */\n\nimport type { Signal } from '@openelement/protocol/signal';\nimport { applyBindingDescriptor } from './binding-activation.js';\nimport { collectEventBindings, hydrateEventMarkers } from './event-hydration.js';\nimport { renderToDom } from './jsx-render-dom.js';\nimport { isVNode } from './vnode.js';\nimport { bindAttr, bindClass, bindRender, bindText } from './binding-descriptor.js';\nimport type { BindingDescriptor, BindingLifecycle, BindingRenderer } from './binding-descriptor.js';\nimport {\n  DATA_SIGNAL,\n  DATA_SIGNAL_ATTR,\n  DATA_SIGNAL_CLASS,\n  DATA_SIGNAL_RENDER,\n  parseSignalAttrSpec,\n} from '@openelement/protocol/hydration-markers';\n\n/** Options for creating a HydrationScope. */\nexport interface HydrationScopeOptions {\n  /** Signal registry used to resolve data-signal markers. */\n  signalRegistry?: Map<string, Signal<unknown>>;\n  /** Renderer used for signal-render and event-marker VNode rendering. */\n  renderer?: BindingRenderer;\n  /** Render function that produces the VNode used for event-marker hydration. */\n  render?: () => unknown;\n}\n\n/** Read-only observables exposed for debugging. */\nexport interface HydrationScopeDebug {\n  isActive: boolean;\n  effectCount: number;\n  eventCleanupCount: number;\n}\n\n/** Collect binding descriptors from data-signal markers in a shadow root. */\nfunction collectHydrationBindings(\n  shadowRoot: ShadowRoot,\n  signalRegistry: Map<string, Signal<unknown>>,\n  lifecycle: BindingLifecycle,\n): BindingDescriptor[] {\n  const descriptors: BindingDescriptor[] = [];\n\n  for (const el of shadowRoot.querySelectorAll(`[${DATA_SIGNAL}]`)) {\n    const name = el.getAttribute(DATA_SIGNAL);\n    if (!name) continue;\n    const sig = signalRegistry.get(name);\n    if (!sig) continue;\n\n    const hasClass = el.hasAttribute(DATA_SIGNAL_CLASS);\n    const hasAttr = el.hasAttribute(DATA_SIGNAL_ATTR);\n\n    if (hasClass) {\n      const className = el.getAttribute(DATA_SIGNAL_CLASS);\n      if (className) {\n        descriptors.push(bindClass(el, className, sig));\n      }\n    }\n\n    if (hasAttr) {\n      const attrSpec = el.getAttribute(DATA_SIGNAL_ATTR);\n      if (attrSpec) {\n        const attrNames = parseSignalAttrSpec(attrSpec);\n        if (attrNames.length > 0) {\n          descriptors.push(bindAttr(el, attrNames, sig));\n        }\n      }\n    }\n\n    if (!hasClass && !hasAttr) {\n      descriptors.push(bindText(el, sig));\n    }\n  }\n\n  for (const el of shadowRoot.querySelectorAll(`[${DATA_SIGNAL_RENDER}]`)) {\n    const name = el.getAttribute(DATA_SIGNAL_RENDER);\n    if (!name) continue;\n    const sig = signalRegistry.get(name);\n    if (!sig) continue;\n\n    descriptors.push(bindRender(el, sig, lifecycle));\n  }\n\n  return descriptors;\n}\n\n/**\n * Lifecycle scope for a hydrated shadow root.\n *\n * Keeps effect disposers, event listener cleanups, and the cached VNode in one\n * place so they can be disposed as a unit. The scope does not depend on\n * OpenElement; callers provide the signal registry and optional render function.\n */\nexport class HydrationScope {\n  #effectDisposers: Set<() => void> = new Set();\n  #eventCleanups: Array<() => void> = [];\n  #signalRegistry: Map<string, Signal<unknown>>;\n  #renderer: BindingRenderer;\n  #render?: () => unknown;\n  #cachedVNode: unknown = undefined;\n  #cacheValid = false;\n  #active = true;\n\n  constructor(options: HydrationScopeOptions = {}) {\n    this.#signalRegistry = options.signalRegistry ?? new Map();\n    this.#renderer = options.renderer ?? {\n      render: (node, lifecycle) => renderToDom(node, lifecycle),\n    };\n    this.#render = options.render;\n  }\n\n  /** Create a BindingLifecycle backed by this scope's effect disposers. */\n  createLifecycle(): BindingLifecycle {\n    return { disposers: this.#effectDisposers };\n  }\n\n  /** Set the cached VNode for event-marker hydration. */\n  setCachedVNode(vnode: unknown): void {\n    this.#cachedVNode = vnode;\n    this.#cacheValid = true;\n  }\n\n  /** Resolve data-signal markers in a shadow root and activate bindings. */\n  hydrate(shadowRoot: ShadowRoot, signalRegistry?: Map<string, Signal<unknown>>): void {\n    if (!this.#active) return;\n\n    const registry = signalRegistry ?? this.#signalRegistry;\n    const lifecycle: BindingLifecycle = { disposers: this.#effectDisposers };\n    const descriptors = collectHydrationBindings(shadowRoot, registry, lifecycle);\n\n    for (const desc of descriptors) {\n      if (desc.kind === 'signal-render') {\n        // Preserve the original DSD hydration contract: replace any SSR content\n        // with the client-rendered VNode tree on first activation.\n        while (desc.el.firstChild) desc.el.removeChild(desc.el.firstChild);\n      }\n      applyBindingDescriptor(desc, lifecycle, this.#renderer);\n    }\n\n    // Bind declarative event markers from the cached or freshly-rendered VNode.\n    const vnode = this.#resolveVNode();\n    if (isVNode(vnode)) {\n      const eventBindings = collectEventBindings(vnode);\n      hydrateEventMarkers(\n        shadowRoot,\n        eventBindings,\n        this.#eventCleanups,\n        shadowRoot.host ?? undefined,\n      );\n    }\n\n    // Chromium DSD layout fix: force reflow without DOM rebuild.\n    requestAnimationFrame(() => {\n      void (shadowRoot.host as HTMLElement | undefined)?.offsetHeight;\n    });\n  }\n\n  /** Dispose all effects and event listeners tracked by this scope. */\n  dispose(): void {\n    if (!this.#active) return;\n    this.#active = false;\n\n    this.#clearBindings();\n  }\n\n  /**\n   * Clear effects and event listeners without deactivating the scope.\n   *\n   * Used before re-rendering or re-hydrating an existing shadow root so the\n   * scope can accept a fresh set of bindings. Does not gate on #active so\n   * that a disconnected-then-reconnected element can be re-hydrated.\n   */\n  reset(): void {\n    this.#clearBindings();\n    this.#active = true;\n  }\n\n  #clearBindings(): void {\n    for (const d of this.#effectDisposers) {\n      try {\n        d();\n      } catch { /* ignore dispose errors */ }\n    }\n    this.#effectDisposers.clear();\n\n    for (const f of this.#eventCleanups) {\n      try {\n        f();\n      } catch { /* ignore cleanup errors */ }\n    }\n    this.#eventCleanups = [];\n\n    this.#cachedVNode = undefined;\n    this.#cacheValid = false;\n  }\n\n  /** Debug observables for testing and devtools. */\n  get debug(): HydrationScopeDebug {\n    return {\n      isActive: this.#active,\n      effectCount: this.#effectDisposers.size,\n      eventCleanupCount: this.#eventCleanups.length,\n    };\n  }\n\n  #resolveVNode(): unknown {\n    if (this.#cacheValid) return this.#cachedVNode;\n    if (this.#render) {\n      const vnode = this.#render();\n      this.#cachedVNode = vnode;\n      this.#cacheValid = true;\n      return vnode;\n    }\n    return undefined;\n  }\n}\n"],"names":[],"mappings":"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"}

package/src/index.d.ts

@@ -11,7 +11,7 @@
  * Islands: Custom Element registration + prop deserialization
  *
  * Build orchestration (Vite plugins) lives in @openelement/adapter-vite.
- * For the unified openElement() entry, use @openelement/app/vite instead.
+ * For the unified openElement() entry, use @openelement/adapter-vite.
  */ export type { AppShellConfig, AppShellDefinition, ComponentLayer, FrameworkOptions, HydrateEventDescriptor, HydrationStrategy, IsrManifestEntry, LayoutsConfig, LocalePath, OpenElementApiContext, OpenElementBuildContextLike, OpenElementMiddleware, OpenElementMiddlewareContext, OpenElementRenderer, RegistryIndex, RegistryIndexEntry, RouteEntry, SafeHtml, SpecialFileType, StrategySource, UnsafeHtml, ValidationError, ValidationResult, ValidationWarning } from '@openelement/protocol/framework';
 export type { IslandDescriptor, SsrContext } from '@openelement/protocol/context';
 export { ERROR_PREFIX, ErrorCode, OpenElementError, PropValidationError, RenderError, reportError, setErrorTelemetryHook, SsrRenderError } from "./errors.js";
@@ -30,22 +30,22 @@ export { createRenderDsdStreamMetrics, renderDsd, renderDsdStream } from "./rend
 export type { RenderDsdOptions } from "./render-dsd.js";
 export type { RenderDsdStreamChunk, RenderDsdStreamComponent, RenderDsdStreamMetrics, RenderDsdStreamOptions } from "./render-dsd-stream.js";
 export { camelToKebab, serializeAttrs } from "./render-ir.js";
-export type { DomSimulationAttempt, DomSimulationReport, DsdBuildReport, DsdComponent, DsdComponentConstructor, DsdHydrationHintSummary, DsdHydrationStrategySummary, DsdMetricsSummary, DsdOptions, DsdPageDiagnostics, DsdRenderMetrics, HydrationHint, IsrRouteRecord, ManifestDecision, RendererProtocol, RenderErrorCode, RenderHooks, RenderInput, RenderOutput, RenderPhase, SsrAdmissionDecision } from '@openelement/protocol/render';
-export type { OpenElementAttribute, OpenElementCssPart, OpenElementCssProperty, OpenElementDeclaration, OpenElementEvent, OpenElementExport, OpenElementExtensions, OpenElementMember, OpenElementModule, OpenElementPackageExtensions, OpenElementPackageManifest, OpenElementSlot } from '@openelement/protocol/manifest';
-export type { CemCompatibilityReport, CompatibilityClassification, CompatibilityTier, ManifestValidationReport, ValidatedTag, ValidationDiagnostic } from '@openelement/protocol/manifest';
+export type { DomSimulationAttempt, DomSimulationReport, DsdBuildReport, DsdComponent, DsdComponentConstructor, DsdHydrationHintSummary, DsdHydrationStrategySummary, DsdMetricsSummary, DsdOptions, DsdPageDiagnostics, DsdRenderMetrics, HydrationHint, IsrRouteRecord, ManifestDecision, RenderErrorCode, RenderHooks, RenderInput, RenderOutput, RenderPhase, SsrAdmissionDecision } from '@openelement/protocol/render';
+export type { OpenElementAttribute, OpenElementCssPart, OpenElementDeclaration, OpenElementEvent, OpenElementExport, OpenElementExtensions, OpenElementModule, OpenElementPackageManifest, OpenElementSlot } from '@openelement/protocol/manifest';
+export type { CemCompatibilityReport, CompatibilityClassification, CompatibilityTier } from '@openelement/protocol/manifest';
 export { escapeAttr, escapeAttrValue, escapeHtml } from "./html-escape.js";
 export { isSignalLike, unwrapSignalLike } from '@openelement/signal';
 export type { SignalLike, Unsubscribe } from '@openelement/protocol/signal';
 export { consumeContext, type Context, createContext, provideContext } from "./signal-context.js";
 export { createLogger } from "./logger.js";
-/** @internal — use @openelement/core/security subpath */ export { DANGEROUS_KEYS } from "./security.js";
 export { isValidTagName } from "./tag-utils.js";
 export { bindSsrProps, defineCustomElement, defineIsland, getIslandMeta, getSsrProps } from "./island.js";
 export type { IslandMeta, IslandOptions } from '@openelement/protocol/island';
 export { transformIslandSource } from "./island-transform.js";
 export type { IslandTransformOptions, IslandTransformResult } from '@openelement/protocol/island';
-export { applyBindingDescriptor } from "./binding-activation.js";
-export type { BindingDescriptor, BindingDispose, BindingLifecycle } from "./binding-descriptor.js";
+export { applyBindingDescriptor, commitBindings, registerBindingKind } from "./binding-activation.js";
+export { bindAttr, bindClass, bindConditional, bindEvent, bindHtml, bindList, bindRef, bindRender, bindStaticAttr, bindStaticBoolean, bindStaticProp, bindStaticStyle, bindText } from "./binding-descriptor.js";
+export type { BindingDescriptor, BindingDispose, BindingLifecycle, BindingRenderer } from "./binding-descriptor.js";
 export type { Action, ActionContext, DataAdapter, Loader, LoaderContext } from '@openelement/protocol/data';
 export { clear as clearRegistry, generateIndex, getAll as getAllManifests, getByTagName, register as registerManifest, validate as validateManifest } from "./registry.js";
 export type { VNode } from '@openelement/protocol/vnode';

package/src/index.js

@@ -11,7 +11,7 @@
  * Islands: Custom Element registration + prop deserialization
  *
  * Build orchestration (Vite plugins) lives in @openelement/adapter-vite.
- * For the unified openElement() entry, use @openelement/app/vite instead.
+ * For the unified openElement() entry, use @openelement/adapter-vite.
  */ // --- Public API re-exports -----------------------------------------
 export { ERROR_PREFIX, ErrorCode, OpenElementError, PropValidationError, RenderError, reportError, setErrorTelemetryHook, SsrRenderError } from './errors.js';
 export { createSsrContext, extractParams, parseQuery } from './context.js';
@@ -27,12 +27,12 @@ export { // v0.24.3: Neutral signal utilities — no template dependency
 isSignalLike, unwrapSignalLike } from '@openelement/signal';
 export { consumeContext, createContext, provideContext } from './signal-context.js';
 export { createLogger } from './logger.js';
-/** @internal — use @openelement/core/security subpath */ export { DANGEROUS_KEYS } from './security.js';
 export { isValidTagName } from './tag-utils.js';
 export { bindSsrProps, defineCustomElement, defineIsland, getIslandMeta, getSsrProps } from './island.js';
 export { transformIslandSource } from './island-transform.js';
 // Unified binding layer (ADR-0109 Phase 1)
-export { applyBindingDescriptor } from './binding-activation.js';
+export { applyBindingDescriptor, commitBindings, registerBindingKind } from './binding-activation.js';
+export { bindAttr, bindClass, bindConditional, bindEvent, bindHtml, bindList, bindRef, bindRender, bindStaticAttr, bindStaticBoolean, bindStaticProp, bindStaticStyle, bindText } from './binding-descriptor.js';
 // WC Package Protocol (v0.17+)
 export { clear as clearRegistry, generateIndex, getAll as getAllManifests, getByTagName, register as registerManifest, validate as validateManifest } from './registry.js';
 export { isVNode } from './vnode.js';
@@ -43,4 +43,4 @@ export { renderDsdTree } from './render-ir.js';
 export { collectEventBindings, createEventMarkerContext, eventMarkerId, eventTypeFromProp, hydrateEventMarkers, serializeEventMarkers } from './event-hydration.js';
 // static props runtime + Signal unwrap
 export { disposeStaticProps, handleStaticPropAttributeChange, initializeStaticProps, registerStaticObservedAttributes, syncStaticPropsFromAttributes, unwrap } from './prop.js';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/core/src/index.ts"],"sourcesContent":["/**\n * @openelement/core - Pure runtime.\n *\n * openElement is a static-first framework with a pure runtime core:\n * - Zero node:* imports - no filesystem, no process, no path\n * - Zero Vite dependency - no Plugin, no build orchestration\n * - Zero npm: specifiers - works in Deno, Node, Bun, Edge\n * - Pure Web Standard: URL, fetch, import.meta.url, console\n *\n * Rendering: DSD (Declarative Shadow DOM) string concatenation\n * Islands: Custom Element registration + prop deserialization\n *\n * Build orchestration (Vite plugins) lives in @openelement/adapter-vite.\n * For the unified openElement() entry, use @openelement/app/vite instead.\n */\n\n// --- Public API re-exports -----------------------------------------\n\nexport type {\n  AppShellConfig,\n  AppShellDefinition,\n  ComponentLayer,\n  FrameworkOptions,\n  HydrateEventDescriptor,\n  HydrationStrategy,\n  IsrManifestEntry,\n  LayoutsConfig,\n  LocalePath,\n  OpenElementApiContext,\n  OpenElementBuildContextLike,\n  OpenElementMiddleware,\n  OpenElementMiddlewareContext,\n  OpenElementRenderer,\n  RegistryIndex,\n  RegistryIndexEntry,\n  RouteEntry,\n  SafeHtml,\n  SpecialFileType,\n  StrategySource,\n  UnsafeHtml,\n  ValidationError,\n  ValidationResult,\n  ValidationWarning,\n} from '@openelement/protocol/framework';\nexport type { IslandDescriptor, SsrContext } from '@openelement/protocol/context';\n\nexport {\n  ERROR_PREFIX,\n  ErrorCode,\n  OpenElementError,\n  PropValidationError,\n  RenderError,\n  reportError,\n  setErrorTelemetryHook,\n  SsrRenderError,\n} from './errors.js';\nexport type { ErrorPhase, ErrorSeverity, ErrorTelemetryHook } from '@openelement/protocol/errors';\nexport { createSsrContext, extractParams, parseQuery } from './context.js';\nexport { renderSsrError, wrapInDocument } from './html-escape.js';\nexport { createIsrCacheKey, isIsrRouteConfig, MemoryIsrCache } from './isr.js';\nexport type {\n  CacheAdapter,\n  CacheEntry,\n  IsrCacheEntry,\n  IsrCacheResult,\n  IsrCacheState,\n  IsrRouteConfig,\n} from '@openelement/protocol/isr';\nexport { findIsrManifestEntry, renderIsrResponse } from './isr-runtime.js';\nexport type {\n  IsrRuntimeOptions,\n  IsrRuntimeRenderContext,\n  IsrRuntimeRenderResult,\n  IsrRuntimeResult,\n  IsrRuntimeState,\n} from './isr-runtime.js';\nexport { StyleSheet } from './style-sheet.js';\nexport type { StyleSheetLike, StyleSheetRule } from '@openelement/protocol/style-sheet';\nexport { bindHydrateEvents } from './dsd-hydration-events.js';\nexport type { Constructor, DsdHydration } from './dsd-hydration.js';\nexport { createRenderDsdStreamMetrics, renderDsd, renderDsdStream } from './render-dsd.js';\nexport type { RenderDsdOptions } from './render-dsd.js';\nexport type {\n  RenderDsdStreamChunk,\n  RenderDsdStreamComponent,\n  RenderDsdStreamMetrics,\n  RenderDsdStreamOptions,\n} from './render-dsd-stream.js';\nexport { camelToKebab, serializeAttrs } from './render-ir.js';\nexport type {\n  DomSimulationAttempt,\n  DomSimulationReport,\n  DsdBuildReport,\n  DsdComponent,\n  DsdComponentConstructor,\n  DsdHydrationHintSummary,\n  DsdHydrationStrategySummary,\n  DsdMetricsSummary,\n  DsdOptions,\n  DsdPageDiagnostics,\n  DsdRenderMetrics,\n  HydrationHint,\n  IsrRouteRecord,\n  ManifestDecision,\n  RendererProtocol,\n  RenderErrorCode,\n  RenderHooks,\n  RenderInput,\n  RenderOutput,\n  RenderPhase,\n  SsrAdmissionDecision,\n} from '@openelement/protocol/render';\nexport type {\n  OpenElementAttribute,\n  OpenElementCssPart,\n  OpenElementCssProperty,\n  OpenElementDeclaration,\n  OpenElementEvent,\n  OpenElementExport,\n  OpenElementExtensions,\n  OpenElementMember,\n  OpenElementModule,\n  OpenElementPackageExtensions,\n  OpenElementPackageManifest,\n  OpenElementSlot,\n} from '@openelement/protocol/manifest';\nexport type {\n  CemCompatibilityReport,\n  CompatibilityClassification,\n  CompatibilityTier,\n  ManifestValidationReport,\n  ValidatedTag,\n  ValidationDiagnostic,\n} from '@openelement/protocol/manifest';\nexport { escapeAttr, escapeAttrValue, escapeHtml } from './html-escape.js';\nexport {\n  // v0.24.3: Neutral signal utilities — no template dependency\n  isSignalLike,\n  unwrapSignalLike,\n} from '@openelement/signal';\nexport type { SignalLike, Unsubscribe } from '@openelement/protocol/signal';\nexport { consumeContext, type Context, createContext, provideContext } from './signal-context.js';\nexport { createLogger } from './logger.js';\n/** @internal — use @openelement/core/security subpath */\nexport { DANGEROUS_KEYS } from './security.js';\nexport { isValidTagName } from './tag-utils.js';\nexport {\n  bindSsrProps,\n  defineCustomElement,\n  defineIsland,\n  getIslandMeta,\n  getSsrProps,\n} from './island.js';\nexport type { IslandMeta, IslandOptions } from '@openelement/protocol/island';\nexport { transformIslandSource } from './island-transform.js';\nexport type { IslandTransformOptions, IslandTransformResult } from '@openelement/protocol/island';\n\n// Unified binding layer (ADR-0109 Phase 1)\nexport { applyBindingDescriptor } from './binding-activation.js';\nexport type { BindingDescriptor, BindingDispose, BindingLifecycle } from './binding-descriptor.js';\n\n// Data adapters — type contract surface only (ADR-0095)\nexport type {\n  Action,\n  ActionContext,\n  DataAdapter,\n  Loader,\n  LoaderContext,\n} from '@openelement/protocol/data';\n\n// WC Package Protocol (v0.17+)\nexport {\n  clear as clearRegistry,\n  generateIndex,\n  getAll as getAllManifests,\n  getByTagName,\n  register as registerManifest,\n  validate as validateManifest,\n} from './registry.js';\n// v0.24.1 (ADR-0057): JSX + Signal component model\n// VNode & jsx-runtime\nexport type { VNode } from '@openelement/protocol/vnode';\nexport { isVNode } from './vnode.js';\nexport { Fragment, trustedHtml } from './jsx-runtime.js';\n// Renderers\nexport { renderToDom } from './jsx-render-dom.js';\nexport { renderDsdTree } from './render-ir.js';\nexport {\n  collectEventBindings,\n  createEventMarkerContext,\n  type EventBindingRecord,\n  type EventMarkerContext,\n  eventMarkerId,\n  eventTypeFromProp,\n  hydrateEventMarkers,\n  serializeEventMarkers,\n} from './event-hydration.js';\n// static props runtime + Signal unwrap\nexport {\n  disposeStaticProps,\n  handleStaticPropAttributeChange,\n  initializeStaticProps,\n  registerStaticObservedAttributes,\n  syncStaticPropsFromAttributes,\n  unwrap,\n} from './prop.js';\nexport type {\n  NormalizedPropDecl,\n  PropDecl,\n  PropDeclFull,\n  PropDeclShorthand,\n  PropsFrom,\n  PropType,\n} from '@openelement/protocol/prop';\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;CAcC,GAED,sEAAsE;AA8BtE,SACE,YAAY,EACZ,SAAS,EACT,gBAAgB,EAChB,mBAAmB,EACnB,WAAW,EACX,WAAW,EACX,qBAAqB,EACrB,cAAc,QACT,cAAc;AAErB,SAAS,gBAAgB,EAAE,aAAa,EAAE,UAAU,QAAQ,eAAe;AAC3E,SAAS,cAAc,EAAE,cAAc,QAAQ,mBAAmB;AAClE,SAAS,iBAAiB,EAAE,gBAAgB,EAAE,cAAc,QAAQ,WAAW;AAS/E,SAAS,oBAAoB,EAAE,iBAAiB,QAAQ,mBAAmB;AAQ3E,SAAS,UAAU,QAAQ,mBAAmB;AAE9C,SAAS,iBAAiB,QAAQ,4BAA4B;AAE9D,SAAS,4BAA4B,EAAE,SAAS,EAAE,eAAe,QAAQ,kBAAkB;AAQ3F,SAAS,YAAY,EAAE,cAAc,QAAQ,iBAAiB;AA8C9D,SAAS,UAAU,EAAE,eAAe,EAAE,UAAU,QAAQ,mBAAmB;AAC3E,SACE,6DAA6D;AAC7D,YAAY,EACZ,gBAAgB,QACX,sBAAsB;AAE7B,SAAS,cAAc,EAAgB,aAAa,EAAE,cAAc,QAAQ,sBAAsB;AAClG,SAAS,YAAY,QAAQ,cAAc;AAC3C,uDAAuD,GACvD,SAAS,cAAc,QAAQ,gBAAgB;AAC/C,SAAS,cAAc,QAAQ,iBAAiB;AAChD,SACE,YAAY,EACZ,mBAAmB,EACnB,YAAY,EACZ,aAAa,EACb,WAAW,QACN,cAAc;AAErB,SAAS,qBAAqB,QAAQ,wBAAwB;AAG9D,2CAA2C;AAC3C,SAAS,sBAAsB,QAAQ,0BAA0B;AAYjE,+BAA+B;AAC/B,SACE,SAAS,aAAa,EACtB,aAAa,EACb,UAAU,eAAe,EACzB,YAAY,EACZ,YAAY,gBAAgB,EAC5B,YAAY,gBAAgB,QACvB,gBAAgB;AAIvB,SAAS,OAAO,QAAQ,aAAa;AACrC,SAAS,QAAQ,EAAE,WAAW,QAAQ,mBAAmB;AACzD,YAAY;AACZ,SAAS,WAAW,QAAQ,sBAAsB;AAClD,SAAS,aAAa,QAAQ,iBAAiB;AAC/C,SACE,oBAAoB,EACpB,wBAAwB,EAGxB,aAAa,EACb,iBAAiB,EACjB,mBAAmB,EACnB,qBAAqB,QAChB,uBAAuB;AAC9B,uCAAuC;AACvC,SACE,kBAAkB,EAClB,+BAA+B,EAC/B,qBAAqB,EACrB,gCAAgC,EAChC,6BAA6B,EAC7B,MAAM,QACD,YAAY"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/core/src/index.ts"],"sourcesContent":["/**\n * @openelement/core - Pure runtime.\n *\n * openElement is a static-first framework with a pure runtime core:\n * - Zero node:* imports - no filesystem, no process, no path\n * - Zero Vite dependency - no Plugin, no build orchestration\n * - Zero npm: specifiers - works in Deno, Node, Bun, Edge\n * - Pure Web Standard: URL, fetch, import.meta.url, console\n *\n * Rendering: DSD (Declarative Shadow DOM) string concatenation\n * Islands: Custom Element registration + prop deserialization\n *\n * Build orchestration (Vite plugins) lives in @openelement/adapter-vite.\n * For the unified openElement() entry, use @openelement/adapter-vite.\n */\n\n// --- Public API re-exports -----------------------------------------\n\nexport type {\n  AppShellConfig,\n  AppShellDefinition,\n  ComponentLayer,\n  FrameworkOptions,\n  HydrateEventDescriptor,\n  HydrationStrategy,\n  IsrManifestEntry,\n  LayoutsConfig,\n  LocalePath,\n  OpenElementApiContext,\n  OpenElementBuildContextLike,\n  OpenElementMiddleware,\n  OpenElementMiddlewareContext,\n  OpenElementRenderer,\n  RegistryIndex,\n  RegistryIndexEntry,\n  RouteEntry,\n  SafeHtml,\n  SpecialFileType,\n  StrategySource,\n  UnsafeHtml,\n  ValidationError,\n  ValidationResult,\n  ValidationWarning,\n} from '@openelement/protocol/framework';\nexport type { IslandDescriptor, SsrContext } from '@openelement/protocol/context';\n\nexport {\n  ERROR_PREFIX,\n  ErrorCode,\n  OpenElementError,\n  PropValidationError,\n  RenderError,\n  reportError,\n  setErrorTelemetryHook,\n  SsrRenderError,\n} from './errors.js';\nexport type { ErrorPhase, ErrorSeverity, ErrorTelemetryHook } from '@openelement/protocol/errors';\nexport { createSsrContext, extractParams, parseQuery } from './context.js';\nexport { renderSsrError, wrapInDocument } from './html-escape.js';\nexport { createIsrCacheKey, isIsrRouteConfig, MemoryIsrCache } from './isr.js';\nexport type {\n  CacheAdapter,\n  CacheEntry,\n  IsrCacheEntry,\n  IsrCacheResult,\n  IsrCacheState,\n  IsrRouteConfig,\n} from '@openelement/protocol/isr';\nexport { findIsrManifestEntry, renderIsrResponse } from './isr-runtime.js';\nexport type {\n  IsrRuntimeOptions,\n  IsrRuntimeRenderContext,\n  IsrRuntimeRenderResult,\n  IsrRuntimeResult,\n  IsrRuntimeState,\n} from './isr-runtime.js';\nexport { StyleSheet } from './style-sheet.js';\nexport type { StyleSheetLike, StyleSheetRule } from '@openelement/protocol/style-sheet';\nexport { bindHydrateEvents } from './dsd-hydration-events.js';\nexport type { Constructor, DsdHydration } from './dsd-hydration.js';\nexport { createRenderDsdStreamMetrics, renderDsd, renderDsdStream } from './render-dsd.js';\nexport type { RenderDsdOptions } from './render-dsd.js';\nexport type {\n  RenderDsdStreamChunk,\n  RenderDsdStreamComponent,\n  RenderDsdStreamMetrics,\n  RenderDsdStreamOptions,\n} from './render-dsd-stream.js';\nexport { camelToKebab, serializeAttrs } from './render-ir.js';\nexport type {\n  DomSimulationAttempt,\n  DomSimulationReport,\n  DsdBuildReport,\n  DsdComponent,\n  DsdComponentConstructor,\n  DsdHydrationHintSummary,\n  DsdHydrationStrategySummary,\n  DsdMetricsSummary,\n  DsdOptions,\n  DsdPageDiagnostics,\n  DsdRenderMetrics,\n  HydrationHint,\n  IsrRouteRecord,\n  ManifestDecision,\n  RenderErrorCode,\n  RenderHooks,\n  RenderInput,\n  RenderOutput,\n  RenderPhase,\n  SsrAdmissionDecision,\n} from '@openelement/protocol/render';\nexport type {\n  OpenElementAttribute,\n  OpenElementCssPart,\n  OpenElementDeclaration,\n  OpenElementEvent,\n  OpenElementExport,\n  OpenElementExtensions,\n  OpenElementModule,\n  OpenElementPackageManifest,\n  OpenElementSlot,\n} from '@openelement/protocol/manifest';\nexport type {\n  CemCompatibilityReport,\n  CompatibilityClassification,\n  CompatibilityTier,\n} from '@openelement/protocol/manifest';\nexport { escapeAttr, escapeAttrValue, escapeHtml } from './html-escape.js';\nexport {\n  // v0.24.3: Neutral signal utilities — no template dependency\n  isSignalLike,\n  unwrapSignalLike,\n} from '@openelement/signal';\nexport type { SignalLike, Unsubscribe } from '@openelement/protocol/signal';\nexport { consumeContext, type Context, createContext, provideContext } from './signal-context.js';\nexport { createLogger } from './logger.js';\nexport { isValidTagName } from './tag-utils.js';\nexport {\n  bindSsrProps,\n  defineCustomElement,\n  defineIsland,\n  getIslandMeta,\n  getSsrProps,\n} from './island.js';\nexport type { IslandMeta, IslandOptions } from '@openelement/protocol/island';\nexport { transformIslandSource } from './island-transform.js';\nexport type { IslandTransformOptions, IslandTransformResult } from '@openelement/protocol/island';\n\n// Unified binding layer (ADR-0109 Phase 1)\nexport {\n  applyBindingDescriptor,\n  commitBindings,\n  registerBindingKind,\n} from './binding-activation.js';\nexport {\n  bindAttr,\n  bindClass,\n  bindConditional,\n  bindEvent,\n  bindHtml,\n  bindList,\n  bindRef,\n  bindRender,\n  bindStaticAttr,\n  bindStaticBoolean,\n  bindStaticProp,\n  bindStaticStyle,\n  bindText,\n} from './binding-descriptor.js';\nexport type {\n  BindingDescriptor,\n  BindingDispose,\n  BindingLifecycle,\n  BindingRenderer,\n} from './binding-descriptor.js';\n\n// Data adapters — type contract surface only (ADR-0095)\nexport type {\n  Action,\n  ActionContext,\n  DataAdapter,\n  Loader,\n  LoaderContext,\n} from '@openelement/protocol/data';\n\n// WC Package Protocol (v0.17+)\nexport {\n  clear as clearRegistry,\n  generateIndex,\n  getAll as getAllManifests,\n  getByTagName,\n  register as registerManifest,\n  validate as validateManifest,\n} from './registry.js';\n// v0.24.1 (ADR-0057): JSX + Signal component model\n// VNode & jsx-runtime\nexport type { VNode } from '@openelement/protocol/vnode';\nexport { isVNode } from './vnode.js';\nexport { Fragment, trustedHtml } from './jsx-runtime.js';\n// Renderers\nexport { renderToDom } from './jsx-render-dom.js';\nexport { renderDsdTree } from './render-ir.js';\nexport {\n  collectEventBindings,\n  createEventMarkerContext,\n  type EventBindingRecord,\n  type EventMarkerContext,\n  eventMarkerId,\n  eventTypeFromProp,\n  hydrateEventMarkers,\n  serializeEventMarkers,\n} from './event-hydration.js';\n// static props runtime + Signal unwrap\nexport {\n  disposeStaticProps,\n  handleStaticPropAttributeChange,\n  initializeStaticProps,\n  registerStaticObservedAttributes,\n  syncStaticPropsFromAttributes,\n  unwrap,\n} from './prop.js';\nexport type {\n  NormalizedPropDecl,\n  PropDecl,\n  PropDeclFull,\n  PropDeclShorthand,\n  PropsFrom,\n  PropType,\n} from '@openelement/protocol/prop';\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;CAcC,GAED,sEAAsE;AA8BtE,SACE,YAAY,EACZ,SAAS,EACT,gBAAgB,EAChB,mBAAmB,EACnB,WAAW,EACX,WAAW,EACX,qBAAqB,EACrB,cAAc,QACT,cAAc;AAErB,SAAS,gBAAgB,EAAE,aAAa,EAAE,UAAU,QAAQ,eAAe;AAC3E,SAAS,cAAc,EAAE,cAAc,QAAQ,mBAAmB;AAClE,SAAS,iBAAiB,EAAE,gBAAgB,EAAE,cAAc,QAAQ,WAAW;AAS/E,SAAS,oBAAoB,EAAE,iBAAiB,QAAQ,mBAAmB;AAQ3E,SAAS,UAAU,QAAQ,mBAAmB;AAE9C,SAAS,iBAAiB,QAAQ,4BAA4B;AAE9D,SAAS,4BAA4B,EAAE,SAAS,EAAE,eAAe,QAAQ,kBAAkB;AAQ3F,SAAS,YAAY,EAAE,cAAc,QAAQ,iBAAiB;AAuC9D,SAAS,UAAU,EAAE,eAAe,EAAE,UAAU,QAAQ,mBAAmB;AAC3E,SACE,6DAA6D;AAC7D,YAAY,EACZ,gBAAgB,QACX,sBAAsB;AAE7B,SAAS,cAAc,EAAgB,aAAa,EAAE,cAAc,QAAQ,sBAAsB;AAClG,SAAS,YAAY,QAAQ,cAAc;AAC3C,SAAS,cAAc,QAAQ,iBAAiB;AAChD,SACE,YAAY,EACZ,mBAAmB,EACnB,YAAY,EACZ,aAAa,EACb,WAAW,QACN,cAAc;AAErB,SAAS,qBAAqB,QAAQ,wBAAwB;AAG9D,2CAA2C;AAC3C,SACE,sBAAsB,EACtB,cAAc,EACd,mBAAmB,QACd,0BAA0B;AACjC,SACE,QAAQ,EACR,SAAS,EACT,eAAe,EACf,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,UAAU,EACV,cAAc,EACd,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,QAAQ,QACH,0BAA0B;AAiBjC,+BAA+B;AAC/B,SACE,SAAS,aAAa,EACtB,aAAa,EACb,UAAU,eAAe,EACzB,YAAY,EACZ,YAAY,gBAAgB,EAC5B,YAAY,gBAAgB,QACvB,gBAAgB;AAIvB,SAAS,OAAO,QAAQ,aAAa;AACrC,SAAS,QAAQ,EAAE,WAAW,QAAQ,mBAAmB;AACzD,YAAY;AACZ,SAAS,WAAW,QAAQ,sBAAsB;AAClD,SAAS,aAAa,QAAQ,iBAAiB;AAC/C,SACE,oBAAoB,EACpB,wBAAwB,EAGxB,aAAa,EACb,iBAAiB,EACjB,mBAAmB,EACnB,qBAAqB,QAChB,uBAAuB;AAC9B,uCAAuC;AACvC,SACE,kBAAkB,EAClB,+BAA+B,EAC/B,qBAAqB,EACrB,gCAAgC,EAChC,6BAA6B,EAC7B,MAAM,QACD,YAAY"}