@openelement/core 0.41.0-alpha.1

package/src/html-escape.d.ts

@@ -0,0 +1,29 @@
+import type { SafeHtml, UnsafeHtml } from '@openelement/protocol/framework';
+export type { SafeHtml, UnsafeHtml };
+export declare function escapeHtml(str: string): string;
+/** Escape an HTML attribute value */ export declare function escapeAttr(value: string): string;
+/** Escape a string for use as an attribute value (double-quoted) */ export declare function escapeAttrValue(value: unknown): string;
+/**
+ * Wrap rendered HTML in a full HTML document.
+ * Adds DOCTYPE, head (title, meta, preload), and body.
+ * Supports CSP nonce and dev scripts (e.g. Vite client, route module registration).
+ */ export declare function wrapInDocument(html: string, options?: {
+  title?: string;
+  lang?: string;
+  /** Client-side module script injected after rendered HTML. */ clientScript?: string;
+  meta?: {
+    description?: string;
+    tags?: Array<Record<string, string | number | boolean>>;
+  };
+  /** Raw HTML script tags to inject after rendered HTML (e.g. Vite client, route module registration). */ devScripts?: string;
+  headExtras?: string;
+  /** Raw route-local head fragments from explicit dangerous page metadata. */ dangerouslyHeadFragments?: string[];
+  /** Trust script tags that were produced by structured framework injection APIs. */ allowHeadExtrasScripts?: boolean;
+  /** CSP nonce, if provided, added to all generated <script> tags. */ cspNonce?: string;
+}): string;
+import type { RouteEntry } from '@openelement/protocol/framework';
+/**
+ * Render an error page to HTML string.
+ * In dev mode, shows detailed error information for debugging.
+ * In production, shows a generic safe error page.
+ */ export declare function renderSsrError(error: Error, statusOrRoute: number | RouteEntry, isDev?: boolean): string;

package/src/html-escape.js

