@openelement/element 0.41.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 openElement
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,60 @@
+# @openelement/element
+
+First-class Elements authoring surface for openElement.
+
+This package exposes `OpenElement`, the product-facing base class for native Web
+Components built on openElement's existing shadow/DSD implementation. Shadow/DSD
+is the default render mode; light DOM remains explicit opt-in.
+
+Also includes:
+
+- `ErrorBoundary` — catch child render errors with fallback UI
+- `defineElement` / `defineLayout` — functional component-style authoring
+- Prop system: `PropDecl`, `PropsFrom`, `PropType`
+- Full re-export of JSX, VNode, context, signals, StyleSheet, and island utilities
+
+## Install
+
+```bash
+npm install @openelement/element
+```
+
+## Usage
+
+```tsx
+import { OpenElement } from '@openelement/element';
+import type { VNode } from '@openelement/element';
+
+class MyCard extends OpenElement {
+  render(): VNode {
+    return (
+      <article>
+        <slot />
+      </article>
+    );
+  }
+}
+```
+
+## Functional Component Style
+
+```tsx
+import { defineElement } from '@openelement/element';
+
+defineElement('my-card', ({ title }) => (
+  <article>
+    <h2>{title}</h2>
+    <slot />
+  </article>
+));
+```
+
+## Boundary
+
+`@openelement/element` does not own routing, Vite, Nitro, UI components,
+database, auth, cache, or the default signal engine. Those remain Framework,
+UI, Protocols, or adapter concerns.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@openelement/element",
+  "version": "0.41.0-alpha.1",
+  "type": "module",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js",
+      "default": "./src/index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/open-element/openelement.git"
+  },
+  "keywords": [
+    "openelement",
+    "web-components",
+    "ssg",
+    "framework",
+    "deno"
+  ],
+  "dependencies": {
+    "@openelement/protocol": "^0.41.0-alpha.1",
+    "@openelement/core": "^0.41.0-alpha.1",
+    "@openelement/signal": "^0.41.0-alpha.1"
+  }
+}

package/src/define-element.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @openelement/element — defineElement / defineLayout helpers.
+ *
+ * Functional component-style authoring for OpenElement.
+ */ import { OpenElement } from "./open-element.js";
+import type { ElementDefinition } from "./types.js";
+import type { VNode } from '@openelement/protocol/vnode';
+export declare function defineElement<Props extends Record<string, unknown> = Record<string, unknown>>(tagName: string, input: ((props: Props) => VNode | null) | ElementDefinition<Props>): typeof OpenElement;
+export declare function defineLayout<Props extends Record<string, unknown> = Record<string, unknown>>(tagName: string, input: ((props: Props) => VNode | null) | ElementDefinition<Props>): typeof OpenElement;

package/src/define-element.js

