@openelement/core 0.41.0-alpha.1

package/src/render-dsd.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @openelement/core - DSD Renderer.
+ *
+ * Declarative Shadow DOM SSR renderer.
+ * Framework-agnostic: no Lit dependency and no TemplateResult knowledge.
+ *
+ * v0.29.1: Inlined render-errors, render-instantiate, and render-serialize helpers.
+ * Uses unified serializeAttrs from render-ir. Removed renderDsdByName.
+ * Changed renderDsdTree import from jsx-render-string to render-ir.
+ *
+ * @module @openelement/core/render-dsd
+ */ import { type DsdOptions, type RenderHooks, type RenderOutput } from '@openelement/protocol/render';
+import { type RenderNode } from "./render-ir.js";
+export interface RenderDsdOptions {
+  componentClass?: CustomElementConstructor;
+  props?: Record<string, unknown>;
+  sourceInfo?: {
+    route?: string;
+    source?: string;
+  };
+  dsdOptions?: DsdOptions;
+  nestingDepth?: number;
+  hooks?: RenderHooks;
+  lightDom?: RenderNode[];
+}
+export declare function renderDsd(input: string | CustomElementConstructor, options?: RenderDsdOptions): Promise<RenderOutput>;
+export { createRenderDsdStreamMetrics, renderDsdStream } from "./render-dsd-stream.js";

package/src/render-dsd.js