@@ -0,0 +1,126 @@
+/**
+ * @openelement/core - Safe/Unsafe HTML Contract
+ *
+ * Branded types for HTML escaping semantics:
+ * - SafeHtml:  A string that has been HTML-escaped (safe for text content)
+ * - UnsafeHtml: A string that is intentionally raw HTML (do not double-escape)
+ *
+ * @module @openelement/core/html-escape
+ */ // ─── L1: Safe/Unsafe HTML Contract ──────────────────────────────
+import { createLogger, warnOnce } from './logger.js';
+const log = createLogger('core');
+/**
+ * Escape a string for safe HTML text content insertion.
+ * Uses single-pass replacement for performance (P-01 fix).
+ * Branded types are compile-time only - removed dead runtime branches (M-01 fix).
+ */ const ESCAPE_MAP = {
+  '&': '&',
+  '<': '&lt;',
+  '>': '&gt;',
+  '"': '&quot;',
+  "'": '&#39;'
+};
+export function escapeHtml(str) {
+  if (typeof str !== 'string') return '';
+  return str.replace(/[&<>"']/g, (ch)=>ESCAPE_MAP[ch] || ch);
+}
+/** Escape an HTML attribute value */ export function escapeAttr(value) {
+  return value.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/'/g, '&#39;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+/** Escape a string for use as an attribute value (double-quoted) */ export function escapeAttrValue(value) {
+  if (value === null || value === undefined) return '';
+  return escapeAttr(String(value));
+}
+/**
+ * Wrap rendered HTML in a full HTML document.
+ * Adds DOCTYPE, head (title, meta, preload), and body.
+ * Supports CSP nonce and dev scripts (e.g. Vite client, route module registration).
+ */ export function wrapInDocument(html, options = {}) {
+  const { title = 'openElement', lang = 'en', clientScript = '', meta, devScripts = '', headExtras = '', dangerouslyHeadFragments = [], allowHeadExtrasScripts = false, cspNonce } = options;
+  // v0.14.5: CSP nonce format validation per CSP spec (base64 value)
+  const NONCE_RE = /^[A-Za-z0-9+/=_-]+$/;
+  const validNonce = cspNonce && NONCE_RE.test(cspNonce) ? cspNonce : undefined;
+  if (cspNonce && !validNonce) {
+    log.warn(`Invalid CSP nonce format: "${cspNonce}". Nonce should be a base64-encoded value.`);
+  }
+  // v0.14.8: C-02 fix - Runtime enforcement for headExtras.
+  // If headExtras contains <script> tags and allowHeadExtrasScripts is false,
+  // strip them to prevent XSS. Developer should use inject.scripts for safe injection.
+  let safeHeadExtras = headExtras;
+  if (!allowHeadExtrasScripts && headExtras) {
+    // Strip <script> tags and their content
+    safeHeadExtras = headExtras.replace(/<script[\s>][\s\S]*?<\/script\s*>/gi, '');
+    if (safeHeadExtras !== headExtras) {
+      warnOnce('headExtrasScripts', log, 'headExtras contained <script> tags which were stripped for security. ' + 'Use inject.scripts for safe script injection, or set allowHeadExtrasScripts: true.');
+    }
+    // Strip on* event handler attributes (strong XSS indicator)
+    if (/\s+on\w+\s*=/i.test(safeHeadExtras)) {
+      safeHeadExtras = safeHeadExtras.replace(/\s+on\w+\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)/gi, '');
+      log.warn('headExtras contained on* event handler attributes which were stripped for security.');
+    }
+  }
+  // v0.14.3: Basic HTML tag balance validation for headExtras.
+  // Checks that opening and closing tag counts match for major HTML elements.
+  // This catches obviously malformed HTML (e.g., unclosed <!-- comments).
+  if (headExtras) {
+    // Check for unclosed HTML comments: <!-- without matching -->
+    const commentOpens = (headExtras.match(/<!--/g) || []).length;
+    const commentCloses = (headExtras.match(/-->/g) || []).length;
+    if (commentOpens !== commentCloses) {
+      log.warn('headExtras has unbalanced HTML comments (<!-- vs -->). ' + 'This may cause HTML parsing issues.');
+    }
+  }
+  const metaTags = [];
+  if (meta?.description) {
+    const safeDesc = escapeAttrValue(meta.description);
+    metaTags.push(`  <meta name="description" content="${safeDesc}">`);
+  }
+  if (Array.isArray(meta?.tags)) {
+    for (const tag of meta.tags){
+      const attrs = Object.entries(tag).map(([key, value])=>`${escapeAttr(key)}="${escapeAttrValue(value)}"`).join(' ');
+      if (attrs) metaTags.push(`  <meta ${attrs}>`);
+    }
+  }
+  const metaBlock = metaTags.length > 0 ? '\n' + metaTags.join('\n') + '\n' : '';
+  const dangerousHeadBlock = dangerouslyHeadFragments.length > 0 ? '\n  ' + dangerouslyHeadFragments.join('\n  ') : '';
+  const safeTitle = escapeHtml(title);
+  const safeLang = escapeAttr(lang);
+  return `<!DOCTYPE html>
+<html lang="${safeLang}">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${safeTitle}</title>${metaBlock}
+  ${safeHeadExtras}${dangerousHeadBlock}
+</head>
+<body>
+  ${html}
+  ${clientScript}${devScripts}
+</body>
+</html>`;
+}
+/**
+ * Render an error page to HTML string.
+ * In dev mode, shows detailed error information for debugging.
+ * In production, shows a generic safe error page.
+ */ export function renderSsrError(error, statusOrRoute, isDev = false) {
+  const status = typeof statusOrRoute === 'number' ? statusOrRoute : 500;
+  const title = isDev ? 'SSR Render Error' : `Error ${status}`;
+  const message = escapeHtml(error.message);
+  const stack = isDev && error.stack ? escapeHtml(error.stack) : '';
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${title}</title>
+  ${isDev ? '<style>body{font-family:system-ui;max-width:800px;margin:2rem auto;padding:0 1rem}pre{background:#f5f5f5;padding:1rem;overflow:auto;border-radius:4px}</style>' : ''}
+</head>
+<body>
+  <h1>${title}</h1>
+  <p>${isDev ? `<strong>${message}</strong>` : message}</p>
+  ${stack ? `<pre>${stack}</pre>` : ''}
+</body>
+</html>`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/core/src/html-escape.ts"],"sourcesContent":["/**\n * @openelement/core - Safe/Unsafe HTML Contract\n *\n * Branded types for HTML escaping semantics:\n * - SafeHtml:  A string that has been HTML-escaped (safe for text content)\n * - UnsafeHtml: A string that is intentionally raw HTML (do not double-escape)\n *\n * @module @openelement/core/html-escape\n */\n\n// ─── L1: Safe/Unsafe HTML Contract ──────────────────────────────\n\nimport { createLogger, warnOnce } from './logger.js';\n\nconst log = createLogger('core');\n\nimport type { SafeHtml, UnsafeHtml } from '@openelement/protocol/framework';\nexport type { SafeHtml, UnsafeHtml };\n\n/**\n * Escape a string for safe HTML text content insertion.\n * Uses single-pass replacement for performance (P-01 fix).\n * Branded types are compile-time only - removed dead runtime branches (M-01 fix).\n */\nconst ESCAPE_MAP: Record<string, string> = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&quot;',\n  \"'\": '&#39;',\n};\nexport function escapeHtml(str: string): string {\n  if (typeof str !== 'string') return '';\n  return str.replace(/[&<>\"']/g, (ch) => ESCAPE_MAP[ch] || ch);\n}\n\n/** Escape an HTML attribute value */\nexport function escapeAttr(value: string): string {\n  return value\n    .replace(/&/g, '&amp;')\n    .replace(/\"/g, '&quot;')\n    .replace(/'/g, '&#39;')\n    .replace(/</g, '&lt;')\n    .replace(/>/g, '&gt;');\n}\n\n/** Escape a string for use as an attribute value (double-quoted) */\nexport function escapeAttrValue(value: unknown): string {\n  if (value === null || value === undefined) return '';\n  return escapeAttr(String(value));\n}\n\n/**\n * Wrap rendered HTML in a full HTML document.\n * Adds DOCTYPE, head (title, meta, preload), and body.\n * Supports CSP nonce and dev scripts (e.g. Vite client, route module registration).\n */\nexport function wrapInDocument(\n  html: string,\n  options: {\n    title?: string;\n    lang?: string;\n    /** Client-side module script injected after rendered HTML. */\n    clientScript?: string;\n    meta?: {\n      description?: string;\n      tags?: Array<Record<string, string | number | boolean>>;\n    };\n    /** Raw HTML script tags to inject after rendered HTML (e.g. Vite client, route module registration). */\n    devScripts?: string;\n    headExtras?: string;\n    /** Raw route-local head fragments from explicit dangerous page metadata. */\n    dangerouslyHeadFragments?: string[];\n    /** Trust script tags that were produced by structured framework injection APIs. */\n    allowHeadExtrasScripts?: boolean;\n    /** CSP nonce, if provided, added to all generated <script> tags. */\n    cspNonce?: string;\n  } = {},\n): string {\n  const {\n    title = 'openElement',\n    lang = 'en',\n    clientScript = '',\n    meta,\n    devScripts = '',\n    headExtras = '',\n    dangerouslyHeadFragments = [],\n    allowHeadExtrasScripts = false,\n    cspNonce,\n  } = options;\n  // v0.14.5: CSP nonce format validation per CSP spec (base64 value)\n  const NONCE_RE = /^[A-Za-z0-9+/=_-]+$/;\n  const validNonce = cspNonce && NONCE_RE.test(cspNonce) ? cspNonce : undefined;\n  if (cspNonce && !validNonce) {\n    log.warn(`Invalid CSP nonce format: \"${cspNonce}\". Nonce should be a base64-encoded value.`);\n  }\n  // v0.14.8: C-02 fix - Runtime enforcement for headExtras.\n  // If headExtras contains <script> tags and allowHeadExtrasScripts is false,\n  // strip them to prevent XSS. Developer should use inject.scripts for safe injection.\n  let safeHeadExtras = headExtras;\n  if (!allowHeadExtrasScripts && headExtras) {\n    // Strip <script> tags and their content\n    safeHeadExtras = headExtras.replace(/<script[\\s>][\\s\\S]*?<\\/script\\s*>/gi, '');\n    if (safeHeadExtras !== headExtras) {\n      warnOnce(\n        'headExtrasScripts',\n        log,\n        'headExtras contained <script> tags which were stripped for security. ' +\n          'Use inject.scripts for safe script injection, or set allowHeadExtrasScripts: true.',\n      );\n    }\n    // Strip on* event handler attributes (strong XSS indicator)\n    if (/\\s+on\\w+\\s*=/i.test(safeHeadExtras)) {\n      safeHeadExtras = safeHeadExtras.replace(\n        /\\s+on\\w+\\s*=\\s*(?:\"[^\"]*\"|'[^']*'|[^\\s>]+)/gi,\n        '',\n      );\n      log.warn(\n        'headExtras contained on* event handler attributes which were stripped for security.',\n      );\n    }\n  }\n\n  // v0.14.3: Basic HTML tag balance validation for headExtras.\n  // Checks that opening and closing tag counts match for major HTML elements.\n  // This catches obviously malformed HTML (e.g., unclosed <!-- comments).\n  if (headExtras) {\n    // Check for unclosed HTML comments: <!-- without matching -->\n    const commentOpens = (headExtras.match(/<!--/g) || []).length;\n    const commentCloses = (headExtras.match(/-->/g) || []).length;\n    if (commentOpens !== commentCloses) {\n      log.warn(\n        'headExtras has unbalanced HTML comments (<!-- vs -->). ' +\n          'This may cause HTML parsing issues.',\n      );\n    }\n  }\n  const metaTags: string[] = [];\n  if (meta?.description) {\n    const safeDesc = escapeAttrValue(meta.description);\n    metaTags.push(`  <meta name=\"description\" content=\"${safeDesc}\">`);\n  }\n  if (Array.isArray(meta?.tags)) {\n    for (const tag of meta.tags) {\n      const attrs = Object.entries(tag)\n        .map(([key, value]) => `${escapeAttr(key)}=\"${escapeAttrValue(value)}\"`)\n        .join(' ');\n      if (attrs) metaTags.push(`  <meta ${attrs}>`);\n    }\n  }\n  const metaBlock = metaTags.length > 0 ? '\\n' + metaTags.join('\\n') + '\\n' : '';\n  const dangerousHeadBlock = dangerouslyHeadFragments.length > 0\n    ? '\\n  ' + dangerouslyHeadFragments.join('\\n  ')\n    : '';\n\n  const safeTitle = escapeHtml(title);\n  const safeLang = escapeAttr(lang);\n\n  return `<!DOCTYPE html>\n<html lang=\"${safeLang}\">\n<head>\n  <meta charset=\"UTF-8\">\n  <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n  <title>${safeTitle}</title>${metaBlock}\n  ${safeHeadExtras}${dangerousHeadBlock}\n</head>\n<body>\n  ${html}\n  ${clientScript}${devScripts}\n</body>\n</html>`;\n}\n\n// ─── Error page rendering ────────────────────────────────────────\n\nimport type { RouteEntry } from '@openelement/protocol/framework';\n\n/**\n * Render an error page to HTML string.\n * In dev mode, shows detailed error information for debugging.\n * In production, shows a generic safe error page.\n */\nexport function renderSsrError(\n  error: Error,\n  statusOrRoute: number | RouteEntry,\n  isDev: boolean = false,\n): string {\n  const status = typeof statusOrRoute === 'number' ? statusOrRoute : 500;\n  const title = isDev ? 'SSR Render Error' : `Error ${status}`;\n  const message = escapeHtml(error.message);\n  const stack = isDev && error.stack ? escapeHtml(error.stack) : '';\n\n  return `<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n  <meta charset=\"UTF-8\">\n  <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n  <title>${title}</title>\n  ${\n    isDev\n      ? '<style>body{font-family:system-ui;max-width:800px;margin:2rem auto;padding:0 1rem}pre{background:#f5f5f5;padding:1rem;overflow:auto;border-radius:4px}</style>'\n      : ''\n  }\n</head>\n<body>\n  <h1>${title}</h1>\n  <p>${isDev ? `<strong>${message}</strong>` : message}</p>\n  ${stack ? `<pre>${stack}</pre>` : ''}\n</body>\n</html>`;\n}\n"],"names":[],"mappings":"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"}

