@openelement/element 0.41.0-alpha.1

package/src/open-element.js

@@ -0,0 +1,419 @@
+/**
+ * @openelement/element - OpenElement base class.
+ *
+ * Zero-dependency Custom Element base class providing:
+ *   - Declarative Shadow DOM (DSD) detection at upgrade time
+ *   - Client-Side Rendering (CSR) fallback when no DSD content exists
+ *   - StyleSheet (SSR-safe CSSStyleSheet) via adoptedStyleSheets
+ *   - Declarative event binding via html template @click / @keydown etc.
+ *   - Signal-driven fine-grained DOM patching via data-signal markers
+ *   - AbortController cleanup on disconnect
+ *   - formAssociated + delegatesFocus support
+ *
+ * OpenElement extends HTMLElement directly - ZERO Lit dependency.
+ * Components return `render(): VNode | null`.
+ *
+ * Lifecycle:
+ *   SSR: instantiate -> set props -> render() -> wrap in DSD template
+ *   Client (DSD): browser attaches shadow root from DSD -> upgrade -> bind template events
+ *   Client (CSR): connectedCallback -> createRenderRoot -> render into shadowRoot
+ *
+ * Usage (static DSD component):
+ * ```ts
+ * class MyCard extends OpenElement {
+ *   static styles = myStyleSheet;
+ *   render(): VNode {
+ *     return <div class="card"><slot /></div>;
+ *   }
+ * }
+ * customElements.define('my-card', MyCard);
+ * ```
+ *
+ * Usage (reactive DSD component):
+ * ```ts
+ * class MyToggle extends OpenElement {
+ *   #active = signal(false);
+ *   render() {
+ *     return (
+ *       <button onClick={() => this.#active.value = !this.#active.value}>
+ *         {this.#active.value ? 'ON' : 'OFF'}
+ *       </button>
+ *     );
+ *   }
+ * }
+ * ```
+ *
+ * @module @openelement/element/open-element
+ */ import { formatError } from '@openelement/core/errors';
+import { disposeStaticProps, handleStaticPropAttributeChange, initializeStaticProps, syncStaticPropsFromAttributes } from '@openelement/core/prop';
+import { signal } from '@openelement/signal';
+import { createLogger } from '@openelement/core/logger';
+import { disposeRenderBindings, renderErrorFallback, renderIntoLightDom, renderIntoShadowRoot } from './open-element-render.js';
+import { hydrateExistingDom, hydrateSignals } from './open-element-hydration.js';
+/**
+ * SSR-safe base class for OpenElement.
+ *
+ * In browser: extends HTMLElement directly.
+ * In SSR: assigns a minimal stub to globalThis.HTMLElement so the entire
+ * dependency graph shares the same base class.
+ */ const _Base = typeof HTMLElement !== 'undefined' ? HTMLElement : class {
+  hasAttribute(_name) {
+    return false;
+  }
+  getAttribute(_name) {
+    return null;
+  }
+  setAttribute(_name, _value) {}
+  removeAttribute(_name) {}
+  get tagName() {
+    return '';
+  }
+  get isConnected() {
+    return false;
+  }
+};
+// In SSR, assign globalThis.HTMLElement so other code can reference it
+if (typeof HTMLElement === 'undefined') {
+  globalThis.HTMLElement = _Base;
+}
+/**
+ * Zero-dependency Custom Element base class for DSD rendering.
+ *
+ * Provides DSD detection, CSR fallback, event hydration, and style management
+ * without any framework dependency (no Lit, no reactive-element).
+ *
+ * Subclasses MUST override `render(): VNode | null`.
+ */ export class OpenElement extends _Base {
+  /** Component stylesheets (SSR-safe - StyleSheet delegates to native CSSStyleSheet in browser). */ static styles;
+  /** Rendering mode. Defaults to shadow/DSD; light DOM is explicit opt-in. */ static renderMode;
+  /** v0.25.0: Page head metadata. SSG reads this to inject <title> and <meta> tags. */ static head;
+  /** @internal — use openPipeline({ island: { upgradeStrategy } }) instead */ static client;
+  /**
+   * Attributes that trigger attributeChangedCallback.
+   * Subclasses override this to declare reactive attributes.
+   */ static observedAttributes;
+  /**
+   * Whether to delegate focus within the shadow root.
+   * When true, attachShadow is called with `delegatesFocus: true`.
+   */ static delegatesFocus;
+  /**
+   * Whether this element participates in form submission.
+   * When true, ElementInternals are attached in connectedCallback.
+   */ static formAssociated;
+  /**
+   * Effect dispose tracking (ADR-0065).
+   * Replaces effectScope() — effects are created at top level
+   * so they fire on signal changes. Disposed as a batch in
+   * disconnectedCallback.
+   */ #effectDisposers = new Set();
+  /** v0.28 (ADR-0067): Event listener cleanup tracking for _hydrateSignals(). */ #eventCleanups = [];
+  /** v0.28.1: Cached VNode from render() — avoids double-render mismatch between SSR and hydration. */ #vnodeCache = undefined;
+  #vnodeCacheValid = false;
+  /**
+   * Signal registry for attribute-based hydration (ADR-0065).
+   * Maps signal names → signal objects. Built by registerSignal()
+   * in component constructors, consumed during hydration.
+   *
+   * Exposed internally for render helper modules.
+   */ signalRegistry = new Map();
+  /**
+   * Register a signal for hydration by name.
+   * Call in constructor: this.registerSignal('count', this.#count);
+   */ registerSignal(name, sig) {
+    this.signalRegistry.set(name, sig);
+  }
+  /** Reactive route parameters Signal. Updates automatically on SPA navigation. */ #params = signal({});
+  /** Reactive route parameters. Updates automatically on SPA navigation. */ get params() {
+    return this.#params.value;
+  }
+  set params(value) {
+    this.#params.value = {
+      ...value
+    };
+  }
+  /** ElementInternals for form-associated custom elements */ _internals;
+  /**
+   * Create or reuse the shadow root.
+   *
+   * DSD detection: if `this.shadowRoot` already exists and has nodes,
+   * the browser pre-populated it from a <template shadowrootmode> tag.
+   * In that case we mark `_dsdHydrated = true` and return the existing root.
+   *
+   * CSR fallback: if no shadow root exists, we call `attachShadow()`. If an
+   * empty shadow root already exists, we reuse it and let connectedCallback()
+   * populate it from render().
+   *
+   * @returns The existing or newly created ShadowRoot.
+   */ createRenderRoot() {
+    const ctor = this.constructor;
+    if (ctor.renderMode === 'light') {
+      return this;
+    }
+    // DSD pre-populated shadow root detection
+    if (this.shadowRoot) {
+      this._applyStyles(ctor, this.shadowRoot);
+      return this.shadowRoot;
+    }
+    // CSR: create a new shadow root
+    const delegatesFocus = ctor.delegatesFocus ?? false;
+    const root = this.attachShadow({
+      mode: 'open',
+      delegatesFocus
+    });
+    // Apply static styles via adoptedStyleSheets
+    this._applyStyles(ctor, root);
+    return root;
+  }
+  /**
+   * Apply static styles to the shadow root via adoptedStyleSheets.
+   * Shared between CSR (createRenderRoot) and DSD (connectedCallback) paths.
+   */ _applyStyles(ctor, root) {
+    const target = root ?? this.shadowRoot;
+    if (!target || !ctor.styles) return;
+    const sheets = Array.isArray(ctor.styles) ? ctor.styles : [
+      ctor.styles
+    ];
+    if (sheets.length > 0) {
+      // StyleSheet delegates to native CSSStyleSheet in browser
+      // type-escape: adoptedStyleSheets may not be in the configured DOM lib
+      target.adoptedStyleSheets = sheets;
+    }
+  }
+  /**
+   * Lifecycle: called when the element is connected to the DOM.
+   *
+   * DSD path (_dsdHydrated = true):
+   *   - Calls _hydrateEvents() to bind declarative events on existing DOM.
+   *
+   * CSR path (_dsdHydrated = false):
+   *   - Calls createRenderRoot() if no shadow root exists.
+   *   - Renders this.render() through the VNode DOM renderer.
+   *
+   * If formAssociated is true, ElementInternals are attached.
+   */ connectedCallback() {
+    const ctor = this.constructor;
+    // v0.24.1 (ADR-0057): Initialize static props signals and accessors
+    initializeStaticProps(this);
+    syncStaticPropsFromAttributes(this);
+    const isLightDom = ctor.renderMode === 'light';
+    // Ensure render target exists and detect DSD pre-population
+    if (!this.shadowRoot && !isLightDom) {
+      this.createRenderRoot();
+    } else if (this.shadowRoot) {
+      // DSD path: shadow root already populated.
+      this.style.display = 'block';
+      this._applyStyles(ctor);
+    }
+    // Sync data-theme from document root
+    const docTheme = document.documentElement?.dataset?.theme;
+    if (docTheme && !this.hasAttribute('data-theme')) {
+      this.setAttribute('data-theme', docTheme);
+    }
+    // TG-01: Read route params from attribute if present.
+    // (SSR/SSG injects params as JS property via injectProps — setter handles it)
+    const attrParams = this.getAttribute('params');
+    if (attrParams) {
+      try {
+        this.#params.value = JSON.parse(attrParams);
+      } catch  {}
+    }
+    // v0.25.0 (SOP-012): Unified render path — DSD and CSR both go through
+    // _renderOrHydrate(). The _dsdHydrated flag and _bindCurrentRenderTemplate()
+    // are removed. DSD pre-populated DOM is preserved; only events and signal
+    // subscriptions are added.
+    this._renderOrHydrate();
+    // v0.40.0: Client-side activation hook for framework hydration
+    this.clientActivate();
+    // Attach ElementInternals for form-associated custom elements
+    if (ctor.formAssociated && typeof this.attachInternals === 'function') {
+      this._internals = this.attachInternals();
+    }
+  }
+  /**
+   * v0.25.0 (SOP-012): Unified render path.
+   */ _renderOrHydrate() {
+    try {
+      const ctor = this.constructor;
+      if (ctor.renderMode === 'light') {
+        this._renderIntoLightDom();
+        this.onCsrRendered();
+        return;
+      }
+      const isDsd = this.shadowRoot && this.shadowRoot.childNodes.length > 0;
+      if (isDsd) {
+        // DSD: DOM already correct — bind events via VNode walk
+        this._hydrateExistingDom();
+        this.onDsdHydrated();
+      } else if (this.shadowRoot) {
+        // CSR: full render from VNode
+        this._renderIntoShadowRoot();
+        this.onCsrRendered();
+      }
+    } catch (err) {
+      this._renderErrorFallback(err);
+    }
+  }
+  /**
+   * v0.28 (ADR-0067): Signal-native hydration.
+   *
+   * Replaces _walkAndBind() — reads data-signal markers
+   * from DSD shadow root and creates direct signal→DOM effect bindings.
+   * No position matching, no childNodes filtering, no VNode traversal.
+   *
+   * Effects are tracked in #effectDisposers for batch cleanup.
+   * VNode event marker listeners are tracked in #eventCleanups.
+   *
+   * Implementation lives in open-element-hydration.ts.
+   */ _hydrateSignals() {
+    if (!this.shadowRoot) return;
+    hydrateSignals(this, this.shadowRoot, this.signalRegistry, this.#effectDisposers, this.#eventCleanups, this.#cacheAccess());
+  }
+  /**
+   * Hydrate DSD DOM with signal and event bindings.
+   *
+   * v0.28 (ADR-0067): Delegates to _hydrateSignals().
+   * _walkAndBind position matching is DELETED.
+   *
+   * Implementation lives in open-element-hydration.ts.
+   */ _hydrateExistingDom() {
+    this.#eventCleanups = hydrateExistingDom(this, this.signalRegistry, this.#effectDisposers, this.#eventCleanups, this.#cacheAccess());
+  }
+  /**
+   * v0.23.0: Hook called after DSD hydration completes.
+   *
+   * Subclasses override this instead of relying on fragile
+   * `super.connectedCallback()` call order. At this point the
+   * shadow DOM is populated from DSD and declarative events
+   * (@click, @keydown) are bound.
+   *
+   * No-op by default.
+   */ onDsdHydrated() {}
+  /**
+   * v0.23.0: Hook called after CSR first render completes.
+   *
+   * Subclasses override this for post-render initialization
+   * that depends on the shadow DOM being populated. At this
+   * point render() has been called and declarative events
+   * are bound.
+   *
+   * No-op by default.
+   */ onCsrRendered() {}
+  /**
+   * v0.40.0: Client-side activation hook.
+   *
+   * Called once after the element is connected, the shadow root
+   * is ready, and any DSD hydration or CSR rendering has completed.
+   * This is the right place for framework hydration (Preact, React,
+   * Vue, Lit) to take over the shadow DOM.
+   *
+   * Default implementation is a no-op. Subclasses override this to
+   * hydrate or render framework components into the shadow root.
+   */ clientActivate() {
+  // default no-op
+  }
+  /**
+   * Hook called when the unified client render/hydrate path throws.
+   * Subclasses may return a VNode fallback.
+   */ onRenderError(error) {
+    createLogger('dsd').error(`<${this.tagName.toLowerCase()}> render/hydrate failed: ${formatError(error)}`);
+    return null;
+  }
+  _renderErrorFallback(error) {
+    this.#eventCleanups = renderErrorFallback(this, error, this.#effectDisposers, this.#eventCleanups, (err)=>this.onRenderError(err));
+  }
+  /**
+   * Lifecycle: called when the element is disconnected from the DOM.
+   * Aborts all hydration event listeners for cleanup.
+   */ disconnectedCallback() {
+    this.#eventCleanups = disposeRenderBindings(this.#effectDisposers, this.#eventCleanups);
+    disposeStaticProps(this);
+  }
+  // v0.28 (ADR-0067): Effect + event lifecycle managed by Set/Array.
+  // _walkAndBind DELETED — replaced by _hydrateSignals().
+  /**
+   * Lifecycle: called when an observed attribute changes.
+   *
+   * Base implementation is a no-op. Subclasses override this to react
+   * to attribute changes, typically by calling `this.render()` to update
+   * the shadow DOM.
+   *
+   * @param name - Attribute name (lowercase).
+   * @param oldValue - Previous value, or null if the attribute was not set.
+   * @param newValue - New value, or null if the attribute was removed.
+   */ attributeChangedCallback(_name, _oldValue, _newValue) {
+    // v0.24.1 (ADR-0057): Route to static props handler
+    handleStaticPropAttributeChange(this, _name, _oldValue, _newValue);
+  // Subclass override point - base implementation is intentionally empty.
+  }
+  /**
+   * Re-render the shadow DOM from `render()` and re-bind declarative events.
+   *
+   * OpenElement intentionally does not include a reactive scheduler. Components
+   * with local state can call this method after state changes instead of
+   * duplicating renderToDom() and event hydration.
+   */ update() {
+    const ctor = this.constructor;
+    if (ctor.renderMode === 'light') {
+      this._renderIntoLightDom();
+      return;
+    }
+    this._renderIntoShadowRoot();
+  }
+  /**
+   * ReactiveController-compatible update hook.
+   *
+   * Async state controllers call this method when state changes. Keeping this
+   * tiny alias lets OpenElement host controllers without inheriting Lit or a
+   * scheduler.
+   */ requestUpdate() {
+    this.update();
+  }
+  _renderIntoLightDom() {
+    this.#eventCleanups = renderIntoLightDom(this, this.#effectDisposers, this.#eventCleanups, this.#cacheAccess());
+  }
+  _renderIntoShadowRoot() {
+    this.#eventCleanups = renderIntoShadowRoot(this, this.#effectDisposers, this.#eventCleanups, this.#cacheAccess());
+  }
+  /**
+   * Accessor for the private VNode cache used by extracted render/hydration
+   * helpers. Keeps #vnodeCache / #vnodeCacheValid encapsulated while allowing
+   * the logic to live in separate modules.
+   */ #cacheAccess() {
+    return {
+      get: ()=>({
+          vnode: this.#vnodeCache,
+          valid: this.#vnodeCacheValid
+        }),
+      set: (vnode)=>{
+        this.#vnodeCache = vnode;
+        this.#vnodeCacheValid = true;
+      }
+    };
+  }
+  /**
+   * Read locale from JS property (set by SSR injectProps) first,
+   * then HTML attribute, then fallback to provided default.
+   *
+   * SSR injectProps() sets camelCase JS properties (e.g. this.locale = 'en')
+   * but getAttribute() only reads HTML attributes, which remain null.
+   * This method resolves the mismatch by checking JS property first.
+   *
+   * @param fallback - Default value when neither source has a value. Defaults to 'en'.
+   */ _getLocale(fallback = 'en') {
+    const prop = this.locale;
+    if (typeof prop === 'string' && prop) return prop;
+    return this.getAttribute('locale') || fallback;
+  }
+  /**
+   * Return Shadow DOM content as a VNode.
+   *
+   * Subclasses MUST override this method. During SSR, rendered content is
+   * wrapped in a <template shadowrootmode="open"> tag. During CSR, VNode values
+   * are rendered via renderToDom() with event binding and signal tracking.
+   *
+   * @returns VNode for the shadow DOM content, or null for empty content.
+   */ render() {
+    return null;
+  }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/element/src/open-element.ts"],"sourcesContent":["/**\n * @openelement/element - OpenElement base class.\n *\n * Zero-dependency Custom Element base class providing:\n *   - Declarative Shadow DOM (DSD) detection at upgrade time\n *   - Client-Side Rendering (CSR) fallback when no DSD content exists\n *   - StyleSheet (SSR-safe CSSStyleSheet) via adoptedStyleSheets\n *   - Declarative event binding via html template @click / @keydown etc.\n *   - Signal-driven fine-grained DOM patching via data-signal markers\n *   - AbortController cleanup on disconnect\n *   - formAssociated + delegatesFocus support\n *\n * OpenElement extends HTMLElement directly - ZERO Lit dependency.\n * Components return `render(): VNode | null`.\n *\n * Lifecycle:\n *   SSR: instantiate -> set props -> render() -> wrap in DSD template\n *   Client (DSD): browser attaches shadow root from DSD -> upgrade -> bind template events\n *   Client (CSR): connectedCallback -> createRenderRoot -> render into shadowRoot\n *\n * Usage (static DSD component):\n * ```ts\n * class MyCard extends OpenElement {\n *   static styles = myStyleSheet;\n *   render(): VNode {\n *     return <div class=\"card\"><slot /></div>;\n *   }\n * }\n * customElements.define('my-card', MyCard);\n * ```\n *\n * Usage (reactive DSD component):\n * ```ts\n * class MyToggle extends OpenElement {\n *   #active = signal(false);\n *   render() {\n *     return (\n *       <button onClick={() => this.#active.value = !this.#active.value}>\n *         {this.#active.value ? 'ON' : 'OFF'}\n *       </button>\n *     );\n *   }\n * }\n * ```\n *\n * @module @openelement/element/open-element\n */\n\nimport { formatError } from '@openelement/core/errors';\nimport type { StyleSheetLike } from '@openelement/protocol/style-sheet';\nimport {\n  disposeStaticProps,\n  handleStaticPropAttributeChange,\n  initializeStaticProps,\n  syncStaticPropsFromAttributes,\n} from '@openelement/core/prop';\nimport type { VNode } from '@openelement/protocol/vnode';\nimport type { Signal } from '@openelement/protocol/signal';\nimport { signal } from '@openelement/signal';\nimport { createLogger } from '@openelement/core/logger';\nimport {\n  disposeRenderBindings,\n  renderErrorFallback,\n  renderIntoLightDom,\n  renderIntoShadowRoot,\n  type VNodeCacheAccess,\n} from './open-element-render.js';\nimport { hydrateExistingDom, hydrateSignals } from './open-element-hydration.js';\n\n/**\n * SSR-safe base class for OpenElement.\n *\n * In browser: extends HTMLElement directly.\n * In SSR: assigns a minimal stub to globalThis.HTMLElement so the entire\n * dependency graph shares the same base class.\n */\nconst _Base = typeof HTMLElement !== 'undefined' ? HTMLElement : (class {\n  hasAttribute(_name: string): boolean {\n    return false;\n  }\n  getAttribute(_name: string): string | null {\n    return null;\n  }\n  setAttribute(_name: string, _value: string): void {}\n  removeAttribute(_name: string): void {}\n  get tagName(): string {\n    return '';\n  }\n  get isConnected(): boolean {\n    return false;\n  }\n} as unknown as typeof HTMLElement);\n\n// In SSR, assign globalThis.HTMLElement so other code can reference it\nif (typeof HTMLElement === 'undefined') {\n  (globalThis as Record<string, unknown>).HTMLElement = _Base;\n}\n\n/**\n * Zero-dependency Custom Element base class for DSD rendering.\n *\n * Provides DSD detection, CSR fallback, event hydration, and style management\n * without any framework dependency (no Lit, no reactive-element).\n *\n * Subclasses MUST override `render(): VNode | null`.\n */\nexport class OpenElement extends _Base {\n  /** Component stylesheets (SSR-safe - StyleSheet delegates to native CSSStyleSheet in browser). */\n  static styles?: StyleSheetLike | StyleSheetLike[];\n\n  /** Rendering mode. Defaults to shadow/DSD; light DOM is explicit opt-in. */\n  static renderMode?: 'shadow' | 'light';\n\n  /** v0.25.0: Page head metadata. SSG reads this to inject <title> and <meta> tags. */\n  static head?: { title?: string; description?: string; ogImage?: string };\n\n  /** @internal — use openPipeline({ island: { upgradeStrategy } }) instead */\n  static client?: { strategy?: 'load' | 'idle' | 'visible' | 'only' };\n\n  /**\n   * Attributes that trigger attributeChangedCallback.\n   * Subclasses override this to declare reactive attributes.\n   */\n  static observedAttributes?: string[];\n\n  /**\n   * Whether to delegate focus within the shadow root.\n   * When true, attachShadow is called with `delegatesFocus: true`.\n   */\n  static delegatesFocus?: boolean;\n\n  /**\n   * Whether this element participates in form submission.\n   * When true, ElementInternals are attached in connectedCallback.\n   */\n  static formAssociated?: boolean;\n\n  /**\n   * Effect dispose tracking (ADR-0065).\n   * Replaces effectScope() — effects are created at top level\n   * so they fire on signal changes. Disposed as a batch in\n   * disconnectedCallback.\n   */\n  #effectDisposers: Set<() => void> = new Set();\n\n  /** v0.28 (ADR-0067): Event listener cleanup tracking for _hydrateSignals(). */\n  #eventCleanups: Array<() => void> = [];\n\n  /** v0.28.1: Cached VNode from render() — avoids double-render mismatch between SSR and hydration. */\n  #vnodeCache: unknown = undefined;\n  #vnodeCacheValid = false;\n\n  /**\n   * Signal registry for attribute-based hydration (ADR-0065).\n   * Maps signal names → signal objects. Built by registerSignal()\n   * in component constructors, consumed during hydration.\n   *\n   * Exposed internally for render helper modules.\n   */\n  signalRegistry: Map<string, Signal<unknown>> = new Map();\n\n  /**\n   * Register a signal for hydration by name.\n   * Call in constructor: this.registerSignal('count', this.#count);\n   */\n  protected registerSignal(name: string, sig: Signal<unknown>): void {\n    this.signalRegistry.set(name, sig);\n  }\n\n  /** Reactive route parameters Signal. Updates automatically on SPA navigation. */\n  #params = signal<Record<string, string>>({});\n\n  /** Reactive route parameters. Updates automatically on SPA navigation. */\n  get params(): Record<string, string> {\n    return this.#params.value;\n  }\n\n  set params(value: Record<string, string>) {\n    this.#params.value = { ...value };\n  }\n\n  /** ElementInternals for form-associated custom elements */\n  protected _internals?: ElementInternals;\n\n  /**\n   * Create or reuse the shadow root.\n   *\n   * DSD detection: if `this.shadowRoot` already exists and has nodes,\n   * the browser pre-populated it from a <template shadowrootmode> tag.\n   * In that case we mark `_dsdHydrated = true` and return the existing root.\n   *\n   * CSR fallback: if no shadow root exists, we call `attachShadow()`. If an\n   * empty shadow root already exists, we reuse it and let connectedCallback()\n   * populate it from render().\n   *\n   * @returns The existing or newly created ShadowRoot.\n   */\n  createRenderRoot(): ShadowRoot | this {\n    const ctor = this.constructor as typeof OpenElement;\n    if (ctor.renderMode === 'light') {\n      return this;\n    }\n\n    // DSD pre-populated shadow root detection\n    if (this.shadowRoot) {\n      this._applyStyles(ctor, this.shadowRoot);\n      return this.shadowRoot;\n    }\n\n    // CSR: create a new shadow root\n    const delegatesFocus = ctor.delegatesFocus ?? false;\n    const root = this.attachShadow({ mode: 'open', delegatesFocus });\n\n    // Apply static styles via adoptedStyleSheets\n    this._applyStyles(ctor, root);\n\n    return root;\n  }\n\n  /**\n   * Apply static styles to the shadow root via adoptedStyleSheets.\n   * Shared between CSR (createRenderRoot) and DSD (connectedCallback) paths.\n   */\n  private _applyStyles(ctor: typeof OpenElement, root?: ShadowRoot): void {\n    const target = root ?? this.shadowRoot;\n    if (!target || !ctor.styles) return;\n    const sheets = Array.isArray(ctor.styles) ? ctor.styles : [ctor.styles];\n    if (sheets.length > 0) {\n      // StyleSheet delegates to native CSSStyleSheet in browser\n      // type-escape: adoptedStyleSheets may not be in the configured DOM lib\n      (target as unknown as { adoptedStyleSheets: typeof sheets }).adoptedStyleSheets = sheets;\n    }\n  }\n\n  /**\n   * Lifecycle: called when the element is connected to the DOM.\n   *\n   * DSD path (_dsdHydrated = true):\n   *   - Calls _hydrateEvents() to bind declarative events on existing DOM.\n   *\n   * CSR path (_dsdHydrated = false):\n   *   - Calls createRenderRoot() if no shadow root exists.\n   *   - Renders this.render() through the VNode DOM renderer.\n   *\n   * If formAssociated is true, ElementInternals are attached.\n   */\n  connectedCallback(): void {\n    const ctor = this.constructor as typeof OpenElement;\n\n    // v0.24.1 (ADR-0057): Initialize static props signals and accessors\n    initializeStaticProps(this);\n    syncStaticPropsFromAttributes(this);\n\n    const isLightDom = ctor.renderMode === 'light';\n\n    // Ensure render target exists and detect DSD pre-population\n    if (!this.shadowRoot && !isLightDom) {\n      this.createRenderRoot();\n    } else if (this.shadowRoot) {\n      // DSD path: shadow root already populated.\n      this.style.display = 'block';\n      this._applyStyles(ctor);\n    }\n\n    // Sync data-theme from document root\n    const docTheme = document.documentElement?.dataset?.theme;\n    if (docTheme && !this.hasAttribute('data-theme')) {\n      this.setAttribute('data-theme', docTheme);\n    }\n\n    // TG-01: Read route params from attribute if present.\n    // (SSR/SSG injects params as JS property via injectProps — setter handles it)\n    const attrParams = this.getAttribute('params');\n    if (attrParams) {\n      try {\n        this.#params.value = JSON.parse(attrParams);\n      } catch { /* ignore malformed JSON */ }\n    }\n\n    // v0.25.0 (SOP-012): Unified render path — DSD and CSR both go through\n    // _renderOrHydrate(). The _dsdHydrated flag and _bindCurrentRenderTemplate()\n    // are removed. DSD pre-populated DOM is preserved; only events and signal\n    // subscriptions are added.\n    this._renderOrHydrate();\n\n    // v0.40.0: Client-side activation hook for framework hydration\n    this.clientActivate();\n\n    // Attach ElementInternals for form-associated custom elements\n    if (ctor.formAssociated && typeof this.attachInternals === 'function') {\n      this._internals = this.attachInternals();\n    }\n  }\n\n  /**\n   * v0.25.0 (SOP-012): Unified render path.\n   */\n  private _renderOrHydrate(): void {\n    try {\n      const ctor = this.constructor as typeof OpenElement;\n      if (ctor.renderMode === 'light') {\n        this._renderIntoLightDom();\n        this.onCsrRendered();\n        return;\n      }\n\n      const isDsd = this.shadowRoot && this.shadowRoot.childNodes.length > 0;\n      if (isDsd) {\n        // DSD: DOM already correct — bind events via VNode walk\n        this._hydrateExistingDom();\n        this.onDsdHydrated();\n      } else if (this.shadowRoot) {\n        // CSR: full render from VNode\n        this._renderIntoShadowRoot();\n        this.onCsrRendered();\n      }\n    } catch (err) {\n      this._renderErrorFallback(err);\n    }\n  }\n\n  /**\n   * v0.28 (ADR-0067): Signal-native hydration.\n   *\n   * Replaces _walkAndBind() — reads data-signal markers\n   * from DSD shadow root and creates direct signal→DOM effect bindings.\n   * No position matching, no childNodes filtering, no VNode traversal.\n   *\n   * Effects are tracked in #effectDisposers for batch cleanup.\n   * VNode event marker listeners are tracked in #eventCleanups.\n   *\n   * Implementation lives in open-element-hydration.ts.\n   */\n  private _hydrateSignals(): void {\n    if (!this.shadowRoot) return;\n    hydrateSignals(\n      this,\n      this.shadowRoot,\n      this.signalRegistry,\n      this.#effectDisposers,\n      this.#eventCleanups,\n      this.#cacheAccess(),\n    );\n  }\n\n  /**\n   * Hydrate DSD DOM with signal and event bindings.\n   *\n   * v0.28 (ADR-0067): Delegates to _hydrateSignals().\n   * _walkAndBind position matching is DELETED.\n   *\n   * Implementation lives in open-element-hydration.ts.\n   */\n  private _hydrateExistingDom(): void {\n    this.#eventCleanups = hydrateExistingDom(\n      this,\n      this.signalRegistry,\n      this.#effectDisposers,\n      this.#eventCleanups,\n      this.#cacheAccess(),\n    );\n  }\n\n  /**\n   * v0.23.0: Hook called after DSD hydration completes.\n   *\n   * Subclasses override this instead of relying on fragile\n   * `super.connectedCallback()` call order. At this point the\n   * shadow DOM is populated from DSD and declarative events\n   * (@click, @keydown) are bound.\n   *\n   * No-op by default.\n   */\n  protected onDsdHydrated(): void {}\n\n  /**\n   * v0.23.0: Hook called after CSR first render completes.\n   *\n   * Subclasses override this for post-render initialization\n   * that depends on the shadow DOM being populated. At this\n   * point render() has been called and declarative events\n   * are bound.\n   *\n   * No-op by default.\n   */\n  protected onCsrRendered(): void {}\n\n  /**\n   * v0.40.0: Client-side activation hook.\n   *\n   * Called once after the element is connected, the shadow root\n   * is ready, and any DSD hydration or CSR rendering has completed.\n   * This is the right place for framework hydration (Preact, React,\n   * Vue, Lit) to take over the shadow DOM.\n   *\n   * Default implementation is a no-op. Subclasses override this to\n   * hydrate or render framework components into the shadow root.\n   */\n  protected clientActivate(): void {\n    // default no-op\n  }\n\n  /**\n   * Hook called when the unified client render/hydrate path throws.\n   * Subclasses may return a VNode fallback.\n   */\n  protected onRenderError(error: unknown): VNode | null {\n    createLogger('dsd').error(\n      `<${this.tagName.toLowerCase()}> render/hydrate failed: ${formatError(error)}`,\n    );\n    return null;\n  }\n\n  private _renderErrorFallback(error: unknown): void {\n    this.#eventCleanups = renderErrorFallback(\n      this,\n      error,\n      this.#effectDisposers,\n      this.#eventCleanups,\n      (err) => this.onRenderError(err),\n    );\n  }\n\n  /**\n   * Lifecycle: called when the element is disconnected from the DOM.\n   * Aborts all hydration event listeners for cleanup.\n   */\n  disconnectedCallback(): void {\n    this.#eventCleanups = disposeRenderBindings(this.#effectDisposers, this.#eventCleanups);\n    disposeStaticProps(this);\n  }\n\n  // v0.28 (ADR-0067): Effect + event lifecycle managed by Set/Array.\n  // _walkAndBind DELETED — replaced by _hydrateSignals().\n\n  /**\n   * Lifecycle: called when an observed attribute changes.\n   *\n   * Base implementation is a no-op. Subclasses override this to react\n   * to attribute changes, typically by calling `this.render()` to update\n   * the shadow DOM.\n   *\n   * @param name - Attribute name (lowercase).\n   * @param oldValue - Previous value, or null if the attribute was not set.\n   * @param newValue - New value, or null if the attribute was removed.\n   */\n  attributeChangedCallback(\n    _name: string,\n    _oldValue: string | null,\n    _newValue: string | null,\n  ): void {\n    // v0.24.1 (ADR-0057): Route to static props handler\n    handleStaticPropAttributeChange(\n      this,\n      _name,\n      _oldValue,\n      _newValue,\n    );\n    // Subclass override point - base implementation is intentionally empty.\n  }\n\n  /**\n   * Re-render the shadow DOM from `render()` and re-bind declarative events.\n   *\n   * OpenElement intentionally does not include a reactive scheduler. Components\n   * with local state can call this method after state changes instead of\n   * duplicating renderToDom() and event hydration.\n   */\n  update(): void {\n    const ctor = this.constructor as typeof OpenElement;\n    if (ctor.renderMode === 'light') {\n      this._renderIntoLightDom();\n      return;\n    }\n    this._renderIntoShadowRoot();\n  }\n\n  /**\n   * ReactiveController-compatible update hook.\n   *\n   * Async state controllers call this method when state changes. Keeping this\n   * tiny alias lets OpenElement host controllers without inheriting Lit or a\n   * scheduler.\n   */\n  requestUpdate(): void {\n    this.update();\n  }\n\n  private _renderIntoLightDom(): void {\n    this.#eventCleanups = renderIntoLightDom(\n      this,\n      this.#effectDisposers,\n      this.#eventCleanups,\n      this.#cacheAccess(),\n    );\n  }\n\n  private _renderIntoShadowRoot(): void {\n    this.#eventCleanups = renderIntoShadowRoot(\n      this,\n      this.#effectDisposers,\n      this.#eventCleanups,\n      this.#cacheAccess(),\n    );\n  }\n\n  /**\n   * Accessor for the private VNode cache used by extracted render/hydration\n   * helpers. Keeps #vnodeCache / #vnodeCacheValid encapsulated while allowing\n   * the logic to live in separate modules.\n   */\n  #cacheAccess(): VNodeCacheAccess {\n    return {\n      get: () => ({ vnode: this.#vnodeCache, valid: this.#vnodeCacheValid }),\n      set: (vnode: unknown) => {\n        this.#vnodeCache = vnode;\n        this.#vnodeCacheValid = true;\n      },\n    };\n  }\n\n  /**\n   * Read locale from JS property (set by SSR injectProps) first,\n   * then HTML attribute, then fallback to provided default.\n   *\n   * SSR injectProps() sets camelCase JS properties (e.g. this.locale = 'en')\n   * but getAttribute() only reads HTML attributes, which remain null.\n   * This method resolves the mismatch by checking JS property first.\n   *\n   * @param fallback - Default value when neither source has a value. Defaults to 'en'.\n   */\n  protected _getLocale(fallback = 'en'): string {\n    const prop = (this as Record<string, unknown>).locale;\n    if (typeof prop === 'string' && prop) return prop;\n    return this.getAttribute('locale') || fallback;\n  }\n\n  /**\n   * Return Shadow DOM content as a VNode.\n   *\n   * Subclasses MUST override this method. During SSR, rendered content is\n   * wrapped in a <template shadowrootmode=\"open\"> tag. During CSR, VNode values\n   * are rendered via renderToDom() with event binding and signal tracking.\n   *\n   * @returns VNode for the shadow DOM content, or null for empty content.\n   */\n  render(): VNode | null {\n    return null;\n  }\n}\n\n/** OpenElement constructor with framework-convention static properties. */\nexport interface OpenElementComponentConstructor extends CustomElementConstructor {\n  styles?:\n    | StyleSheetLike\n    | StyleSheetLike[];\n  tagName?: string;\n  renderMode?: 'shadow' | 'light';\n  observedAttributes?: string[];\n}\n"],"names":[],"mappings":"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"}

