@openelement/core 0.41.0-alpha.1

package/src/island.js

@@ -0,0 +1,342 @@
+import { ERROR_PREFIX } from '@openelement/core';
+import { formatError } from './errors.js';
+/**
+ * @openelement/core - defineIsland() wrapper
+ *
+ * v0.6.2: defineIsland() wraps any Custom Element class to provide:
+ *   - Automatic registration via customElements.define()
+ *   - Hydration strategy support (load, idle, visible, only)
+ *   - __island / __tagName / __layer metadata markers
+ *   - data-ssr-props restoration on client upgrade
+ *   - DSD opt-out via `dsd: false` (Pure Island / Layer 3)
+ *
+ * Framework-agnostic: works with Lit, vanilla Custom Elements,
+ * FAST, or any Web Component library. bindSsrProps() sets props
+ * directly; adapters handle framework-specific update triggers.
+ *
+ * v0.29.1: defineCustomElement helper inlined from custom-element.ts.
+ */ import { createLogger } from './logger.js';
+/** WeakSet to track elements that have already had SSR props bound (idempotent). */ const ssrPropsBoundSet = new WeakSet();
+const log = createLogger('core');
+/**
+ * SSR-safe custom element registration helper.
+ * v0.29.1: Merged from custom-element.ts.
+ */ export function defineCustomElement(tag, ctor) {
+  if (typeof globalThis.customElements === 'undefined') return;
+  if (!globalThis.customElements.get(tag)) {
+    globalThis.customElements.define(tag, ctor);
+  }
+}
+const VALID_STRATEGIES = new Set([
+  'load',
+  'idle',
+  'visible',
+  'only'
+]);
+// Module-level store of active visibility strategy timeout IDs.
+// Used for test cleanup - tests can call _clearAllVisibilityTimeouts()
+// to prevent timer leaks.
+const _visibilityTimeouts = new Set();
+const _islandMeta = new WeakMap();
+export function getIslandMeta(ctor) {
+  return _islandMeta.get(ctor);
+}
+/** Clear all active visibility strategy timeouts (for test cleanup). */ export function _clearAllVisibilityTimeouts() {
+  for (const id of _visibilityTimeouts){
+    clearTimeout(id);
+  }
+  _visibilityTimeouts.clear();
+}
+/**
+ * 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 function getSsrProps(el) {
+  const raw = el.getAttribute('data-ssr-props');
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch  {
+    log.warn(`Failed to parse data-ssr-props on <${el.tagName.toLowerCase()}>`);
+    return null;
+  }
+}
+/**
+ * Apply SSR props from data-ssr-props to a component instance.
+ * This restores server-rendered property values to the
+ * client-side component on upgrade, ensuring consistency between
+ * SSR and client state.
+ *
+ * v0.6.2: Framework-agnostic. No Lit-specific detection.
+ * Props are set directly on the instance. DSD hydration and VNode event
+ * markers are handled at the component level via DsdElement.
+ *
+ * v0.14.3: Prototype pollution fix - filters dangerous keys
+ * (__proto__, constructor, prototype) from parsed SSR props.
+ *
+ * @param el - The upgraded custom element
+ */ /** Keys that could cause prototype pollution if assigned to an object instance.
+ * v0.14.7: Extended to cover all Object.prototype methods that could be
+ * exploited via arbitrary property assignment (C-03 fix).
+ */ import { DANGEROUS_KEYS } from './security.js';
+export function bindSsrProps(el) {
+  const props = getSsrProps(el);
+  if (!props) return;
+  for (const [key, value] of Object.entries(props)){
+    // v0.14.3: Prevent prototype pollution - skip dangerous keys
+    if (DANGEROUS_KEYS.has(key)) {
+      log.warn(`Skipping dangerous key "${key}" in data-ssr-props on <${el.tagName.toLowerCase()}>`);
+      continue;
+    }
+    try {
+      el[key] = value;
+    } catch (e) {
+      // Some properties may be read-only - safe to skip, but log for debuggability
+      log.debug(`Cannot set read-only property "${key}" on <${el.tagName.toLowerCase()}>: ${formatError(e)}`);
+    }
+  }
+}
+/**
+ * Create an IntersectionObserver-based upgrade strategy.
+ * v0.6': Uses querySelectorAll to observe ALL instances of the tag,
+ * not just the first one. Per WHATWG IntersectionObserver spec.
+ */ function createVisibleStrategy(tagName, registerFn) {
+  let registered = false;
+  const observer = new IntersectionObserver((entries)=>{
+    for (const entry of entries){
+      if (entry.isIntersecting) {
+        observer.disconnect();
+        if (!registered) {
+          registered = true;
+          clearTimeout(timeoutId);
+          _visibilityTimeouts.delete(timeoutId);
+          registerFn();
+        }
+        return;
+      }
+    }
+  }, {
+    rootMargin: '200px'
+  });
+  // We need to wait for elements to be in the DOM first
+  const observeAll = ()=>{
+    const elements = document.querySelectorAll(tagName);
+    if (elements.length > 0) {
+      elements.forEach((el)=>observer.observe(el));
+      return true;
+    }
+    return false;
+  };
+  const mo = new MutationObserver((_mutations, mutObs)=>{
+    if (observeAll()) {
+      mutObs.disconnect();
+    } else {
+      // v0.14.5: If elements were removed from DOM, disconnect all observers
+      const elements = document.querySelectorAll(tagName);
+      if (elements.length === 0 && !registered) {
+        mutObs.disconnect();
+        observer.disconnect();
+        clearTimeout(timeoutId);
+        _visibilityTimeouts.delete(timeoutId);
+      }
+    }
+  });
+  // v0.14.3: Timeout guard - if the target element never appears
+  // (e.g., route changed after island was registered), disconnect
+  // both observers after 30 seconds to prevent memory/perf leaks.
+  const VISIBILITY_TIMEOUT = 30_000; // 30s
+  const timeoutId = setTimeout(()=>{
+    _visibilityTimeouts.delete(timeoutId);
+    if (!registered) {
+      mo.disconnect();
+      observer.disconnect();
+      log.debug(`Visibility strategy for <${tagName}> timed out after ${VISIBILITY_TIMEOUT}ms`);
+    }
+  }, VISIBILITY_TIMEOUT);
+  _visibilityTimeouts.add(timeoutId);
+  // Start observing after DOM content loaded
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', ()=>{
+      if (!observeAll()) {
+        mo.observe(document.body, {
+          childList: true,
+          subtree: true
+        });
+      }
+    });
+  } else {
+    if (!observeAll()) {
+      mo.observe(document.body, {
+        childList: true,
+        subtree: true
+      });
+    }
+  }
+}
+/**
+ * Create an idle (requestIdleCallback-based) hydration strategy.
+ * v0.6': Improved fallback chain:
+ *   1. requestIdleCallback (optimal, progressive)
+ *   2. requestAnimationFrame (next frame, good for interaction)
+ *   3. setTimeout(fn, 50) (final fallback, shorter than old 200ms)
+ */ function createIdleStrategy(registerFn) {
+  const g = globalThis;
+  if (typeof g.requestIdleCallback === 'function') {
+    g.requestIdleCallback(registerFn);
+  } else if (typeof g.requestAnimationFrame === 'function') {
+    g.requestAnimationFrame(()=>registerFn());
+  } else {
+    setTimeout(registerFn, 50);
+  }
+}
+/**
+ * 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 function defineIsland(tagName, componentClass, options = {}) {
+  const strategy = options.strategy || 'idle';
+  if (!VALID_STRATEGIES.has(strategy)) {
+    throw new Error(`${ERROR_PREFIX} Invalid island hydration strategy "${String(strategy)}". ` + 'Use one of: load, idle, visible, only.');
+  }
+  const useDsd = strategy === 'only' ? false : options.dsd !== false; // default true
+  const useSsr = strategy === 'only' ? false : options.ssr !== false; // default true
+  // Validate tag name per WHATWG Custom Element name rules
+  // https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name
+  if (!tagName || !tagName.includes('-')) {
+    throw new Error(`${ERROR_PREFIX} defineIsland() requires a hyphenated tag name, got "${tagName}". ` + 'Custom Element names must contain a hyphen per the HTML spec.');
+  }
+  // WHATWG: must start with lowercase letter, only lowercase/digits/hyphens,
+  // must not start with a reserved prefix, no uppercase
+  if (!/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/.test(tagName)) {
+    throw new Error(`${ERROR_PREFIX} defineIsland() tag name "${tagName}" is not a valid custom element name. ` + 'Must start with a lowercase ASCII letter, contain only lowercase ASCII ' + 'letters, digits, and hyphens, and not use reserved names.');
+  }
+  // Reserved names per WHATWG (partial list)
+  const reservedPrefixes = [
+    'annotation-',
+    'color-profile',
+    'font-face',
+    'font-face-',
+    'missing-glyph'
+  ];
+  for (const prefix of reservedPrefixes){
+    if (tagName.startsWith(prefix)) {
+      throw new Error(`${ERROR_PREFIX} defineIsland() tag name "${tagName}" uses a reserved prefix "${prefix}".`);
+    }
+  }
+  _islandMeta.set(componentClass, {
+    isIsland: true,
+    tagName,
+    layer: useDsd ? 'dsd-interactive' : 'pure-island',
+    ssr: useSsr,
+    dsd: useDsd
+  });
+  // v0.6': Mixin pattern for connectedCallback - replaces monkey-patch.
+  // Instead of modifying the prototype directly, we create a wrapper
+  // that calls the original callback + auto-binds SSR props.
+  // This is safer than monkey-patching because it doesn't interfere
+  // with Lit's own connectedCallback chain.
+  //
+  // v0.14.3: Added __ssrPropsBound idempotency guard to prevent
+  // double bindSsrProps() calls when a subclass island inherits from a
+  // parent island (both registered via defineIsland()). Without this guard,
+  // the parent's wrapped connectedCallback and the subclass's both
+  // call bindSsrProps on the same element.
+  const origConnected = componentClass.prototype.connectedCallback;
+  if (!componentClass.prototype.__openIslandWrapped) {
+    componentClass.prototype.__openIslandWrapped = true;
+    componentClass.prototype.connectedCallback = function() {
+      // Call original connectedCallback first (super.connectedCallback)
+      if (typeof origConnected === 'function') {
+        origConnected.call(this);
+      }
+      // Auto-bind SSR props on upgrade (idempotent - only once per element)
+      if (this.hasAttribute('data-ssr-props') && !ssrPropsBoundSet.has(this)) {
+        ssrPropsBoundSet.add(this);
+        Promise.resolve().then(()=>bindSsrProps(this));
+      }
+    };
+  }
+  // Define a registration function that's idempotent
+  const register = ()=>{
+    const registry = globalThis.customElements;
+    if (!registry) return;
+    if (!registry.get(tagName)) {
+      try {
+        registry.define(tagName, componentClass);
+      } catch (e) {
+        // Already defined - safe to ignore in SSR contexts
+        log.debug(`customElements.define("${tagName}") skipped: ${formatError(e)}`);
+      }
+    }
+  };
+  // SSR guard: browser-specific strategy scheduling is a no-op during SSR.
+  // IntersectionObserver, MutationObserver etc. are browser-only APIs.
+  // During SSR we just define the custom element and let the generated
+  // client entry handle strategy dispatch in the browser.
+  const isBrowser = typeof IntersectionObserver !== 'undefined';
+  if (isBrowser) {
+    switch(strategy){
+      case 'load':
+      case 'only':
+        register();
+        break;
+      case 'idle':
+        createIdleStrategy(register);
+        break;
+      case 'visible':
+        createVisibleStrategy(tagName, register);
+        break;
+    }
+  } else {
+    // SSR path: define the element idempotently, strategy runs on client.
+    register();
+  }
+  return componentClass;
+}
+/**
+ * Exports the `island` function as default for convenience imports.
+ * Tree-shakable: bundlers can eliminate unused named exports from the same module.
+ */ export default defineIsland;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/core/src/island.ts"],"sourcesContent":["import { ERROR_PREFIX } from '@openelement/core';\nimport { formatError } from './errors.js';\n/**\n * @openelement/core - defineIsland() wrapper\n *\n * v0.6.2: defineIsland() wraps any Custom Element class to provide:\n *   - Automatic registration via customElements.define()\n *   - Hydration strategy support (load, idle, visible, only)\n *   - __island / __tagName / __layer metadata markers\n *   - data-ssr-props restoration on client upgrade\n *   - DSD opt-out via `dsd: false` (Pure Island / Layer 3)\n *\n * Framework-agnostic: works with Lit, vanilla Custom Elements,\n * FAST, or any Web Component library. bindSsrProps() sets props\n * directly; adapters handle framework-specific update triggers.\n *\n * v0.29.1: defineCustomElement helper inlined from custom-element.ts.\n */\n\nimport { createLogger } from './logger.js';\nimport type { HydrationStrategy } from '@openelement/protocol/framework';\nimport type { IslandMeta, IslandOptions } from '@openelement/protocol/island';\nexport type { IslandMeta, IslandOptions };\n\n/** WeakSet to track elements that have already had SSR props bound (idempotent). */\nconst ssrPropsBoundSet = new WeakSet<HTMLElement>();\nconst log = createLogger('core');\n\n/**\n * SSR-safe custom element registration helper.\n * v0.29.1: Merged from custom-element.ts.\n */\nexport function defineCustomElement(\n  tag: string,\n  ctor: CustomElementConstructor,\n): void {\n  if (typeof globalThis.customElements === 'undefined') return;\n  if (!globalThis.customElements.get(tag)) {\n    globalThis.customElements.define(tag, ctor);\n  }\n}\n\nconst VALID_STRATEGIES = new Set<HydrationStrategy>(['load', 'idle', 'visible', 'only']);\n\n// Module-level store of active visibility strategy timeout IDs.\n// Used for test cleanup - tests can call _clearAllVisibilityTimeouts()\n// to prevent timer leaks.\nconst _visibilityTimeouts = new Set<ReturnType<typeof setTimeout>>();\n\nconst _islandMeta = new WeakMap<CustomElementConstructor, IslandMeta>();\n\nexport function getIslandMeta(ctor: CustomElementConstructor): IslandMeta | undefined {\n  return _islandMeta.get(ctor);\n}\n\n/** Clear all active visibility strategy timeouts (for test cleanup). */\nexport function _clearAllVisibilityTimeouts(): void {\n  for (const id of _visibilityTimeouts) {\n    clearTimeout(id);\n  }\n  _visibilityTimeouts.clear();\n}\n\n/**\n * Get the value of the data-ssr-props attribute from a host element.\n * Used to reconstruct SSR props on client upgrade.\n *\n * @param el - The custom element host element\n * @returns Parsed props object, or null if no data-ssr-props attribute\n *\n * @example\n * ```ts\n * connectedCallback() {\n *   super.connectedCallback();\n *   const props = getSsrProps(this);\n *   if (props) {\n *     this.count = props.count ?? 0;\n *   }\n * }\n * ```\n */\nexport function getSsrProps(el: HTMLElement): Record<string, unknown> | null {\n  const raw = el.getAttribute('data-ssr-props');\n  if (!raw) return null;\n  try {\n    return JSON.parse(raw) as Record<string, unknown>;\n  } catch {\n    log.warn(`Failed to parse data-ssr-props on <${el.tagName.toLowerCase()}>`);\n    return null;\n  }\n}\n\n/**\n * Apply SSR props from data-ssr-props to a component instance.\n * This restores server-rendered property values to the\n * client-side component on upgrade, ensuring consistency between\n * SSR and client state.\n *\n * v0.6.2: Framework-agnostic. No Lit-specific detection.\n * Props are set directly on the instance. DSD hydration and VNode event\n * markers are handled at the component level via DsdElement.\n *\n * v0.14.3: Prototype pollution fix - filters dangerous keys\n * (__proto__, constructor, prototype) from parsed SSR props.\n *\n * @param el - The upgraded custom element\n */\n\n/** Keys that could cause prototype pollution if assigned to an object instance.\n * v0.14.7: Extended to cover all Object.prototype methods that could be\n * exploited via arbitrary property assignment (C-03 fix).\n */\nimport { DANGEROUS_KEYS } from './security.js';\n\nexport function bindSsrProps(el: HTMLElement): void {\n  const props = getSsrProps(el);\n  if (!props) return;\n\n  for (const [key, value] of Object.entries(props)) {\n    // v0.14.3: Prevent prototype pollution - skip dangerous keys\n    if (DANGEROUS_KEYS.has(key)) {\n      log.warn(\n        `Skipping dangerous key \"${key}\" in data-ssr-props on <${el.tagName.toLowerCase()}>`,\n      );\n      continue;\n    }\n    try {\n      (el as unknown as Record<string, unknown>)[key] = value;\n    } catch (e) {\n      // Some properties may be read-only - safe to skip, but log for debuggability\n      log.debug(\n        `Cannot set read-only property \"${key}\" on <${el.tagName.toLowerCase()}>: ${\n          formatError(e)\n        }`,\n      );\n    }\n  }\n}\n\n/**\n * Create an IntersectionObserver-based upgrade strategy.\n * v0.6': Uses querySelectorAll to observe ALL instances of the tag,\n * not just the first one. Per WHATWG IntersectionObserver spec.\n */\nfunction createVisibleStrategy(\n  tagName: string,\n  registerFn: () => void,\n): void {\n  let registered = false;\n  const observer = new IntersectionObserver(\n    (entries) => {\n      for (const entry of entries) {\n        if (entry.isIntersecting) {\n          observer.disconnect();\n          if (!registered) {\n            registered = true;\n            clearTimeout(timeoutId);\n            _visibilityTimeouts.delete(timeoutId);\n            registerFn();\n          }\n          return;\n        }\n      }\n    },\n    { rootMargin: '200px' }, // Start loading 200px before visible\n  );\n\n  // We need to wait for elements to be in the DOM first\n  const observeAll = () => {\n    const elements = document.querySelectorAll(tagName);\n    if (elements.length > 0) {\n      elements.forEach((el) => observer.observe(el));\n      return true;\n    }\n    return false;\n  };\n\n  const mo = new MutationObserver((_mutations, mutObs) => {\n    if (observeAll()) {\n      mutObs.disconnect();\n    } else {\n      // v0.14.5: If elements were removed from DOM, disconnect all observers\n      const elements = document.querySelectorAll(tagName);\n      if (elements.length === 0 && !registered) {\n        mutObs.disconnect();\n        observer.disconnect();\n        clearTimeout(timeoutId);\n        _visibilityTimeouts.delete(timeoutId);\n      }\n    }\n  });\n\n  // v0.14.3: Timeout guard - if the target element never appears\n  // (e.g., route changed after island was registered), disconnect\n  // both observers after 30 seconds to prevent memory/perf leaks.\n  const VISIBILITY_TIMEOUT = 30_000; // 30s\n  const timeoutId = setTimeout(() => {\n    _visibilityTimeouts.delete(timeoutId);\n    if (!registered) {\n      mo.disconnect();\n      observer.disconnect();\n      log.debug(`Visibility strategy for <${tagName}> timed out after ${VISIBILITY_TIMEOUT}ms`);\n    }\n  }, VISIBILITY_TIMEOUT);\n  _visibilityTimeouts.add(timeoutId);\n\n  // Start observing after DOM content loaded\n  if (document.readyState === 'loading') {\n    document.addEventListener('DOMContentLoaded', () => {\n      if (!observeAll()) {\n        mo.observe(document.body, { childList: true, subtree: true });\n      }\n    });\n  } else {\n    if (!observeAll()) {\n      mo.observe(document.body, { childList: true, subtree: true });\n    }\n  }\n}\n\n/**\n * Create an idle (requestIdleCallback-based) hydration strategy.\n * v0.6': Improved fallback chain:\n *   1. requestIdleCallback (optimal, progressive)\n *   2. requestAnimationFrame (next frame, good for interaction)\n *   3. setTimeout(fn, 50) (final fallback, shorter than old 200ms)\n */\nfunction createIdleStrategy(registerFn: () => void): void {\n  const g = globalThis as {\n    requestIdleCallback?: (fn: () => void) => void;\n    requestAnimationFrame?: (fn: () => void) => number;\n  };\n\n  if (typeof g.requestIdleCallback === 'function') {\n    g.requestIdleCallback(registerFn);\n  } else if (typeof g.requestAnimationFrame === 'function') {\n    g.requestAnimationFrame(() => registerFn());\n  } else {\n    setTimeout(registerFn, 50);\n  }\n}\n\n/**\n * Wrap a component class as a openElement Island.\n *\n * Handles:\n *   - Automatic customElements.define() registration\n *   - Strategy-based upgrade timing\n *   - data-ssr-props binding (open:bind)\n *   - __island / __tagName export markers\n *   - __layer metadata (dsd-static, dsd-interactive, or pure-island)\n *   - Idempotent registration (safe for SSR with multiple routes)\n *\n * v0.6.2: Added `dsd` option. When false, the island is a Pure Island\n * (Layer 3) - no DSD template is emitted, framework fully owns shadow root.\n *\n * @param tagName - Custom element tag name (must contain hyphen)\n * @param componentClass - Custom Element constructor (framework-agnostic)\n * @param options - Island options\n * @returns The component class (for chaining / re-export)\n *\n * @example\n * ```ts\n * // Basic usage (DSD enabled by default)\n * export default defineIsland('my-counter', MyCounter);\n *\n * // Pure Island - no DSD, full framework reactivity\n * export default defineIsland('my-counter', MyCounter, { dsd: false });\n *\n * // With visible strategy (IntersectionObserver)\n * export default defineIsland('my-counter', MyCounter, { strategy: 'visible' });\n *\n * // With load strategy (immediate upgrade)\n * export default defineIsland('my-counter', MyCounter, { strategy: 'load' });\n * ```\n */\nexport function defineIsland<T extends CustomElementConstructor>(\n  tagName: string,\n  componentClass: T,\n  options: IslandOptions = {},\n): T {\n  const strategy = options.strategy || 'idle';\n  if (!VALID_STRATEGIES.has(strategy)) {\n    throw new Error(\n      `${ERROR_PREFIX} Invalid island hydration strategy \"${String(strategy)}\". ` +\n        'Use one of: load, idle, visible, only.',\n    );\n  }\n  const useDsd = strategy === 'only' ? false : options.dsd !== false; // default true\n  const useSsr = strategy === 'only' ? false : options.ssr !== false; // default true\n\n  // Validate tag name per WHATWG Custom Element name rules\n  // https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name\n  if (!tagName || !tagName.includes('-')) {\n    throw new Error(\n      `${ERROR_PREFIX} defineIsland() requires a hyphenated tag name, got \"${tagName}\". ` +\n        'Custom Element names must contain a hyphen per the HTML spec.',\n    );\n  }\n  // WHATWG: must start with lowercase letter, only lowercase/digits/hyphens,\n  // must not start with a reserved prefix, no uppercase\n  if (!/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/.test(tagName)) {\n    throw new Error(\n      `${ERROR_PREFIX} defineIsland() tag name \"${tagName}\" is not a valid custom element name. ` +\n        'Must start with a lowercase ASCII letter, contain only lowercase ASCII ' +\n        'letters, digits, and hyphens, and not use reserved names.',\n    );\n  }\n  // Reserved names per WHATWG (partial list)\n  const reservedPrefixes = [\n    'annotation-',\n    'color-profile',\n    'font-face',\n    'font-face-',\n    'missing-glyph',\n  ];\n  for (const prefix of reservedPrefixes) {\n    if (tagName.startsWith(prefix)) {\n      throw new Error(\n        `${ERROR_PREFIX} defineIsland() tag name \"${tagName}\" uses a reserved prefix \"${prefix}\".`,\n      );\n    }\n  }\n\n  _islandMeta.set(componentClass, {\n    isIsland: true,\n    tagName,\n    layer: useDsd ? 'dsd-interactive' : 'pure-island',\n    ssr: useSsr,\n    dsd: useDsd,\n  });\n\n  // v0.6': Mixin pattern for connectedCallback - replaces monkey-patch.\n  // Instead of modifying the prototype directly, we create a wrapper\n  // that calls the original callback + auto-binds SSR props.\n  // This is safer than monkey-patching because it doesn't interfere\n  // with Lit's own connectedCallback chain.\n  //\n  // v0.14.3: Added __ssrPropsBound idempotency guard to prevent\n  // double bindSsrProps() calls when a subclass island inherits from a\n  // parent island (both registered via defineIsland()). Without this guard,\n  // the parent's wrapped connectedCallback and the subclass's both\n  // call bindSsrProps on the same element.\n  const origConnected = componentClass.prototype.connectedCallback;\n  if (!componentClass.prototype.__openIslandWrapped) {\n    componentClass.prototype.__openIslandWrapped = true;\n    componentClass.prototype.connectedCallback = function (this: HTMLElement) {\n      // Call original connectedCallback first (super.connectedCallback)\n      if (typeof origConnected === 'function') {\n        origConnected.call(this);\n      }\n      // Auto-bind SSR props on upgrade (idempotent - only once per element)\n      if (\n        this.hasAttribute('data-ssr-props') &&\n        !ssrPropsBoundSet.has(this)\n      ) {\n        ssrPropsBoundSet.add(this);\n        Promise.resolve().then(() => bindSsrProps(this));\n      }\n    } as unknown as typeof componentClass.prototype.connectedCallback;\n  }\n\n  // Define a registration function that's idempotent\n  const register = () => {\n    const registry = globalThis.customElements;\n    if (!registry) return;\n    if (!registry.get(tagName)) {\n      try {\n        registry.define(tagName, componentClass);\n      } catch (e) {\n        // Already defined - safe to ignore in SSR contexts\n        log.debug(\n          `customElements.define(\"${tagName}\") skipped: ${formatError(e)}`,\n        );\n      }\n    }\n  };\n\n  // SSR guard: browser-specific strategy scheduling is a no-op during SSR.\n  // IntersectionObserver, MutationObserver etc. are browser-only APIs.\n  // During SSR we just define the custom element and let the generated\n  // client entry handle strategy dispatch in the browser.\n  const isBrowser = typeof IntersectionObserver !== 'undefined';\n\n  if (isBrowser) {\n    switch (strategy) {\n      case 'load': // ponytail: fallthrough, both 'load' and 'only' call register()\n      case 'only':\n        register();\n        break;\n      case 'idle':\n        createIdleStrategy(register);\n        break;\n      case 'visible':\n        createVisibleStrategy(tagName, register);\n        break;\n    }\n  } else {\n    // SSR path: define the element idempotently, strategy runs on client.\n    register();\n  }\n\n  return componentClass;\n}\n\n/**\n * Exports the `island` function as default for convenience imports.\n * Tree-shakable: bundlers can eliminate unused named exports from the same module.\n */\nexport default defineIsland;\n"],"names":[],"mappings":"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"}