package/src/hydrate.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @openelement/core/hydrate - DSD interactive runtime surface.
+ *
+ * Includes the static rendering surface plus marker-based event hydration
+ * and DSD shadow-root hydration helpers. Used by DSD interactive islands.
+ *
+ * ADR-0109 Phase 1: split @openelement/core into static, hydrate, and csr.
+ */ export * from "./static.js";
+export type { BindingDescriptor, BindingDispose, BindingLifecycle } from "./binding-descriptor.js";
+export { applyBindingDescriptor } from "./binding-activation.js";
+export { collectEventBindings, eventRecordsToDescriptors, hydrateEventMarkers } from "./event-hydration.js";
+export type { EventBinding, EventBindingRecord } from "./event-hydration.js";
+export { createDsdRenderRoot, hydrateDsdEvents } from "./dsd-hydration.js";
+export type { Constructor, DsdHydration } from "./dsd-hydration.js";
+export { bindHydrateEvents } from "./dsd-hydration-events.js";

package/src/hydrate.js

@@ -0,0 +1,15 @@
+/**
+ * @openelement/core/hydrate - DSD interactive runtime surface.
+ *
+ * Includes the static rendering surface plus marker-based event hydration
+ * and DSD shadow-root hydration helpers. Used by DSD interactive islands.
+ *
+ * ADR-0109 Phase 1: split @openelement/core into static, hydrate, and csr.
+ */ export * from './static.js';
+export { applyBindingDescriptor } from './binding-activation.js';
+// Marker-based event hydration (DOM-specific parts not in static.ts)
+export { collectEventBindings, eventRecordsToDescriptors, hydrateEventMarkers } from './event-hydration.js';
+// DSD hydration contract
+export { createDsdRenderRoot, hydrateDsdEvents } from './dsd-hydration.js';
+export { bindHydrateEvents } from './dsd-hydration-events.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vaG9tZS9ydW5uZXIvd29yay9vcGVuZWxlbWVudC9vcGVuZWxlbWVudC9wYWNrYWdlcy9jb3JlL3NyYy9oeWRyYXRlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQG9wZW5lbGVtZW50L2NvcmUvaHlkcmF0ZSAtIERTRCBpbnRlcmFjdGl2ZSBydW50aW1lIHN1cmZhY2UuXG4gKlxuICogSW5jbHVkZXMgdGhlIHN0YXRpYyByZW5kZXJpbmcgc3VyZmFjZSBwbHVzIG1hcmtlci1iYXNlZCBldmVudCBoeWRyYXRpb25cbiAqIGFuZCBEU0Qgc2hhZG93LXJvb3QgaHlkcmF0aW9uIGhlbHBlcnMuIFVzZWQgYnkgRFNEIGludGVyYWN0aXZlIGlzbGFuZHMuXG4gKlxuICogQURSLTAxMDkgUGhhc2UgMTogc3BsaXQgQG9wZW5lbGVtZW50L2NvcmUgaW50byBzdGF0aWMsIGh5ZHJhdGUsIGFuZCBjc3IuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9zdGF0aWMuanMnO1xuXG4vLyBCaW5kaW5nIGxheWVyXG5leHBvcnQgdHlwZSB7IEJpbmRpbmdEZXNjcmlwdG9yLCBCaW5kaW5nRGlzcG9zZSwgQmluZGluZ0xpZmVjeWNsZSB9IGZyb20gJy4vYmluZGluZy1kZXNjcmlwdG9yLmpzJztcbmV4cG9ydCB7IGFwcGx5QmluZGluZ0Rlc2NyaXB0b3IgfSBmcm9tICcuL2JpbmRpbmctYWN0aXZhdGlvbi5qcyc7XG5cbi8vIE1hcmtlci1iYXNlZCBldmVudCBoeWRyYXRpb24gKERPTS1zcGVjaWZpYyBwYXJ0cyBub3QgaW4gc3RhdGljLnRzKVxuZXhwb3J0IHtcbiAgY29sbGVjdEV2ZW50QmluZGluZ3MsXG4gIGV2ZW50UmVjb3Jkc1RvRGVzY3JpcHRvcnMsXG4gIGh5ZHJhdGVFdmVudE1hcmtlcnMsXG59IGZyb20gJy4vZXZlbnQtaHlkcmF0aW9uLmpzJztcbmV4cG9ydCB0eXBlIHsgRXZlbnRCaW5kaW5nLCBFdmVudEJpbmRpbmdSZWNvcmQgfSBmcm9tICcuL2V2ZW50LWh5ZHJhdGlvbi5qcyc7XG5cbi8vIERTRCBoeWRyYXRpb24gY29udHJhY3RcbmV4cG9ydCB7IGNyZWF0ZURzZFJlbmRlclJvb3QsIGh5ZHJhdGVEc2RFdmVudHMgfSBmcm9tICcuL2RzZC1oeWRyYXRpb24uanMnO1xuZXhwb3J0IHR5cGUgeyBDb25zdHJ1Y3RvciwgRHNkSHlkcmF0aW9uIH0gZnJvbSAnLi9kc2QtaHlkcmF0aW9uLmpzJztcbmV4cG9ydCB7IGJpbmRIeWRyYXRlRXZlbnRzIH0gZnJvbSAnLi9kc2QtaHlkcmF0aW9uLWV2ZW50cy5qcyc7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Q0FPQyxHQUVELGNBQWMsY0FBYztBQUk1QixTQUFTLHNCQUFzQixRQUFRLDBCQUEwQjtBQUVqRSxxRUFBcUU7QUFDckUsU0FDRSxvQkFBb0IsRUFDcEIseUJBQXlCLEVBQ3pCLG1CQUFtQixRQUNkLHVCQUF1QjtBQUc5Qix5QkFBeUI7QUFDekIsU0FBUyxtQkFBbUIsRUFBRSxnQkFBZ0IsUUFBUSxxQkFBcUI7QUFFM0UsU0FBUyxpQkFBaUIsUUFBUSw0QkFBNEIifQ==

