@openelement/core 0.41.0-alpha.1

package/src/context.js

@@ -0,0 +1,76 @@
+/**
+ * @openelement/core - Request Context
+ * Provides a per-request context object that flows through SSR rendering
+ * and is accessible to islands and layout components.
+ *
+ * Web Standards alignment:
+ * - Built on standard Request/URL APIs
+ * - Minimal framework overhead - only what's needed for SSR + Islands
+ */ import { createLogger } from './logger.js';
+import { formatError } from './errors.js';
+const log = createLogger('core');
+/**
+ * Extract route params from a pathname using a route pattern.
+ * e.g., pattern '/posts/:id' + pathname '/posts/123' -> { id: '123' }
+ *
+ * Uses WHATWG URLPattern API - available in:
+ *   ✅ Deno 1.33+ (native, no flags)
+ *   ✅ Node.js 19+ (--experimental-url-pattern)
+ *   ✅ Bun (native)
+ *   ✅ All modern browsers
+ */ export function extractParams(pattern, pathname) {
+  try {
+    const urlPattern = new URLPattern({
+      pathname: pattern
+    });
+    const match = urlPattern.exec({
+      pathname,
+      protocol: 'https',
+      hostname: 'localhost'
+    });
+    return match?.pathname?.groups ?? {};
+  } catch (err) {
+    log.error(`URLPattern failed for pattern "${pattern}" on pathname "${pathname}": ${formatError(err)}`);
+    return {};
+  }
+}
+/**
+ * Parse URL search params into a plain object.
+ * Uses standard URLSearchParams - zero framework magic.
+ * Supports multi-value keys (e.g., ?tag=a&tag=b -> { tag: ['a', 'b'] }).
+ */ export function parseQuery(url) {
+  const query = {};
+  // v0.14.3: Simplified - use `key in query` instead of separate `seen` Set
+  url.searchParams.forEach((value, key)=>{
+    if (key in query) {
+      const existing = query[key];
+      // M-02 fix: Use Array.isArray check instead of fragile type assertion
+      query[key] = Array.isArray(existing) ? [
+        ...existing,
+        value
+      ] : [
+        existing,
+        value
+      ];
+    } else {
+      query[key] = value;
+    }
+  });
+  return query;
+}
+/**
+ * Create a fresh SsrContext for a request.
+ * This is the single source of truth for per-request state.
+ */ export function createSsrContext(route, url, options = {}) {
+  return {
+    route,
+    url,
+    params: extractParams(route.path, url.pathname),
+    query: parseQuery(url),
+    islands: [],
+    status: 200,
+    data: {},
+    requestId: options.requestId
+  };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/csr.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @openelement/core/csr - Client-side rendering runtime surface.
+ *
+ * Includes the static rendering surface plus the full DOM renderer and event
+ * hydration helpers. Used for CSR fallbacks and pure islands.
+ *
+ * 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 { applyProps, collectPropBindings, renderToDom } from "./jsx-render-dom.js";
+export { collectEventBindings, eventRecordsToDescriptors, hydrateEventMarkers } from "./event-hydration.js";
+export type { EventBinding, EventBindingRecord } from "./event-hydration.js";

package/src/csr.js

@@ -0,0 +1,14 @@
+/**
+ * @openelement/core/csr - Client-side rendering runtime surface.
+ *
+ * Includes the static rendering surface plus the full DOM renderer and event
+ * hydration helpers. Used for CSR fallbacks and pure islands.
+ *
+ * ADR-0109 Phase 1: split @openelement/core into static, hydrate, and csr.
+ */ export * from './static.js';
+export { applyBindingDescriptor } 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

package/src/dsd-hydration-events.d.ts

@@ -0,0 +1,2 @@
+import type { HydrateEventDescriptor } from '@openelement/protocol/framework';
+export declare function bindHydrateEvents(root: ParentNode, host: object, events: readonly HydrateEventDescriptor[], signal: AbortSignal): void;

package/src/dsd-hydration-events.js

@@ -0,0 +1,13 @@
+export function bindHydrateEvents(root, host, events, signal) {
+  for (const desc of events){
+    if (desc.method.startsWith('__')) continue;
+    const handler = Reflect.get(host, desc.method);
+    if (typeof handler !== 'function') continue;
+    for (const el of root.querySelectorAll(desc.selector)){
+      el.addEventListener(desc.event, handler.bind(host), {
+        signal
+      });
+    }
+  }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vaG9tZS9ydW5uZXIvd29yay9vcGVuZWxlbWVudC9vcGVuZWxlbWVudC9wYWNrYWdlcy9jb3JlL3NyYy9kc2QtaHlkcmF0aW9uLWV2ZW50cy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IEh5ZHJhdGVFdmVudERlc2NyaXB0b3IgfSBmcm9tICdAb3BlbmVsZW1lbnQvcHJvdG9jb2wvZnJhbWV3b3JrJztcblxuZXhwb3J0IGZ1bmN0aW9uIGJpbmRIeWRyYXRlRXZlbnRzKFxuICByb290OiBQYXJlbnROb2RlLFxuICBob3N0OiBvYmplY3QsXG4gIGV2ZW50czogcmVhZG9ubHkgSHlkcmF0ZUV2ZW50RGVzY3JpcHRvcltdLFxuICBzaWduYWw6IEFib3J0U2lnbmFsLFxuKTogdm9pZCB7XG4gIGZvciAoY29uc3QgZGVzYyBvZiBldmVudHMpIHtcbiAgICBpZiAoZGVzYy5tZXRob2Quc3RhcnRzV2l0aCgnX18nKSkgY29udGludWU7XG4gICAgY29uc3QgaGFuZGxlciA9IFJlZmxlY3QuZ2V0KGhvc3QsIGRlc2MubWV0aG9kKTtcbiAgICBpZiAodHlwZW9mIGhhbmRsZXIgIT09ICdmdW5jdGlvbicpIGNvbnRpbnVlO1xuXG4gICAgZm9yIChjb25zdCBlbCBvZiByb290LnF1ZXJ5U2VsZWN0b3JBbGwoZGVzYy5zZWxlY3RvcikpIHtcbiAgICAgIGVsLmFkZEV2ZW50TGlzdGVuZXIoZGVzYy5ldmVudCwgaGFuZGxlci5iaW5kKGhvc3QpIGFzIEV2ZW50TGlzdGVuZXIsIHsgc2lnbmFsIH0pO1xuICAgIH1cbiAgfVxufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sU0FBUyxrQkFDZCxJQUFnQixFQUNoQixJQUFZLEVBQ1osTUFBeUMsRUFDekMsTUFBbUI7RUFFbkIsS0FBSyxNQUFNLFFBQVEsT0FBUTtJQUN6QixJQUFJLEtBQUssTUFBTSxDQUFDLFVBQVUsQ0FBQyxPQUFPO0lBQ2xDLE1BQU0sVUFBVSxRQUFRLEdBQUcsQ0FBQyxNQUFNLEtBQUssTUFBTTtJQUM3QyxJQUFJLE9BQU8sWUFBWSxZQUFZO0lBRW5DLEtBQUssTUFBTSxNQUFNLEtBQUssZ0JBQWdCLENBQUMsS0FBSyxRQUFRLEVBQUc7TUFDckQsR0FBRyxnQkFBZ0IsQ0FBQyxLQUFLLEtBQUssRUFBRSxRQUFRLElBQUksQ0FBQyxPQUF3QjtRQUFFO01BQU87SUFDaEY7RUFDRjtBQUNGIn0=

package/src/dsd-hydration.d.ts

@@ -0,0 +1,40 @@
+/**
+ * DSD Hydration contract — shared interface for all adapter packages.
+ * ADR-0079: Extracted from adapter-lit/vanilla/react.
+ */ export interface DsdHydration {
+  _dsdHydrated: boolean;
+  _hydrateEvents(): void;
+}
+export type Constructor<T = HTMLElement> = new(...args: unknown[]) => T;
+import type { HydrateEventDescriptor } from '@openelement/protocol/framework';
+/**
+ * Shared DSD createRenderRoot logic.
+ *
+ * Detects a pre-populated shadow root (from SSR DSD), marks the element as
+ * hydrated, and returns the existing shadow root. Otherwise attaches a new
+ * open shadow root.
+ *
+ * Accepts `HTMLElement` and internally casts to `DsdHydration` to set the
+ * `_dsdHydrated` flag. This allows callers where `_dsdHydrated` is declared
+ * as `protected` in their mixin class hierarchy.
+ *
+ * Extracted from adapter-lit / adapter-react / adapter-vanilla to avoid
+ * triplicate identical implementations.
+ */ export declare function createDsdRenderRoot(element: HTMLElement): ShadowRoot;
+/**
+ * Shared _hydrateEvents logic.
+ *
+ * Reads `hydrateEvents` from the constructor, creates an AbortController,
+ * and binds event listeners on the element's shadow root via bindHydrateEvents.
+ *
+ * Returns the AbortController so the caller can store it (e.g. in a private
+ * `_hydrateAbortController` field) and abort listeners on disconnect.
+ *
+ * Accepts `HTMLElement` and internally casts to `DsdHydration` to avoid
+ * accessibility conflicts with `protected` members in caller classes.
+ *
+ * Extracted from adapter-lit / adapter-react / adapter-vanilla to avoid
+ * triplicate identical implementations.
+ */ export declare function hydrateDsdEvents(element: HTMLElement, ctor: {
+  hydrateEvents?: readonly HydrateEventDescriptor[];
+}): AbortController | undefined;

package/src/dsd-hydration.js

@@ -0,0 +1,48 @@
+/**
+ * DSD Hydration contract — shared interface for all adapter packages.
+ * ADR-0079: Extracted from adapter-lit/vanilla/react.
+ */ import { bindHydrateEvents } from './dsd-hydration-events.js';
+/**
+ * Shared DSD createRenderRoot logic.
+ *
+ * Detects a pre-populated shadow root (from SSR DSD), marks the element as
+ * hydrated, and returns the existing shadow root. Otherwise attaches a new
+ * open shadow root.
+ *
+ * Accepts `HTMLElement` and internally casts to `DsdHydration` to set the
+ * `_dsdHydrated` flag. This allows callers where `_dsdHydrated` is declared
+ * as `protected` in their mixin class hierarchy.
+ *
+ * Extracted from adapter-lit / adapter-react / adapter-vanilla to avoid
+ * triplicate identical implementations.
+ */ export function createDsdRenderRoot(element) {
+  if (element.shadowRoot && element.shadowRoot.childElementCount > 0) {
+    return element.shadowRoot;
+  }
+  return element.attachShadow({
+    mode: 'open'
+  });
+}
+/**
+ * Shared _hydrateEvents logic.
+ *
+ * Reads `hydrateEvents` from the constructor, creates an AbortController,
+ * and binds event listeners on the element's shadow root via bindHydrateEvents.
+ *
+ * Returns the AbortController so the caller can store it (e.g. in a private
+ * `_hydrateAbortController` field) and abort listeners on disconnect.
+ *
+ * Accepts `HTMLElement` and internally casts to `DsdHydration` to avoid
+ * accessibility conflicts with `protected` members in caller classes.
+ *
+ * Extracted from adapter-lit / adapter-react / adapter-vanilla to avoid
+ * triplicate identical implementations.
+ */ export function hydrateDsdEvents(element, ctor) {
+  if (!element.shadowRoot) return undefined;
+  const events = ctor.hydrateEvents || [];
+  if (events.length === 0) return undefined;
+  const controller = new AbortController();
+  bindHydrateEvents(element.shadowRoot, element, events, controller.signal);
+  return controller;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/errors.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @openelement/core — Unified Error Architecture (ADR-0053 / SOP-011).
+ */ import type { RenderError as ProtocolRenderError } from '@openelement/protocol/render';
+/** Well-known error code constants for reference. String values are always accepted. */ export declare const ErrorCode: {
+  readonly SSR_RENDER_ERROR: 'SSR_RENDER_ERROR';
+  readonly ISLAND_RENDER_ERROR: 'ISLAND_RENDER_ERROR';
+  readonly PROP_VALIDATION_ERROR: 'PROP_VALIDATION_ERROR';
+  readonly TAG_VALIDATION_ERROR: 'TAG_VALIDATION_ERROR';
+  readonly NAVIGATION_ERROR: 'NAVIGATION_ERROR';
+  readonly BUILD_ERROR: 'BUILD_ERROR';
+  readonly RENDER_ERROR: 'RENDER_ERROR';
+  readonly BOUNDARY_CAUGHT: 'BOUNDARY_CAUGHT';
+  readonly UNKNOWN: 'UNKNOWN';
+};
+/** Error message prefix for all openElement errors. */ export declare const ERROR_PREFIX: '[openElement]';
+/** Format an unknown thrown value as a human-readable string. */ export declare function formatError(e: unknown): string;
+import type { ErrorPhase, ErrorSeverity } from '@openelement/protocol/errors';
+export type { ErrorPhase, ErrorSeverity };
+export interface OpenElementErrorOptions {
+  cause?: Error;
+  code?: string;
+  statusCode?: number;
+  severity?: ErrorSeverity;
+  phase?: ErrorPhase;
+  recoverable?: boolean;
+}
+export declare class OpenElementError extends Error {
+  public readonly code: string;
+  public readonly severity: ErrorSeverity;
+  public readonly phase: ErrorPhase;
+  public readonly recoverable: boolean;
+  public readonly statusCode?: number;
+  constructor(message: string, options?: OpenElementErrorOptions);
+  toJSON(): Record<string, unknown>;
+}
+export declare class SsrRenderError extends OpenElementError {
+  public readonly componentPath: string;
+  public readonly sourceError: Error;
+  constructor(componentPath: string, sourceError: Error);
+}
+export declare class RenderError extends OpenElementError implements ProtocolRenderError {
+  public readonly componentPath: string;
+  public readonly tagName: string;
+  constructor(componentPath: string, message: string, code?: string, tagName?: string, cause?: Error);
+}
+export declare class PropValidationError extends OpenElementError {
+  public readonly propertyName: string;
+  public readonly receivedValue: unknown;
+  constructor(propertyName: string, receivedValue: unknown, cause?: Error);
+}
+import type { ErrorTelemetryHook } from '@openelement/protocol/errors';
+export type { ErrorTelemetryHook };
+export declare function setErrorTelemetryHook(hook: ErrorTelemetryHook): void;
+export declare function reportError(error: OpenElementError): void;

package/src/errors.js

@@ -0,0 +1,113 @@
+/**
+ * @openelement/core — Unified Error Architecture (ADR-0053 / SOP-011).
+ */ /** Well-known error code constants for reference. String values are always accepted. */ // ponytail: duplicated from protocol to avoid cross-package runtime import in SSG bundles
+export const ErrorCode = {
+  SSR_RENDER_ERROR: 'SSR_RENDER_ERROR',
+  ISLAND_RENDER_ERROR: 'ISLAND_RENDER_ERROR',
+  PROP_VALIDATION_ERROR: 'PROP_VALIDATION_ERROR',
+  TAG_VALIDATION_ERROR: 'TAG_VALIDATION_ERROR',
+  NAVIGATION_ERROR: 'NAVIGATION_ERROR',
+  BUILD_ERROR: 'BUILD_ERROR',
+  RENDER_ERROR: 'RENDER_ERROR',
+  BOUNDARY_CAUGHT: 'BOUNDARY_CAUGHT',
+  UNKNOWN: 'UNKNOWN'
+};
+/** Error message prefix for all openElement errors. */ export const ERROR_PREFIX = '[openElement]';
+// ─── Error formatting helper ────────────────────────────────────────
+/** Format an unknown thrown value as a human-readable string. */ export function formatError(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+export class OpenElementError extends Error {
+  code;
+  severity;
+  phase;
+  recoverable;
+  statusCode;
+  constructor(message, options = {}){
+    super(message, options.cause ? {
+      cause: options.cause
+    } : undefined);
+    this.name = 'OpenElementError';
+    this.code = options.code ?? ErrorCode.UNKNOWN;
+    this.severity = options.severity ?? 'error';
+    this.phase = options.phase ?? 'unknown';
+    this.recoverable = options.recoverable ?? false;
+    this.statusCode = options.statusCode;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      severity: this.severity,
+      phase: this.phase,
+      recoverable: this.recoverable,
+      statusCode: this.statusCode,
+      cause: this.cause instanceof Error ? this.cause.message : this.cause
+    };
+  }
+}
+// ─── SsrRenderError (backward compat) ────────────────────────────────
+export class SsrRenderError extends OpenElementError {
+  componentPath;
+  sourceError;
+  constructor(componentPath, sourceError){
+    super(`SSR render failed: ${componentPath}`, {
+      code: 'SSR_RENDER_ERROR',
+      severity: 'error',
+      phase: 'ssr',
+      recoverable: false,
+      cause: sourceError
+    });
+    this.name = 'SsrRenderError';
+    this.componentPath = componentPath;
+    this.sourceError = sourceError;
+  }
+}
+// ─── New ADR-0053 error classes ─────────────────────────────────────
+export class RenderError extends OpenElementError {
+  componentPath;
+  tagName;
+  constructor(componentPath, message, code = 'RENDER_ERROR', tagName = '', cause){
+    super(message, {
+      code,
+      severity: 'error',
+      phase: 'render',
+      recoverable: true,
+      cause
+    });
+    this.name = 'RenderError';
+    this.componentPath = componentPath;
+    this.tagName = tagName;
+  }
+}
+export class PropValidationError extends OpenElementError {
+  propertyName;
+  receivedValue;
+  constructor(propertyName, receivedValue, cause){
+    super(`@prop validation failed for "${propertyName}"`, {
+      code: 'PROP_VALIDATION_ERROR',
+      severity: 'warning',
+      phase: 'validation',
+      recoverable: true,
+      cause
+    });
+    this.name = 'PropValidationError';
+    this.propertyName = propertyName;
+    this.receivedValue = receivedValue;
+  }
+}
+let _telemetryHook;
+export function setErrorTelemetryHook(hook) {
+  _telemetryHook = hook;
+}
+export function reportError(error) {
+  if (_telemetryHook) {
+    try {
+      _telemetryHook(error);
+    } catch  {}
+  } else {
+    console.error(`[openElement:${error.code}] ${error.message}`);
+  }
+} // ─── SSR Error Context ──────────────────────────────────────────────
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/core/src/errors.ts"],"sourcesContent":["/**\n * @openelement/core — Unified Error Architecture (ADR-0053 / SOP-011).\n */\n\nimport type { RenderError as ProtocolRenderError } from '@openelement/protocol/render';\n\n/** Well-known error code constants for reference. String values are always accepted. */\n// ponytail: duplicated from protocol to avoid cross-package runtime import in SSG bundles\nexport const ErrorCode = {\n  SSR_RENDER_ERROR: 'SSR_RENDER_ERROR',\n  ISLAND_RENDER_ERROR: 'ISLAND_RENDER_ERROR',\n  PROP_VALIDATION_ERROR: 'PROP_VALIDATION_ERROR',\n  TAG_VALIDATION_ERROR: 'TAG_VALIDATION_ERROR',\n  NAVIGATION_ERROR: 'NAVIGATION_ERROR',\n  BUILD_ERROR: 'BUILD_ERROR',\n  RENDER_ERROR: 'RENDER_ERROR',\n  BOUNDARY_CAUGHT: 'BOUNDARY_CAUGHT',\n  UNKNOWN: 'UNKNOWN',\n} as const;\n\n/** Error message prefix for all openElement errors. */\nexport const ERROR_PREFIX = '[openElement]';\n\n// ─── Error formatting helper ────────────────────────────────────────\n\n/** Format an unknown thrown value as a human-readable string. */\nexport function formatError(e: unknown): string {\n  return e instanceof Error ? e.message : String(e);\n}\n\n// ─── Types ──────────────────────────────────────────────────────────\n\nimport type { ErrorPhase, ErrorSeverity } from '@openelement/protocol/errors';\nexport type { ErrorPhase, ErrorSeverity };\n\n// ─── Base Error ─────────────────────────────────────────────────────\n\nexport interface OpenElementErrorOptions {\n  cause?: Error;\n  code?: string;\n  statusCode?: number;\n  severity?: ErrorSeverity;\n  phase?: ErrorPhase;\n  recoverable?: boolean;\n}\n\nexport class OpenElementError extends Error {\n  public readonly code: string;\n  public readonly severity: ErrorSeverity;\n  public readonly phase: ErrorPhase;\n  public readonly recoverable: boolean;\n  public readonly statusCode?: number;\n\n  constructor(message: string, options: OpenElementErrorOptions = {}) {\n    super(message, options.cause ? { cause: options.cause } : undefined);\n    this.name = 'OpenElementError';\n    this.code = options.code ?? ErrorCode.UNKNOWN;\n    this.severity = options.severity ?? 'error';\n    this.phase = options.phase ?? 'unknown';\n    this.recoverable = options.recoverable ?? false;\n    this.statusCode = options.statusCode;\n  }\n\n  toJSON(): Record<string, unknown> {\n    return {\n      name: this.name,\n      code: this.code,\n      message: this.message,\n      severity: this.severity,\n      phase: this.phase,\n      recoverable: this.recoverable,\n      statusCode: this.statusCode,\n      cause: this.cause instanceof Error ? this.cause.message : this.cause,\n    };\n  }\n}\n\n// ─── SsrRenderError (backward compat) ────────────────────────────────\n\nexport class SsrRenderError extends OpenElementError {\n  public readonly componentPath: string;\n  public readonly sourceError: Error;\n\n  constructor(componentPath: string, sourceError: Error) {\n    super(`SSR render failed: ${componentPath}`, {\n      code: 'SSR_RENDER_ERROR',\n      severity: 'error',\n      phase: 'ssr',\n      recoverable: false,\n      cause: sourceError,\n    });\n    this.name = 'SsrRenderError';\n    this.componentPath = componentPath;\n    this.sourceError = sourceError;\n  }\n}\n\n// ─── New ADR-0053 error classes ─────────────────────────────────────\n\nexport class RenderError extends OpenElementError implements ProtocolRenderError {\n  public readonly componentPath: string;\n  public readonly tagName: string;\n\n  constructor(\n    componentPath: string,\n    message: string,\n    code = 'RENDER_ERROR',\n    tagName = '',\n    cause?: Error,\n  ) {\n    super(message, {\n      code,\n      severity: 'error',\n      phase: 'render',\n      recoverable: true,\n      cause,\n    });\n    this.name = 'RenderError';\n    this.componentPath = componentPath;\n    this.tagName = tagName;\n  }\n}\n\nexport class PropValidationError extends OpenElementError {\n  public readonly propertyName: string;\n  public readonly receivedValue: unknown;\n\n  constructor(propertyName: string, receivedValue: unknown, cause?: Error) {\n    super(`@prop validation failed for \"${propertyName}\"`, {\n      code: 'PROP_VALIDATION_ERROR',\n      severity: 'warning',\n      phase: 'validation',\n      recoverable: true,\n      cause,\n    });\n    this.name = 'PropValidationError';\n    this.propertyName = propertyName;\n    this.receivedValue = receivedValue;\n  }\n}\n\n// ─── Error Telemetry ────────────────────────────────────────────────\n\nimport type { ErrorTelemetryHook } from '@openelement/protocol/errors';\nexport type { ErrorTelemetryHook };\n\nlet _telemetryHook: ErrorTelemetryHook | undefined;\n\nexport function setErrorTelemetryHook(hook: ErrorTelemetryHook): void {\n  _telemetryHook = hook;\n}\n\nexport function reportError(error: OpenElementError): void {\n  if (_telemetryHook) {\n    try {\n      _telemetryHook(error);\n    } catch { /* must not throw */ }\n  } else {\n    console.error(`[openElement:${error.code}] ${error.message}`);\n  }\n}\n\n// ─── SSR Error Context ──────────────────────────────────────────────\n"],"names":[],"mappings":"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"}

package/src/event-hydration.d.ts

@@ -0,0 +1,12 @@
+import type { EventBindingDescriptor } from "./binding-descriptor.js";
+export { createEventMarkerContext, eventMarkerId, eventTypeFromProp, serializeEventMarkers } from "./event-marker.js";
+export type { EventMarkerContext } from "./event-marker.js";
+export interface EventBindingRecord {
+  id: string;
+  type: string;
+  handler: EventListener;
+}
+/** Hydration-time event binding contract (mirrors BindingDescriptor). */ export type EventBinding = EventBindingDescriptor;
+export declare function collectEventBindings(node: unknown): Map<string, EventBindingRecord[]>;
+export declare function eventRecordsToDescriptors(el: Element, records: EventBindingRecord[], owner?: unknown): EventBinding[];
+export declare function hydrateEventMarkers(root: Element | ShadowRoot, bindings: Map<string, EventBindingRecord[]>, cleanupBag: Array<() => void>, owner?: unknown): void;

package/src/event-hydration.js

@@ -0,0 +1,118 @@
+/**
+ * Marker-based event hydration for SSR VNode output.
+ *
+ * SSR emits deterministic `data-eid` markers. During DSD upgrade,
+ * DsdElement renders the same VNode tree in memory, collects event handlers in
+ * the same traversal order, and binds them to matching DOM markers without
+ * replacing the existing DSD DOM.
+ */ import { FOR_TAG, Fragment, SHOW_TAG } from './jsx-runtime.js';
+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 { 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';
+export function collectEventBindings(node) {
+  const bindings = new Map();
+  let count = 0;
+  const visit = (value)=>{
+    if (value == null || value === false || typeof value === 'string' || typeof value === 'number') {
+      return;
+    }
+    if (isSignalLike(value)) {
+      visit(value.value);
+      return;
+    }
+    if (!isVNode(value)) return;
+    const { tag, props, children } = value;
+    if (tag === Fragment || typeof tag === 'symbol' && String(tag) === 'Symbol(openelement.fragment)') {
+      for (const child of children)visit(child);
+      return;
+    }
+    if (tag === SHOW_TAG || tag === 'show') {
+      const whenVal = isSignalLike(props?.when) ? props.when.value : props?.when;
+      const target = whenVal ? children[0] : children[1];
+      visit(target);
+      return;
+    }
+    if (tag === FOR_TAG || tag === 'fore') {
+      const items = isSignalLike(props?.each) ? props.each.value : props?.each;
+      const renderFn = children[0];
+      if (Array.isArray(items) && typeof renderFn === 'function') {
+        items.forEach((item, i)=>visit(renderFn(item, i)));
+      }
+      return;
+    }
+    if (isComponentCtor(tag)) {
+      try {
+        const instance = new tag();
+        for (const [k, v] of Object.entries(props)){
+          instance[k] = v;
+        }
+        visit(instance.render());
+      } catch  {
+        return;
+      }
+      return;
+    }
+    if (typeof tag === 'function') {
+      try {
+        visit(tag({
+          ...props,
+          children
+        }));
+      } catch  {
+        return;
+      }
+      return;
+    }
+    const records = [];
+    for (const [key, value] of Object.entries(props ?? {})){
+      const type = eventTypeFromProp(key);
+      if (type && typeof value === 'function') {
+        records.push({
+          id: '',
+          type,
+          handler: value
+        });
+      }
+    }
+    // Visit children before assigning an ID to this element so the order
+    // matches SSR (renderToNode serializes children first).
+    for (const child of children)visit(child);
+    if (records.length > 0) {
+      const id = eventMarkerId(count++);
+      bindings.set(id, records.map((record)=>({
+          ...record,
+          id
+        })));
+    }
+  };
+  visit(node);
+  return bindings;
+}
+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
+    };
+  });
+}
+export function hydrateEventMarkers(root, bindings, cleanupBag, owner) {
+  for (const el of root.querySelectorAll(`[${DATA_EID}]`)){
+    const id = el.getAttribute(DATA_EID);
+    if (!id) continue;
+    const records = bindings.get(id);
+    if (!records) continue;
+    for (const desc of eventRecordsToDescriptors(el, records, owner)){
+      const dispose = applyBindingDescriptor(desc, {});
+      cleanupBag.push(dispose);
+    }
+  }
+}
+//# 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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"}