@@ -0,0 +1,43 @@
+/**
+ * @openelement/element — defineElement / defineLayout helpers.
+ *
+ * Functional component-style authoring for OpenElement.
+ */ import { OpenElement } from './open-element.js';
+const ERROR_PREFIX = '[openElement]';
+function collectPublicProps(host) {
+  const props = {};
+  for (const key of Object.keys(host)){
+    if (key.startsWith('__openElement')) continue;
+    props[key] = host[key];
+  }
+  return props;
+}
+function normalizeElementDefinition(input) {
+  return typeof input === 'function' ? {
+    render: input
+  } : input;
+}
+function assertCustomElementTag(tagName) {
+  if (!/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/.test(tagName)) {
+    throw new Error(`${ERROR_PREFIX} "${tagName}" is not a valid custom element name. ` + 'Use lowercase ASCII letters, digits, and at least one hyphen.');
+  }
+}
+export function defineElement(tagName, input) {
+  assertCustomElementTag(tagName);
+  const definition = normalizeElementDefinition(input);
+  class OpenElementComponent extends OpenElement {
+    static styles = definition.styles;
+    render() {
+      return definition.render(collectPublicProps(this));
+    }
+  }
+  if (typeof customElements !== 'undefined' && !customElements.get(tagName)) {
+    customElements.define(tagName, OpenElementComponent);
+  }
+  return OpenElementComponent;
+}
+// ponytail: semantic alias for defineElement, trim when template/doc migration done
+export function defineLayout(tagName, input) {
+  return defineElement(tagName, input);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/error-boundary.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @openelement/element — ErrorBoundary (ADR-0053 Layer 2).
+ *
+ * Catches child component render() errors and displays a fallback
+ * UI instead of a bare tag or broken DOM. Errors bubble up through
+ * the parent tree if no boundary catches them.
+ *
+ * v0.36.0: Added retry mechanism and degraded rendering fallback.
+ *
+ * Usage:
+ * ```ts
+ * class MyBoundary extends ErrorBoundary {
+ *   onError(error: OpenElementError) {
+ *     return html`<error-panel .message=${error.message}></error-panel>`;
+ *   }
+ *   render() {
+ *     return html`<slot></slot>`;
+ *   }
+ * }
+ * ```
+ */ import type { VNode } from '@openelement/protocol/vnode';
+import { OpenElement } from "./open-element.js";
+import { OpenElementError } from '@openelement/core';
+export declare abstract class ErrorBoundary extends OpenElement {
+  private _error: any;
+  private _retryCount: any;
+  /** Maximum number of retry attempts before giving up. Default: 3. */ protected maxRetries: number;
+  get hasError(): boolean;
+  get error(): OpenElementError | null;
+  get retryCount(): number;
+  /**
+   * Render fallback UI when a child component's render() throws.
+   * Subclasses SHOULD override this for custom error UI.
+   *
+   * Default implementation renders a degraded static fallback.
+   */ onError(error: OpenElementError): VNode;
+  /**
+   * Retry rendering after an error. Resets error state and increments
+   * retry counter. If maxRetries is exceeded, shows exhausted state.
+   */ retry(): void;
+  /**
+   * Fully reset the error boundary, including retry count.
+   * Call this when the underlying issue has been resolved externally.
+   */ reset(): void;
+  /**
+   * Capture and reset error state on re-render.
+   */ override connectedCallback(): void;
+  /**
+   * Wrap child render in try/catch.
+   */ override render(): VNode | null;
+  /**
+   * Call this from parent to catch a child's error.
+   */ catchError(error: Error): void;
+}

package/src/error-boundary.js

@@ -0,0 +1,125 @@
+/**
+ * @openelement/element — ErrorBoundary (ADR-0053 Layer 2).
+ *
+ * Catches child component render() errors and displays a fallback
+ * UI instead of a bare tag or broken DOM. Errors bubble up through
+ * the parent tree if no boundary catches them.
+ *
+ * v0.36.0: Added retry mechanism and degraded rendering fallback.
+ *
+ * Usage:
+ * ```ts
+ * class MyBoundary extends ErrorBoundary {
+ *   onError(error: OpenElementError) {
+ *     return html`<error-panel .message=${error.message}></error-panel>`;
+ *   }
+ *   render() {
+ *     return html`<slot></slot>`;
+ *   }
+ * }
+ * ```
+ */ import { OpenElement } from './open-element.js';
+import { ErrorCode, OpenElementError } from '@openelement/core';
+export class ErrorBoundary extends OpenElement {
+  _error = null;
+  _retryCount = 0;
+  /** Maximum number of retry attempts before giving up. Default: 3. */ maxRetries = 3;
+  get hasError() {
+    return this._error !== null;
+  }
+  get error() {
+    return this._error;
+  }
+  get retryCount() {
+    return this._retryCount;
+  }
+  /**
+   * Render fallback UI when a child component's render() throws.
+   * Subclasses SHOULD override this for custom error UI.
+   *
+   * Default implementation renders a degraded static fallback.
+   */ onError(error) {
+    return {
+      tag: 'div',
+      props: {
+        class: 'error-boundary-fallback',
+        role: 'alert'
+      },
+      children: [
+        {
+          tag: 'p',
+          props: {},
+          children: [
+            `Something went wrong: ${error.message}`
+          ]
+        },
+        this._retryCount < this.maxRetries ? {
+          tag: 'button',
+          props: {
+            onclick: ()=>this.retry()
+          },
+          children: [
+            `Retry (${this._retryCount}/${this.maxRetries})`
+          ]
+        } : {
+          tag: 'p',
+          props: {
+            class: 'error-boundary-exhausted'
+          },
+          children: [
+            'Max retries reached. Please reload the page.'
+          ]
+        }
+      ]
+    };
+  }
+  /**
+   * Retry rendering after an error. Resets error state and increments
+   * retry counter. If maxRetries is exceeded, shows exhausted state.
+   */ retry() {
+    if (this._retryCount >= this.maxRetries) {
+      return; // exhausted
+    }
+    this._retryCount++;
+    this._error = null;
+    this.update(); // trigger re-render
+  }
+  /**
+   * Fully reset the error boundary, including retry count.
+   * Call this when the underlying issue has been resolved externally.
+   */ reset() {
+    this._error = null;
+    this._retryCount = 0;
+    this.update();
+  }
+  /**
+   * Capture and reset error state on re-render.
+   */ connectedCallback() {
+    this._error = null;
+    this._retryCount = 0;
+    super.connectedCallback();
+  }
+  /**
+   * Wrap child render in try/catch.
+   */ render() {
+    if (this._error) {
+      return this.onError(this._error);
+    }
+    return super.render();
+  }
+  /**
+   * Call this from parent to catch a child's error.
+   */ catchError(error) {
+    const openElementError = error instanceof OpenElementError ? error : new OpenElementError(error.message, {
+      code: ErrorCode.BOUNDARY_CAUGHT,
+      severity: 'error',
+      phase: 'render',
+      recoverable: true,
+      cause: error
+    });
+    this._error = openElementError;
+    // Trigger re-render with error state
+    this.update();
+  }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vaG9tZS9ydW5uZXIvd29yay9vcGVuZWxlbWVudC9vcGVuZWxlbWVudC9wYWNrYWdlcy9lbGVtZW50L3NyYy9lcnJvci1ib3VuZGFyeS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBvcGVuZWxlbWVudC9lbGVtZW50IOKAlCBFcnJvckJvdW5kYXJ5IChBRFItMDA1MyBMYXllciAyKS5cbiAqXG4gKiBDYXRjaGVzIGNoaWxkIGNvbXBvbmVudCByZW5kZXIoKSBlcnJvcnMgYW5kIGRpc3BsYXlzIGEgZmFsbGJhY2tcbiAqIFVJIGluc3RlYWQgb2YgYSBiYXJlIHRhZyBvciBicm9rZW4gRE9NLiBFcnJvcnMgYnViYmxlIHVwIHRocm91Z2hcbiAqIHRoZSBwYXJlbnQgdHJlZSBpZiBubyBib3VuZGFyeSBjYXRjaGVzIHRoZW0uXG4gKlxuICogdjAuMzYuMDogQWRkZWQgcmV0cnkgbWVjaGFuaXNtIGFuZCBkZWdyYWRlZCByZW5kZXJpbmcgZmFsbGJhY2suXG4gKlxuICogVXNhZ2U6XG4gKiBgYGB0c1xuICogY2xhc3MgTXlCb3VuZGFyeSBleHRlbmRzIEVycm9yQm91bmRhcnkge1xuICogICBvbkVycm9yKGVycm9yOiBPcGVuRWxlbWVudEVycm9yKSB7XG4gKiAgICAgcmV0dXJuIGh0bWxgPGVycm9yLXBhbmVsIC5tZXNzYWdlPSR7ZXJyb3IubWVzc2FnZX0+PC9lcnJvci1wYW5lbD5gO1xuICogICB9XG4gKiAgIHJlbmRlcigpIHtcbiAqICAgICByZXR1cm4gaHRtbGA8c2xvdD48L3Nsb3Q+YDtcbiAqICAgfVxuICogfVxuICogYGBgXG4gKi9cblxuaW1wb3J0IHR5cGUgeyBWTm9kZSB9IGZyb20gJ0BvcGVuZWxlbWVudC9wcm90b2NvbC92bm9kZSc7XG5pbXBvcnQgeyBPcGVuRWxlbWVudCB9IGZyb20gJy4vb3Blbi1lbGVtZW50LmpzJztcbmltcG9ydCB7IEVycm9yQ29kZSwgT3BlbkVsZW1lbnRFcnJvciB9IGZyb20gJ0BvcGVuZWxlbWVudC9jb3JlJztcbmltcG9ydCB0eXBlIHsgRXJyb3JTZXZlcml0eSB9IGZyb20gJ0BvcGVuZWxlbWVudC9wcm90b2NvbC9lcnJvcnMnO1xuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgRXJyb3JCb3VuZGFyeSBleHRlbmRzIE9wZW5FbGVtZW50IHtcbiAgcHJpdmF0ZSBfZXJyb3I6IE9wZW5FbGVtZW50RXJyb3IgfCBudWxsID0gbnVsbDtcbiAgcHJpdmF0ZSBfcmV0cnlDb3VudCA9IDA7XG5cbiAgLyoqIE1heGltdW0gbnVtYmVyIG9mIHJldHJ5IGF0dGVtcHRzIGJlZm9yZSBnaXZpbmcgdXAuIERlZmF1bHQ6IDMuICovXG4gIHByb3RlY3RlZCBtYXhSZXRyaWVzID0gMztcblxuICBnZXQgaGFzRXJyb3IoKTogYm9vbGVhbiB7XG4gICAgcmV0dXJuIHRoaXMuX2Vycm9yICE9PSBudWxsO1xuICB9XG5cbiAgZ2V0IGVycm9yKCk6IE9wZW5FbGVtZW50RXJyb3IgfCBudWxsIHtcbiAgICByZXR1cm4gdGhpcy5fZXJyb3I7XG4gIH1cblxuICBnZXQgcmV0cnlDb3VudCgpOiBudW1iZXIge1xuICAgIHJldHVybiB0aGlzLl9yZXRyeUNvdW50O1xuICB9XG5cbiAgLyoqXG4gICAqIFJlbmRlciBmYWxsYmFjayBVSSB3aGVuIGEgY2hpbGQgY29tcG9uZW50J3MgcmVuZGVyKCkgdGhyb3dzLlxuICAgKiBTdWJjbGFzc2VzIFNIT1VMRCBvdmVycmlkZSB0aGlzIGZvciBjdXN0b20gZXJyb3IgVUkuXG4gICAqXG4gICAqIERlZmF1bHQgaW1wbGVtZW50YXRpb24gcmVuZGVycyBhIGRlZ3JhZGVkIHN0YXRpYyBmYWxsYmFjay5cbiAgICovXG4gIG9uRXJyb3IoZXJyb3I6IE9wZW5FbGVtZW50RXJyb3IpOiBWTm9kZSB7XG4gICAgcmV0dXJuIHtcbiAgICAgIHRhZzogJ2RpdicsXG4gICAgICBwcm9wczogeyBjbGFzczogJ2Vycm9yLWJvdW5kYXJ5LWZhbGxiYWNrJywgcm9sZTogJ2FsZXJ0JyB9LFxuICAgICAgY2hpbGRyZW46IFtcbiAgICAgICAge1xuICAgICAgICAgIHRhZzogJ3AnLFxuICAgICAgICAgIHByb3BzOiB7fSxcbiAgICAgICAgICBjaGlsZHJlbjogW2BTb21ldGhpbmcgd2VudCB3cm9uZzogJHtlcnJvci5tZXNzYWdlfWBdLFxuICAgICAgICB9LFxuICAgICAgICB0aGlzLl9yZXRyeUNvdW50IDwgdGhpcy5tYXhSZXRyaWVzXG4gICAgICAgICAgPyB7XG4gICAgICAgICAgICB0YWc6ICdidXR0b24nLFxuICAgICAgICAgICAgcHJvcHM6IHtcbiAgICAgICAgICAgICAgb25jbGljazogKCkgPT4gdGhpcy5yZXRyeSgpLFxuICAgICAgICAgICAgfSxcbiAgICAgICAgICAgIGNoaWxkcmVuOiBbYFJldHJ5ICgke3RoaXMuX3JldHJ5Q291bnR9LyR7dGhpcy5tYXhSZXRyaWVzfSlgXSxcbiAgICAgICAgICB9XG4gICAgICAgICAgOiB7XG4gICAgICAgICAgICB0YWc6ICdwJyxcbiAgICAgICAgICAgIHByb3BzOiB7IGNsYXNzOiAnZXJyb3ItYm91bmRhcnktZXhoYXVzdGVkJyB9LFxuICAgICAgICAgICAgY2hpbGRyZW46IFsnTWF4IHJldHJpZXMgcmVhY2hlZC4gUGxlYXNlIHJlbG9hZCB0aGUgcGFnZS4nXSxcbiAgICAgICAgICB9LFxuICAgICAgXSxcbiAgICB9O1xuICB9XG5cbiAgLyoqXG4gICAqIFJldHJ5IHJlbmRlcmluZyBhZnRlciBhbiBlcnJvci4gUmVzZXRzIGVycm9yIHN0YXRlIGFuZCBpbmNyZW1lbnRzXG4gICAqIHJldHJ5IGNvdW50ZXIuIElmIG1heFJldHJpZXMgaXMgZXhjZWVkZWQsIHNob3dzIGV4aGF1c3RlZCBzdGF0ZS5cbiAgICovXG4gIHJldHJ5KCk6IHZvaWQge1xuICAgIGlmICh0aGlzLl9yZXRyeUNvdW50ID49IHRoaXMubWF4UmV0cmllcykge1xuICAgICAgcmV0dXJuOyAvLyBleGhhdXN0ZWRcbiAgICB9XG4gICAgdGhpcy5fcmV0cnlDb3VudCsrO1xuICAgIHRoaXMuX2Vycm9yID0gbnVsbDtcbiAgICB0aGlzLnVwZGF0ZSgpOyAvLyB0cmlnZ2VyIHJlLXJlbmRlclxuICB9XG5cbiAgLyoqXG4gICAqIEZ1bGx5IHJlc2V0IHRoZSBlcnJvciBib3VuZGFyeSwgaW5jbHVkaW5nIHJldHJ5IGNvdW50LlxuICAgKiBDYWxsIHRoaXMgd2hlbiB0aGUgdW5kZXJseWluZyBpc3N1ZSBoYXMgYmVlbiByZXNvbHZlZCBleHRlcm5hbGx5LlxuICAgKi9cbiAgcmVzZXQoKTogdm9pZCB7XG4gICAgdGhpcy5fZXJyb3IgPSBudWxsO1xuICAgIHRoaXMuX3JldHJ5Q291bnQgPSAwO1xuICAgIHRoaXMudXBkYXRlKCk7XG4gIH1cblxuICAvKipcbiAgICogQ2FwdHVyZSBhbmQgcmVzZXQgZXJyb3Igc3RhdGUgb24gcmUtcmVuZGVyLlxuICAgKi9cbiAgb3ZlcnJpZGUgY29ubmVjdGVkQ2FsbGJhY2soKTogdm9pZCB7XG4gICAgdGhpcy5fZXJyb3IgPSBudWxsO1xuICAgIHRoaXMuX3JldHJ5Q291bnQgPSAwO1xuICAgIHN1cGVyLmNvbm5lY3RlZENhbGxiYWNrKCk7XG4gIH1cblxuICAvKipcbiAgICogV3JhcCBjaGlsZCByZW5kZXIgaW4gdHJ5L2NhdGNoLlxuICAgKi9cbiAgb3ZlcnJpZGUgcmVuZGVyKCk6IFZOb2RlIHwgbnVsbCB7XG4gICAgaWYgKHRoaXMuX2Vycm9yKSB7XG4gICAgICByZXR1cm4gdGhpcy5vbkVycm9yKHRoaXMuX2Vycm9yKTtcbiAgICB9XG4gICAgcmV0dXJuIHN1cGVyLnJlbmRlcigpO1xuICB9XG5cbiAgLyoqXG4gICAqIENhbGwgdGhpcyBmcm9tIHBhcmVudCB0byBjYXRjaCBhIGNoaWxkJ3MgZXJyb3IuXG4gICAqL1xuICBjYXRjaEVycm9yKGVycm9yOiBFcnJvcik6IHZvaWQge1xuICAgIGNvbnN0IG9wZW5FbGVtZW50RXJyb3IgPSBlcnJvciBpbnN0YW5jZW9mIE9wZW5FbGVtZW50RXJyb3IgPyBlcnJvciA6IG5ldyBPcGVuRWxlbWVudEVycm9yKFxuICAgICAgZXJyb3IubWVzc2FnZSxcbiAgICAgIHtcbiAgICAgICAgY29kZTogRXJyb3JDb2RlLkJPVU5EQVJZX0NBVUdIVCxcbiAgICAgICAgc2V2ZXJpdHk6ICdlcnJvcicgYXMgRXJyb3JTZXZlcml0eSxcbiAgICAgICAgcGhhc2U6ICdyZW5kZXInLFxuICAgICAgICByZWNvdmVyYWJsZTogdHJ1ZSxcbiAgICAgICAgY2F1c2U6IGVycm9yLFxuICAgICAgfSxcbiAgICApO1xuICAgIHRoaXMuX2Vycm9yID0gb3BlbkVsZW1lbnRFcnJvcjtcbiAgICAvLyBUcmlnZ2VyIHJlLXJlbmRlciB3aXRoIGVycm9yIHN0YXRlXG4gICAgdGhpcy51cGRhdGUoKTtcbiAgfVxufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7OztDQW9CQyxHQUdELFNBQVMsV0FBVyxRQUFRLG9CQUFvQjtBQUNoRCxTQUFTLFNBQVMsRUFBRSxnQkFBZ0IsUUFBUSxvQkFBb0I7QUFHaEUsT0FBTyxNQUFlLHNCQUFzQjtFQUNsQyxTQUFrQyxLQUFLO0VBQ3ZDLGNBQWMsRUFBRTtFQUV4QixtRUFBbUUsR0FDbkUsQUFBVSxhQUFhLEVBQUU7RUFFekIsSUFBSSxXQUFvQjtJQUN0QixPQUFPLElBQUksQ0FBQyxNQUFNLEtBQUs7RUFDekI7RUFFQSxJQUFJLFFBQWlDO0lBQ25DLE9BQU8sSUFBSSxDQUFDLE1BQU07RUFDcEI7RUFFQSxJQUFJLGFBQXFCO0lBQ3ZCLE9BQU8sSUFBSSxDQUFDLFdBQVc7RUFDekI7RUFFQTs7Ozs7R0FLQyxHQUNELFFBQVEsS0FBdUIsRUFBUztJQUN0QyxPQUFPO01BQ0wsS0FBSztNQUNMLE9BQU87UUFBRSxPQUFPO1FBQTJCLE1BQU07TUFBUTtNQUN6RCxVQUFVO1FBQ1I7VUFDRSxLQUFLO1VBQ0wsT0FBTyxDQUFDO1VBQ1IsVUFBVTtZQUFDLENBQUMsc0JBQXNCLEVBQUUsTUFBTSxPQUFPLEVBQUU7V0FBQztRQUN0RDtRQUNBLElBQUksQ0FBQyxXQUFXLEdBQUcsSUFBSSxDQUFDLFVBQVUsR0FDOUI7VUFDQSxLQUFLO1VBQ0wsT0FBTztZQUNMLFNBQVMsSUFBTSxJQUFJLENBQUMsS0FBSztVQUMzQjtVQUNBLFVBQVU7WUFBQyxDQUFDLE9BQU8sRUFBRSxJQUFJLENBQUMsV0FBVyxDQUFDLENBQUMsRUFBRSxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQztXQUFDO1FBQzlELElBQ0U7VUFDQSxLQUFLO1VBQ0wsT0FBTztZQUFFLE9BQU87VUFBMkI7VUFDM0MsVUFBVTtZQUFDO1dBQStDO1FBQzVEO09BQ0g7SUFDSDtFQUNGO0VBRUE7OztHQUdDLEdBQ0QsUUFBYztJQUNaLElBQUksSUFBSSxDQUFDLFdBQVcsSUFBSSxJQUFJLENBQUMsVUFBVSxFQUFFO01BQ3ZDLFFBQVEsWUFBWTtJQUN0QjtJQUNBLElBQUksQ0FBQyxXQUFXO0lBQ2hCLElBQUksQ0FBQyxNQUFNLEdBQUc7SUFDZCxJQUFJLENBQUMsTUFBTSxJQUFJLG9CQUFvQjtFQUNyQztFQUVBOzs7R0FHQyxHQUNELFFBQWM7SUFDWixJQUFJLENBQUMsTUFBTSxHQUFHO0lBQ2QsSUFBSSxDQUFDLFdBQVcsR0FBRztJQUNuQixJQUFJLENBQUMsTUFBTTtFQUNiO0VBRUE7O0dBRUMsR0FDRCxBQUFTLG9CQUEwQjtJQUNqQyxJQUFJLENBQUMsTUFBTSxHQUFHO0lBQ2QsSUFBSSxDQUFDLFdBQVcsR0FBRztJQUNuQixLQUFLLENBQUM7RUFDUjtFQUVBOztHQUVDLEdBQ0QsQUFBUyxTQUF1QjtJQUM5QixJQUFJLElBQUksQ0FBQyxNQUFNLEVBQUU7TUFDZixPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLE1BQU07SUFDakM7SUFDQSxPQUFPLEtBQUssQ0FBQztFQUNmO0VBRUE7O0dBRUMsR0FDRCxXQUFXLEtBQVksRUFBUTtJQUM3QixNQUFNLG1CQUFtQixpQkFBaUIsbUJBQW1CLFFBQVEsSUFBSSxpQkFDdkUsTUFBTSxPQUFPLEVBQ2I7TUFDRSxNQUFNLFVBQVUsZUFBZTtNQUMvQixVQUFVO01BQ1YsT0FBTztNQUNQLGFBQWE7TUFDYixPQUFPO0lBQ1Q7SUFFRixJQUFJLENBQUMsTUFBTSxHQUFHO0lBQ2QscUNBQXFDO0lBQ3JDLElBQUksQ0FBQyxNQUFNO0VBQ2I7QUFDRiJ9

package/src/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Canonical component-authoring facade for openElement.
+ *
+ * This package is the single import surface for authoring custom elements,
+ * DSD components, and islands. Build orchestration remains in
+ * @openelement/app and @openelement/adapter-vite.
+ */ export { OpenElement } from "./open-element.js";
+export type { OpenElementComponentConstructor } from "./open-element.js";
+export { ErrorBoundary } from "./error-boundary.js";
+export { defineElement, defineLayout } from "./define-element.js";
+export type { ElementDefinition } from "./types.js";
+export type { PropDecl, PropDeclFull, PropDeclShorthand, PropsFrom, PropType } from '@openelement/protocol/prop';
+export { disposeStaticProps, handleStaticPropAttributeChange, initializeStaticProps, normalizePropDecl, registerStaticObservedAttributes, syncStaticPropsFromAttributes, unwrap } from '@openelement/core/prop';
+export { Fragment, jsx, jsxDEV, jsxs } from '@openelement/core/jsx-runtime';
+export type { OpenElementRenderer } from '@openelement/protocol/framework';
+export type { VNode } from '@openelement/protocol/vnode';
+export { isVNode } from '@openelement/core';
+export { renderDsdTree, renderToDom } from '@openelement/core';
+export { consumeContext, createContext, provideContext } from '@openelement/core';
+export type { Context } from '@openelement/core';
+export type { OpenElementError, PropValidationError, RenderError, SsrRenderError } from '@openelement/core';
+export type { ErrorCode, ErrorPhase, ErrorSeverity } from '@openelement/protocol/errors';
+export type { SignalLike } from '@openelement/protocol/signal';
+export { isSignalLike } from '@openelement/core';
+export { computed, effect, signal } from '@openelement/signal';
+export type { Signal } from '@openelement/protocol/signal';
+export { escapeAttr, escapeAttrValue, escapeHtml } from '@openelement/core';
+export type { SafeHtml, UnsafeHtml } from '@openelement/protocol/framework';
+export { trustedHtml } from '@openelement/core';
+export { bindSsrProps, defineIsland, getSsrProps } from '@openelement/core';
+export type { IslandOptions } from '@openelement/protocol/island';
+export { StyleSheet } from '@openelement/core/style-sheet';
+export type { StyleSheetLike, StyleSheetRule } from '@openelement/protocol/style-sheet';

package/src/index.js

@@ -0,0 +1,29 @@
+/**
+ * Canonical component-authoring facade for openElement.
+ *
+ * This package is the single import surface for authoring custom elements,
+ * DSD components, and islands. Build orchestration remains in
+ * @openelement/app and @openelement/adapter-vite.
+ */ // ─── Core exports ───────────────────────────────────────
+export { OpenElement } from './open-element.js';
+export { ErrorBoundary } from './error-boundary.js';
+export { defineElement, defineLayout } from './define-element.js';
+export { disposeStaticProps, handleStaticPropAttributeChange, initializeStaticProps, normalizePropDecl, registerStaticObservedAttributes, syncStaticPropsFromAttributes, unwrap } from '@openelement/core/prop';
+// ─── JSX runtime (re-export from core) ───────────────────
+export { Fragment, jsx, jsxDEV, jsxs } from '@openelement/core/jsx-runtime';
+export { isVNode } from '@openelement/core';
+// ─── Renderers (re-export from core) ─────────────────────
+export { renderDsdTree, renderToDom } from '@openelement/core';
+// ─── Context (re-export from core) ───────────────────────
+export { consumeContext, createContext, provideContext } from '@openelement/core';
+export { isSignalLike } from '@openelement/core';
+export { computed, effect, signal } from '@openelement/signal';
+// ─── HTML utilities (re-export from core) ────────────────
+export { escapeAttr, escapeAttrValue, escapeHtml } from '@openelement/core';
+// ─── Trusted HTML (re-export from core) ──────────────────────────
+export { trustedHtml } from '@openelement/core';
+// ─── Island utilities (re-export from core) ──────────────
+export { bindSsrProps, defineIsland, getSsrProps } from '@openelement/core';
+// ─── StyleSheet (re-export from core) ────────────────────
+export { StyleSheet } from '@openelement/core/style-sheet';
+//# sourceMappingURL=data:application/json;base64,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

package/src/open-element-hydration.js

@@ -0,0 +1,120 @@
+/**
+ * Internal hydration helpers for OpenElement.
+ *
+ * Extracted from open-element.ts to isolate DSD signal/event hydration logic
+ * from the base class lifecycle. These functions are NOT part of the public
+ * package surface and should only be consumed by OpenElement itself.
+ *
+ * @internal
+ * @module @openelement/element/open-element-hydration
+ */ import { applyBindingDescriptor, collectEventBindings, hydrateEventMarkers, isVNode } from '@openelement/core';
+import { DATA_SIGNAL, DATA_SIGNAL_ATTR, DATA_SIGNAL_CLASS, DATA_SIGNAL_RENDER, parseSignalAttrSpec } from '@openelement/protocol/hydration-markers';
+import { disposeRenderBindings } from './open-element-render.js';
+/**
+ * v0.28 (ADR-0067): Signal-native hydration.
+ *
+ * Reads data-signal markers from the DSD shadow root and creates direct
+ * signal→DOM effect bindings. No position matching, no childNodes filtering,
+ * no VNode traversal.
+ *
+ * Effects are added to `effectDisposers` for batch cleanup. VNode event marker
+ * listeners are added to `eventCleanups`.
+ */ function collectHydrationBindings(shadowRoot, signalRegistry) {
+  const descriptors = [];
+  // --- Signal → text / class / attribute bindings: data-signal="signalName" ---
+  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({
+          kind: 'signal-class',
+          el,
+          className,
+          signal: sig
+        });
+      }
+    }
+    if (hasAttr) {
+      const attrSpec = el.getAttribute(DATA_SIGNAL_ATTR);
+      if (attrSpec) {
+        const attrNames = parseSignalAttrSpec(attrSpec);
+        if (attrNames.length > 0) {
+          descriptors.push({
+            kind: 'signal-attr',
+            el,
+            attrNames,
+            signal: sig
+          });
+        }
+      }
+    }
+    if (!hasClass && !hasAttr) {
+      descriptors.push({
+        kind: 'signal-text',
+        el,
+        signal: sig
+      });
+    }
+  }
+  // --- Signal → VNode rendering: data-signal-render="signalName" (v0.30.1 / ADR-0081) ---
+  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({
+      kind: 'signal-render',
+      el,
+      signal: sig,
+      lifecycle: {}
+    });
+  }
+  return descriptors;
+}
+export function hydrateSignals(instance, shadowRoot, signalRegistry, effectDisposers, eventCleanups, cache) {
+  const lifecycle = {
+    disposers: effectDisposers
+  };
+  const descriptors = collectHydrationBindings(shadowRoot, signalRegistry);
+  for (const desc of descriptors){
+    if (desc.kind === 'signal-render') {
+      desc.lifecycle = lifecycle;
+      // 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);
+  }
+  // v0.28.1: Cache VNode so SSR and hydration use the same event IDs.
+  // render() may have been called at build time for SSR — reuse cached VNode
+  // if available, otherwise call render() once and cache for hydration.
+  if (!cache.get().valid) {
+    cache.set(instance.render());
+  }
+  const vnode = cache.get().vnode;
+  if (isVNode(vnode)) {
+    hydrateEventMarkers(shadowRoot, collectEventBindings(vnode), eventCleanups, instance);
+  }
+  // Chromium DSD layout fix: force reflow without DOM rebuild
+  requestAnimationFrame(()=>{
+    void instance.offsetHeight;
+  });
+}
+/**
+ * Hydrate DSD DOM with signal and event bindings.
+ *
+ * v0.28 (ADR-0067): Disposes previous effects and events, then delegates to
+ * hydrateSignals().
+ */ export function hydrateExistingDom(instance, signalRegistry, effectDisposers, eventCleanups, cache) {
+  if (!instance.shadowRoot) return eventCleanups;
+  const newEventCleanups = disposeRenderBindings(effectDisposers, eventCleanups);
+  hydrateSignals(instance, instance.shadowRoot, signalRegistry, effectDisposers, newEventCleanups, cache);
+  return newEventCleanups;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/element/src/open-element-hydration.ts"],"sourcesContent":["/**\n * Internal hydration helpers for OpenElement.\n *\n * Extracted from open-element.ts to isolate DSD signal/event hydration logic\n * from the base class lifecycle. These functions are NOT part of the public\n * package surface and should only be consumed by OpenElement itself.\n *\n * @internal\n * @module @openelement/element/open-element-hydration\n */\n\nimport {\n  applyBindingDescriptor,\n  collectEventBindings,\n  hydrateEventMarkers,\n  isVNode,\n} from '@openelement/core';\nimport type { BindingDescriptor, BindingLifecycle } from '@openelement/core';\nimport type { Signal } from '@openelement/protocol/signal';\nimport {\n  DATA_SIGNAL,\n  DATA_SIGNAL_ATTR,\n  DATA_SIGNAL_CLASS,\n  DATA_SIGNAL_RENDER,\n  parseSignalAttrSpec,\n} from '@openelement/protocol/hydration-markers';\nimport { disposeRenderBindings, type VNodeCacheAccess } from './open-element-render.js';\nimport type { OpenElement } from './open-element.js';\n\n/**\n * v0.28 (ADR-0067): Signal-native hydration.\n *\n * Reads data-signal markers from the DSD shadow root and creates direct\n * signal→DOM effect bindings. No position matching, no childNodes filtering,\n * no VNode traversal.\n *\n * Effects are added to `effectDisposers` for batch cleanup. VNode event marker\n * listeners are added to `eventCleanups`.\n */\nfunction collectHydrationBindings(\n  shadowRoot: ShadowRoot,\n  signalRegistry: Map<string, Signal<unknown>>,\n): BindingDescriptor[] {\n  const descriptors: BindingDescriptor[] = [];\n\n  // --- Signal → text / class / attribute bindings: data-signal=\"signalName\" ---\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({\n          kind: 'signal-class',\n          el,\n          className,\n          signal: sig,\n        });\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({\n            kind: 'signal-attr',\n            el,\n            attrNames,\n            signal: sig,\n          });\n        }\n      }\n    }\n\n    if (!hasClass && !hasAttr) {\n      descriptors.push({\n        kind: 'signal-text',\n        el,\n        signal: sig,\n      });\n    }\n  }\n\n  // --- Signal → VNode rendering: data-signal-render=\"signalName\" (v0.30.1 / ADR-0081) ---\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({\n      kind: 'signal-render',\n      el,\n      signal: sig,\n      lifecycle: {}, // Filled by hydrateSignals before application.\n    });\n  }\n\n  return descriptors;\n}\n\nexport function hydrateSignals(\n  instance: OpenElement,\n  shadowRoot: ShadowRoot,\n  signalRegistry: Map<string, Signal<unknown>>,\n  effectDisposers: Set<() => void>,\n  eventCleanups: Array<() => void>,\n  cache: VNodeCacheAccess,\n): void {\n  const lifecycle: BindingLifecycle = { disposers: effectDisposers };\n  const descriptors = collectHydrationBindings(shadowRoot, signalRegistry);\n\n  for (const desc of descriptors) {\n    if (desc.kind === 'signal-render') {\n      desc.lifecycle = lifecycle;\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);\n  }\n\n  // v0.28.1: Cache VNode so SSR and hydration use the same event IDs.\n  // render() may have been called at build time for SSR — reuse cached VNode\n  // if available, otherwise call render() once and cache for hydration.\n  if (!cache.get().valid) {\n    cache.set(instance.render());\n  }\n  const vnode = cache.get().vnode;\n  if (isVNode(vnode)) {\n    hydrateEventMarkers(shadowRoot, collectEventBindings(vnode), eventCleanups, instance);\n  }\n\n  // Chromium DSD layout fix: force reflow without DOM rebuild\n  requestAnimationFrame(() => {\n    void (instance as HTMLElement).offsetHeight;\n  });\n}\n\n/**\n * Hydrate DSD DOM with signal and event bindings.\n *\n * v0.28 (ADR-0067): Disposes previous effects and events, then delegates to\n * hydrateSignals().\n */\nexport function hydrateExistingDom(\n  instance: OpenElement,\n  signalRegistry: Map<string, Signal<unknown>>,\n  effectDisposers: Set<() => void>,\n  eventCleanups: Array<() => void>,\n  cache: VNodeCacheAccess,\n): Array<() => void> {\n  if (!instance.shadowRoot) return eventCleanups;\n\n  const newEventCleanups = disposeRenderBindings(effectDisposers, eventCleanups);\n  hydrateSignals(\n    instance,\n    instance.shadowRoot,\n    signalRegistry,\n    effectDisposers,\n    newEventCleanups,\n    cache,\n  );\n\n  return newEventCleanups;\n}\n"],"names":[],"mappings":"AAAA;;;;;;;;;CASC,GAED,SACE,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,OAAO,QACF,oBAAoB;AAG3B,SACE,WAAW,EACX,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,QACd,0CAA0C;AACjD,SAAS,qBAAqB,QAA+B,2BAA2B;AAGxF;;;;;;;;;CASC,GACD,SAAS,yBACP,UAAsB,EACtB,cAA4C;EAE5C,MAAM,cAAmC,EAAE;EAE3C,+EAA+E;EAC/E,KAAK,MAAM,MAAM,WAAW,gBAAgB,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,EAAG;IAChE,MAAM,OAAO,GAAG,YAAY,CAAC;IAC7B,IAAI,CAAC,MAAM;IACX,MAAM,MAAM,eAAe,GAAG,CAAC;IAC/B,IAAI,CAAC,KAAK;IAEV,MAAM,WAAW,GAAG,YAAY,CAAC;IACjC,MAAM,UAAU,GAAG,YAAY,CAAC;IAEhC,IAAI,UAAU;MACZ,MAAM,YAAY,GAAG,YAAY,CAAC;MAClC,IAAI,WAAW;QACb,YAAY,IAAI,CAAC;UACf,MAAM;UACN;UACA;UACA,QAAQ;QACV;MACF;IACF;IAEA,IAAI,SAAS;MACX,MAAM,WAAW,GAAG,YAAY,CAAC;MACjC,IAAI,UAAU;QACZ,MAAM,YAAY,oBAAoB;QACtC,IAAI,UAAU,MAAM,GAAG,GAAG;UACxB,YAAY,IAAI,CAAC;YACf,MAAM;YACN;YACA;YACA,QAAQ;UACV;QACF;MACF;IACF;IAEA,IAAI,CAAC,YAAY,CAAC,SAAS;MACzB,YAAY,IAAI,CAAC;QACf,MAAM;QACN;QACA,QAAQ;MACV;IACF;EACF;EAEA,yFAAyF;EACzF,KAAK,MAAM,MAAM,WAAW,gBAAgB,CAAC,CAAC,CAAC,EAAE,mBAAmB,CAAC,CAAC,EAAG;IACvE,MAAM,OAAO,GAAG,YAAY,CAAC;IAC7B,IAAI,CAAC,MAAM;IACX,MAAM,MAAM,eAAe,GAAG,CAAC;IAC/B,IAAI,CAAC,KAAK;IAEV,YAAY,IAAI,CAAC;MACf,MAAM;MACN;MACA,QAAQ;MACR,WAAW,CAAC;IACd;EACF;EAEA,OAAO;AACT;AAEA,OAAO,SAAS,eACd,QAAqB,EACrB,UAAsB,EACtB,cAA4C,EAC5C,eAAgC,EAChC,aAAgC,EAChC,KAAuB;EAEvB,MAAM,YAA8B;IAAE,WAAW;EAAgB;EACjE,MAAM,cAAc,yBAAyB,YAAY;EAEzD,KAAK,MAAM,QAAQ,YAAa;IAC9B,IAAI,KAAK,IAAI,KAAK,iBAAiB;MACjC,KAAK,SAAS,GAAG;MACjB,wEAAwE;MACxE,2DAA2D;MAC3D,MAAO,KAAK,EAAE,CAAC,UAAU,CAAE,KAAK,EAAE,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC,UAAU;IACnE;IACA,uBAAuB,MAAM;EAC/B;EAEA,oEAAoE;EACpE,2EAA2E;EAC3E,sEAAsE;EACtE,IAAI,CAAC,MAAM,GAAG,GAAG,KAAK,EAAE;IACtB,MAAM,GAAG,CAAC,SAAS,MAAM;EAC3B;EACA,MAAM,QAAQ,MAAM,GAAG,GAAG,KAAK;EAC/B,IAAI,QAAQ,QAAQ;IAClB,oBAAoB,YAAY,qBAAqB,QAAQ,eAAe;EAC9E;EAEA,4DAA4D;EAC5D,sBAAsB;IACpB,KAAK,AAAC,SAAyB,YAAY;EAC7C;AACF;AAEA;;;;;CAKC,GACD,OAAO,SAAS,mBACd,QAAqB,EACrB,cAA4C,EAC5C,eAAgC,EAChC,aAAgC,EAChC,KAAuB;EAEvB,IAAI,CAAC,SAAS,UAAU,EAAE,OAAO;EAEjC,MAAM,mBAAmB,sBAAsB,iBAAiB;EAChE,eACE,UACA,SAAS,UAAU,EACnB,gBACA,iBACA,kBACA;EAGF,OAAO;AACT"}