package/src/index.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @openelement/core - Pure runtime.
+ *
+ * openElement is a static-first framework with a pure runtime core:
+ * - Zero node:* imports - no filesystem, no process, no path
+ * - Zero Vite dependency - no Plugin, no build orchestration
+ * - Zero npm: specifiers - works in Deno, Node, Bun, Edge
+ * - Pure Web Standard: URL, fetch, import.meta.url, console
+ *
+ * Rendering: DSD (Declarative Shadow DOM) string concatenation
+ * Islands: Custom Element registration + prop deserialization
+ *
+ * Build orchestration (Vite plugins) lives in @openelement/adapter-vite.
+ * For the unified openElement() entry, use @openelement/app/vite instead.
+ */ export type { AppShellConfig, AppShellDefinition, ComponentLayer, FrameworkOptions, HydrateEventDescriptor, HydrationStrategy, IsrManifestEntry, LayoutsConfig, LocalePath, OpenElementApiContext, OpenElementBuildContextLike, OpenElementMiddleware, OpenElementMiddlewareContext, OpenElementRenderer, RegistryIndex, RegistryIndexEntry, RouteEntry, SafeHtml, SpecialFileType, StrategySource, UnsafeHtml, ValidationError, ValidationResult, ValidationWarning } from '@openelement/protocol/framework';
+export type { IslandDescriptor, SsrContext } from '@openelement/protocol/context';
+export { ERROR_PREFIX, ErrorCode, OpenElementError, PropValidationError, RenderError, reportError, setErrorTelemetryHook, SsrRenderError } from "./errors.js";
+export type { ErrorPhase, ErrorSeverity, ErrorTelemetryHook } from '@openelement/protocol/errors';
+export { createSsrContext, extractParams, parseQuery } from "./context.js";
+export { renderSsrError, wrapInDocument } from "./html-escape.js";
+export { createIsrCacheKey, isIsrRouteConfig, MemoryIsrCache } from "./isr.js";
+export type { CacheAdapter, CacheEntry, IsrCacheEntry, IsrCacheResult, IsrCacheState, IsrRouteConfig } from '@openelement/protocol/isr';
+export { findIsrManifestEntry, renderIsrResponse } from "./isr-runtime.js";
+export type { IsrRuntimeOptions, IsrRuntimeRenderContext, IsrRuntimeRenderResult, IsrRuntimeResult, IsrRuntimeState } from "./isr-runtime.js";
+export { StyleSheet } from "./style-sheet.js";
+export type { StyleSheetLike, StyleSheetRule } from '@openelement/protocol/style-sheet';
+export { bindHydrateEvents } from "./dsd-hydration-events.js";
+export type { Constructor, DsdHydration } from "./dsd-hydration.js";
+export { createRenderDsdStreamMetrics, renderDsd, renderDsdStream } from "./render-dsd.js";
+export type { RenderDsdOptions } from "./render-dsd.js";
+export type { RenderDsdStreamChunk, RenderDsdStreamComponent, RenderDsdStreamMetrics, RenderDsdStreamOptions } from "./render-dsd-stream.js";
+export { camelToKebab, serializeAttrs } from "./render-ir.js";
+export type { DomSimulationAttempt, DomSimulationReport, DsdBuildReport, DsdComponent, DsdComponentConstructor, DsdHydrationHintSummary, DsdHydrationStrategySummary, DsdMetricsSummary, DsdOptions, DsdPageDiagnostics, DsdRenderMetrics, HydrationHint, IsrRouteRecord, ManifestDecision, RendererProtocol, RenderErrorCode, RenderHooks, RenderInput, RenderOutput, RenderPhase, SsrAdmissionDecision } from '@openelement/protocol/render';
+export type { OpenElementAttribute, OpenElementCssPart, OpenElementCssProperty, OpenElementDeclaration, OpenElementEvent, OpenElementExport, OpenElementExtensions, OpenElementMember, OpenElementModule, OpenElementPackageExtensions, OpenElementPackageManifest, OpenElementSlot } from '@openelement/protocol/manifest';
+export type { CemCompatibilityReport, CompatibilityClassification, CompatibilityTier, ManifestValidationReport, ValidatedTag, ValidationDiagnostic } from '@openelement/protocol/manifest';
+export { escapeAttr, escapeAttrValue, escapeHtml } from "./html-escape.js";
+export { isSignalLike, unwrapSignalLike } from '@openelement/signal';
+export type { SignalLike, Unsubscribe } from '@openelement/protocol/signal';
+export { consumeContext, type Context, createContext, provideContext } from "./signal-context.js";
+export { createLogger } from "./logger.js";
+/** @internal — use @openelement/core/security subpath */ export { DANGEROUS_KEYS } from "./security.js";
+export { isValidTagName } from "./tag-utils.js";
+export { bindSsrProps, defineCustomElement, defineIsland, getIslandMeta, getSsrProps } from "./island.js";
+export type { IslandMeta, IslandOptions } from '@openelement/protocol/island';
+export { transformIslandSource } from "./island-transform.js";
+export type { IslandTransformOptions, IslandTransformResult } from '@openelement/protocol/island';
+export { applyBindingDescriptor } from "./binding-activation.js";
+export type { BindingDescriptor, BindingDispose, BindingLifecycle } from "./binding-descriptor.js";
+export type { Action, ActionContext, DataAdapter, Loader, LoaderContext } from '@openelement/protocol/data';
+export { clear as clearRegistry, generateIndex, getAll as getAllManifests, getByTagName, register as registerManifest, validate as validateManifest } from "./registry.js";
+export type { VNode } from '@openelement/protocol/vnode';
+export { isVNode } from "./vnode.js";
+export { Fragment, trustedHtml } from "./jsx-runtime.js";
+export { renderToDom } from "./jsx-render-dom.js";
+export { renderDsdTree } from "./render-ir.js";
+export { collectEventBindings, createEventMarkerContext, type EventBindingRecord, type EventMarkerContext, eventMarkerId, eventTypeFromProp, hydrateEventMarkers, serializeEventMarkers } from "./event-hydration.js";
+export { disposeStaticProps, handleStaticPropAttributeChange, initializeStaticProps, registerStaticObservedAttributes, syncStaticPropsFromAttributes, unwrap } from "./prop.js";
+export type { NormalizedPropDecl, PropDecl, PropDeclFull, PropDeclShorthand, PropsFrom, PropType } from '@openelement/protocol/prop';