package/src/event-marker.d.ts

@@ -0,0 +1,7 @@
+export interface EventMarkerContext {
+  nextId(): string;
+}
+export declare function createEventMarkerContext(): EventMarkerContext;
+export declare function eventMarkerId(index: number): string;
+export declare function eventTypeFromProp(prop: string): string | null;
+export declare function serializeEventMarkers(props: Record<string, unknown> | undefined, context: EventMarkerContext): string;

package/src/event-marker.js

@@ -0,0 +1,54 @@
+/**
+ * @openelement/core - Deterministic event marker generation for SSR output.
+ *
+ * Pure, side-effect-free helper used by the SSR renderer to emit `data-eid`
+ * markers. This module intentionally does NOT depend on the DOM binding layer
+ * so that static-only bundles can use it without pulling in hydration code.
+ *
+ * Hydration-time binding logic lives in `event-hydration.ts`.
+ *
+ * @module @openelement/core/event-marker
+ */ import { DATA_EID } from '@openelement/protocol/hydration-markers';
+const EVENT_PROP_RE = /^on[A-Z]/;
+const EVENT_TYPE_ALIASES = {
+  Dblclick: 'dblclick',
+  DoubleClick: 'dblclick',
+  FocusIn: 'focusin',
+  FocusOut: 'focusout',
+  MouseEnter: 'mouseenter',
+  MouseLeave: 'mouseleave',
+  PointerCancel: 'pointercancel',
+  PointerDown: 'pointerdown',
+  PointerEnter: 'pointerenter',
+  PointerLeave: 'pointerleave',
+  PointerMove: 'pointermove',
+  PointerOut: 'pointerout',
+  PointerOver: 'pointerover',
+  PointerUp: 'pointerup'
+};
+export function createEventMarkerContext() {
+  let count = 0;
+  return {
+    nextId () {
+      return eventMarkerId(count++);
+    }
+  };
+}
+export function eventMarkerId(index) {
+  return `e${index}`;
+}
+export function eventTypeFromProp(prop) {
+  if (!EVENT_PROP_RE.test(prop)) return null;
+  const eventName = prop.slice(2);
+  return EVENT_TYPE_ALIASES[eventName] ?? eventName.toLowerCase();
+}
+export function serializeEventMarkers(props, context) {
+  if (!props) return '';
+  for (const [key, value] of Object.entries(props)){
+    if (eventTypeFromProp(key) && typeof value === 'function') {
+      return ` ${DATA_EID}="${context.nextId()}"`;
+    }
+  }
+  return '';
+}
+//# sourceMappingURL=data:application/json;base64,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