@@ -0,0 +1,315 @@
+/**
+ * @openelement/core - DSD Renderer.
+ *
+ * Declarative Shadow DOM SSR renderer.
+ * Framework-agnostic: no Lit dependency and no TemplateResult knowledge.
+ *
+ * v0.29.1: Inlined render-errors, render-instantiate, and render-serialize helpers.
+ * Uses unified serializeAttrs from render-ir. Removed renderDsdByName.
+ * Changed renderDsdTree import from jsx-render-string to render-ir.
+ *
+ * @module @openelement/core/render-dsd
+ */ import { createLogger } from './logger.js';
+import { formatError } from './errors.js';
+import { escapeAttrValue } from './html-escape.js';
+import { isVNode } from './vnode.js';
+import { renderDsdTree } from './render-ir.js';
+import { dsdHostNode, serializeAttrs, serializeRenderNode, trustedHtmlNode } from './render-ir.js';
+import { DANGEROUS_KEYS } from './security.js';
+const log = createLogger('core');
+// ─── Error Classification ──────────────────────────────────────
+// RenderPhase and RenderErrorCode are imported from @openelement/protocol/render.
+export function classifyError(phase, tagName, err, recoverable = false) {
+  const message = formatError(err);
+  return {
+    code: codeForRenderError(phase, message),
+    severity: recoverable ? 'warning' : 'error',
+    phase,
+    tagName,
+    message,
+    recoverable
+  };
+}
+// ponytail: lookup table replaces 5-case if/else chain
+const ERROR_CODES = {
+  instantiate: 'LESS_RENDER_INSTANTIATE_FAILED',
+  nested: 'LESS_RENDER_NESTED_FAILED',
+  style: 'LESS_RENDER_STYLE_FAILED',
+  serialize: 'LESS_RENDER_SERIALIZE_FAILED'
+};
+function codeForRenderError(phase, message) {
+  if (message.includes('Components must return a VNode')) {
+    return 'LESS_RENDER_INVALID_OUTPUT';
+  }
+  return ERROR_CODES[phase] ?? 'LESS_RENDER_RENDER_FAILED';
+}
+function instantiationErrorHtml(tagName, _errMsg, _sourceStr, _route, _source) {
+  return `<${tagName}></${tagName}>`;
+}
+// ─── Component Instantiation ───────────────────────────────────
+function instantiateComponent(tagName, componentClass) {
+  try {
+    const instance = new componentClass();
+    if (!isDsdComponent(instance)) {
+      log.error(`<${tagName}> does not implement render(): VNode | null.`);
+      return null;
+    }
+    return instance;
+  } catch (err) {
+    const errMsg = formatError(err);
+    log.error(`Failed to instantiate <${tagName}>: ${errMsg}`);
+    return null;
+  }
+}
+function isDsdComponent(value) {
+  return typeof value === 'object' && value !== null && typeof Reflect.get(value, 'render') === 'function';
+}
+function injectProps(instance, tagName, props) {
+  for (const [key, value] of Object.entries(props)){
+    if (DANGEROUS_KEYS.has(key)) {
+      log.warn(`Skipping dangerous prop key "${key}" on <${tagName}> - potential prototype pollution`);
+      continue;
+    }
+    try {
+      instance[key] = value;
+    } catch (e) {
+      log.debug(`Cannot set read-only property "${key}" on <${tagName}>: ${formatError(e)}`);
+    }
+  }
+}
+// ─── DSD Template Attributes ───────────────────────────────────
+function buildDsdTemplateAttrs(options) {
+  if (!options) return '';
+  const parts = [];
+  if (options.delegatesFocus) parts.push(' shadowrootdelegatesfocus');
+  if (options.clonable) parts.push(' shadowrootclonable');
+  if (options.serializable) parts.push(' shadowrootserializable');
+  if (options.slotAssignment === 'manual') {
+    parts.push(' shadowrootslotassignment="manual"');
+  }
+  if (options.customElementRegistry) {
+    parts.push(' shadowrootcustomelementregistry');
+  }
+  return parts.join('');
+}
+// ─── DSD Output Wrapping ───────────────────────────────────────
+function wrapDsdOutput(params) {
+  const { tagName, props, content, styleCss, layer, sourceStr, dsdOptions, lightDom } = params;
+  const publicProps = filterPublicDsdProps(props);
+  const ssrPropsAttr = Object.keys(publicProps).length > 0 ? ` data-ssr-props="${escapeAttrValue(JSON.stringify(publicProps))}"` : '';
+  return serializeRenderNode(dsdHostNode({
+    tag: tagName,
+    attrs: publicProps,
+    ssrPropsAttr,
+    source: sourceStr,
+    templateAttrs: buildDsdTemplateAttrs(dsdOptions),
+    styleCss,
+    shadow: [
+      trustedHtmlNode(content)
+    ],
+    light: lightDom ?? [],
+    layer
+  }));
+}
+function filterPublicDsdProps(props) {
+  const publicProps = {};
+  for (const [key, value] of Object.entries(props)){
+    if (key.startsWith('__openElement')) continue;
+    publicProps[key] = value;
+  }
+  return publicProps;
+}
+export async function renderDsd(input, options = {}) {
+  let tagName;
+  let componentClass;
+  const props = options.props ?? {};
+  if (typeof input === 'string') {
+    tagName = input;
+    if (options?.componentClass) {
+      componentClass = options.componentClass;
+    } else {
+      const cls = globalThis.customElements?.get(tagName);
+      if (!cls) {
+        log.warn(`<${tagName}> is not registered - rendering as void element`);
+        const attrs = serializeAttrs(tagName, props);
+        const html = `<${tagName}${attrs}></${tagName}>`;
+        return {
+          html,
+          errors: [],
+          metrics: {
+            tagName,
+            renderTimeMs: 0,
+            templateSize: 0,
+            layer: 'dsd-static',
+            hasError: false,
+            nestingDepth: 0
+          },
+          hydrationHints: []
+        };
+      }
+      componentClass = cls;
+    }
+  } else {
+    componentClass = input;
+    tagName = input.tagName ?? 'unknown';
+  }
+  const sourceInfo = options.sourceInfo;
+  const dsdOptions = options.dsdOptions;
+  const nestingDepth = options.nestingDepth;
+  const hooks = options.hooks;
+  const _nestingDepth = nestingDepth ?? 0;
+  const startTime = typeof performance !== 'undefined' ? performance.now() : 0;
+  const sourceStr = sourceInfo ? `${sourceInfo.route ? ` route="${sourceInfo.route}"` : ''}${sourceInfo.source ? ` source="${sourceInfo.source}"` : ''}` : '';
+  const collectedErrors = [];
+  const collectedHints = [];
+  let hasError = false;
+  const renderInput = {
+    tagName,
+    componentClass,
+    props,
+    dsdOptions,
+    nestingDepth: _nestingDepth
+  };
+  if (hooks?.beforeRender) {
+    try {
+      hooks.beforeRender(renderInput);
+    } catch (e) {
+      log.debug(`beforeRender hook threw: ${formatError(e)}`);
+    }
+  }
+  const instance = instantiateComponent(tagName, componentClass);
+  if (!instance) {
+    const errMsg = 'Failed to instantiate';
+    const err = classifyError('instantiate', tagName, errMsg, false);
+    collectedErrors.push(err);
+    hasError = true;
+    hooks?.onError?.(err);
+    const html = instantiationErrorHtml(tagName, errMsg, sourceStr, sourceInfo?.route, sourceInfo?.source);
+    const result = {
+      html,
+      errors: collectedErrors,
+      metrics: {
+        tagName,
+        renderTimeMs: 0,
+        templateSize: 0,
+        layer: 'dsd-static',
+        hasError: true,
+        nestingDepth: _nestingDepth
+      },
+      hydrationHints: collectedHints
+    };
+    hooks?.afterRender?.(result);
+    return result;
+  }
+  injectProps(instance, tagName, props);
+  let content = '';
+  try {
+    const result = instance.render();
+    if (result == null) {
+      content = '';
+    } else if (isVNode(result)) {
+      content = await renderDsdTree(result);
+    } else {
+      log.debug(`Unsupported render() return for <${tagName}>: ${describeRenderValue(result)}`);
+      const errDetail = `Components must return a VNode from render(), got ${typeof result}.`;
+      const err = classifyError('render', tagName, errDetail, false);
+      collectedErrors.push(err);
+      hasError = true;
+      hooks?.onError?.(err);
+      content = '';
+    }
+  } catch (err) {
+    const classifiedErr = classifyError('render', tagName, err, true);
+    collectedErrors.push(classifiedErr);
+    hasError = true;
+    hooks?.onError?.(classifiedErr);
+    const attrs = serializeAttrs(tagName, props);
+    const renderEndFallback = safeNow();
+    const fallbackResult = {
+      html: `<${tagName}${attrs}></${tagName}>`,
+      errors: collectedErrors,
+      metrics: {
+        tagName,
+        renderTimeMs: renderEndFallback - startTime,
+        templateSize: 0,
+        layer: 'dsd-static',
+        hasError: hasError,
+        nestingDepth: _nestingDepth
+      },
+      hydrationHints: collectedHints
+    };
+    hooks?.afterRender?.(fallbackResult);
+    return fallbackResult;
+  }
+  let styleCss = '';
+  const ctor = componentClass;
+  if (ctor.styles) {
+    const sheets = Array.isArray(ctor.styles) ? ctor.styles : [
+      ctor.styles
+    ];
+    for (const sheet of sheets){
+      try {
+        for (const rule of [
+          ...sheet.cssRules
+        ]){
+          styleCss += rule.cssText + '\n';
+        }
+      } catch  {
+      // Cross-origin stylesheet or empty sheet - skip silently
+      }
+    }
+  }
+  const renderMode = ctor.renderMode ?? 'shadow';
+  const resolvedLayer = renderMode === 'light' ? 'light-dom' : dsdOptions?.layer || instance.layer || 'dsd-static';
+  const renderEnd = safeNow();
+  const renderTimeMs = renderEnd - startTime;
+  const metrics = {
+    tagName,
+    renderTimeMs,
+    templateSize: content.length,
+    layer: resolvedLayer,
+    hasError,
+    nestingDepth: _nestingDepth
+  };
+  if (resolvedLayer !== 'dsd-static') {
+    collectedHints.push({
+      tagName,
+      layer: resolvedLayer
+    });
+  }
+  const html = wrapDsdOutput({
+    tagName,
+    props,
+    content,
+    styleCss,
+    layer: resolvedLayer,
+    sourceStr,
+    dsdOptions,
+    lightDom: options.lightDom
+  });
+  const output = {
+    html,
+    errors: collectedErrors,
+    metrics,
+    hydrationHints: collectedHints
+  };
+  if (hooks?.afterRender) {
+    try {
+      hooks.afterRender(output);
+    } catch (e) {
+      log.debug(`afterRender hook threw: ${formatError(e)}`);
+    }
+  }
+  return output;
+}
+/** Safe high-resolution timestamp with SSR/environment fallback. */ export function safeNow() {
+  return typeof performance !== 'undefined' ? performance.now() : Date.now();
+}
+function describeRenderValue(value) {
+  if (value === null || typeof value !== 'object') return typeof value;
+  const keys = Object.keys(value).join(',');
+  return `object keys=[${keys}]`;
+}
+// v0.21.0: Streaming types and functions moved to render-dsd-stream.ts.
+export { createRenderDsdStreamMetrics, renderDsdStream } from './render-dsd-stream.js';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/core/src/render-dsd.ts"],"sourcesContent":["/**\n * @openelement/core - DSD Renderer.\n *\n * Declarative Shadow DOM SSR renderer.\n * Framework-agnostic: no Lit dependency and no TemplateResult knowledge.\n *\n * v0.29.1: Inlined render-errors, render-instantiate, and render-serialize helpers.\n * Uses unified serializeAttrs from render-ir. Removed renderDsdByName.\n * Changed renderDsdTree import from jsx-render-string to render-ir.\n *\n * @module @openelement/core/render-dsd\n */\n\nimport {\n  type DsdComponent,\n  type DsdOptions,\n  type DsdRenderMetrics,\n  type HydrationHint,\n  type RenderError,\n  type RenderErrorCode,\n  type RenderHooks,\n  type RenderInput,\n  type RenderOutput,\n  type RenderPhase,\n} from '@openelement/protocol/render';\nimport { type DsdComponentConstructor } from '@openelement/protocol/render';\nimport type { ComponentLayer } from '@openelement/protocol/framework';\nimport { createLogger } from './logger.js';\nimport { formatError } from './errors.js';\nimport { escapeAttrValue } from './html-escape.js';\nimport { isVNode } from './vnode.js';\nimport { renderDsdTree } from './render-ir.js';\nimport {\n  dsdHostNode,\n  type RenderNode,\n  serializeAttrs,\n  serializeRenderNode,\n  trustedHtmlNode,\n} from './render-ir.js';\nimport { DANGEROUS_KEYS } from './security.js';\n\nconst log = createLogger('core');\n\n// ─── Error Classification ──────────────────────────────────────\n// RenderPhase and RenderErrorCode are imported from @openelement/protocol/render.\n\nexport function classifyError(\n  phase: RenderPhase,\n  tagName: string,\n  err: unknown,\n  recoverable = false,\n): RenderError {\n  const message = formatError(err);\n  return {\n    code: codeForRenderError(phase, message),\n    severity: recoverable ? 'warning' : 'error',\n    phase,\n    tagName,\n    message,\n    recoverable,\n  };\n}\n\n// ponytail: lookup table replaces 5-case if/else chain\nconst ERROR_CODES: Record<string, RenderErrorCode> = {\n  instantiate: 'LESS_RENDER_INSTANTIATE_FAILED',\n  nested: 'LESS_RENDER_NESTED_FAILED',\n  style: 'LESS_RENDER_STYLE_FAILED',\n  serialize: 'LESS_RENDER_SERIALIZE_FAILED',\n};\n\nfunction codeForRenderError(phase: RenderPhase, message: string): RenderErrorCode {\n  if (message.includes('Components must return a VNode')) {\n    return 'LESS_RENDER_INVALID_OUTPUT';\n  }\n  return ERROR_CODES[phase] ?? 'LESS_RENDER_RENDER_FAILED';\n}\n\nfunction instantiationErrorHtml(\n  tagName: string,\n  _errMsg: string,\n  _sourceStr: string,\n  _route?: string,\n  _source?: string,\n): string {\n  return `<${tagName}></${tagName}>`;\n}\n\n// ─── Component Instantiation ───────────────────────────────────\n\nfunction instantiateComponent(\n  tagName: string,\n  componentClass: CustomElementConstructor,\n): DsdComponent | null {\n  try {\n    const instance = new componentClass();\n    if (!isDsdComponent(instance)) {\n      log.error(`<${tagName}> does not implement render(): VNode | null.`);\n      return null;\n    }\n    return instance;\n  } catch (err) {\n    const errMsg = formatError(err);\n    log.error(`Failed to instantiate <${tagName}>: ${errMsg}`);\n    return null;\n  }\n}\n\nfunction isDsdComponent(value: unknown): value is DsdComponent {\n  return typeof value === 'object' &&\n    value !== null &&\n    typeof Reflect.get(value, 'render') === 'function';\n}\n\nfunction injectProps(\n  instance: DsdComponent,\n  tagName: string,\n  props: Record<string, unknown>,\n): void {\n  for (const [key, value] of Object.entries(props)) {\n    if (DANGEROUS_KEYS.has(key)) {\n      log.warn(\n        `Skipping dangerous prop key \"${key}\" on <${tagName}> - potential prototype pollution`,\n      );\n      continue;\n    }\n    try {\n      (instance as Record<string, unknown>)[key] = value;\n    } catch (e) {\n      log.debug(\n        `Cannot set read-only property \"${key}\" on <${tagName}>: ${formatError(e)}`,\n      );\n    }\n  }\n}\n\n// ─── DSD Template Attributes ───────────────────────────────────\n\nfunction buildDsdTemplateAttrs(options?: DsdOptions): string {\n  if (!options) return '';\n  const parts: string[] = [];\n  if (options.delegatesFocus) parts.push(' shadowrootdelegatesfocus');\n  if (options.clonable) parts.push(' shadowrootclonable');\n  if (options.serializable) parts.push(' shadowrootserializable');\n  if (options.slotAssignment === 'manual') {\n    parts.push(' shadowrootslotassignment=\"manual\"');\n  }\n  if (options.customElementRegistry) {\n    parts.push(' shadowrootcustomelementregistry');\n  }\n  return parts.join('');\n}\n\n// ─── DSD Output Wrapping ───────────────────────────────────────\n\nfunction wrapDsdOutput(params: {\n  tagName: string;\n  props: Record<string, unknown>;\n  content: string;\n  styleCss: string;\n  layer: string;\n  sourceStr: string;\n  dsdOptions?: DsdOptions;\n  lightDom?: RenderNode[];\n}): string {\n  const { tagName, props, content, styleCss, layer, sourceStr, dsdOptions, lightDom } = params;\n  const publicProps = filterPublicDsdProps(props);\n  const ssrPropsAttr = Object.keys(publicProps).length > 0\n    ? ` data-ssr-props=\"${escapeAttrValue(JSON.stringify(publicProps))}\"`\n    : '';\n\n  return serializeRenderNode(\n    dsdHostNode({\n      tag: tagName,\n      attrs: publicProps,\n      ssrPropsAttr,\n      source: sourceStr,\n      templateAttrs: buildDsdTemplateAttrs(dsdOptions),\n      styleCss,\n      shadow: [trustedHtmlNode(content)],\n      light: lightDom ?? [],\n      layer,\n    }),\n  );\n}\n\nfunction filterPublicDsdProps(props: Record<string, unknown>): Record<string, unknown> {\n  const publicProps: Record<string, unknown> = {};\n  for (const [key, value] of Object.entries(props)) {\n    if (key.startsWith('__openElement')) continue;\n    publicProps[key] = value;\n  }\n  return publicProps;\n}\n\n// ─── DSD Rendering ─────────────────────────────────────────────\n\nexport interface RenderDsdOptions {\n  componentClass?: CustomElementConstructor;\n  props?: Record<string, unknown>;\n  sourceInfo?: { route?: string; source?: string };\n  dsdOptions?: DsdOptions;\n  nestingDepth?: number;\n  hooks?: RenderHooks;\n  lightDom?: RenderNode[];\n}\n\nexport async function renderDsd(\n  input: string | CustomElementConstructor,\n  options: RenderDsdOptions = {},\n): Promise<RenderOutput> {\n  let tagName: string;\n  let componentClass: CustomElementConstructor;\n  const props = options.props ?? {};\n\n  if (typeof input === 'string') {\n    tagName = input;\n    if (options?.componentClass) {\n      componentClass = options.componentClass;\n    } else {\n      const cls = globalThis.customElements?.get(tagName) as CustomElementConstructor | undefined;\n      if (!cls) {\n        log.warn(`<${tagName}> is not registered - rendering as void element`);\n        const attrs = serializeAttrs(tagName, props);\n        const html = `<${tagName}${attrs}></${tagName}>`;\n        return {\n          html,\n          errors: [],\n          metrics: {\n            tagName,\n            renderTimeMs: 0,\n            templateSize: 0,\n            layer: 'dsd-static',\n            hasError: false,\n            nestingDepth: 0,\n          },\n          hydrationHints: [],\n        };\n      }\n      componentClass = cls;\n    }\n  } else {\n    componentClass = input;\n    tagName = (input as DsdComponentConstructor).tagName ?? 'unknown';\n  }\n\n  const sourceInfo = options.sourceInfo;\n  const dsdOptions = options.dsdOptions;\n  const nestingDepth = options.nestingDepth;\n  const hooks = options.hooks;\n\n  const _nestingDepth = nestingDepth ?? 0;\n  const startTime = typeof performance !== 'undefined' ? performance.now() : 0;\n  const sourceStr = sourceInfo\n    ? `${sourceInfo.route ? ` route=\"${sourceInfo.route}\"` : ''}${\n      sourceInfo.source ? ` source=\"${sourceInfo.source}\"` : ''\n    }`\n    : '';\n\n  const collectedErrors: RenderError[] = [];\n  const collectedHints: HydrationHint[] = [];\n  let hasError = false;\n\n  const renderInput: RenderInput = {\n    tagName,\n    componentClass,\n    props,\n    dsdOptions,\n    nestingDepth: _nestingDepth,\n  };\n\n  if (hooks?.beforeRender) {\n    try {\n      hooks.beforeRender(renderInput);\n    } catch (e) {\n      log.debug(`beforeRender hook threw: ${formatError(e)}`);\n    }\n  }\n\n  const instance = instantiateComponent(tagName, componentClass);\n  if (!instance) {\n    const errMsg = 'Failed to instantiate';\n    const err = classifyError('instantiate', tagName, errMsg, false);\n    collectedErrors.push(err);\n    hasError = true;\n    hooks?.onError?.(err);\n\n    const html = instantiationErrorHtml(\n      tagName,\n      errMsg,\n      sourceStr,\n      sourceInfo?.route,\n      sourceInfo?.source,\n    );\n\n    const result: RenderOutput = {\n      html,\n      errors: collectedErrors,\n      metrics: {\n        tagName,\n        renderTimeMs: 0,\n        templateSize: 0,\n        layer: 'dsd-static',\n        hasError: true,\n        nestingDepth: _nestingDepth,\n      },\n      hydrationHints: collectedHints,\n    };\n    hooks?.afterRender?.(result);\n    return result;\n  }\n\n  injectProps(instance, tagName, props);\n\n  let content = '';\n  try {\n    const result: unknown = instance.render();\n    if (result == null) {\n      content = '';\n    } else if (isVNode(result)) {\n      content = await renderDsdTree(result);\n    } else {\n      log.debug(`Unsupported render() return for <${tagName}>: ${describeRenderValue(result)}`);\n      const errDetail = `Components must return a VNode from render(), got ${typeof result}.`;\n      const err = classifyError('render', tagName, errDetail, false);\n      collectedErrors.push(err);\n      hasError = true;\n      hooks?.onError?.(err);\n      content = '';\n    }\n  } catch (err) {\n    const classifiedErr = classifyError('render', tagName, err, true);\n    collectedErrors.push(classifiedErr);\n    hasError = true;\n    hooks?.onError?.(classifiedErr);\n\n    const attrs = serializeAttrs(tagName, props);\n    const renderEndFallback = safeNow();\n    const fallbackResult: RenderOutput = {\n      html: `<${tagName}${attrs}></${tagName}>`,\n      errors: collectedErrors,\n      metrics: {\n        tagName,\n        renderTimeMs: renderEndFallback - startTime,\n        templateSize: 0,\n        layer: 'dsd-static',\n        hasError: hasError,\n        nestingDepth: _nestingDepth,\n      },\n      hydrationHints: collectedHints,\n    };\n    hooks?.afterRender?.(fallbackResult);\n    return fallbackResult;\n  }\n\n  let styleCss = '';\n\n  const ctor = componentClass as DsdComponentConstructor;\n  if (ctor.styles) {\n    const sheets = Array.isArray(ctor.styles) ? ctor.styles : [ctor.styles];\n    for (const sheet of sheets) {\n      try {\n        for (const rule of [...sheet.cssRules]) {\n          styleCss += rule.cssText + '\\n';\n        }\n      } catch {\n        // Cross-origin stylesheet or empty sheet - skip silently\n      }\n    }\n  }\n\n  const renderMode = ctor.renderMode ?? 'shadow';\n  const resolvedLayer = renderMode === 'light'\n    ? 'light-dom'\n    : dsdOptions?.layer || instance.layer || 'dsd-static';\n\n  const renderEnd = safeNow();\n  const renderTimeMs = renderEnd - startTime;\n\n  const metrics: DsdRenderMetrics = {\n    tagName,\n    renderTimeMs,\n    templateSize: content.length,\n    layer: resolvedLayer,\n    hasError,\n    nestingDepth: _nestingDepth,\n  };\n\n  if (resolvedLayer !== 'dsd-static') {\n    collectedHints.push({\n      tagName,\n      layer: resolvedLayer as ComponentLayer,\n    });\n  }\n\n  const html = wrapDsdOutput({\n    tagName,\n    props,\n    content,\n    styleCss,\n    layer: resolvedLayer,\n    sourceStr,\n    dsdOptions,\n    lightDom: options.lightDom,\n  });\n\n  const output: RenderOutput = {\n    html,\n    errors: collectedErrors,\n    metrics,\n    hydrationHints: collectedHints,\n  };\n\n  if (hooks?.afterRender) {\n    try {\n      hooks.afterRender(output);\n    } catch (e) {\n      log.debug(`afterRender hook threw: ${formatError(e)}`);\n    }\n  }\n\n  return output;\n}\n\n/** Safe high-resolution timestamp with SSR/environment fallback. */\nexport function safeNow(): number {\n  return typeof performance !== 'undefined' ? performance.now() : Date.now();\n}\n\nfunction describeRenderValue(value: unknown): string {\n  if (value === null || typeof value !== 'object') return typeof value;\n  const keys = Object.keys(value).join(',');\n  return `object keys=[${keys}]`;\n}\n\n// v0.21.0: Streaming types and functions moved to render-dsd-stream.ts.\nexport { createRenderDsdStreamMetrics, renderDsdStream } from './render-dsd-stream.js';\nexport type {\n  RenderDsdStreamChunk,\n  RenderDsdStreamComponent,\n  RenderDsdStreamMetrics,\n  RenderDsdStreamOptions,\n} from './render-dsd-stream.js';\n"],"names":[],"mappings":"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"}

package/src/render-ir.d.ts

@@ -0,0 +1,32 @@
+import { type EventMarkerContext } from "./event-marker.js";
+export type RenderNode = {
+  kind: 'text';
+  value: string;
+} | {
+  kind: 'trusted-html';
+  value: string;
+} | {
+  kind: 'fragment';
+  children: RenderNode[];
+} | {
+  kind: 'element';
+  tag: string;
+  attrs: Record<string, unknown>;
+  eventAttrs?: string;
+  children: RenderNode[];
+  voidElement?: boolean;
+} | {
+  kind: 'dsd-host';
+  tag: string;
+  attrs: Record<string, unknown>;
+  ssrPropsAttr: string;
+  source: string;
+  templateAttrs: string;
+  styleCss: string;
+  shadow: RenderNode[];
+  light: RenderNode[];
+  layer: string;
+};
+export declare function camelToKebab(str: string): string;
+export declare function serializeAttrs(tag: string, props: Record<string, unknown>): string;
+export declare function renderDsdTree(node: unknown, eventContext?: EventMarkerContext): Promise<string>;