package/src/index.js

@@ -0,0 +1,46 @@
+/**
+ * @openelement/core - Pure runtime.
+ *
+ * openElement is a static-first framework with a pure runtime core:
+ * - Zero node:* imports - no filesystem, no process, no path
+ * - Zero Vite dependency - no Plugin, no build orchestration
+ * - Zero npm: specifiers - works in Deno, Node, Bun, Edge
+ * - Pure Web Standard: URL, fetch, import.meta.url, console
+ *
+ * Rendering: DSD (Declarative Shadow DOM) string concatenation
+ * Islands: Custom Element registration + prop deserialization
+ *
+ * Build orchestration (Vite plugins) lives in @openelement/adapter-vite.
+ * For the unified openElement() entry, use @openelement/app/vite instead.
+ */ // --- Public API re-exports -----------------------------------------
+export { ERROR_PREFIX, ErrorCode, OpenElementError, PropValidationError, RenderError, reportError, setErrorTelemetryHook, SsrRenderError } from './errors.js';
+export { createSsrContext, extractParams, parseQuery } from './context.js';
+export { renderSsrError, wrapInDocument } from './html-escape.js';
+export { createIsrCacheKey, isIsrRouteConfig, MemoryIsrCache } from './isr.js';
+export { findIsrManifestEntry, renderIsrResponse } from './isr-runtime.js';
+export { StyleSheet } from './style-sheet.js';
+export { bindHydrateEvents } from './dsd-hydration-events.js';
+export { createRenderDsdStreamMetrics, renderDsd, renderDsdStream } from './render-dsd.js';
+export { camelToKebab, serializeAttrs } from './render-ir.js';
+export { escapeAttr, escapeAttrValue, escapeHtml } from './html-escape.js';
+export { // v0.24.3: Neutral signal utilities — no template dependency
+isSignalLike, unwrapSignalLike } from '@openelement/signal';
+export { consumeContext, createContext, provideContext } from './signal-context.js';
+export { createLogger } from './logger.js';
+/** @internal — use @openelement/core/security subpath */ export { DANGEROUS_KEYS } from './security.js';
+export { isValidTagName } from './tag-utils.js';
+export { bindSsrProps, defineCustomElement, defineIsland, getIslandMeta, getSsrProps } from './island.js';
+export { transformIslandSource } from './island-transform.js';
+// Unified binding layer (ADR-0109 Phase 1)
+export { applyBindingDescriptor } from './binding-activation.js';
+// WC Package Protocol (v0.17+)
+export { clear as clearRegistry, generateIndex, getAll as getAllManifests, getByTagName, register as registerManifest, validate as validateManifest } from './registry.js';
+export { isVNode } from './vnode.js';
+export { Fragment, trustedHtml } from './jsx-runtime.js';
+// Renderers
+export { renderToDom } from './jsx-render-dom.js';
+export { renderDsdTree } from './render-ir.js';
+export { collectEventBindings, createEventMarkerContext, eventMarkerId, eventTypeFromProp, hydrateEventMarkers, serializeEventMarkers } from './event-hydration.js';
+// static props runtime + Signal unwrap
+export { disposeStaticProps, handleStaticPropAttributeChange, initializeStaticProps, registerStaticObservedAttributes, syncStaticPropsFromAttributes, unwrap } from './prop.js';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/core/src/index.ts"],"sourcesContent":["/**\n * @openelement/core - Pure runtime.\n *\n * openElement is a static-first framework with a pure runtime core:\n * - Zero node:* imports - no filesystem, no process, no path\n * - Zero Vite dependency - no Plugin, no build orchestration\n * - Zero npm: specifiers - works in Deno, Node, Bun, Edge\n * - Pure Web Standard: URL, fetch, import.meta.url, console\n *\n * Rendering: DSD (Declarative Shadow DOM) string concatenation\n * Islands: Custom Element registration + prop deserialization\n *\n * Build orchestration (Vite plugins) lives in @openelement/adapter-vite.\n * For the unified openElement() entry, use @openelement/app/vite instead.\n */\n\n// --- Public API re-exports -----------------------------------------\n\nexport type {\n  AppShellConfig,\n  AppShellDefinition,\n  ComponentLayer,\n  FrameworkOptions,\n  HydrateEventDescriptor,\n  HydrationStrategy,\n  IsrManifestEntry,\n  LayoutsConfig,\n  LocalePath,\n  OpenElementApiContext,\n  OpenElementBuildContextLike,\n  OpenElementMiddleware,\n  OpenElementMiddlewareContext,\n  OpenElementRenderer,\n  RegistryIndex,\n  RegistryIndexEntry,\n  RouteEntry,\n  SafeHtml,\n  SpecialFileType,\n  StrategySource,\n  UnsafeHtml,\n  ValidationError,\n  ValidationResult,\n  ValidationWarning,\n} from '@openelement/protocol/framework';\nexport type { IslandDescriptor, SsrContext } from '@openelement/protocol/context';\n\nexport {\n  ERROR_PREFIX,\n  ErrorCode,\n  OpenElementError,\n  PropValidationError,\n  RenderError,\n  reportError,\n  setErrorTelemetryHook,\n  SsrRenderError,\n} from './errors.js';\nexport type { ErrorPhase, ErrorSeverity, ErrorTelemetryHook } from '@openelement/protocol/errors';\nexport { createSsrContext, extractParams, parseQuery } from './context.js';\nexport { renderSsrError, wrapInDocument } from './html-escape.js';\nexport { createIsrCacheKey, isIsrRouteConfig, MemoryIsrCache } from './isr.js';\nexport type {\n  CacheAdapter,\n  CacheEntry,\n  IsrCacheEntry,\n  IsrCacheResult,\n  IsrCacheState,\n  IsrRouteConfig,\n} from '@openelement/protocol/isr';\nexport { findIsrManifestEntry, renderIsrResponse } from './isr-runtime.js';\nexport type {\n  IsrRuntimeOptions,\n  IsrRuntimeRenderContext,\n  IsrRuntimeRenderResult,\n  IsrRuntimeResult,\n  IsrRuntimeState,\n} from './isr-runtime.js';\nexport { StyleSheet } from './style-sheet.js';\nexport type { StyleSheetLike, StyleSheetRule } from '@openelement/protocol/style-sheet';\nexport { bindHydrateEvents } from './dsd-hydration-events.js';\nexport type { Constructor, DsdHydration } from './dsd-hydration.js';\nexport { createRenderDsdStreamMetrics, renderDsd, renderDsdStream } from './render-dsd.js';\nexport type { RenderDsdOptions } from './render-dsd.js';\nexport type {\n  RenderDsdStreamChunk,\n  RenderDsdStreamComponent,\n  RenderDsdStreamMetrics,\n  RenderDsdStreamOptions,\n} from './render-dsd-stream.js';\nexport { camelToKebab, serializeAttrs } from './render-ir.js';\nexport type {\n  DomSimulationAttempt,\n  DomSimulationReport,\n  DsdBuildReport,\n  DsdComponent,\n  DsdComponentConstructor,\n  DsdHydrationHintSummary,\n  DsdHydrationStrategySummary,\n  DsdMetricsSummary,\n  DsdOptions,\n  DsdPageDiagnostics,\n  DsdRenderMetrics,\n  HydrationHint,\n  IsrRouteRecord,\n  ManifestDecision,\n  RendererProtocol,\n  RenderErrorCode,\n  RenderHooks,\n  RenderInput,\n  RenderOutput,\n  RenderPhase,\n  SsrAdmissionDecision,\n} from '@openelement/protocol/render';\nexport type {\n  OpenElementAttribute,\n  OpenElementCssPart,\n  OpenElementCssProperty,\n  OpenElementDeclaration,\n  OpenElementEvent,\n  OpenElementExport,\n  OpenElementExtensions,\n  OpenElementMember,\n  OpenElementModule,\n  OpenElementPackageExtensions,\n  OpenElementPackageManifest,\n  OpenElementSlot,\n} from '@openelement/protocol/manifest';\nexport type {\n  CemCompatibilityReport,\n  CompatibilityClassification,\n  CompatibilityTier,\n  ManifestValidationReport,\n  ValidatedTag,\n  ValidationDiagnostic,\n} from '@openelement/protocol/manifest';\nexport { escapeAttr, escapeAttrValue, escapeHtml } from './html-escape.js';\nexport {\n  // v0.24.3: Neutral signal utilities — no template dependency\n  isSignalLike,\n  unwrapSignalLike,\n} from '@openelement/signal';\nexport type { SignalLike, Unsubscribe } from '@openelement/protocol/signal';\nexport { consumeContext, type Context, createContext, provideContext } from './signal-context.js';\nexport { createLogger } from './logger.js';\n/** @internal — use @openelement/core/security subpath */\nexport { DANGEROUS_KEYS } from './security.js';\nexport { isValidTagName } from './tag-utils.js';\nexport {\n  bindSsrProps,\n  defineCustomElement,\n  defineIsland,\n  getIslandMeta,\n  getSsrProps,\n} from './island.js';\nexport type { IslandMeta, IslandOptions } from '@openelement/protocol/island';\nexport { transformIslandSource } from './island-transform.js';\nexport type { IslandTransformOptions, IslandTransformResult } from '@openelement/protocol/island';\n\n// Unified binding layer (ADR-0109 Phase 1)\nexport { applyBindingDescriptor } from './binding-activation.js';\nexport type { BindingDescriptor, BindingDispose, BindingLifecycle } from './binding-descriptor.js';\n\n// Data adapters — type contract surface only (ADR-0095)\nexport type {\n  Action,\n  ActionContext,\n  DataAdapter,\n  Loader,\n  LoaderContext,\n} from '@openelement/protocol/data';\n\n// WC Package Protocol (v0.17+)\nexport {\n  clear as clearRegistry,\n  generateIndex,\n  getAll as getAllManifests,\n  getByTagName,\n  register as registerManifest,\n  validate as validateManifest,\n} from './registry.js';\n// v0.24.1 (ADR-0057): JSX + Signal component model\n// VNode & jsx-runtime\nexport type { VNode } from '@openelement/protocol/vnode';\nexport { isVNode } from './vnode.js';\nexport { Fragment, trustedHtml } from './jsx-runtime.js';\n// Renderers\nexport { renderToDom } from './jsx-render-dom.js';\nexport { renderDsdTree } from './render-ir.js';\nexport {\n  collectEventBindings,\n  createEventMarkerContext,\n  type EventBindingRecord,\n  type EventMarkerContext,\n  eventMarkerId,\n  eventTypeFromProp,\n  hydrateEventMarkers,\n  serializeEventMarkers,\n} from './event-hydration.js';\n// static props runtime + Signal unwrap\nexport {\n  disposeStaticProps,\n  handleStaticPropAttributeChange,\n  initializeStaticProps,\n  registerStaticObservedAttributes,\n  syncStaticPropsFromAttributes,\n  unwrap,\n} from './prop.js';\nexport type {\n  NormalizedPropDecl,\n  PropDecl,\n  PropDeclFull,\n  PropDeclShorthand,\n  PropsFrom,\n  PropType,\n} from '@openelement/protocol/prop';\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;CAcC,GAED,sEAAsE;AA8BtE,SACE,YAAY,EACZ,SAAS,EACT,gBAAgB,EAChB,mBAAmB,EACnB,WAAW,EACX,WAAW,EACX,qBAAqB,EACrB,cAAc,QACT,cAAc;AAErB,SAAS,gBAAgB,EAAE,aAAa,EAAE,UAAU,QAAQ,eAAe;AAC3E,SAAS,cAAc,EAAE,cAAc,QAAQ,mBAAmB;AAClE,SAAS,iBAAiB,EAAE,gBAAgB,EAAE,cAAc,QAAQ,WAAW;AAS/E,SAAS,oBAAoB,EAAE,iBAAiB,QAAQ,mBAAmB;AAQ3E,SAAS,UAAU,QAAQ,mBAAmB;AAE9C,SAAS,iBAAiB,QAAQ,4BAA4B;AAE9D,SAAS,4BAA4B,EAAE,SAAS,EAAE,eAAe,QAAQ,kBAAkB;AAQ3F,SAAS,YAAY,EAAE,cAAc,QAAQ,iBAAiB;AA8C9D,SAAS,UAAU,EAAE,eAAe,EAAE,UAAU,QAAQ,mBAAmB;AAC3E,SACE,6DAA6D;AAC7D,YAAY,EACZ,gBAAgB,QACX,sBAAsB;AAE7B,SAAS,cAAc,EAAgB,aAAa,EAAE,cAAc,QAAQ,sBAAsB;AAClG,SAAS,YAAY,QAAQ,cAAc;AAC3C,uDAAuD,GACvD,SAAS,cAAc,QAAQ,gBAAgB;AAC/C,SAAS,cAAc,QAAQ,iBAAiB;AAChD,SACE,YAAY,EACZ,mBAAmB,EACnB,YAAY,EACZ,aAAa,EACb,WAAW,QACN,cAAc;AAErB,SAAS,qBAAqB,QAAQ,wBAAwB;AAG9D,2CAA2C;AAC3C,SAAS,sBAAsB,QAAQ,0BAA0B;AAYjE,+BAA+B;AAC/B,SACE,SAAS,aAAa,EACtB,aAAa,EACb,UAAU,eAAe,EACzB,YAAY,EACZ,YAAY,gBAAgB,EAC5B,YAAY,gBAAgB,QACvB,gBAAgB;AAIvB,SAAS,OAAO,QAAQ,aAAa;AACrC,SAAS,QAAQ,EAAE,WAAW,QAAQ,mBAAmB;AACzD,YAAY;AACZ,SAAS,WAAW,QAAQ,sBAAsB;AAClD,SAAS,aAAa,QAAQ,iBAAiB;AAC/C,SACE,oBAAoB,EACpB,wBAAwB,EAGxB,aAAa,EACb,iBAAiB,EACjB,mBAAmB,EACnB,qBAAqB,QAChB,uBAAuB;AAC9B,uCAAuC;AACvC,SACE,kBAAkB,EAClB,+BAA+B,EAC/B,qBAAqB,EACrB,gCAAgC,EAChC,6BAA6B,EAC7B,MAAM,QACD,YAAY"}