package/src/isr-runtime.d.ts

@@ -0,0 +1,28 @@
+import type { IsrCacheResult } from '@openelement/protocol/isr';
+import type { IsrManifestEntry } from '@openelement/protocol/framework';
+import type { MemoryIsrCache } from "./isr.js";
+export type IsrRuntimeState = IsrCacheResult['state'] | 'not-found';
+export interface IsrRuntimeRenderResult {
+  html: string;
+  headers?: Record<string, string>;
+}
+export interface IsrRuntimeRenderContext {
+  entry: IsrManifestEntry;
+  request?: Request;
+}
+export interface IsrRuntimeOptions {
+  manifest: IsrManifestEntry[];
+  cache: MemoryIsrCache;
+  render: (path: string, context: IsrRuntimeRenderContext) => Promise<IsrRuntimeRenderResult> | IsrRuntimeRenderResult;
+  now?: () => number;
+  regenerate?: 'blocking' | 'background';
+  onRegenerateError?: (error: unknown, entry: IsrManifestEntry) => void;
+  schedule?: (task: Promise<void>) => void;
+}
+export interface IsrRuntimeResult {
+  state: IsrRuntimeState;
+  entry?: IsrManifestEntry;
+  response: Response;
+}
+export declare function findIsrManifestEntry(manifest: IsrManifestEntry[], path: string, params?: Record<string, string>): IsrManifestEntry | undefined;
+export declare function renderIsrResponse(path: string, params: Record<string, string>, options: IsrRuntimeOptions, request?: Request): Promise<IsrRuntimeResult>;

