@openelement/core 0.41.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zhi
+
+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,36 @@
+# @openelement/core
+
+Advanced openElement runtime kernel.
+
+Most users should start from `@openelement/app`, `@openelement/element`, or
+`@openelement/ui`. `@openelement/core` owns low-level primitives used by those
+products:
+
+- JSX and VNode runtime primitives.
+- DSD rendering through `renderDsd()` and `renderDsdStream()`.
+- Static props, event hydration, island metadata, and SSR context helpers.
+- Unified errors, signal-like utilities, and DOM rendering helpers.
+- StyleSheet (SSR-safe CSSStyleSheet abstraction).
+
+The `OpenElement` base class is now authored from `@openelement/element`.
+
+This package does not contain Vite, CLI, or build orchestration logic.
+
+## Install
+
+```bash
+npm install @openelement/core
+```
+
+## Low-Level Component Authoring
+
+For component authoring with `OpenElement`, ErrorBoundary, prop system,
+and defineElement helper, use `@openelement/element`:
+
+```bash
+npm install @openelement/element
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,124 @@
+{
+  "name": "@openelement/core",
+  "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"
+    },
+    "./static": {
+      "types": "./src/static.d.ts",
+      "import": "./src/static.js",
+      "default": "./src/static.js"
+    },
+    "./hydrate": {
+      "types": "./src/hydrate.d.ts",
+      "import": "./src/hydrate.js",
+      "default": "./src/hydrate.js"
+    },
+    "./csr": {
+      "types": "./src/csr.d.ts",
+      "import": "./src/csr.js",
+      "default": "./src/csr.js"
+    },
+    "./prop": {
+      "types": "./src/prop.d.ts",
+      "import": "./src/prop.js",
+      "default": "./src/prop.js"
+    },
+    "./errors": {
+      "types": "./src/errors.d.ts",
+      "import": "./src/errors.js",
+      "default": "./src/errors.js"
+    },
+    "./context": {
+      "types": "./src/context.d.ts",
+      "import": "./src/context.js",
+      "default": "./src/context.js"
+    },
+    "./logger": {
+      "types": "./src/logger.d.ts",
+      "import": "./src/logger.js",
+      "default": "./src/logger.js"
+    },
+    "./isr": {
+      "types": "./src/isr.d.ts",
+      "import": "./src/isr.js",
+      "default": "./src/isr.js"
+    },
+    "./isr-runtime": {
+      "types": "./src/isr-runtime.d.ts",
+      "import": "./src/isr-runtime.js",
+      "default": "./src/isr-runtime.js"
+    },
+    "./runtime": {
+      "types": "./src/runtime.d.ts",
+      "import": "./src/runtime.js",
+      "default": "./src/runtime.js"
+    },
+    "./signal-context": {
+      "types": "./src/signal-context.d.ts",
+      "import": "./src/signal-context.js",
+      "default": "./src/signal-context.js"
+    },
+    "./render-dsd-stream": {
+      "types": "./src/render-dsd-stream.d.ts",
+      "import": "./src/render-dsd-stream.js",
+      "default": "./src/render-dsd-stream.js"
+    },
+    "./style-sheet": {
+      "types": "./src/style-sheet.d.ts",
+      "import": "./src/style-sheet.js",
+      "default": "./src/style-sheet.js"
+    },
+    "./html-escape": {
+      "types": "./src/html-escape.d.ts",
+      "import": "./src/html-escape.js",
+      "default": "./src/html-escape.js"
+    },
+    "./tag-utils": {
+      "types": "./src/tag-utils.d.ts",
+      "import": "./src/tag-utils.js",
+      "default": "./src/tag-utils.js"
+    },
+    "./jsx-runtime": {
+      "types": "./src/jsx-runtime.d.ts",
+      "import": "./src/jsx-runtime.js",
+      "default": "./src/jsx-runtime.js"
+    },
+    "./jsx-dev-runtime": {
+      "types": "./src/jsx-runtime.d.ts",
+      "import": "./src/jsx-runtime.js",
+      "default": "./src/jsx-runtime.js"
+    },
+    "./island-transform": {
+      "types": "./src/island-transform.d.ts",
+      "import": "./src/island-transform.js",
+      "default": "./src/island-transform.js"
+    },
+    "./dsd-hydration": {
+      "types": "./src/dsd-hydration.d.ts",
+      "import": "./src/dsd-hydration.js",
+      "default": "./src/dsd-hydration.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/signal": "^0.41.0-alpha.1"
+  }
+}

package/src/binding-activation.d.ts

@@ -0,0 +1,2 @@
+import type { BindingDescriptor, BindingDispose, BindingLifecycle } from "./binding-descriptor.js";
+/** Apply a single binding descriptor and return a dispose function. */ export declare function applyBindingDescriptor(desc: BindingDescriptor, lifecycle: BindingLifecycle): BindingDispose;

package/src/binding-activation.js

@@ -0,0 +1,254 @@
+/**
+ * @openelement/core - Unified binding activation (ADR-0109 Phase 1).
+ *
+ * Applies a declarative BindingDescriptor to a host element.
+ *
+ * @module @openelement/core/binding-activation
+ */ import { effect, unwrapSignalLike } from '@openelement/signal';
+import { trustRenderHtml } from './security.js';
+import { renderToDom } from './jsx-render-dom.js';
+import { Fragment } from './jsx-runtime.js';
+import { createLogger } from './logger.js';
+import { formatError } from './errors.js';
+const bindingLog = createLogger('binding');
+const noop = ()=>{};
+/** Register a dispose function with the lifecycle. */ export function registerDispose(dispose, lifecycle) {
+  lifecycle.disposers?.add(dispose);
+  if (lifecycle.signal) {
+    lifecycle.signal.addEventListener('abort', dispose, {
+      once: true
+    });
+  }
+}
+/** Apply a single binding descriptor and return a dispose function. */ export function applyBindingDescriptor(desc, lifecycle) {
+  switch(desc.kind){
+    case 'static-attr':
+      return applyStaticAttr(desc, lifecycle);
+    case 'static-prop':
+      return applyStaticProp(desc, lifecycle);
+    case 'static-boolean':
+      return applyStaticBoolean(desc, lifecycle);
+    case 'static-style':
+      return applyStaticStyle(desc, lifecycle);
+    case 'signal-text':
+      return applySignalText(desc, lifecycle);
+    case 'signal-class':
+      return applySignalClass(desc, lifecycle);
+    case 'signal-attr':
+      return applySignalAttr(desc, lifecycle);
+    case 'signal-html':
+      return applySignalHtml(desc, lifecycle);
+    case 'signal-render':
+      return applySignalRender(desc, lifecycle);
+    case 'event':
+      return applyEvent(desc, lifecycle);
+    case 'ref':
+      return applyRef(desc, lifecycle);
+    default:
+      {
+        // Exhaustiveness guard: unknown descriptor kinds are no-ops.
+        const _exhaustive = desc;
+        void _exhaustive;
+        return noop;
+      }
+  }
+}
+function applyStaticAttr(desc, _lifecycle) {
+  if (desc.value == null) {
+    desc.el.removeAttribute(desc.attrName);
+  } else {
+    desc.el.setAttribute(desc.attrName, String(desc.value));
+  }
+  return noop;
+}
+function applyStaticProp(desc, _lifecycle) {
+  desc.el[desc.propName] = desc.value;
+  return noop;
+}
+function applyStaticBoolean(desc, _lifecycle) {
+  if (desc.value) {
+    desc.el.setAttribute(desc.attrName, '');
+  } else {
+    desc.el.removeAttribute(desc.attrName);
+  }
+  return noop;
+}
+function applyStaticStyle(desc, _lifecycle) {
+  const target = desc.el;
+  for (const [k, v] of Object.entries(desc.value)){
+    target.style.setProperty(k, String(v));
+  }
+  return noop;
+}
+function applySignalText(desc, lifecycle) {
+  const target = desc.el;
+  const sig = desc.signal;
+  const update = ()=>{
+    const value = unwrapSignalLike(sig.value);
+    const text = value == null ? '' : String(value);
+    target.textContent = text;
+  };
+  const dispose = effect(()=>{
+    try {
+      update();
+    } catch (err) {
+      bindingLog.error(`signal-text binding failed: ${formatError(err)}`);
+    }
+  });
+  registerDispose(dispose, lifecycle);
+  return dispose;
+}
+function applySignalClass(desc, lifecycle) {
+  const { el, className, signal } = desc;
+  const update = ()=>{
+    const value = Boolean(unwrapSignalLike(signal.value));
+    el.classList.toggle(className, value);
+  };
+  const dispose = effect(()=>{
+    try {
+      update();
+    } catch (err) {
+      bindingLog.error(`signal-class binding failed: ${formatError(err)}`);
+    }
+  });
+  registerDispose(dispose, lifecycle);
+  return dispose;
+}
+function applySignalAttr(desc, lifecycle) {
+  const { el, attrNames, signal } = desc;
+  const update = ()=>{
+    const value = unwrapSignalLike(signal.value);
+    for (const attrName of attrNames){
+      if (value == null || value === false) {
+        el.removeAttribute(attrName);
+      } else if (value === true) {
+        el.setAttribute(attrName, '');
+      } else {
+        el.setAttribute(attrName, String(value));
+      }
+    }
+  };
+  const dispose = effect(()=>{
+    try {
+      update();
+    } catch (err) {
+      bindingLog.error(`signal-attr binding failed: ${formatError(err)}`);
+    }
+  });
+  registerDispose(dispose, lifecycle);
+  return dispose;
+}
+function applySignalHtml(desc, lifecycle) {
+  const { el, signal, trusted } = desc;
+  const update = ()=>{
+    const raw = unwrapSignalLike(signal.value);
+    const str = raw == null ? '' : String(raw);
+    if (trusted) {
+      el.innerHTML = trustRenderHtml(str);
+    } else {
+      el.textContent = str;
+    }
+  };
+  const dispose = effect(()=>{
+    try {
+      update();
+    } catch (err) {
+      bindingLog.error(`signal-html binding failed: ${formatError(err)}`);
+    }
+  });
+  registerDispose(dispose, lifecycle);
+  return dispose;
+}
+function applySignalRender(desc, lifecycle) {
+  const { el, signal } = desc;
+  let currentChildren = [];
+  const currentNestedDisposers = new Set();
+  const clearRender = ()=>{
+    for (const dispose of currentNestedDisposers){
+      try {
+        dispose();
+      } catch (err) {
+        bindingLog.error(`signal-render nested dispose failed: ${formatError(err)}`);
+      }
+    }
+    currentNestedDisposers.clear();
+    for (const child of currentChildren){
+      child.remove();
+    }
+    currentChildren = [];
+  };
+  const render = ()=>{
+    clearRender();
+    const raw = unwrapSignalLike(signal.value);
+    if (raw == null) return;
+    // Render into a fresh child lifecycle so nested signal effects can be
+    // disposed per render without leaking into previous renders.
+    const renderLifecycle = {
+      disposers: currentNestedDisposers
+    };
+    if (lifecycle.signal) {
+      renderLifecycle.signal = lifecycle.signal;
+    }
+    // Normalize VNode[] into a Fragment so multiple rendered nodes can be
+    // tracked and replaced together across updates.
+    const node = Array.isArray(raw) ? {
+      tag: Fragment,
+      props: {},
+      children: raw
+    } : raw;
+    const result = renderToDom(node, renderLifecycle);
+    if (result.nodeType === 11 || result.nodeType === 0) {
+      const fragChildren = [];
+      while(result.firstChild){
+        const child = result.firstChild;
+        fragChildren.push(child);
+        el.appendChild(child);
+      }
+      currentChildren = fragChildren;
+    } else {
+      const child = result;
+      el.appendChild(child);
+      currentChildren = [
+        child
+      ];
+    }
+  };
+  const dispose = effect(()=>{
+    try {
+      render();
+    } catch (err) {
+      bindingLog.error(`signal-render binding failed: ${formatError(err)}`);
+    }
+  });
+  const fullDispose = ()=>{
+    clearRender();
+    dispose();
+  };
+  registerDispose(fullDispose, lifecycle);
+  return fullDispose;
+}
+function applyEvent(desc, lifecycle) {
+  const { el, type, handler, options } = desc;
+  const listenerOptions = lifecycle.signal ? {
+    ...typeof options === 'object' && options !== null ? options : {},
+    signal: lifecycle.signal
+  } : options ?? {};
+  el.addEventListener(type, handler, listenerOptions);
+  const dispose = ()=>{
+    el.removeEventListener(type, handler, listenerOptions);
+  };
+  // When no AbortSignal was provided we still want an explicit dispose path.
+  if (!lifecycle.signal) {
+    registerDispose(dispose, lifecycle);
+  }
+  return dispose;
+}
+function applyRef(desc, _lifecycle) {
+  try {
+    desc.callback(desc.el);
+  } catch (err) {
+    bindingLog.error(`ref binding failed: ${formatError(err)}`);
+  }
+  return noop;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/core/src/binding-activation.ts"],"sourcesContent":["/**\n * @openelement/core - Unified binding activation (ADR-0109 Phase 1).\n *\n * Applies a declarative BindingDescriptor to a host element.\n *\n * @module @openelement/core/binding-activation\n */\n\nimport { effect, unwrapSignalLike } from '@openelement/signal';\nimport { trustRenderHtml } from './security.js';\nimport { renderToDom } from './jsx-render-dom.js';\nimport { Fragment } from './jsx-runtime.js';\nimport { createLogger } from './logger.js';\nimport { formatError } from './errors.js';\nimport type { BindingDescriptor, BindingDispose, BindingLifecycle } from './binding-descriptor.js';\n\nconst bindingLog = createLogger('binding');\n\nconst noop: BindingDispose = () => {};\n\n/** Register a dispose function with the lifecycle. */\nexport function registerDispose(dispose: BindingDispose, lifecycle: BindingLifecycle): void {\n  lifecycle.disposers?.add(dispose);\n  if (lifecycle.signal) {\n    lifecycle.signal.addEventListener('abort', dispose, { once: true });\n  }\n}\n\n/** Apply a single binding descriptor and return a dispose function. */\nexport function applyBindingDescriptor(\n  desc: BindingDescriptor,\n  lifecycle: BindingLifecycle,\n): BindingDispose {\n  switch (desc.kind) {\n    case 'static-attr':\n      return applyStaticAttr(desc, lifecycle);\n    case 'static-prop':\n      return applyStaticProp(desc, lifecycle);\n    case 'static-boolean':\n      return applyStaticBoolean(desc, lifecycle);\n    case 'static-style':\n      return applyStaticStyle(desc, lifecycle);\n    case 'signal-text':\n      return applySignalText(desc, lifecycle);\n    case 'signal-class':\n      return applySignalClass(desc, lifecycle);\n    case 'signal-attr':\n      return applySignalAttr(desc, lifecycle);\n    case 'signal-html':\n      return applySignalHtml(desc, lifecycle);\n    case 'signal-render':\n      return applySignalRender(desc, lifecycle);\n    case 'event':\n      return applyEvent(desc, lifecycle);\n    case 'ref':\n      return applyRef(desc, lifecycle);\n    default: {\n      // Exhaustiveness guard: unknown descriptor kinds are no-ops.\n      const _exhaustive: never = desc;\n      void _exhaustive;\n      return noop;\n    }\n  }\n}\n\nfunction applyStaticAttr(\n  desc: Extract<BindingDescriptor, { kind: 'static-attr' }>,\n  _lifecycle: BindingLifecycle,\n): BindingDispose {\n  if (desc.value == null) {\n    desc.el.removeAttribute(desc.attrName);\n  } else {\n    desc.el.setAttribute(desc.attrName, String(desc.value));\n  }\n  return noop;\n}\n\nfunction applyStaticProp(\n  desc: Extract<BindingDescriptor, { kind: 'static-prop' }>,\n  _lifecycle: BindingLifecycle,\n): BindingDispose {\n  (desc.el as unknown as Record<string, unknown>)[desc.propName] = desc.value;\n  return noop;\n}\n\nfunction applyStaticBoolean(\n  desc: Extract<BindingDescriptor, { kind: 'static-boolean' }>,\n  _lifecycle: BindingLifecycle,\n): BindingDispose {\n  if (desc.value) {\n    desc.el.setAttribute(desc.attrName, '');\n  } else {\n    desc.el.removeAttribute(desc.attrName);\n  }\n  return noop;\n}\n\nfunction applyStaticStyle(\n  desc: Extract<BindingDescriptor, { kind: 'static-style' }>,\n  _lifecycle: BindingLifecycle,\n): BindingDispose {\n  const target = desc.el as HTMLElement;\n  for (const [k, v] of Object.entries(desc.value)) {\n    target.style.setProperty(k, String(v));\n  }\n  return noop;\n}\n\nfunction applySignalText(\n  desc: Extract<BindingDescriptor, { kind: 'signal-text' }>,\n  lifecycle: BindingLifecycle,\n): BindingDispose {\n  const target = desc.el as Text | Element;\n  const sig = desc.signal;\n\n  const update = () => {\n    const value = unwrapSignalLike(sig.value);\n    const text = value == null ? '' : String(value);\n    target.textContent = text;\n  };\n\n  const dispose = effect(() => {\n    try {\n      update();\n    } catch (err) {\n      bindingLog.error(`signal-text binding failed: ${formatError(err)}`);\n    }\n  });\n  registerDispose(dispose, lifecycle);\n  return dispose;\n}\n\nfunction applySignalClass(\n  desc: Extract<BindingDescriptor, { kind: 'signal-class' }>,\n  lifecycle: BindingLifecycle,\n): BindingDispose {\n  const { el, className, signal } = desc;\n\n  const update = () => {\n    const value = Boolean(unwrapSignalLike(signal.value));\n    el.classList.toggle(className, value);\n  };\n\n  const dispose = effect(() => {\n    try {\n      update();\n    } catch (err) {\n      bindingLog.error(`signal-class binding failed: ${formatError(err)}`);\n    }\n  });\n  registerDispose(dispose, lifecycle);\n  return dispose;\n}\n\nfunction applySignalAttr(\n  desc: Extract<BindingDescriptor, { kind: 'signal-attr' }>,\n  lifecycle: BindingLifecycle,\n): BindingDispose {\n  const { el, attrNames, signal } = desc;\n\n  const update = () => {\n    const value = unwrapSignalLike(signal.value);\n    for (const attrName of attrNames) {\n      if (value == null || value === false) {\n        el.removeAttribute(attrName);\n      } else if (value === true) {\n        el.setAttribute(attrName, '');\n      } else {\n        el.setAttribute(attrName, String(value));\n      }\n    }\n  };\n\n  const dispose = effect(() => {\n    try {\n      update();\n    } catch (err) {\n      bindingLog.error(`signal-attr binding failed: ${formatError(err)}`);\n    }\n  });\n  registerDispose(dispose, lifecycle);\n  return dispose;\n}\n\nfunction applySignalHtml(\n  desc: Extract<BindingDescriptor, { kind: 'signal-html' }>,\n  lifecycle: BindingLifecycle,\n): BindingDispose {\n  const { el, signal, trusted } = desc;\n\n  const update = () => {\n    const raw = unwrapSignalLike(signal.value);\n    const str = raw == null ? '' : String(raw);\n    if (trusted) {\n      el.innerHTML = trustRenderHtml(str);\n    } else {\n      el.textContent = str;\n    }\n  };\n\n  const dispose = effect(() => {\n    try {\n      update();\n    } catch (err) {\n      bindingLog.error(`signal-html binding failed: ${formatError(err)}`);\n    }\n  });\n  registerDispose(dispose, lifecycle);\n  return dispose;\n}\n\nfunction applySignalRender(\n  desc: Extract<BindingDescriptor, { kind: 'signal-render' }>,\n  lifecycle: BindingLifecycle,\n): BindingDispose {\n  const { el, signal } = desc;\n\n  let currentChildren: ChildNode[] = [];\n  const currentNestedDisposers = new Set<() => void>();\n\n  const clearRender = () => {\n    for (const dispose of currentNestedDisposers) {\n      try {\n        dispose();\n      } catch (err) {\n        bindingLog.error(`signal-render nested dispose failed: ${formatError(err)}`);\n      }\n    }\n    currentNestedDisposers.clear();\n    for (const child of currentChildren) {\n      child.remove();\n    }\n    currentChildren = [];\n  };\n\n  const render = () => {\n    clearRender();\n    const raw = unwrapSignalLike(signal.value);\n    if (raw == null) return;\n\n    // Render into a fresh child lifecycle so nested signal effects can be\n    // disposed per render without leaking into previous renders.\n    const renderLifecycle: BindingLifecycle = {\n      disposers: currentNestedDisposers,\n    };\n    if (lifecycle.signal) {\n      renderLifecycle.signal = lifecycle.signal;\n    }\n\n    // Normalize VNode[] into a Fragment so multiple rendered nodes can be\n    // tracked and replaced together across updates.\n    const node = Array.isArray(raw) ? { tag: Fragment, props: {}, children: raw } : raw;\n    const result = renderToDom(node, renderLifecycle);\n\n    if (result.nodeType === 11 || result.nodeType === 0) {\n      const fragChildren: ChildNode[] = [];\n      while (result.firstChild) {\n        const child = result.firstChild as ChildNode;\n        fragChildren.push(child);\n        el.appendChild(child);\n      }\n      currentChildren = fragChildren;\n    } else {\n      const child = result as ChildNode;\n      el.appendChild(child);\n      currentChildren = [child];\n    }\n  };\n\n  const dispose = effect(() => {\n    try {\n      render();\n    } catch (err) {\n      bindingLog.error(`signal-render binding failed: ${formatError(err)}`);\n    }\n  });\n\n  const fullDispose: BindingDispose = () => {\n    clearRender();\n    dispose();\n  };\n  registerDispose(fullDispose, lifecycle);\n  return fullDispose;\n}\n\nfunction applyEvent(\n  desc: Extract<BindingDescriptor, { kind: 'event' }>,\n  lifecycle: BindingLifecycle,\n): BindingDispose {\n  const { el, type, handler, options } = desc;\n\n  const listenerOptions: AddEventListenerOptions | boolean = lifecycle.signal\n    ? {\n      ...(typeof options === 'object' && options !== null ? options : {}),\n      signal: lifecycle.signal,\n    }\n    : (options ?? {});\n\n  el.addEventListener(type, handler, listenerOptions);\n\n  const dispose: BindingDispose = () => {\n    el.removeEventListener(type, handler, listenerOptions);\n  };\n\n  // When no AbortSignal was provided we still want an explicit dispose path.\n  if (!lifecycle.signal) {\n    registerDispose(dispose, lifecycle);\n  }\n  return dispose;\n}\n\nfunction applyRef(\n  desc: Extract<BindingDescriptor, { kind: 'ref' }>,\n  _lifecycle: BindingLifecycle,\n): BindingDispose {\n  try {\n    desc.callback(desc.el);\n  } catch (err) {\n    bindingLog.error(`ref binding failed: ${formatError(err)}`);\n  }\n  return noop;\n}\n"],"names":[],"mappings":"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"}

package/src/binding-descriptor.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @openelement/core - Unified binding descriptor types (ADR-0109 Phase 1).
+ *
+ * Declarative DOM binding contracts used by the runtime and hydration layers.
+ * Each descriptor captures one side effect to apply to a host element.
+ *
+ * @module @openelement/core/binding-descriptor
+ */ import type { Signal } from '@openelement/protocol/signal';
+/** Shared lifecycle context for a set of bindings. */ export interface BindingLifecycle {
+  /** AbortSignal that triggers automatic disposal when aborted. */ signal?: AbortSignal;
+  /** Explicit disposers collected for batch cleanup. */ disposers?: Set<() => void>;
+}
+/** Dispose function returned by bindings and registered into lifecycle. */ export type BindingDispose = () => void;
+export interface StaticAttrBindingDescriptor {
+  kind: 'static-attr';
+  el: Element;
+  key: string;
+  attrName: string;
+  value: unknown;
+}
+export interface StaticPropBindingDescriptor {
+  kind: 'static-prop';
+  el: Element;
+  propName: string;
+  value: unknown;
+}
+export interface StaticBooleanBindingDescriptor {
+  kind: 'static-boolean';
+  el: Element;
+  attrName: string;
+  value: boolean;
+}
+export interface StaticStyleBindingDescriptor {
+  kind: 'static-style';
+  el: Element;
+  value: Record<string, string | number>;
+}
+export interface SignalTextBindingDescriptor {
+  kind: 'signal-text';
+  el: Element | Text;
+  signal: Signal<unknown>;
+}
+export interface SignalClassBindingDescriptor {
+  kind: 'signal-class';
+  el: Element;
+  className: string;
+  signal: Signal<unknown>;
+}
+export interface SignalAttrBindingDescriptor {
+  kind: 'signal-attr';
+  el: Element;
+  attrNames: string[];
+  signal: Signal<unknown>;
+}
+export interface SignalHtmlBindingDescriptor {
+  kind: 'signal-html';
+  el: Element;
+  signal: Signal<unknown>;
+  trusted: boolean;
+}
+export interface SignalRenderBindingDescriptor {
+  kind: 'signal-render';
+  el: Element;
+  signal: Signal<unknown>;
+  lifecycle: BindingLifecycle;
+}
+export interface EventBindingDescriptor {
+  kind: 'event';
+  el: EventTarget;
+  type: string;
+  handler: EventListenerOrEventListenerObject;
+  options?: AddEventListenerOptions | boolean;
+}
+export interface RefBindingDescriptor {
+  kind: 'ref';
+  el: Element;
+  callback: (el: Element) => void;
+}
+/** Union of all supported binding descriptors. */ export type BindingDescriptor = StaticAttrBindingDescriptor | StaticPropBindingDescriptor | StaticBooleanBindingDescriptor | StaticStyleBindingDescriptor | SignalTextBindingDescriptor | SignalClassBindingDescriptor | SignalAttrBindingDescriptor | SignalHtmlBindingDescriptor | SignalRenderBindingDescriptor | EventBindingDescriptor | RefBindingDescriptor;

package/src/binding-descriptor.js

@@ -0,0 +1,9 @@
+/**
+ * @openelement/core - Unified binding descriptor types (ADR-0109 Phase 1).
+ *
+ * Declarative DOM binding contracts used by the runtime and hydration layers.
+ * Each descriptor captures one side effect to apply to a host element.
+ *
+ * @module @openelement/core/binding-descriptor
+ */ 
+//# sourceMappingURL=data:application/json;base64,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

package/src/context.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @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 type { RouteEntry } from '@openelement/protocol/framework';
+import type { IslandDescriptor, SsrContext } from '@openelement/protocol/context';
+export type { IslandDescriptor, SsrContext };
+/**
+ * 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 declare function extractParams(pattern: string, pathname: string): Record<string, string>;
+/**
+ * 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 declare function parseQuery(url: URL): Record<string, string | string[]>;
+/**
+ * Create a fresh SsrContext for a request.
+ * This is the single source of truth for per-request state.
+ */ export declare function createSsrContext(route: RouteEntry, url: URL, options?: {
+  requestId?: string;
+}): SsrContext;