package/src/island-transform.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @openelement/core — Island transform core logic.
+ *
+ * Pure function: injects island metadata markers into source code.
+ * Zero Vite dependency. Usable with any build tool.
+ */ import type { IslandTransformOptions, IslandTransformResult } from '@openelement/protocol/island';
+export type { IslandTransformOptions, IslandTransformResult };
+/**
+ * Inject island metadata markers into source code.
+ *
+ * Only transforms files inside the islands directory.
+ * Tag names must be lowercase + hyphens (Custom Elements spec).
+ * Unsafe characters cause a thrown error.
+ */ export declare function transformIslandSource(source: string, options: IslandTransformOptions): IslandTransformResult;

package/src/island-transform.js

@@ -0,0 +1,60 @@
+/**
+ * @openelement/core — Island transform core logic.
+ *
+ * Pure function: injects island metadata markers into source code.
+ * Zero Vite dependency. Usable with any build tool.
+ */ /**
+ * Inject island metadata markers into source code.
+ *
+ * Only transforms files inside the islands directory.
+ * Tag names must be lowercase + hyphens (Custom Elements spec).
+ * Unsafe characters cause a thrown error.
+ */ export function transformIslandSource(source, options) {
+  const { islandsDir, filePath } = options;
+  // Normalize to forward slashes and ensure leading slash for reliable matching
+  let normalizedPath = filePath.replace(/\\/g, '/');
+  if (!normalizedPath.startsWith('/')) {
+    normalizedPath = '/' + normalizedPath;
+  }
+  const normalizedIslandsDir = islandsDir.replace(/\\/g, '/');
+  // Only transform files in the islands directory
+  if (!normalizedPath.includes(`/${normalizedIslandsDir}/`)) {
+    return {
+      code: source,
+      islands: []
+    };
+  }
+  // Extract tag name from file path: replace path separators with hyphens
+  // matching route-scanner.ts fileToTagName() behavior.
+  // e.g. "nested/my-widget.tsx" → "my-widget", "my-widget.tsx" → "my-widget"
+  const relativePath = normalizedPath.split(`/${islandsDir}/`)[1] ?? normalizedPath.split('/').pop();
+  const tagName = relativePath.replace(/\.(tsx?|jsx?)$/, '').replace(/[/\\]/g, '-').toLowerCase();
+  // Validate tag name (must contain a hyphen for Custom Elements)
+  if (!tagName.includes('-')) {
+    return {
+      code: source,
+      islands: []
+    };
+  }
+  // Security: only allow lowercase letters, digits, and hyphens
+  if (!/^[a-z0-9-]+$/.test(tagName)) {
+    throw new Error(`Island tag name "${tagName}" contains unsafe characters. ` + `Only lowercase letters, digits, and hyphens are allowed.`);
+  }
+  // Inject metadata markers
+  const injected = `
+// --- Island Markers (auto-injected) ---
+export const __island = true;
+export const __tagName = '${tagName}';
+// --- End Island Markers ---
+`;
+  return {
+    code: source + '\n' + injected,
+    islands: [
+      {
+        tagName,
+        filePath
+      }
+    ]
+  };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/island.d.ts

@@ -0,0 +1,59 @@
+import type { IslandMeta, IslandOptions } from '@openelement/protocol/island';
+/**
+ * SSR-safe custom element registration helper.
+ * v0.29.1: Merged from custom-element.ts.
+ */ export declare function defineCustomElement(tag: string, ctor: CustomElementConstructor): void;
+export declare function getIslandMeta(ctor: CustomElementConstructor): IslandMeta | undefined;
+/**
+ * Get the value of the data-ssr-props attribute from a host element.
+ * Used to reconstruct SSR props on client upgrade.
+ *
+ * @param el - The custom element host element
+ * @returns Parsed props object, or null if no data-ssr-props attribute
+ *
+ * @example
+ * ```ts
+ * connectedCallback() {
+ *   super.connectedCallback();
+ *   const props = getSsrProps(this);
+ *   if (props) {
+ *     this.count = props.count ?? 0;
+ *   }
+ * }
+ * ```
+ */ export declare function getSsrProps(el: HTMLElement): Record<string, unknown> | null;
+export declare function bindSsrProps(el: HTMLElement): void;
+/**
+ * Wrap a component class as a openElement Island.
+ *
+ * Handles:
+ *   - Automatic customElements.define() registration
+ *   - Strategy-based upgrade timing
+ *   - data-ssr-props binding (open:bind)
+ *   - __island / __tagName export markers
+ *   - __layer metadata (dsd-static, dsd-interactive, or pure-island)
+ *   - Idempotent registration (safe for SSR with multiple routes)
+ *
+ * v0.6.2: Added `dsd` option. When false, the island is a Pure Island
+ * (Layer 3) - no DSD template is emitted, framework fully owns shadow root.
+ *
+ * @param tagName - Custom element tag name (must contain hyphen)
+ * @param componentClass - Custom Element constructor (framework-agnostic)
+ * @param options - Island options
+ * @returns The component class (for chaining / re-export)
+ *
+ * @example
+ * ```ts
+ * // Basic usage (DSD enabled by default)
+ * export default defineIsland('my-counter', MyCounter);
+ *
+ * // Pure Island - no DSD, full framework reactivity
+ * export default defineIsland('my-counter', MyCounter, { dsd: false });
+ *
+ * // With visible strategy (IntersectionObserver)
+ * export default defineIsland('my-counter', MyCounter, { strategy: 'visible' });
+ *
+ * // With load strategy (immediate upgrade)
+ * export default defineIsland('my-counter', MyCounter, { strategy: 'load' });
+ * ```
+ */ export declare function defineIsland<T extends CustomElementConstructor>(tagName: string, componentClass: T, options?: IslandOptions): T;