@openelement/core 0.41.0-alpha.1

package/src/render-ir.js

@@ -0,0 +1,245 @@
+/**
+ * Internal structured render IR.
+ *
+ * v0.29.1: Unified attribute serialization and single async render path.
+ * `renderDsdTree` is the only public rendering API. All internal rendering
+ * flows through `renderToNode`.
+ */ import { escapeAttr, escapeHtml } from './html-escape.js';
+import { createEventMarkerContext, serializeEventMarkers } from './event-marker.js';
+import { FOR_TAG, Fragment, HTML_TAG, SHOW_TAG } from './jsx-runtime.js';
+import { DANGEROUS_KEYS, trustRenderHtml } from './security.js';
+import { isSignalLike, unwrapSignalLike } from '@openelement/signal';
+import { isComponentCtor, isComponentFn, isVNode } from './vnode.js';
+import { renderDsd } from './render-dsd.js';
+import { createLogger } from './logger.js';
+import { formatError } from './errors.js';
+export const VOID_ELEMENTS = new Set([
+  'area',
+  'base',
+  'br',
+  'col',
+  'embed',
+  'hr',
+  'img',
+  'input',
+  'link',
+  'meta',
+  'param',
+  'source',
+  'track',
+  'wbr'
+]);
+export function textNode(value) {
+  return {
+    kind: 'text',
+    value: String(value)
+  };
+}
+export function trustedHtmlNode(value) {
+  return {
+    kind: 'trusted-html',
+    value: trustRenderHtml(String(value))
+  };
+}
+export function fragmentNode(children) {
+  return {
+    kind: 'fragment',
+    children
+  };
+}
+export function dsdHostNode(params) {
+  return {
+    kind: 'dsd-host',
+    ...params
+  };
+}
+export function camelToKebab(str) {
+  return str.replace(/([A-Z])/g, '-$1').toLowerCase();
+}
+// ─── Unified Attribute Serialization ────────────────────────────
+const SKIP_ATTR_KEYS = new Set([
+  'children',
+  'ref',
+  'key',
+  'trustedHtml',
+  'innerHTML',
+  'textContent'
+]);
+export function serializeAttrs(tag, props) {
+  const isCustomElement = tag.includes('-');
+  let result = '';
+  for (const [key, value] of Object.entries(props)){
+    if (SKIP_ATTR_KEYS.has(key)) continue;
+    if (key.startsWith('on') && typeof value === 'function') continue;
+    if (typeof value === 'function') continue;
+    if (value == null) continue;
+    let attrName = key === 'className' ? 'class' : key === 'htmlFor' ? 'for' : key;
+    if (isCustomElement && attrName === key) {
+      attrName = camelToKebab(attrName);
+    }
+    const resolved = unwrapSignalLike(value);
+    if (typeof resolved === 'boolean') {
+      if (resolved) result += ` ${attrName}`;
+      continue;
+    }
+    if (key === 'style' && typeof resolved === 'object' && resolved !== null) {
+      const styleObj = {};
+      for (const [sk, sv] of Object.entries(resolved)){
+        styleObj[sk] = unwrapSignalLike(sv);
+      }
+      const css = styleObjectToString(styleObj);
+      if (css) result += ` style="${escapeAttr(css)}"`;
+      continue;
+    }
+    if (typeof resolved === 'object') {
+      result += ` ${attrName}="${escapeAttr(JSON.stringify(resolved))}"`;
+    } else {
+      result += ` ${attrName}="${escapeAttr(String(resolved))}"`;
+    }
+  }
+  return result;
+}
+// ─── Serialization ──────────────────────────────────────────────
+export function serializeRenderNode(node) {
+  switch(node.kind){
+    case 'text':
+      return escapeHtml(node.value);
+    case 'trusted-html':
+      return node.value;
+    case 'fragment':
+      return node.children.map(serializeRenderNode).join('');
+    case 'element':
+      {
+        const attrs = serializeAttrs(node.tag, node.attrs);
+        const events = node.eventAttrs ?? '';
+        if (node.voidElement || VOID_ELEMENTS.has(node.tag)) {
+          return `<${node.tag}${attrs}${events}>`;
+        }
+        return `<${node.tag}${attrs}${events}>${node.children.map(serializeRenderNode).join('')}</${node.tag}>`;
+      }
+    case 'dsd-host':
+      {
+        const attrs = serializeAttrs(node.tag, node.attrs);
+        if (node.layer === 'pure-island' || node.layer === 'light-dom') {
+          return `<${node.tag}${attrs}${node.ssrPropsAttr}${node.source}>${[
+            ...node.shadow,
+            ...node.light
+          ].map(serializeRenderNode).join('')}</${node.tag}>`;
+        }
+        const style = node.styleCss ? `\n    <style>${node.styleCss}</style>` : '';
+        return `<${node.tag}${attrs}${node.ssrPropsAttr}${node.source}>
+  <template shadowrootmode="open"${node.templateAttrs}>${style}
+    ${node.shadow.map(serializeRenderNode).join('')}
+  </template>
+${node.light.map(serializeRenderNode).join('')}</${node.tag}>`;
+      }
+  }
+}
+// ─── Single async render path ───────────────────────────────────
+export async function renderToNode(node, eventContext = createEventMarkerContext()) {
+  if (node == null || node === false || typeof node === 'boolean') return fragmentNode([]);
+  if (typeof node === 'string' || typeof node === 'number') return textNode(node);
+  if (isSignalLike(node)) {
+    return await renderToNode(node.value, eventContext);
+  }
+  if (!isVNode(node)) return textNode(String(node));
+  const { tag, props, children } = node;
+  // Fragment
+  if (tag === Fragment || typeof tag === 'symbol' && String(tag) === 'Symbol(openelement.fragment)') {
+    const parts = [];
+    for (const child of children)parts.push(await renderToNode(child, eventContext));
+    return fragmentNode(parts);
+  }
+  // Trusted HTML (raw HTML insertion, no wrapping tag)
+  if (tag === HTML_TAG) {
+    return trustedHtmlNode(props?.html ?? '');
+  }
+  // Show
+  if (tag === SHOW_TAG || tag === 'show') {
+    const whenVal = isSignalLike(props?.when) ? props.when.value : props?.when;
+    const target = whenVal ? children[0] : children[1];
+    return target ? await renderToNode(target, eventContext) : fragmentNode([]);
+  }
+  // For
+  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') {
+      return fragmentNode([]);
+    }
+    const parts = [];
+    for(let index = 0; index < items.length; index++){
+      parts.push(await renderToNode(renderFn(items[index], index), eventContext));
+    }
+    return fragmentNode(parts);
+  }
+  // Component function/class
+  if (isComponentCtor(tag) || isComponentFn(tag)) {
+    try {
+      return await renderToNode(callComponent(tag, props, children), eventContext);
+    } catch (err) {
+      createLogger('render').error(`render failed for <${String(tag)}>:` + ` ${formatError(err)}`);
+      return fragmentNode([]);
+    }
+  }
+  // HTML / SVG element
+  const tagName = String(tag);
+  const childNodes = [];
+  if (props?.innerHTML !== undefined) {
+    const value = unwrapSignalLike(props.innerHTML);
+    childNodes.push(props.trustedHtml === true ? trustedHtmlNode(value) : textNode(value));
+  } else if (props?.textContent !== undefined) {
+    childNodes.push(textNode(unwrapSignalLike(props.textContent)));
+  } else {
+    for (const child of children)childNodes.push(await renderToNode(child, eventContext));
+  }
+  if (typeof customElements !== 'undefined' && customElements.get && customElements.get(tagName)) {
+    try {
+      const dsdResult = await renderDsd(tagName, {
+        componentClass: customElements.get(tagName),
+        props,
+        lightDom: childNodes
+      });
+      return trustedHtmlNode(dsdResult.html);
+    } catch (err) {
+      createLogger('render').error(`renderDsd failed for registered CE <${tagName}>:` + ` ${formatError(err)}`);
+    }
+  }
+  return {
+    kind: 'element',
+    tag: tagName,
+    attrs: props,
+    eventAttrs: serializeEventMarkers(props, eventContext),
+    children: childNodes,
+    voidElement: VOID_ELEMENTS.has(tagName)
+  };
+}
+// ─── Public API ─────────────────────────────────────────────────
+export async function renderDsdTree(node, eventContext = createEventMarkerContext()) {
+  return serializeRenderNode(await renderToNode(node, eventContext));
+}
+// ─── Helpers ────────────────────────────────────────────────────
+function callComponent(tag, props, children) {
+  if (isComponentCtor(tag)) {
+    const instance = new tag();
+    for (const [key, value] of Object.entries(props)){
+      if (DANGEROUS_KEYS.has(key)) continue;
+      instance[key] = value;
+    }
+    return instance.render();
+  }
+  if (isComponentFn(tag)) {
+    return tag({
+      ...props,
+      children
+    });
+  }
+  return null;
+}
+function styleObjectToString(obj) {
+  return Object.entries(obj).filter(([, value])=>value != null).map(([key, value])=>{
+    const prop = key.replace(/([A-Z])/g, (match)=>`-${match.toLowerCase()}`);
+    return `${prop}: ${value}`;
+  }).join('; ');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/core/src/render-ir.ts"],"sourcesContent":["/**\n * Internal structured render IR.\n *\n * v0.29.1: Unified attribute serialization and single async render path.\n * `renderDsdTree` is the only public rendering API. All internal rendering\n * flows through `renderToNode`.\n */\n\nimport { escapeAttr, escapeHtml } from './html-escape.js';\nimport {\n  createEventMarkerContext,\n  type EventMarkerContext,\n  serializeEventMarkers,\n} from './event-marker.js';\nimport { FOR_TAG, Fragment, HTML_TAG, SHOW_TAG } from './jsx-runtime.js';\nimport { DANGEROUS_KEYS, trustRenderHtml } from './security.js';\nimport { isSignalLike, unwrapSignalLike } from '@openelement/signal';\nimport { isComponentCtor, isComponentFn, isVNode } from './vnode.js';\nimport type { RenderFn, VNode } from '@openelement/protocol/vnode';\nimport { renderDsd } from './render-dsd.js';\nimport { createLogger } from './logger.js';\nimport { formatError } from './errors.js';\n\nexport type RenderNode =\n  | { kind: 'text'; value: string }\n  | { kind: 'trusted-html'; value: string }\n  | { kind: 'fragment'; children: RenderNode[] }\n  | {\n    kind: 'element';\n    tag: string;\n    attrs: Record<string, unknown>;\n    eventAttrs?: string;\n    children: RenderNode[];\n    voidElement?: boolean;\n  }\n  | {\n    kind: 'dsd-host';\n    tag: string;\n    attrs: Record<string, unknown>;\n    ssrPropsAttr: string;\n    source: string;\n    templateAttrs: string;\n    styleCss: string;\n    shadow: RenderNode[];\n    light: RenderNode[];\n    layer: string;\n  };\n\nexport const VOID_ELEMENTS = new Set([\n  'area',\n  'base',\n  'br',\n  'col',\n  'embed',\n  'hr',\n  'img',\n  'input',\n  'link',\n  'meta',\n  'param',\n  'source',\n  'track',\n  'wbr',\n]);\n\nexport function textNode(value: unknown): RenderNode {\n  return { kind: 'text', value: String(value) };\n}\n\nexport function trustedHtmlNode(value: unknown): RenderNode {\n  return { kind: 'trusted-html', value: trustRenderHtml(String(value)) };\n}\n\nexport function fragmentNode(children: RenderNode[]): RenderNode {\n  return { kind: 'fragment', children };\n}\n\nexport function dsdHostNode(params: Omit<Extract<RenderNode, { kind: 'dsd-host' }>, 'kind'>) {\n  return { kind: 'dsd-host', ...params } satisfies RenderNode;\n}\n\nexport function camelToKebab(str: string): string {\n  return str.replace(/([A-Z])/g, '-$1').toLowerCase();\n}\n\n// ─── Unified Attribute Serialization ────────────────────────────\n\nconst SKIP_ATTR_KEYS = new Set([\n  'children',\n  'ref',\n  'key',\n  'trustedHtml',\n  'innerHTML',\n  'textContent',\n]);\n\nexport function serializeAttrs(tag: string, props: Record<string, unknown>): string {\n  const isCustomElement = tag.includes('-');\n  let result = '';\n\n  for (const [key, value] of Object.entries(props)) {\n    if (SKIP_ATTR_KEYS.has(key)) continue;\n    if (key.startsWith('on') && typeof value === 'function') continue;\n    if (typeof value === 'function') continue;\n    if (value == null) continue;\n\n    let attrName = key === 'className' ? 'class' : key === 'htmlFor' ? 'for' : key;\n    if (isCustomElement && attrName === key) {\n      attrName = camelToKebab(attrName);\n    }\n\n    const resolved = unwrapSignalLike(value);\n\n    if (typeof resolved === 'boolean') {\n      if (resolved) result += ` ${attrName}`;\n      continue;\n    }\n\n    if (key === 'style' && typeof resolved === 'object' && resolved !== null) {\n      const styleObj: Record<string, unknown> = {};\n      for (const [sk, sv] of Object.entries(resolved as Record<string, unknown>)) {\n        styleObj[sk] = unwrapSignalLike(sv);\n      }\n      const css = styleObjectToString(styleObj);\n      if (css) result += ` style=\"${escapeAttr(css)}\"`;\n      continue;\n    }\n\n    if (typeof resolved === 'object') {\n      result += ` ${attrName}=\"${escapeAttr(JSON.stringify(resolved))}\"`;\n    } else {\n      result += ` ${attrName}=\"${escapeAttr(String(resolved))}\"`;\n    }\n  }\n\n  return result;\n}\n\n// ─── Serialization ──────────────────────────────────────────────\n\nexport function serializeRenderNode(node: RenderNode): string {\n  switch (node.kind) {\n    case 'text':\n      return escapeHtml(node.value);\n    case 'trusted-html':\n      return node.value;\n    case 'fragment':\n      return node.children.map(serializeRenderNode).join('');\n    case 'element': {\n      const attrs = serializeAttrs(node.tag, node.attrs);\n      const events = node.eventAttrs ?? '';\n      if (node.voidElement || VOID_ELEMENTS.has(node.tag)) {\n        return `<${node.tag}${attrs}${events}>`;\n      }\n      return `<${node.tag}${attrs}${events}>${\n        node.children.map(serializeRenderNode).join('')\n      }</${node.tag}>`;\n    }\n    case 'dsd-host': {\n      const attrs = serializeAttrs(node.tag, node.attrs);\n      if (node.layer === 'pure-island' || node.layer === 'light-dom') {\n        return `<${node.tag}${attrs}${node.ssrPropsAttr}${node.source}>${\n          [...node.shadow, ...node.light].map(serializeRenderNode).join('')\n        }</${node.tag}>`;\n      }\n      const style = node.styleCss ? `\\n    <style>${node.styleCss}</style>` : '';\n      return `<${node.tag}${attrs}${node.ssrPropsAttr}${node.source}>\n  <template shadowrootmode=\"open\"${node.templateAttrs}>${style}\n    ${node.shadow.map(serializeRenderNode).join('')}\n  </template>\n${node.light.map(serializeRenderNode).join('')}</${node.tag}>`;\n    }\n  }\n}\n\n// ─── Single async render path ───────────────────────────────────\n\nexport async function renderToNode(\n  node: unknown,\n  eventContext: EventMarkerContext = createEventMarkerContext(),\n): Promise<RenderNode> {\n  if (node == null || node === false || typeof node === 'boolean') return fragmentNode([]);\n  if (typeof node === 'string' || typeof node === 'number') return textNode(node);\n  if (isSignalLike(node)) {\n    return await renderToNode((node as { value: unknown }).value, eventContext);\n  }\n  if (!isVNode(node)) return textNode(String(node));\n\n  const { tag, props, children } = node;\n\n  // Fragment\n  if (\n    tag === Fragment || (typeof tag === 'symbol' && String(tag) === 'Symbol(openelement.fragment)')\n  ) {\n    const parts: RenderNode[] = [];\n    for (const child of children) parts.push(await renderToNode(child, eventContext));\n    return fragmentNode(parts);\n  }\n\n  // Trusted HTML (raw HTML insertion, no wrapping tag)\n  if (tag === HTML_TAG) {\n    return trustedHtmlNode(props?.html ?? '');\n  }\n\n  // Show\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    return target ? await renderToNode(target, eventContext) : fragmentNode([]);\n  }\n\n  // For\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      return fragmentNode([]);\n    }\n    const parts: RenderNode[] = [];\n    for (let index = 0; index < items.length; index++) {\n      parts.push(await renderToNode(renderFn(items[index], index), eventContext));\n    }\n    return fragmentNode(parts);\n  }\n\n  // Component function/class\n  if (isComponentCtor(tag) || isComponentFn(tag)) {\n    try {\n      return await renderToNode(callComponent(tag, props, children), eventContext);\n    } catch (err) {\n      createLogger('render').error(\n        `render failed for <${String(tag)}>:` +\n          ` ${formatError(err)}`,\n      );\n      return fragmentNode([]);\n    }\n  }\n\n  // HTML / SVG element\n  const tagName = String(tag);\n  const childNodes: RenderNode[] = [];\n\n  if (props?.innerHTML !== undefined) {\n    const value = unwrapSignalLike(props.innerHTML);\n    childNodes.push(props.trustedHtml === true ? trustedHtmlNode(value) : textNode(value));\n  } else if (props?.textContent !== undefined) {\n    childNodes.push(textNode(unwrapSignalLike(props.textContent)));\n  } else {\n    for (const child of children) childNodes.push(await renderToNode(child, eventContext));\n  }\n\n  if (\n    typeof customElements !== 'undefined' &&\n    customElements.get &&\n    customElements.get(tagName)\n  ) {\n    try {\n      const dsdResult = await renderDsd(tagName, {\n        componentClass: customElements.get(tagName) as CustomElementConstructor,\n        props,\n        lightDom: childNodes,\n      });\n      return trustedHtmlNode(dsdResult.html);\n    } catch (err) {\n      createLogger('render').error(\n        `renderDsd failed for registered CE <${tagName}>:` +\n          ` ${formatError(err)}`,\n      );\n    }\n  }\n\n  return {\n    kind: 'element',\n    tag: tagName,\n    attrs: props,\n    eventAttrs: serializeEventMarkers(props, eventContext),\n    children: childNodes,\n    voidElement: VOID_ELEMENTS.has(tagName),\n  };\n}\n\n// ─── Public API ─────────────────────────────────────────────────\n\nexport async function renderDsdTree(\n  node: unknown,\n  eventContext: EventMarkerContext = createEventMarkerContext(),\n): Promise<string> {\n  return serializeRenderNode(await renderToNode(node, eventContext));\n}\n\n// ─── Helpers ────────────────────────────────────────────────────\n\nfunction callComponent(\n  tag: VNode['tag'],\n  props: Record<string, unknown>,\n  children: (VNode | string | RenderFn)[],\n): unknown {\n  if (isComponentCtor(tag)) {\n    const instance = new tag();\n    for (const [key, value] of Object.entries(props)) {\n      if (DANGEROUS_KEYS.has(key)) continue;\n      (instance as Record<string, unknown>)[key] = value;\n    }\n    return instance.render();\n  }\n  if (isComponentFn(tag)) {\n    return tag({ ...props, children });\n  }\n  return null;\n}\n\nfunction styleObjectToString(obj: Record<string, unknown>): string {\n  return Object.entries(obj)\n    .filter(([, value]) => value != null)\n    .map(([key, value]) => {\n      const prop = key.replace(/([A-Z])/g, (match) => `-${match.toLowerCase()}`);\n      return `${prop}: ${value}`;\n    })\n    .join('; ');\n}\n"],"names":[],"mappings":"AAAA;;;;;;CAMC,GAED,SAAS,UAAU,EAAE,UAAU,QAAQ,mBAAmB;AAC1D,SACE,wBAAwB,EAExB,qBAAqB,QAChB,oBAAoB;AAC3B,SAAS,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,QAAQ,mBAAmB;AACzE,SAAS,cAAc,EAAE,eAAe,QAAQ,gBAAgB;AAChE,SAAS,YAAY,EAAE,gBAAgB,QAAQ,sBAAsB;AACrE,SAAS,eAAe,EAAE,aAAa,EAAE,OAAO,QAAQ,aAAa;AAErE,SAAS,SAAS,QAAQ,kBAAkB;AAC5C,SAAS,YAAY,QAAQ,cAAc;AAC3C,SAAS,WAAW,QAAQ,cAAc;AA2B1C,OAAO,MAAM,gBAAgB,IAAI,IAAI;EACnC;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACD,EAAE;AAEH,OAAO,SAAS,SAAS,KAAc;EACrC,OAAO;IAAE,MAAM;IAAQ,OAAO,OAAO;EAAO;AAC9C;AAEA,OAAO,SAAS,gBAAgB,KAAc;EAC5C,OAAO;IAAE,MAAM;IAAgB,OAAO,gBAAgB,OAAO;EAAQ;AACvE;AAEA,OAAO,SAAS,aAAa,QAAsB;EACjD,OAAO;IAAE,MAAM;IAAY;EAAS;AACtC;AAEA,OAAO,SAAS,YAAY,MAA+D;EACzF,OAAO;IAAE,MAAM;IAAY,GAAG,MAAM;EAAC;AACvC;AAEA,OAAO,SAAS,aAAa,GAAW;EACtC,OAAO,IAAI,OAAO,CAAC,YAAY,OAAO,WAAW;AACnD;AAEA,mEAAmE;AAEnE,MAAM,iBAAiB,IAAI,IAAI;EAC7B;EACA;EACA;EACA;EACA;EACA;CACD;AAED,OAAO,SAAS,eAAe,GAAW,EAAE,KAA8B;EACxE,MAAM,kBAAkB,IAAI,QAAQ,CAAC;EACrC,IAAI,SAAS;EAEb,KAAK,MAAM,CAAC,KAAK,MAAM,IAAI,OAAO,OAAO,CAAC,OAAQ;IAChD,IAAI,eAAe,GAAG,CAAC,MAAM;IAC7B,IAAI,IAAI,UAAU,CAAC,SAAS,OAAO,UAAU,YAAY;IACzD,IAAI,OAAO,UAAU,YAAY;IACjC,IAAI,SAAS,MAAM;IAEnB,IAAI,WAAW,QAAQ,cAAc,UAAU,QAAQ,YAAY,QAAQ;IAC3E,IAAI,mBAAmB,aAAa,KAAK;MACvC,WAAW,aAAa;IAC1B;IAEA,MAAM,WAAW,iBAAiB;IAElC,IAAI,OAAO,aAAa,WAAW;MACjC,IAAI,UAAU,UAAU,CAAC,CAAC,EAAE,UAAU;MACtC;IACF;IAEA,IAAI,QAAQ,WAAW,OAAO,aAAa,YAAY,aAAa,MAAM;MACxE,MAAM,WAAoC,CAAC;MAC3C,KAAK,MAAM,CAAC,IAAI,GAAG,IAAI,OAAO,OAAO,CAAC,UAAsC;QAC1E,QAAQ,CAAC,GAAG,GAAG,iBAAiB;MAClC;MACA,MAAM,MAAM,oBAAoB;MAChC,IAAI,KAAK,UAAU,CAAC,QAAQ,EAAE,WAAW,KAAK,CAAC,CAAC;MAChD;IACF;IAEA,IAAI,OAAO,aAAa,UAAU;MAChC,UAAU,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,WAAW,KAAK,SAAS,CAAC,WAAW,CAAC,CAAC;IACpE,OAAO;MACL,UAAU,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,WAAW,OAAO,WAAW,CAAC,CAAC;IAC5D;EACF;EAEA,OAAO;AACT;AAEA,mEAAmE;AAEnE,OAAO,SAAS,oBAAoB,IAAgB;EAClD,OAAQ,KAAK,IAAI;IACf,KAAK;MACH,OAAO,WAAW,KAAK,KAAK;IAC9B,KAAK;MACH,OAAO,KAAK,KAAK;IACnB,KAAK;MACH,OAAO,KAAK,QAAQ,CAAC,GAAG,CAAC,qBAAqB,IAAI,CAAC;IACrD,KAAK;MAAW;QACd,MAAM,QAAQ,eAAe,KAAK,GAAG,EAAE,KAAK,KAAK;QACjD,MAAM,SAAS,KAAK,UAAU,IAAI;QAClC,IAAI,KAAK,WAAW,IAAI,cAAc,GAAG,CAAC,KAAK,GAAG,GAAG;UACnD,OAAO,CAAC,CAAC,EAAE,KAAK,GAAG,GAAG,QAAQ,OAAO,CAAC,CAAC;QACzC;QACA,OAAO,CAAC,CAAC,EAAE,KAAK,GAAG,GAAG,QAAQ,OAAO,CAAC,EACpC,KAAK,QAAQ,CAAC,GAAG,CAAC,qBAAqB,IAAI,CAAC,IAC7C,EAAE,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC;MAClB;IACA,KAAK;MAAY;QACf,MAAM,QAAQ,eAAe,KAAK,GAAG,EAAE,KAAK,KAAK;QACjD,IAAI,KAAK,KAAK,KAAK,iBAAiB,KAAK,KAAK,KAAK,aAAa;UAC9D,OAAO,CAAC,CAAC,EAAE,KAAK,GAAG,GAAG,QAAQ,KAAK,YAAY,GAAG,KAAK,MAAM,CAAC,CAAC,EAC7D;eAAI,KAAK,MAAM;eAAK,KAAK,KAAK;WAAC,CAAC,GAAG,CAAC,qBAAqB,IAAI,CAAC,IAC/D,EAAE,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC;QAClB;QACA,MAAM,QAAQ,KAAK,QAAQ,GAAG,CAAC,aAAa,EAAE,KAAK,QAAQ,CAAC,QAAQ,CAAC,GAAG;QACxE,OAAO,CAAC,CAAC,EAAE,KAAK,GAAG,GAAG,QAAQ,KAAK,YAAY,GAAG,KAAK,MAAM,CAAC;iCACnC,EAAE,KAAK,aAAa,CAAC,CAAC,EAAE,MAAM;IAC3D,EAAE,KAAK,MAAM,CAAC,GAAG,CAAC,qBAAqB,IAAI,CAAC,IAAI;;AAEpD,EAAE,KAAK,KAAK,CAAC,GAAG,CAAC,qBAAqB,IAAI,CAAC,IAAI,EAAE,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC;MAC1D;EACF;AACF;AAEA,mEAAmE;AAEnE,OAAO,eAAe,aACpB,IAAa,EACb,eAAmC,0BAA0B;EAE7D,IAAI,QAAQ,QAAQ,SAAS,SAAS,OAAO,SAAS,WAAW,OAAO,aAAa,EAAE;EACvF,IAAI,OAAO,SAAS,YAAY,OAAO,SAAS,UAAU,OAAO,SAAS;EAC1E,IAAI,aAAa,OAAO;IACtB,OAAO,MAAM,aAAa,AAAC,KAA4B,KAAK,EAAE;EAChE;EACA,IAAI,CAAC,QAAQ,OAAO,OAAO,SAAS,OAAO;EAE3C,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG;EAEjC,WAAW;EACX,IACE,QAAQ,YAAa,OAAO,QAAQ,YAAY,OAAO,SAAS,gCAChE;IACA,MAAM,QAAsB,EAAE;IAC9B,KAAK,MAAM,SAAS,SAAU,MAAM,IAAI,CAAC,MAAM,aAAa,OAAO;IACnE,OAAO,aAAa;EACtB;EAEA,qDAAqD;EACrD,IAAI,QAAQ,UAAU;IACpB,OAAO,gBAAgB,OAAO,QAAQ;EACxC;EAEA,OAAO;EACP,IAAI,QAAQ,YAAY,QAAQ,QAAQ;IACtC,MAAM,UAAU,aAAa,OAAO,QAChC,AAAC,MAAO,IAAI,CAAwB,KAAK,GACzC,OAAO;IACX,MAAM,SAAS,UAAU,QAAQ,CAAC,EAAE,GAAG,QAAQ,CAAC,EAAE;IAClD,OAAO,SAAS,MAAM,aAAa,QAAQ,gBAAgB,aAAa,EAAE;EAC5E;EAEA,MAAM;EACN,IAAI,QAAQ,WAAW,QAAQ,QAAQ;IACrC,MAAM,QAAS,aAAa,OAAO,QAC/B,AAAC,MAAO,IAAI,CAAwB,KAAK,GACzC,OAAO;IACX,MAAM,WAAW,QAAQ,CAAC,EAAE;IAC5B,IAAI,CAAC,MAAM,OAAO,CAAC,UAAU,OAAO,aAAa,YAAY;MAC3D,OAAO,aAAa,EAAE;IACxB;IACA,MAAM,QAAsB,EAAE;IAC9B,IAAK,IAAI,QAAQ,GAAG,QAAQ,MAAM,MAAM,EAAE,QAAS;MACjD,MAAM,IAAI,CAAC,MAAM,aAAa,SAAS,KAAK,CAAC,MAAM,EAAE,QAAQ;IAC/D;IACA,OAAO,aAAa;EACtB;EAEA,2BAA2B;EAC3B,IAAI,gBAAgB,QAAQ,cAAc,MAAM;IAC9C,IAAI;MACF,OAAO,MAAM,aAAa,cAAc,KAAK,OAAO,WAAW;IACjE,EAAE,OAAO,KAAK;MACZ,aAAa,UAAU,KAAK,CAC1B,CAAC,mBAAmB,EAAE,OAAO,KAAK,EAAE,CAAC,GACnC,CAAC,CAAC,EAAE,YAAY,MAAM;MAE1B,OAAO,aAAa,EAAE;IACxB;EACF;EAEA,qBAAqB;EACrB,MAAM,UAAU,OAAO;EACvB,MAAM,aAA2B,EAAE;EAEnC,IAAI,OAAO,cAAc,WAAW;IAClC,MAAM,QAAQ,iBAAiB,MAAM,SAAS;IAC9C,WAAW,IAAI,CAAC,MAAM,WAAW,KAAK,OAAO,gBAAgB,SAAS,SAAS;EACjF,OAAO,IAAI,OAAO,gBAAgB,WAAW;IAC3C,WAAW,IAAI,CAAC,SAAS,iBAAiB,MAAM,WAAW;EAC7D,OAAO;IACL,KAAK,MAAM,SAAS,SAAU,WAAW,IAAI,CAAC,MAAM,aAAa,OAAO;EAC1E;EAEA,IACE,OAAO,mBAAmB,eAC1B,eAAe,GAAG,IAClB,eAAe,GAAG,CAAC,UACnB;IACA,IAAI;MACF,MAAM,YAAY,MAAM,UAAU,SAAS;QACzC,gBAAgB,eAAe,GAAG,CAAC;QACnC;QACA,UAAU;MACZ;MACA,OAAO,gBAAgB,UAAU,IAAI;IACvC,EAAE,OAAO,KAAK;MACZ,aAAa,UAAU,KAAK,CAC1B,CAAC,oCAAoC,EAAE,QAAQ,EAAE,CAAC,GAChD,CAAC,CAAC,EAAE,YAAY,MAAM;IAE5B;EACF;EAEA,OAAO;IACL,MAAM;IACN,KAAK;IACL,OAAO;IACP,YAAY,sBAAsB,OAAO;IACzC,UAAU;IACV,aAAa,cAAc,GAAG,CAAC;EACjC;AACF;AAEA,mEAAmE;AAEnE,OAAO,eAAe,cACpB,IAAa,EACb,eAAmC,0BAA0B;EAE7D,OAAO,oBAAoB,MAAM,aAAa,MAAM;AACtD;AAEA,mEAAmE;AAEnE,SAAS,cACP,GAAiB,EACjB,KAA8B,EAC9B,QAAuC;EAEvC,IAAI,gBAAgB,MAAM;IACxB,MAAM,WAAW,IAAI;IACrB,KAAK,MAAM,CAAC,KAAK,MAAM,IAAI,OAAO,OAAO,CAAC,OAAQ;MAChD,IAAI,eAAe,GAAG,CAAC,MAAM;MAC5B,QAAoC,CAAC,IAAI,GAAG;IAC/C;IACA,OAAO,SAAS,MAAM;EACxB;EACA,IAAI,cAAc,MAAM;IACtB,OAAO,IAAI;MAAE,GAAG,KAAK;MAAE;IAAS;EAClC;EACA,OAAO;AACT;AAEA,SAAS,oBAAoB,GAA4B;EACvD,OAAO,OAAO,OAAO,CAAC,KACnB,MAAM,CAAC,CAAC,GAAG,MAAM,GAAK,SAAS,MAC/B,GAAG,CAAC,CAAC,CAAC,KAAK,MAAM;IAChB,MAAM,OAAO,IAAI,OAAO,CAAC,YAAY,CAAC,QAAU,CAAC,CAAC,EAAE,MAAM,WAAW,IAAI;IACzE,OAAO,GAAG,KAAK,EAAE,EAAE,OAAO;EAC5B,GACC,IAAI,CAAC;AACV"}

package/src/runtime.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Runtime adapter protocol.
+ *
+ * Replacement boundary for Nitro, Workers, Node, Deno, or future
+ * fetch-compatible runtimes. Preserves openElement semantics while leaving
+ * concrete server engines outside this package.
+ */ import type { OpenElementRequestHandler, RuntimeAdapter, RuntimeAdapterOptions, RuntimeContext, RuntimePrerenderResult } from '@openelement/protocol/runtime';
+export type { OpenElementRequestHandler, RuntimeAdapter, RuntimeAdapterOptions, RuntimeContext, RuntimePrerenderResult };
+export declare function createRuntimeAdapter<Env extends Record<string, unknown> = Record<string, unknown>>(options: RuntimeAdapterOptions<Env>): RuntimeAdapter<Env>;

package/src/runtime.js

@@ -0,0 +1,16 @@
+/**
+ * Runtime adapter protocol.
+ *
+ * Replacement boundary for Nitro, Workers, Node, Deno, or future
+ * fetch-compatible runtimes. Preserves openElement semantics while leaving
+ * concrete server engines outside this package.
+ */ export function createRuntimeAdapter(options) {
+  return {
+    name: options.name,
+    fetch: options.fetch,
+    ...options.prerender ? {
+      prerender: options.prerender
+    } : {}
+  };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vaG9tZS9ydW5uZXIvd29yay9vcGVuZWxlbWVudC9vcGVuZWxlbWVudC9wYWNrYWdlcy9jb3JlL3NyYy9ydW50aW1lLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUnVudGltZSBhZGFwdGVyIHByb3RvY29sLlxuICpcbiAqIFJlcGxhY2VtZW50IGJvdW5kYXJ5IGZvciBOaXRybywgV29ya2VycywgTm9kZSwgRGVubywgb3IgZnV0dXJlXG4gKiBmZXRjaC1jb21wYXRpYmxlIHJ1bnRpbWVzLiBQcmVzZXJ2ZXMgb3BlbkVsZW1lbnQgc2VtYW50aWNzIHdoaWxlIGxlYXZpbmdcbiAqIGNvbmNyZXRlIHNlcnZlciBlbmdpbmVzIG91dHNpZGUgdGhpcyBwYWNrYWdlLlxuICovXG5cbmltcG9ydCB0eXBlIHtcbiAgT3BlbkVsZW1lbnRSZXF1ZXN0SGFuZGxlcixcbiAgUnVudGltZUFkYXB0ZXIsXG4gIFJ1bnRpbWVBZGFwdGVyT3B0aW9ucyxcbiAgUnVudGltZUNvbnRleHQsXG4gIFJ1bnRpbWVQcmVyZW5kZXJSZXN1bHQsXG59IGZyb20gJ0BvcGVuZWxlbWVudC9wcm90b2NvbC9ydW50aW1lJztcbmV4cG9ydCB0eXBlIHtcbiAgT3BlbkVsZW1lbnRSZXF1ZXN0SGFuZGxlcixcbiAgUnVudGltZUFkYXB0ZXIsXG4gIFJ1bnRpbWVBZGFwdGVyT3B0aW9ucyxcbiAgUnVudGltZUNvbnRleHQsXG4gIFJ1bnRpbWVQcmVyZW5kZXJSZXN1bHQsXG59O1xuXG5leHBvcnQgZnVuY3Rpb24gY3JlYXRlUnVudGltZUFkYXB0ZXI8XG4gIEVudiBleHRlbmRzIFJlY29yZDxzdHJpbmcsIHVua25vd24+ID0gUmVjb3JkPHN0cmluZywgdW5rbm93bj4sXG4+KG9wdGlvbnM6IFJ1bnRpbWVBZGFwdGVyT3B0aW9uczxFbnY+KTogUnVudGltZUFkYXB0ZXI8RW52PiB7XG4gIHJldHVybiB7XG4gICAgbmFtZTogb3B0aW9ucy5uYW1lLFxuICAgIGZldGNoOiBvcHRpb25zLmZldGNoLFxuICAgIC4uLihvcHRpb25zLnByZXJlbmRlciA/IHsgcHJlcmVuZGVyOiBvcHRpb25zLnByZXJlbmRlciB9IDoge30pLFxuICB9O1xufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Q0FNQyxHQWlCRCxPQUFPLFNBQVMscUJBRWQsT0FBbUM7RUFDbkMsT0FBTztJQUNMLE1BQU0sUUFBUSxJQUFJO0lBQ2xCLE9BQU8sUUFBUSxLQUFLO0lBQ3BCLEdBQUksUUFBUSxTQUFTLEdBQUc7TUFBRSxXQUFXLFFBQVEsU0FBUztJQUFDLElBQUksQ0FBQyxDQUFDO0VBQy9EO0FBQ0YifQ==

package/src/security.d.ts

@@ -0,0 +1 @@
+/** Object prototype keys that must never be injected as SSR props. */ export declare const DANGEROUS_KEYS: ReadonlySet<string>;

package/src/security.js

@@ -0,0 +1,40 @@
+/**
+ * @openelement/core - SSR Security Guards.
+ *
+ * Properties that MUST NOT be injected from untrusted SSR props.
+ * These are Object.prototype internals and dangerous overrides that
+ * could be exploited via arbitrary property assignment.
+ *
+ * Shared by island.ts (client-side SSR prop restoration) and render-dsd.ts
+ * (SSR injectProps). Previously defined in island.ts and imported by
+ * render-instantiate.ts (v0.29.1: merged into render-dsd.ts).
+ *
+ * @module @openelement/core/security
+ */ import { createLogger, warnOnce } from './logger.js';
+/** Object prototype keys that must never be injected as SSR props. */ export const DANGEROUS_KEYS = new Set([
+  '__proto__',
+  'constructor',
+  'prototype',
+  '__defineGetter__',
+  '__defineSetter__',
+  '__lookupGetter__',
+  '__lookupSetter__',
+  'hasOwnProperty',
+  'isPrototypeOf',
+  'propertyIsEnumerable',
+  'toString',
+  'toLocaleString',
+  'valueOf'
+]);
+/**
+ * Mark caller-supplied HTML as trusted before injection into a DOM/string render path.
+ *
+ * `trustedHtml` is an explicit trust boundary, not a sanitizer. Core escapes
+ * untrusted text by default; callers that cross this boundary must sanitize or
+ * otherwise trust the HTML before passing it to openElement.
+ */ const _securityLog = createLogger('security');
+export function trustRenderHtml(html) {
+  warnOnce('trustedHtml', _securityLog, 'trustRenderHtml is a trust boundary, not a sanitizer. ' + 'Caller must ensure HTML content is safe before passing to openElement.');
+  return html;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/signal-context.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @openelement/core - SignalContext DOM-tree-based cross-component signal sharing.
+ *
+ * v0.29.6: WeakMap replaces symbol-keyed DOM property stamping.
+ * Consumer walks parentElement / shadowRoot.host upward to find signals.
+ *
+ * @module @openelement/core/signal-context
+ */ import type { WritableSignal } from '@openelement/signal';
+export interface Context<T> {
+  key: symbol;
+  defaultValue: T;
+}
+export declare function createContext<T>(key: symbol, defaultValue: T): Context<T>;
+export declare function provideContext<T>(host: HTMLElement, ctx: Context<T>, value: T): void;
+export declare function consumeContext<T>(ctx: Context<T>, host?: HTMLElement): WritableSignal<T>;

package/src/signal-context.js

@@ -0,0 +1,59 @@
+/**
+ * @openelement/core - SignalContext DOM-tree-based cross-component signal sharing.
+ *
+ * v0.29.6: WeakMap replaces symbol-keyed DOM property stamping.
+ * Consumer walks parentElement / shadowRoot.host upward to find signals.
+ *
+ * @module @openelement/core/signal-context
+ */ import { signal } from '@openelement/signal';
+const defaultSignals = new Map();
+const hostSignals = new WeakMap();
+export function createContext(key, defaultValue) {
+  const s = signal(defaultValue);
+  defaultSignals.set(key, s);
+  return {
+    key,
+    defaultValue
+  };
+}
+function getOrCreateHostSignal(host, ctx, initialValue) {
+  let map = hostSignals.get(host);
+  if (!map) {
+    map = new Map();
+    hostSignals.set(host, map);
+  }
+  let scoped = map.get(ctx.key);
+  if (!scoped) {
+    scoped = signal(initialValue);
+    map.set(ctx.key, scoped);
+  }
+  return scoped;
+}
+export function provideContext(host, ctx, value) {
+  const scoped = getOrCreateHostSignal(host, ctx, value);
+  scoped.value = value;
+}
+function findProvidedSignal(host, ctx) {
+  let current = host;
+  while(current){
+    const store = hostSignals.get(current);
+    if (store) {
+      const candidate = store.get(ctx.key);
+      if (candidate) return candidate;
+    }
+    current = current.parentNode;
+    if (!current) {
+      const root = host?.getRootNode?.();
+      current = root instanceof ShadowRoot ? root.host : null;
+    }
+  }
+  return undefined;
+}
+export function consumeContext(ctx, host) {
+  const scoped = findProvidedSignal(host, ctx);
+  if (scoped) return scoped;
+  const s = defaultSignals.get(ctx.key);
+  if (s) return s;
+  return signal(ctx.defaultValue);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/static.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @openelement/core/static - SSR/SSG runtime surface.
+ *
+ * Pure static rendering entry point. Contains everything needed to create
+ * VNodes and render them to DSD/HTML strings, without pulling in any DOM
+ * binding, effect, or hydration code.
+ *
+ * ADR-0109 Phase 1: split @openelement/core into static, hydrate, and csr.
+ */ export type { VNode } from '@openelement/protocol/vnode';
+export { isVNode } from "./vnode.js";
+export { For, Fragment, jsx, jsxDEV, jsxs, Show, trustedHtml } from "./jsx-runtime.js";
+export { camelToKebab, renderDsdTree, serializeAttrs } from "./render-ir.js";
+export { renderDsd } from "./render-dsd.js";
+export { createRenderDsdStreamMetrics, renderDsdStream } from "./render-dsd-stream.js";
+export type { RenderDsdStreamChunk, RenderDsdStreamComponent, RenderDsdStreamMetrics, RenderDsdStreamOptions } from "./render-dsd-stream.js";
+export type { RenderDsdOptions } from "./render-dsd.js";
+export { escapeAttr, escapeAttrValue, escapeHtml, renderSsrError, wrapInDocument } from "./html-escape.js";
+export type { SafeHtml, UnsafeHtml } from '@openelement/protocol/framework';
+export { DANGEROUS_KEYS } from "./security.js";
+export { ERROR_PREFIX, ErrorCode, formatError, OpenElementError, PropValidationError, RenderError, reportError, setErrorTelemetryHook, SsrRenderError } from "./errors.js";
+export type { ErrorPhase, ErrorSeverity, ErrorTelemetryHook } from '@openelement/protocol/errors';
+export { createLogger } from "./logger.js";
+export { disposeStaticProps, handleStaticPropAttributeChange, initializeStaticProps, normalizePropDecl, registerStaticObservedAttributes, syncStaticPropsFromAttributes, unwrap } from "./prop.js";
+export type { NormalizedPropDecl, PropDecl, PropDeclFull, PropDeclShorthand, PropsFrom, PropType } from '@openelement/protocol/prop';
+export { isSignalLike, unwrapSignalLike } from '@openelement/signal';
+export type { SignalLike, Unsubscribe } from '@openelement/protocol/signal';
+export { createSsrContext, extractParams, parseQuery } from "./context.js";
+export type { IslandDescriptor, SsrContext } from '@openelement/protocol/context';
+export { consumeContext, createContext, provideContext } from "./signal-context.js";
+export type { Context } from "./signal-context.js";
+export { isValidTagName } from "./tag-utils.js";
+export { StyleSheet } from "./style-sheet.js";
+export type { StyleSheetLike, StyleSheetRule } from '@openelement/protocol/style-sheet';
+export { createEventMarkerContext, eventMarkerId, eventTypeFromProp, serializeEventMarkers } from "./event-marker.js";
+export type { EventMarkerContext } from "./event-marker.js";

package/src/static.js

@@ -0,0 +1,34 @@
+/**
+ * @openelement/core/static - SSR/SSG runtime surface.
+ *
+ * Pure static rendering entry point. Contains everything needed to create
+ * VNodes and render them to DSD/HTML strings, without pulling in any DOM
+ * binding, effect, or hydration code.
+ *
+ * ADR-0109 Phase 1: split @openelement/core into static, hydrate, and csr.
+ */ // VNode / JSX runtime
+export { isVNode } from './vnode.js';
+export { For, Fragment, jsx, jsxDEV, jsxs, Show, trustedHtml } from './jsx-runtime.js';
+// Static rendering (IR + DSD)
+export { camelToKebab, renderDsdTree, serializeAttrs } from './render-ir.js';
+export { renderDsd } from './render-dsd.js';
+export { createRenderDsdStreamMetrics, renderDsdStream } from './render-dsd-stream.js';
+// HTML escaping / document wrapping
+export { escapeAttr, escapeAttrValue, escapeHtml, renderSsrError, wrapInDocument } from './html-escape.js';
+// Security / errors / logging
+export { DANGEROUS_KEYS } from './security.js';
+export { ERROR_PREFIX, ErrorCode, formatError, OpenElementError, PropValidationError, RenderError, reportError, setErrorTelemetryHook, SsrRenderError } from './errors.js';
+export { createLogger } from './logger.js';
+// Static props runtime
+export { disposeStaticProps, handleStaticPropAttributeChange, initializeStaticProps, normalizePropDecl, registerStaticObservedAttributes, syncStaticPropsFromAttributes, unwrap } from './prop.js';
+// Signal utilities (neutral, no DOM)
+export { isSignalLike, unwrapSignalLike } from '@openelement/signal';
+// Context / request helpers
+export { createSsrContext, extractParams, parseQuery } from './context.js';
+export { consumeContext, createContext, provideContext } from './signal-context.js';
+// Misc static utilities
+export { isValidTagName } from './tag-utils.js';
+export { StyleSheet } from './style-sheet.js';
+// Event marker serialization (used by SSR; hydration lives in hydrate.ts)
+export { createEventMarkerContext, eventMarkerId, eventTypeFromProp, serializeEventMarkers } from './event-marker.js';
+//# sourceMappingURL=data:application/json;base64,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

package/src/style-sheet.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Cross-environment CSSStyleSheet abstraction.
+ *
+ * In browsers this delegates to the native CSSStyleSheet API. In SSR runtimes
+ * it falls back to a minimal in-memory implementation that exposes the subset
+ * used by OpenElement and renderDsd().
+ */ import type { StyleSheetLike, StyleSheetRule } from '@openelement/protocol/style-sheet';
+export type { StyleSheetLike, StyleSheetRule };
+export declare const StyleSheet: new() => StyleSheetLike;

package/src/style-sheet.js

@@ -0,0 +1,56 @@
+/**
+ * Cross-environment CSSStyleSheet abstraction.
+ *
+ * In browsers this delegates to the native CSSStyleSheet API. In SSR runtimes
+ * it falls back to a minimal in-memory implementation that exposes the subset
+ * used by OpenElement and renderDsd().
+ */ function parseRules(css) {
+  const rules = [];
+  let i = 0;
+  const len = css.length;
+  while(i < len){
+    while(i < len && /\s/.test(css[i]))i++;
+    if (i >= len) break;
+    if (css[i] === '/' && css[i + 1] === '*') {
+      const end = css.indexOf('*/', i + 2);
+      if (end === -1) break;
+      i = end + 2;
+      continue;
+    }
+    const openBrace = css.indexOf('{', i);
+    if (openBrace === -1) break;
+    let depth = 0;
+    let j = openBrace;
+    while(j < len){
+      if (css[j] === '{') depth++;
+      else if (css[j] === '}') {
+        depth--;
+        if (depth === 0) break;
+      }
+      j++;
+    }
+    if (depth !== 0) break;
+    const ruleText = css.substring(i, j + 1).trim();
+    if (ruleText) rules.push({
+      cssText: ruleText
+    });
+    i = j + 1;
+  }
+  if (rules.length === 0 && css.trim()) {
+    rules.push({
+      cssText: css.trim()
+    });
+  }
+  return rules;
+}
+class ShimStyleSheet {
+  #rules = [];
+  get cssRules() {
+    return this.#rules;
+  }
+  replaceSync(text) {
+    this.#rules = parseRules(text);
+  }
+}
+export const StyleSheet = typeof globalThis.CSSStyleSheet === 'function' ? globalThis.CSSStyleSheet : ShimStyleSheet;
+//# sourceMappingURL=data:application/json;base64,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

package/src/tag-utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @openelement/core — Tag name validation utility.
+ *
+ * Validates custom element tag names per HTML spec:
+ * - Must contain at least one hyphen
+ * - Must start with a lowercase letter
+ * - Only lowercase letters, digits, and hyphens allowed
+ * - Must not be a reserved name
+ *
+ * @module @openelement/core/tag-utils
+ */ /** Check if a tag name is a valid custom element name per HTML spec. */ export declare function isValidTagName(tagName: string): boolean;