package/src/types.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @openelement/element — Public types.
+ */ import type { VNode } from '@openelement/protocol/vnode';
+import type { StyleSheetLike } from '@openelement/protocol/style-sheet';
+export interface ElementDefinition<Props extends Record<string, unknown> = Record<string, unknown>> {
+  styles?: StyleSheetLike | StyleSheetLike[];
+  render: (props: Props) => VNode | null;
+}

package/src/types.js

@@ -0,0 +1,4 @@
+/**
+ * @openelement/element — Public types.
+ */ 
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vaG9tZS9ydW5uZXIvd29yay9vcGVuZWxlbWVudC9vcGVuZWxlbWVudC9wYWNrYWdlcy9lbGVtZW50L3NyYy90eXBlcy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBvcGVuZWxlbWVudC9lbGVtZW50IOKAlCBQdWJsaWMgdHlwZXMuXG4gKi9cblxuaW1wb3J0IHR5cGUgeyBWTm9kZSB9IGZyb20gJ0BvcGVuZWxlbWVudC9wcm90b2NvbC92bm9kZSc7XG5pbXBvcnQgdHlwZSB7IFN0eWxlU2hlZXRMaWtlIH0gZnJvbSAnQG9wZW5lbGVtZW50L3Byb3RvY29sL3N0eWxlLXNoZWV0JztcblxuZXhwb3J0IGludGVyZmFjZSBFbGVtZW50RGVmaW5pdGlvbjxcbiAgUHJvcHMgZXh0ZW5kcyBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPiA9IFJlY29yZDxzdHJpbmcsIHVua25vd24+LFxuPiB7XG4gIHN0eWxlcz86IFN0eWxlU2hlZXRMaWtlIHwgU3R5bGVTaGVldExpa2VbXTtcbiAgcmVuZGVyOiAocHJvcHM6IFByb3BzKSA9PiBWTm9kZSB8IG51bGw7XG59XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0NBRUMsR0FFRCJ9