hexo-theme-stellar 1.44.0 → 2.0.0-rc.2

package/source/js/plugins/voice.js

@@ -1,3 +1,27 @@
+function isDarkColorScheme(documentRef, mediaQuery) {
+    const explicit = documentRef.documentElement.getAttribute('data-theme');
+    if (explicit === 'dark') return true;
+    if (explicit === 'light') return false;
+    return mediaQuery.matches;
+}
+
+function listenColorScheme(documentRef, mediaQuery, callback) {
+    documentRef.addEventListener('stellar:color-scheme-change', callback);
+    if (typeof mediaQuery.addEventListener === 'function') {
+        mediaQuery.addEventListener('change', callback);
+    } else if (typeof mediaQuery.addListener === 'function') {
+        mediaQuery.addListener(callback);
+    }
+    return function cleanup() {
+        documentRef.removeEventListener('stellar:color-scheme-change', callback);
+        if (typeof mediaQuery.removeEventListener === 'function') {
+            mediaQuery.removeEventListener('change', callback);
+        } else if (typeof mediaQuery.removeListener === 'function') {
+            mediaQuery.removeListener(callback);
+        }
+    };
+}
+
 /**该方法用来绘制一个有填充色的圆角矩形 
     *@param cxt:canvas的上下文环境 
     *@param x:左上角x轴坐标 
@@ -152,6 +176,7 @@ function drawPlayLine(context, playLineHeight, playLineX, playLineColor) {
 }
 
 function createVoiceDom(audios) {
+    const cleanups = [];
     for (let i = 0; i < audios.length; ++i) {
         let audio = audios[i];
         audio.loop = false;
@@ -159,13 +184,17 @@ function createVoiceDom(audios) {
 
         if (audio.classList.contains('qq')) {
             if (isNaN(audio.duration) || audio.duration === Infinity) {
-                audio.addEventListener('durationchange', ()=>{
+                const handleDurationChange = ()=>{
                     // createCssStyle(audio, i);
-                    createWaveDom(audio);
-                });
+                    const cleanup = createWaveDom(audio);
+                    if (cleanup) cleanups.push(cleanup);
+                };
+                audio.addEventListener('durationchange', handleDurationChange, { once: true });
+                cleanups.push(() => audio.removeEventListener('durationchange', handleDurationChange));
             } else {
                 // createCssStyle(audio, i);
-                createWaveDom(audio);
+                const cleanup = createWaveDom(audio);
+                if (cleanup) cleanups.push(cleanup);
             }
         } else if (audio.classList.contains('wechat')) {
             if (isNaN(audio.duration) || audio.duration === Infinity) {
@@ -177,6 +206,10 @@ function createVoiceDom(audios) {
             }
         }
     }
+    return function cleanup() {
+        for (let index = cleanups.length - 1; index >= 0; index -= 1) cleanups[index]();
+        cleanups.length = 0;
+    };
 }
 
 // cancas 效果更好
@@ -213,22 +246,20 @@ function createWaveDom(audio) {
         var context = audioCanvas.getContext("2d"); //获取画布context的上下文环境 
         context.scale(dpr, 1);
 
-        let activeWaveColor = '#333';
-        let inactiveWaveColor = '#999';
+        const mediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
+        let activeWaveColor;
+        let inactiveWaveColor;
 
-        if (audioCanvas.classList.contains('right')) {
-            activeWaveColor = '#ffffff';
-            inactiveWaveColor = '#1373b3';
-        }
-
-        if (utils.dark.mode === "dark") {
-            activeWaveColor = '#ccc';
-            inactiveWaveColor = '#707070';
+        function updateWaveColors() {
+            const dark = isDarkColorScheme(document, mediaQuery);
+            activeWaveColor = dark ? '#ccc' : '#333';
+            inactiveWaveColor = dark ? '#707070' : '#999';
             if (audioCanvas.classList.contains('right')) {
-                activeWaveColor = '#fff9';
-                inactiveWaveColor = '#6797b780';
+                activeWaveColor = dark ? '#fff9' : '#ffffff';
+                inactiveWaveColor = dark ? '#6797b780' : '#1373b3';
             }
         }
+        updateWaveColors();
 
         let playFlag = false;
 
@@ -237,21 +268,7 @@ function createWaveDom(audio) {
 
         audio.addEventListener('timeupdate', ()=>{
             if (audio.currentTime > 0) {
-                if (utils.dark.mode === "dark") {
-                    activeWaveColor = '#ccc';
-                    inactiveWaveColor = '#707070';
-                    if (audioCanvas.classList.contains('right')) {
-                        activeWaveColor = '#fff9';
-                        inactiveWaveColor = '#6797b780';
-                    }
-                } else {
-                    activeWaveColor = '#333';
-                    inactiveWaveColor = '#999';
-                    if (audioCanvas.classList.contains('right')) {
-                        activeWaveColor = '#ffffff';
-                        inactiveWaveColor = '#1373b3';
-                    }
-                }
+                updateWaveColors();
                 utils.requestAnimationFrame(()=>{
                     context.clearRect(0, 0, audioCanvas.width, audioCanvas.height);
                     drawWaveWhenPlaying(context,audioCanvas.height,(audio.currentTime / audio.duration) * audioCanvas.width / dpr,waveHeightArr,1,activeWaveColor,inactiveWaveColor);
@@ -285,23 +302,9 @@ function createWaveDom(audio) {
             }
         });
 
-        utils.dark.push(function () {
+        const cleanupColorScheme = listenColorScheme(document, mediaQuery, function () {
             if (!playFlag) {
-                if (utils.dark.mode === "dark") {
-                    activeWaveColor = '#ccc';
-                    inactiveWaveColor = '#707070';
-                    if (audioCanvas.classList.contains('right')) {
-                        activeWaveColor = '#fff9';
-                        inactiveWaveColor = '#6797b780';
-                    }
-                } else {
-                    activeWaveColor = '#333';
-                    inactiveWaveColor = '#999';
-                    if (audioCanvas.classList.contains('right')) {
-                        activeWaveColor = '#ffffff';
-                        inactiveWaveColor = '#1373b3';
-                    }
-                }
+                updateWaveColors();
                 if (audio.currentTime > 0) {
                     utils.requestAnimationFrame(()=>{
                         context.clearRect(0, 0, audioCanvas.width, audioCanvas.height);
@@ -316,7 +319,7 @@ function createWaveDom(audio) {
                 }
             }
         });
-        
+        return cleanupColorScheme;
     } else {
         console.log("浏览器不支持canvas");
     }

package/source/js/profile.js

@@ -0,0 +1,316 @@
+(function () {
+  var SUPPORTED_PROVIDERS = ['artalk', 'waline', 'twikoo'];
+  var SETTINGS_ICON = 'default:settings';
+  var PROFILE_ICON = 'default:profile';
+  var GRAVATAR_BASE_URL = 'https://gravatar.com/avatar/';
+  var localStore = null;
+  var sessionStore = null;
+  var gravatarHashes = new Map();
+  var widgetRenderRevisions = new WeakMap();
+  try { localStore = localStorage; } catch (error) {}
+  try { sessionStore = sessionStorage; } catch (error) {}
+
+  function parseStorage(store, key) {
+    try {
+      var raw = store?.getItem?.(key);
+      if (!raw) return null;
+      var value = JSON.parse(raw);
+      return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  function hasStorageValue(store, key) {
+    try { return store?.getItem?.(key) != null; } catch (error) { return false; }
+  }
+
+  function writeStorage(store, key, value) {
+    try {
+      store?.setItem?.(key, JSON.stringify(value));
+      return !!store?.setItem;
+    } catch (error) { return false; }
+  }
+
+  function removeStorage(store, key) {
+    try {
+      store?.removeItem?.(key);
+      return !!store?.removeItem;
+    } catch (error) { return false; }
+  }
+
+  function cleanText(value, maxLength) {
+    return typeof value === 'string' ? value.trim().slice(0, maxLength || 80) : '';
+  }
+
+  function cleanEmail(value) {
+    var email = cleanText(value, 254);
+    if (!email) return '';
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email) ? email : null;
+  }
+
+  function cleanHttpUrl(value) {
+    if (typeof value !== 'string' || value.trim().length === 0) return '';
+    var candidate = value.trim();
+    if (candidate.startsWith('//')) candidate = 'https:' + candidate;
+    try {
+      var parsed = new URL(candidate);
+      return parsed.protocol === 'http:' || parsed.protocol === 'https:' ? parsed.href : null;
+    } catch (error) { return null; }
+  }
+
+  function normalizeGravatarEmail(value) {
+    var email = cleanEmail(value);
+    return email ? email.toLowerCase() : '';
+  }
+
+  function hashToHex(buffer) {
+    return Array.from(new Uint8Array(buffer), function (byte) {
+      return byte.toString(16).padStart(2, '0');
+    }).join('');
+  }
+
+  function getGravatarHash(email) {
+    var normalized = normalizeGravatarEmail(email);
+    if (!normalized) return Promise.resolve('');
+    if (gravatarHashes.has(normalized)) return gravatarHashes.get(normalized);
+    var cryptoApi = window.crypto;
+    if (!cryptoApi?.subtle?.digest || typeof TextEncoder !== 'function') return Promise.resolve('');
+    var promise;
+    try {
+      promise = Promise.resolve(cryptoApi.subtle.digest('SHA-256', new TextEncoder().encode(normalized)))
+        .then(hashToHex)
+        .catch(function () { return ''; });
+    } catch (error) {
+      promise = Promise.resolve('');
+    }
+    gravatarHashes.set(normalized, promise);
+    return promise;
+  }
+
+  function getGravatarUrl(email, size) {
+    var requestedSize = Math.round(Number(size));
+    var safeSize = Number.isFinite(requestedSize) ? Math.min(2048, Math.max(1, requestedSize)) : 80;
+    return getGravatarHash(email).then(function (hash) {
+      return hash ? GRAVATAR_BASE_URL + hash + '?s=' + safeSize + '&r=g&d=404' : '';
+    });
+  }
+
+  function emptyIdentity(provider) {
+    var id = String(provider || '').toLowerCase();
+    return { provider: id, supported: SUPPORTED_PROVIDERS.includes(id), name: '', email: '', url: '', avatar: '' };
+  }
+
+  function readIdentity(provider) {
+    var id = String(provider || '').toLowerCase();
+    var identity = emptyIdentity(id);
+    var value = null;
+    if (id === 'artalk') {
+      value = parseStorage(localStore, 'ArtalkUser') || {};
+      identity.name = cleanText(value.name || value.nick);
+      identity.email = cleanText(value.email || value.mail, 254);
+      identity.url = cleanHttpUrl(value.link || value.url) || '';
+      identity.avatar = cleanHttpUrl(value.avatar) || '';
+      return identity;
+    }
+    if (id === 'waline') {
+      value = parseStorage(sessionStore, 'WALINE_USER') || parseStorage(localStore, 'WALINE_USER') || {};
+      var meta = parseStorage(sessionStore, 'WALINE_USER_META') || parseStorage(localStore, 'WALINE_USER_META') || {};
+      identity.name = cleanText(value.display_name || value.nick || meta.nick);
+      identity.email = cleanText(value.email || value.mail || meta.mail, 254);
+      identity.url = cleanHttpUrl(value.url || value.link || meta.link) || '';
+      identity.avatar = cleanHttpUrl(value.avatar || meta.avatar) || '';
+      return identity;
+    }
+    if (id === 'twikoo') {
+      value = parseStorage(localStore, 'twikoo') || {};
+      identity.name = cleanText(value.nick);
+      identity.email = cleanText(value.mail, 254);
+      identity.url = cleanHttpUrl(value.link) || '';
+      identity.avatar = cleanHttpUrl(value.avatar) || '';
+      return identity;
+    }
+    return identity;
+  }
+
+  function dispatchChange(provider) {
+    try {
+      window.dispatchEvent?.(new CustomEvent('stellar:profile-change', { detail: { provider: provider } }));
+    } catch (error) {
+      window.dispatchEvent?.({ type: 'stellar:profile-change', detail: { provider: provider } });
+    }
+  }
+
+  function updateExistingCopies(key, updater) {
+    return [localStore, sessionStore]
+      .filter(function (store) { return hasStorageValue(store, key); })
+      .map(function (store) { return writeStorage(store, key, updater(parseStorage(store, key) || {})); });
+  }
+
+  function writeIdentity(provider, fields) {
+    var id = String(provider || '').toLowerCase();
+    if (!SUPPORTED_PROVIDERS.includes(id)) return { ok: false, unsupported: true, partial: false };
+    var rawName = typeof fields?.name === 'string' ? fields.name.trim() : '';
+    var name = cleanText(rawName);
+    var email = cleanEmail(fields?.email);
+    var url = cleanHttpUrl(fields?.url);
+    if (!name || rawName.length > 80) return { ok: false, validation: 'name', partial: false };
+    if (email === null) return { ok: false, validation: 'email', partial: false };
+    if (url === null) return { ok: false, validation: 'url', partial: false };
+
+    var results = [];
+    if (id === 'artalk') {
+      var artalk = parseStorage(localStore, 'ArtalkUser') || {};
+      results.push(writeStorage(localStore, 'ArtalkUser', Object.assign({}, artalk, { name: name, email: email, link: url })));
+    } else if (id === 'twikoo') {
+      var twikoo = parseStorage(localStore, 'twikoo') || {};
+      results.push(writeStorage(localStore, 'twikoo', Object.assign({}, twikoo, { nick: name, mail: email, link: url })));
+    } else {
+      results = results.concat(
+        updateExistingCopies('WALINE_USER', function (current) { return Object.assign({}, current, { display_name: name, email: email, url: url }); }),
+        updateExistingCopies('WALINE_USER_META', function (current) { return Object.assign({}, current, { nick: name, mail: email, link: url }); })
+      );
+      if (results.length === 0) results.push(writeStorage(localStore, 'WALINE_USER_META', { nick: name, mail: email, link: url }));
+    }
+    var succeeded = results.filter(Boolean).length;
+    var outcome = { ok: succeeded === results.length && succeeded > 0, partial: succeeded > 0 && succeeded < results.length };
+    if (succeeded > 0) dispatchChange(id);
+    return outcome;
+  }
+
+  function logout(provider) {
+    var id = String(provider || '').toLowerCase();
+    if (!SUPPORTED_PROVIDERS.includes(id)) return { ok: false, unsupported: true, partial: false };
+    var targets = id === 'artalk'
+      ? [[localStore, 'ArtalkUser']]
+      : id === 'twikoo'
+        ? [[localStore, 'twikoo']]
+        : [[localStore, 'WALINE_USER'], [sessionStore, 'WALINE_USER'], [localStore, 'WALINE_USER_META'], [sessionStore, 'WALINE_USER_META']];
+    var results = targets.map(function (target) { return removeStorage(target[0], target[1]); });
+    var succeeded = results.filter(Boolean).length;
+    var outcome = { ok: succeeded === results.length, partial: succeeded > 0 && succeeded < results.length };
+    if (succeeded > 0) dispatchChange(id);
+    return outcome;
+  }
+
+  function renderIconMedia(avatar, key) {
+    var media = document.createElement('span');
+    media.className = 'ui-icon';
+    media.innerHTML = window.stellarIcons?.[key] || '';
+    avatar.replaceChildren(media);
+  }
+
+  function renderImageMedia(avatar, url, onError) {
+    var media = document.createElement('img');
+    media.className = 'settings-widget__image';
+    media.alt = '';
+    media.onerror = onError || function () { renderIconMedia(avatar, PROFILE_ICON); };
+    media.src = url;
+    avatar.replaceChildren(media);
+  }
+
+  function isCurrentWidgetRender(widget, revision) {
+    return widgetRenderRevisions.get(widget) === revision;
+  }
+
+  function renderWidgetFallback(widget, avatar, fallbackAvatar, revision) {
+    if (!isCurrentWidgetRender(widget, revision)) return;
+    if (!fallbackAvatar) {
+      renderIconMedia(avatar, PROFILE_ICON);
+      return;
+    }
+    renderImageMedia(avatar, fallbackAvatar, function () {
+      if (isCurrentWidgetRender(widget, revision)) renderIconMedia(avatar, PROFILE_ICON);
+    });
+  }
+
+  function renderWidgetGravatar(widget, avatar, identity, fallbackAvatar, revision) {
+    if (!identity.email) {
+      renderWidgetFallback(widget, avatar, fallbackAvatar, revision);
+      return;
+    }
+    renderIconMedia(avatar, PROFILE_ICON);
+    getGravatarUrl(identity.email, 64).then(function (url) {
+      if (!isCurrentWidgetRender(widget, revision)) return;
+      if (!url) {
+        renderWidgetFallback(widget, avatar, fallbackAvatar, revision);
+        return;
+      }
+      renderImageMedia(avatar, url, function () {
+        renderWidgetFallback(widget, avatar, fallbackAvatar, revision);
+      });
+    }, function () {
+      renderWidgetFallback(widget, avatar, fallbackAvatar, revision);
+    });
+  }
+
+  function renderWidget(widget) {
+    var revision = (widgetRenderRevisions.get(widget) || 0) + 1;
+    widgetRenderRevisions.set(widget, revision);
+    var settingsName = widget.dataset.settingsLabel || widget.getAttribute('aria-label') || 'Settings';
+    var identityEnabled = widget.dataset.profileIdentityEnabled === 'true';
+    var identity = readIdentity(widget.dataset.profileProvider);
+    var hasIdentity = identityEnabled && identity.supported && !!identity.name;
+    var name = hasIdentity ? identity.name : settingsName;
+    var nameElement = widget.querySelector('.settings-widget__name');
+    var avatar = widget.querySelector('.settings-widget__avatar');
+    if (nameElement) nameElement.textContent = name;
+    widget.setAttribute('aria-label', name);
+    widget.setAttribute('title', name);
+    if (!avatar) return;
+    if (!hasIdentity) {
+      renderIconMedia(avatar, SETTINGS_ICON);
+      return;
+    }
+    var fallbackAvatar = widget.dataset.profileFallbackAvatar || '';
+    if (identity.avatar) {
+      renderImageMedia(avatar, identity.avatar, function () {
+        renderWidgetGravatar(widget, avatar, identity, fallbackAvatar, revision);
+      });
+      return;
+    }
+    renderWidgetGravatar(widget, avatar, identity, fallbackAvatar, revision);
+  }
+
+  var mountedRoots = new WeakMap();
+  function mount(root) {
+    root = root || document;
+    if (mountedRoots.has(root)) return mountedRoots.get(root);
+    var refresh = function () { root.querySelectorAll?.('.settings-widget').forEach(renderWidget); };
+    var delayedRefresh = function () { setTimeout(refresh, 0); };
+    var onInteraction = function (event) {
+      if (event.target?.closest?.('#comments, .comments, [class*="comment"]')) delayedRefresh();
+    };
+    window.addEventListener?.('storage', refresh);
+    window.addEventListener?.('focus', refresh);
+    window.addEventListener?.('stellar:profile-change', refresh);
+    root.addEventListener?.('input', onInteraction);
+    root.addEventListener?.('change', onInteraction);
+    root.addEventListener?.('submit', onInteraction);
+    root.addEventListener?.('click', onInteraction);
+    refresh();
+    var cleanup = function () {
+      window.removeEventListener?.('storage', refresh);
+      window.removeEventListener?.('focus', refresh);
+      window.removeEventListener?.('stellar:profile-change', refresh);
+      root.removeEventListener?.('input', onInteraction);
+      root.removeEventListener?.('change', onInteraction);
+      root.removeEventListener?.('submit', onInteraction);
+      root.removeEventListener?.('click', onInteraction);
+      mountedRoots.delete(root);
+    };
+    mountedRoots.set(root, cleanup);
+    return cleanup;
+  }
+
+  window.stellarProfile = {
+    mount: mount,
+    supports: function (provider) { return SUPPORTED_PROVIDERS.includes(String(provider || '').toLowerCase()); },
+    getGravatarUrl: getGravatarUrl,
+    readIdentity: readIdentity,
+    writeIdentity: writeIdentity,
+    logout: logout
+  };
+  if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', function () { mount(document); }, { once: true });
+  else mount(document);
+})();

package/source/js/runtime/asset-loader.js

@@ -0,0 +1,61 @@
+function resolveAsset(root, value) {
+  if (typeof value !== 'string' || value.length === 0) return '';
+  if (!value.startsWith('/')) return value;
+  const base = typeof root === 'string' && root.length > 0 ? root : '/';
+  return `${base.replace(/\/$/, '')}${value}`;
+}
+
+function versionAsset(value, url, version) {
+  if (typeof value !== 'string' || !value.startsWith('/') || !version) return url;
+  const suffix = version.replace(/^\?/, '');
+  return `${url}${url.includes('?') ? '&' : '?'}${suffix}`;
+}
+
+export function createAssetLoader(options = {}) {
+  const documentRef = options.document || document;
+  const root = options.root || '/';
+  const version = options.version || '';
+  const scripts = new Map();
+  const styles = new Map();
+
+  function script(src, attributes = {}) {
+    const url = versionAsset(src, resolveAsset(root, src), version);
+    if (!url) return Promise.reject(new TypeError('[stellar runtime] script URL is required'));
+    if (scripts.has(url)) return scripts.get(url);
+    const promise = new Promise((resolve, reject) => {
+      const element = documentRef.createElement('script');
+      element.src = url;
+      element.async = attributes.async !== false;
+      Object.keys(attributes).forEach(key => {
+        if (key === 'async') return;
+        element[key] = attributes[key];
+      });
+      element.addEventListener('load', () => resolve(element), { once: true });
+      element.addEventListener('error', () => reject(new Error(`failed to load ${url}`)), { once: true });
+      documentRef.head.appendChild(element);
+    });
+    scripts.set(url, promise);
+    promise.catch(() => scripts.delete(url));
+    return promise;
+  }
+
+  function style(href, attributes = {}) {
+    const url = versionAsset(href, resolveAsset(root, href), version);
+    if (!url) return Promise.reject(new TypeError('[stellar runtime] style URL is required'));
+    if (styles.has(url)) return styles.get(url);
+    const promise = new Promise((resolve, reject) => {
+      const element = documentRef.createElement('link');
+      element.rel = 'stylesheet';
+      element.href = url;
+      Object.keys(attributes).forEach(key => element.setAttribute(key, attributes[key]));
+      element.addEventListener('load', () => resolve(element), { once: true });
+      element.addEventListener('error', () => reject(new Error(`failed to load ${url}`)), { once: true });
+      documentRef.head.appendChild(element);
+    });
+    styles.set(url, promise);
+    promise.catch(() => styles.delete(url));
+    return promise;
+  }
+
+  return Object.freeze({ script, style, resolve: value => resolveAsset(root, value) });
+}

package/source/js/runtime/extension-registry.js

@@ -0,0 +1,149 @@
+const PHASES = new Set(['import', 'mount', 'unmount']);
+
+function validateDeclaration(declaration) {
+  if (!declaration || typeof declaration !== 'object' || Array.isArray(declaration)) {
+    throw new TypeError('[stellar runtime] extension declaration must be an object');
+  }
+  if (typeof declaration.id !== 'string' || !/^[a-z][a-z0-9-]*$/.test(declaration.id)) {
+    throw new TypeError('[stellar runtime] extension id is invalid');
+  }
+  if (typeof declaration.module !== 'string' || declaration.module.length === 0) {
+    throw new TypeError(`[stellar runtime] extension ${declaration.id} module is invalid`);
+  }
+  const unknown = Object.keys(declaration).filter(key => !['id', 'module', 'when', 'config'].includes(key));
+  if (unknown.length > 0) {
+    throw new TypeError(`[stellar runtime] extension ${declaration.id} has unknown field ${unknown[0]}`);
+  }
+  if (!declaration.when || typeof declaration.when !== 'object' || Array.isArray(declaration.when)) {
+    throw new TypeError(`[stellar runtime] extension ${declaration.id} when is invalid`);
+  }
+  const whenKeys = Object.keys(declaration.when);
+  if (whenKeys.length !== 1 || !['always', 'selector'].includes(whenKeys[0])) {
+    throw new TypeError(`[stellar runtime] extension ${declaration.id} must declare exactly one of always/selector`);
+  }
+  if (whenKeys[0] === 'always' && declaration.when.always !== true) {
+    throw new TypeError(`[stellar runtime] extension ${declaration.id} when.always must be true`);
+  }
+  if (whenKeys[0] === 'selector' && (typeof declaration.when.selector !== 'string' || declaration.when.selector.length === 0)) {
+    throw new TypeError(`[stellar runtime] extension ${declaration.id} when.selector is invalid`);
+  }
+  if (declaration.config == null || typeof declaration.config !== 'object' || Array.isArray(declaration.config)) {
+    throw new TypeError(`[stellar runtime] extension ${declaration.id} config is invalid`);
+  }
+}
+
+function shouldMount(root, when) {
+  if (when?.always === true) return true;
+  if (typeof when?.selector !== 'string' || when.selector.length === 0) return false;
+  if (typeof root?.matches === 'function' && root.matches(when.selector)) return true;
+  return typeof root?.querySelector === 'function' && root.querySelector(when.selector) !== null;
+}
+
+export function createExtensionRegistry(options = {}) {
+  const importer = options.importer || (specifier => import(specifier));
+  const onError = typeof options.onError === 'function' ? options.onError : () => {};
+  const declarations = new Map();
+  const modulePromises = new Map();
+  const roots = new WeakMap();
+
+  function report(id, phase, error) {
+    const detail = { id, phase: PHASES.has(phase) ? phase : 'mount', error };
+    try {
+      onError(detail);
+    } catch (ignored) {
+      void ignored;
+    }
+    return { id, status: 'failed', phase: detail.phase, error };
+  }
+
+  function register(declaration) {
+    validateDeclaration(declaration);
+    if (declarations.has(declaration.id)) {
+      throw new TypeError(`[stellar runtime] duplicate extension id ${declaration.id}`);
+    }
+    declarations.set(declaration.id, Object.freeze({
+      id: declaration.id,
+      module: declaration.module,
+      when: declaration.when || {},
+      config: declaration.config || {}
+    }));
+  }
+
+  async function load(declaration) {
+    if (!modulePromises.has(declaration.module)) {
+      modulePromises.set(declaration.module, Promise.resolve().then(() => importer(declaration.module)));
+    }
+    return modulePromises.get(declaration.module);
+  }
+
+  async function unmount(root) {
+    const instances = roots.get(root) || [];
+    const results = [];
+    for (let index = instances.length - 1; index >= 0; index--) {
+      const instance = instances[index];
+      if (typeof instance.cleanup !== 'function') continue;
+      try {
+        await instance.cleanup();
+        results.push({ id: instance.id, status: 'unmounted' });
+      } catch (error) {
+        results.push(report(instance.id, 'unmount', error));
+      }
+    }
+    roots.delete(root);
+    return results;
+  }
+
+  async function mount(root, context = {}) {
+    if (!root || typeof root !== 'object') {
+      throw new TypeError('[stellar runtime] mount root must be an object');
+    }
+    await unmount(root);
+    const instances = [];
+    const results = [];
+    roots.set(root, instances);
+
+    for (const declaration of declarations.values()) {
+      let eligible;
+      try {
+        eligible = shouldMount(root, declaration.when);
+      } catch (error) {
+        results.push(report(declaration.id, 'mount', error));
+        continue;
+      }
+      if (!eligible) {
+        results.push({ id: declaration.id, status: 'skipped' });
+        continue;
+      }
+      let module;
+      try {
+        module = await load(declaration);
+      } catch (error) {
+        results.push(report(declaration.id, 'import', error));
+        continue;
+      }
+      if (typeof module?.mount !== 'function') {
+        results.push(report(declaration.id, 'mount', new TypeError('module must export mount(root, context)')));
+        continue;
+      }
+      const extensionContext = Object.freeze(Object.assign({}, context, {
+        extension: declaration,
+        reportError(error, phase = 'mount') {
+          return report(declaration.id, phase, error);
+        }
+      }));
+      try {
+        const result = await module.mount(root, extensionContext);
+        instances.push({
+          id: declaration.id,
+          cleanup: typeof result === 'function' ? result : null
+        });
+        results.push({ id: declaration.id, status: 'mounted' });
+      } catch (error) {
+        results.push(report(declaration.id, 'mount', error));
+      }
+    }
+    return results;
+  }
+
+  return Object.freeze({ register, mount, unmount });
+}