package/src/isr-runtime.js

@@ -0,0 +1,99 @@
+export function findIsrManifestEntry(manifest, path, params = {}) {
+  const paramEntries = Object.entries(params).sort(([a], [b])=>a.localeCompare(b));
+  return manifest.find((entry)=>{
+    if (entry.path !== path) return false;
+    const entryParams = Object.entries(entry.params).sort(([a], [b])=>a.localeCompare(b));
+    if (entryParams.length !== paramEntries.length) return false;
+    return entryParams.every(([key, value], index)=>{
+      const [otherKey, otherValue] = paramEntries[index];
+      return key === otherKey && value === otherValue;
+    });
+  });
+}
+export async function renderIsrResponse(path, params, options, request) {
+  const entry = findIsrManifestEntry(options.manifest, path, params);
+  if (!entry) {
+    return {
+      state: 'not-found',
+      response: new Response('Not found', {
+        status: 404
+      })
+    };
+  }
+  const now = options.now?.() ?? Date.now();
+  const cached = await options.cache.get(entry.cacheKey, now);
+  if (cached.state === 'hit' && cached.entry) {
+    return {
+      state: 'hit',
+      entry,
+      response: responseFromCacheEntry(cached.entry, 'hit')
+    };
+  }
+  if (cached.state === 'stale' && cached.entry) {
+    const regenerate = regenerateEntry(entry, options, request, now);
+    if (options.regenerate === 'background') {
+      options.schedule?.(regenerate);
+      if (!options.schedule) regenerate.catch((error)=>options.onRegenerateError?.(error, entry));
+      return {
+        state: 'stale',
+        entry,
+        response: responseFromCacheEntry(cached.entry, 'stale')
+      };
+    }
+    await regenerate;
+    const refreshed = await options.cache.get(entry.cacheKey, options.now?.() ?? Date.now());
+    return {
+      state: 'stale',
+      entry,
+      response: refreshed.entry ? responseFromCacheEntry(refreshed.entry, 'stale') : responseFromCacheEntry(cached.entry, 'stale')
+    };
+  }
+  if (cached.state === 'error') {
+    return {
+      state: 'error',
+      entry,
+      response: new Response('ISR cache error', {
+        status: 500
+      })
+    };
+  }
+  const rendered = await renderAndStore(entry, options, request, now);
+  return {
+    state: 'miss',
+    entry,
+    response: responseFromCacheEntry(rendered, 'miss')
+  };
+}
+async function regenerateEntry(entry, options, request, now) {
+  try {
+    await renderAndStore(entry, options, request, now);
+  } catch (error) {
+    options.onRegenerateError?.(error, entry);
+    throw error;
+  }
+}
+async function renderAndStore(entry, options, request, now) {
+  const result = await options.render(entry.path, {
+    entry,
+    request
+  });
+  const cacheEntry = {
+    html: result.html,
+    headers: result.headers,
+    createdAt: now,
+    revalidate: entry.revalidate
+  };
+  await options.cache.set(entry.cacheKey, cacheEntry);
+  return cacheEntry;
+}
+function responseFromCacheEntry(entry, state) {
+  const headers = new Headers(entry.headers);
+  if (!headers.has('content-type')) {
+    headers.set('content-type', 'text/html; charset=utf-8');
+  }
+  headers.set('x-openelement-isr', state);
+  return new Response(entry.html, {
+    headers
+  });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/core/src/isr-runtime.ts"],"sourcesContent":["import type { IsrCacheEntry, IsrCacheResult } from '@openelement/protocol/isr';\nimport type { IsrManifestEntry } from '@openelement/protocol/framework';\nimport type { MemoryIsrCache } from './isr.js';\n\nexport type IsrRuntimeState = IsrCacheResult['state'] | 'not-found';\n\nexport interface IsrRuntimeRenderResult {\n  html: string;\n  headers?: Record<string, string>;\n}\n\nexport interface IsrRuntimeRenderContext {\n  entry: IsrManifestEntry;\n  request?: Request;\n}\n\nexport interface IsrRuntimeOptions {\n  manifest: IsrManifestEntry[];\n  cache: MemoryIsrCache;\n  render: (\n    path: string,\n    context: IsrRuntimeRenderContext,\n  ) => Promise<IsrRuntimeRenderResult> | IsrRuntimeRenderResult;\n  now?: () => number;\n  regenerate?: 'blocking' | 'background';\n  onRegenerateError?: (error: unknown, entry: IsrManifestEntry) => void;\n  schedule?: (task: Promise<void>) => void;\n}\n\nexport interface IsrRuntimeResult {\n  state: IsrRuntimeState;\n  entry?: IsrManifestEntry;\n  response: Response;\n}\n\nexport function findIsrManifestEntry(\n  manifest: IsrManifestEntry[],\n  path: string,\n  params: Record<string, string> = {},\n): IsrManifestEntry | undefined {\n  const paramEntries = Object.entries(params).sort(([a], [b]) => a.localeCompare(b));\n  return manifest.find((entry) => {\n    if (entry.path !== path) return false;\n    const entryParams = Object.entries(entry.params).sort(([a], [b]) => a.localeCompare(b));\n    if (entryParams.length !== paramEntries.length) return false;\n    return entryParams.every(([key, value], index) => {\n      const [otherKey, otherValue] = paramEntries[index];\n      return key === otherKey && value === otherValue;\n    });\n  });\n}\n\nexport async function renderIsrResponse(\n  path: string,\n  params: Record<string, string>,\n  options: IsrRuntimeOptions,\n  request?: Request,\n): Promise<IsrRuntimeResult> {\n  const entry = findIsrManifestEntry(options.manifest, path, params);\n  if (!entry) {\n    return {\n      state: 'not-found',\n      response: new Response('Not found', { status: 404 }),\n    };\n  }\n\n  const now = options.now?.() ?? Date.now();\n  const cached = await options.cache.get(entry.cacheKey, now);\n  if (cached.state === 'hit' && cached.entry) {\n    return {\n      state: 'hit',\n      entry,\n      response: responseFromCacheEntry(cached.entry, 'hit'),\n    };\n  }\n\n  if (cached.state === 'stale' && cached.entry) {\n    const regenerate = regenerateEntry(entry, options, request, now);\n    if (options.regenerate === 'background') {\n      options.schedule?.(regenerate);\n      if (!options.schedule) regenerate.catch((error) => options.onRegenerateError?.(error, entry));\n      return {\n        state: 'stale',\n        entry,\n        response: responseFromCacheEntry(cached.entry, 'stale'),\n      };\n    }\n    await regenerate;\n    const refreshed = await options.cache.get(entry.cacheKey, options.now?.() ?? Date.now());\n    return {\n      state: 'stale',\n      entry,\n      response: refreshed.entry\n        ? responseFromCacheEntry(refreshed.entry, 'stale')\n        : responseFromCacheEntry(cached.entry, 'stale'),\n    };\n  }\n\n  if (cached.state === 'error') {\n    return {\n      state: 'error',\n      entry,\n      response: new Response('ISR cache error', { status: 500 }),\n    };\n  }\n\n  const rendered = await renderAndStore(entry, options, request, now);\n  return {\n    state: 'miss',\n    entry,\n    response: responseFromCacheEntry(rendered, 'miss'),\n  };\n}\n\nasync function regenerateEntry(\n  entry: IsrManifestEntry,\n  options: IsrRuntimeOptions,\n  request: Request | undefined,\n  now: number,\n): Promise<void> {\n  try {\n    await renderAndStore(entry, options, request, now);\n  } catch (error) {\n    options.onRegenerateError?.(error, entry);\n    throw error;\n  }\n}\n\nasync function renderAndStore(\n  entry: IsrManifestEntry,\n  options: IsrRuntimeOptions,\n  request: Request | undefined,\n  now: number,\n): Promise<IsrCacheEntry> {\n  const result = await options.render(entry.path, { entry, request });\n  const cacheEntry: IsrCacheEntry = {\n    html: result.html,\n    headers: result.headers,\n    createdAt: now,\n    revalidate: entry.revalidate,\n  };\n  await options.cache.set(entry.cacheKey, cacheEntry);\n  return cacheEntry;\n}\n\nfunction responseFromCacheEntry(entry: IsrCacheEntry, state: IsrCacheResult['state']): Response {\n  const headers = new Headers(entry.headers);\n  if (!headers.has('content-type')) {\n    headers.set('content-type', 'text/html; charset=utf-8');\n  }\n  headers.set('x-openelement-isr', state);\n  return new Response(entry.html, { headers });\n}\n"],"names":[],"mappings":"AAmCA,OAAO,SAAS,qBACd,QAA4B,EAC5B,IAAY,EACZ,SAAiC,CAAC,CAAC;EAEnC,MAAM,eAAe,OAAO,OAAO,CAAC,QAAQ,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,GAAK,EAAE,aAAa,CAAC;EAC/E,OAAO,SAAS,IAAI,CAAC,CAAC;IACpB,IAAI,MAAM,IAAI,KAAK,MAAM,OAAO;IAChC,MAAM,cAAc,OAAO,OAAO,CAAC,MAAM,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,GAAK,EAAE,aAAa,CAAC;IACpF,IAAI,YAAY,MAAM,KAAK,aAAa,MAAM,EAAE,OAAO;IACvD,OAAO,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,EAAE;MACtC,MAAM,CAAC,UAAU,WAAW,GAAG,YAAY,CAAC,MAAM;MAClD,OAAO,QAAQ,YAAY,UAAU;IACvC;EACF;AACF;AAEA,OAAO,eAAe,kBACpB,IAAY,EACZ,MAA8B,EAC9B,OAA0B,EAC1B,OAAiB;EAEjB,MAAM,QAAQ,qBAAqB,QAAQ,QAAQ,EAAE,MAAM;EAC3D,IAAI,CAAC,OAAO;IACV,OAAO;MACL,OAAO;MACP,UAAU,IAAI,SAAS,aAAa;QAAE,QAAQ;MAAI;IACpD;EACF;EAEA,MAAM,MAAM,QAAQ,GAAG,QAAQ,KAAK,GAAG;EACvC,MAAM,SAAS,MAAM,QAAQ,KAAK,CAAC,GAAG,CAAC,MAAM,QAAQ,EAAE;EACvD,IAAI,OAAO,KAAK,KAAK,SAAS,OAAO,KAAK,EAAE;IAC1C,OAAO;MACL,OAAO;MACP;MACA,UAAU,uBAAuB,OAAO,KAAK,EAAE;IACjD;EACF;EAEA,IAAI,OAAO,KAAK,KAAK,WAAW,OAAO,KAAK,EAAE;IAC5C,MAAM,aAAa,gBAAgB,OAAO,SAAS,SAAS;IAC5D,IAAI,QAAQ,UAAU,KAAK,cAAc;MACvC,QAAQ,QAAQ,GAAG;MACnB,IAAI,CAAC,QAAQ,QAAQ,EAAE,WAAW,KAAK,CAAC,CAAC,QAAU,QAAQ,iBAAiB,GAAG,OAAO;MACtF,OAAO;QACL,OAAO;QACP;QACA,UAAU,uBAAuB,OAAO,KAAK,EAAE;MACjD;IACF;IACA,MAAM;IACN,MAAM,YAAY,MAAM,QAAQ,KAAK,CAAC,GAAG,CAAC,MAAM,QAAQ,EAAE,QAAQ,GAAG,QAAQ,KAAK,GAAG;IACrF,OAAO;MACL,OAAO;MACP;MACA,UAAU,UAAU,KAAK,GACrB,uBAAuB,UAAU,KAAK,EAAE,WACxC,uBAAuB,OAAO,KAAK,EAAE;IAC3C;EACF;EAEA,IAAI,OAAO,KAAK,KAAK,SAAS;IAC5B,OAAO;MACL,OAAO;MACP;MACA,UAAU,IAAI,SAAS,mBAAmB;QAAE,QAAQ;MAAI;IAC1D;EACF;EAEA,MAAM,WAAW,MAAM,eAAe,OAAO,SAAS,SAAS;EAC/D,OAAO;IACL,OAAO;IACP;IACA,UAAU,uBAAuB,UAAU;EAC7C;AACF;AAEA,eAAe,gBACb,KAAuB,EACvB,OAA0B,EAC1B,OAA4B,EAC5B,GAAW;EAEX,IAAI;IACF,MAAM,eAAe,OAAO,SAAS,SAAS;EAChD,EAAE,OAAO,OAAO;IACd,QAAQ,iBAAiB,GAAG,OAAO;IACnC,MAAM;EACR;AACF;AAEA,eAAe,eACb,KAAuB,EACvB,OAA0B,EAC1B,OAA4B,EAC5B,GAAW;EAEX,MAAM,SAAS,MAAM,QAAQ,MAAM,CAAC,MAAM,IAAI,EAAE;IAAE;IAAO;EAAQ;EACjE,MAAM,aAA4B;IAChC,MAAM,OAAO,IAAI;IACjB,SAAS,OAAO,OAAO;IACvB,WAAW;IACX,YAAY,MAAM,UAAU;EAC9B;EACA,MAAM,QAAQ,KAAK,CAAC,GAAG,CAAC,MAAM,QAAQ,EAAE;EACxC,OAAO;AACT;AAEA,SAAS,uBAAuB,KAAoB,EAAE,KAA8B;EAClF,MAAM,UAAU,IAAI,QAAQ,MAAM,OAAO;EACzC,IAAI,CAAC,QAAQ,GAAG,CAAC,iBAAiB;IAChC,QAAQ,GAAG,CAAC,gBAAgB;EAC9B;EACA,QAAQ,GAAG,CAAC,qBAAqB;EACjC,OAAO,IAAI,SAAS,MAAM,IAAI,EAAE;IAAE;EAAQ;AAC5C"}

package/src/isr.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @openelement/core - route-level ISR cache primitives.
+ *
+ * v0.22: Platform adapters (CF Workers KV, Deno KV).
+ *
+ * Architecture:
+ *   1. Build: SSG produces static HTML + isr-manifest.json
+ *   2. Runtime: Edge handler checks cache before serving static
+ *   4. Stale: serve cached HTML + async background regeneration
+ *
+ * MemoryIsrCache is the reference in-memory implementation. Production adapters
+ * (Cloudflare Workers KV, Deno KV) are v0.22 scope.
+ */ import type { CacheAdapter, CacheEntry, IsrCacheEntry, IsrCacheResult, IsrCacheState, IsrRouteConfig } from '@openelement/protocol/isr';
+import type { IsrManifestEntry } from '@openelement/protocol/framework';
+export type { CacheAdapter, CacheEntry, IsrCacheEntry, IsrCacheResult, IsrCacheState, IsrManifestEntry, IsrRouteConfig };
+export declare function isIsrRouteConfig(value: unknown): value is IsrRouteConfig;
+export declare function createIsrCacheKey(routePath: string, params?: Record<string, string>): string;
+export declare class MemoryIsrCache {
+  get(key: string, now?: number): IsrCacheResult;
+  set(key: string, entry: IsrCacheEntry): void;
+  delete(key: string): void;
+}

package/src/isr.js

@@ -0,0 +1,41 @@
+/**
+ * @openelement/core - route-level ISR cache primitives.
+ *
+ * v0.22: Platform adapters (CF Workers KV, Deno KV).
+ *
+ * Architecture:
+ *   1. Build: SSG produces static HTML + isr-manifest.json
+ *   2. Runtime: Edge handler checks cache before serving static
+ *   4. Stale: serve cached HTML + async background regeneration
+ *
+ * MemoryIsrCache is the reference in-memory implementation. Production adapters
+ * (Cloudflare Workers KV, Deno KV) are v0.22 scope.
+ */ export function isIsrRouteConfig(value) {
+  return typeof value === 'object' && value !== null && typeof value.revalidate === 'number' && Number.isFinite(value.revalidate) && value.revalidate > 0;
+}
+export function createIsrCacheKey(routePath, params = {}) {
+  const sortedParams = Object.entries(params).sort(([a], [b])=>a.localeCompare(b));
+  const suffix = sortedParams.length === 0 ? '' : '?' + sortedParams.map(([key, value])=>`${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join('&');
+  return `openelement:isr:${routePath}${suffix}`;
+}
+export class MemoryIsrCache {
+  #entries = new Map();
+  get(key, now = Date.now()) {
+    const entry = this.#entries.get(key);
+    if (!entry) return {
+      state: 'miss'
+    };
+    const ageSeconds = Math.max(0, Math.floor((now - entry.createdAt) / 1000));
+    return {
+      state: ageSeconds >= entry.revalidate ? 'stale' : 'hit',
+      entry
+    };
+  }
+  set(key, entry) {
+    this.#entries.set(key, entry);
+  }
+  delete(key) {
+    this.#entries.delete(key);
+  }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/jsx-render-dom.d.ts

@@ -0,0 +1,22 @@
+import type { Signal } from '@openelement/protocol/signal';
+import type { BindingDescriptor, BindingLifecycle } from "./binding-descriptor.js";
+/**
+ * Collect BindingDescriptor objects from a JSX props object.
+ *
+ * @param el - Target element the descriptors will apply to.
+ * @param props - VNode props.
+ * @param signalRegistry - Optional registry used to name signals for hydration markers.
+ * @returns Array of binding descriptors.
+ */ export declare function collectPropBindings(el: Element, props: Record<string, unknown>, signalRegistry?: Map<string, Signal<unknown>>): BindingDescriptor[];
+/**
+ * Apply a props object to a real DOM element.
+ */ export declare function applyProps(el: Element, props: Record<string, unknown>, lifecycle?: BindingLifecycle, signalRegistry?: Map<string, Signal<unknown>>): void;
+/**
+ * Render a VNode tree to a real DOM node.
+ *
+ * @param node - VNode, string, number, or null/undefined
+ * @param lifecycle - Optional BindingLifecycle for automatic cleanup
+ * @param disposers - Optional Set to collect effect dispose fns (backward compat)
+ * @param signalRegistry - Optional registry used to resolve signal names for markers
+ * @returns DOM Node (Element, Text, or DocumentFragment)
+ */ export declare function renderToDom(node: unknown, lifecycle?: BindingLifecycle, disposers?: Set<() => void>, signalRegistry?: Map<string, Signal<unknown>>): Node;