@svadmin/core 0.50.0 → 0.53.0

package/src/task-subscription.ts

@@ -0,0 +1,132 @@
+import { TaskError } from './task-contract';
+
+export function taskClientField(value: unknown, key: string): unknown {
+  try {
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      const field: unknown = Reflect.get(value, key);
+      return field;
+    }
+  } catch {
+    // Configuration accessors must not leak SDK credentials.
+  }
+  throw new TaskError('INVALID_TASK_INPUT');
+}
+
+export function taskClientMethod(value: unknown, key: string, optional = false): ((...args: unknown[]) => unknown) | undefined {
+  const callable = taskClientField(value, key);
+  if (callable === undefined && optional) return undefined;
+  if (typeof callable !== 'function') throw new TaskError('INVALID_TASK_INPUT');
+  return (...args) => {
+    const result: unknown = Reflect.apply(callable, value, args);
+    return result;
+  };
+}
+
+export function requiredTaskClientMethod(value: unknown, key: string): (...args: unknown[]) => unknown {
+  const method = taskClientMethod(value, key);
+  if (!method) throw new TaskError('INVALID_TASK_INPUT');
+  return method;
+}
+
+export function reportTaskError(error: TaskError, onError?: (error: TaskError) => void): void {
+  if (!onError) { console.error(error); return; }
+  try {
+    void Promise.resolve(onError(error)).catch(() => console.error(new TaskError('TASK_CALLBACK_FAILED')));
+  }
+  catch { console.error(new TaskError('TASK_CALLBACK_FAILED')); }
+}
+
+export function taskHandleField(value: unknown, key: string, write = false): unknown {
+  try {
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor) return undefined;
+      if ('value' in descriptor) {
+        const field: unknown = descriptor.value;
+        if (field === undefined) throw new TaskError('INVALID_TASK_RESPONSE', write);
+        return field;
+      }
+    }
+  } catch {
+    // Handle accessors and reflection errors cannot carry trusted protocol values.
+  }
+  throw new TaskError('INVALID_TASK_RESPONSE', write);
+}
+
+export function taskHandleMethod(value: unknown, key: string, write = false): (...args: unknown[]) => unknown {
+  const callable = taskHandleField(value, key, write);
+  if (typeof callable !== 'function') throw new TaskError('INVALID_TASK_RESPONSE', write);
+  return (...args) => {
+    const result: unknown = Reflect.apply(callable, value, args);
+    return result;
+  };
+}
+
+/** Validate synchronous events before publishing, but wait for a valid cleanup handle. */
+export function validatedTaskSubscription<T>(
+  start: (onUpdate: (value: unknown) => void, onFailure: (error: unknown) => void) => unknown,
+  decode: (value: unknown) => T,
+  callback: (task: T) => void,
+  onError?: (error: TaskError) => void,
+): () => void {
+  if (typeof callback !== 'function' || onError !== undefined && typeof onError !== 'function') {
+    throw new TaskError('INVALID_TASK_INPUT');
+  }
+  let stopped = false;
+  let ready = false;
+  let cleanup: (() => unknown) | undefined;
+  const buffered: T[] = [];
+  const release = () => {
+    try {
+      void Promise.resolve(cleanup?.()).catch(() => reportTaskError(new TaskError('TASK_SUBSCRIPTION_FAILED'), onError));
+    } catch { reportTaskError(new TaskError('TASK_SUBSCRIPTION_FAILED'), onError); }
+  };
+  const stop = () => {
+    if (stopped) return;
+    stopped = true;
+    buffered.length = 0;
+    release();
+  };
+  const emit = (task: T) => {
+    if (stopped) return;
+    try {
+      void Promise.resolve(callback(task)).catch(() => reportTaskError(new TaskError('TASK_CALLBACK_FAILED'), onError));
+    }
+    catch { reportTaskError(new TaskError('TASK_CALLBACK_FAILED'), onError); }
+  };
+  const fail = (error: TaskError) => {
+    if (stopped) return;
+    stop();
+    reportTaskError(error, onError);
+  };
+  try {
+    const subscription = start(value => {
+      if (stopped) return;
+      let task: T;
+      try { task = decode(value); }
+      catch (error) {
+        fail(new TaskError(error instanceof TaskError ? error.code : 'INVALID_TASK_RESPONSE'));
+        return;
+      }
+      if (ready) emit(task);
+      else buffered.push(task);
+    }, () => fail(new TaskError('TASK_SUBSCRIPTION_FAILED')));
+    if (subscription instanceof Promise) {
+      void Promise.resolve<unknown>(subscription).catch(() => {});
+      throw new TaskError('TASK_SUBSCRIPTION_FAILED');
+    }
+    cleanup = typeof subscription === 'function'
+      ? () => { const result: unknown = Reflect.apply(subscription, undefined, []); return result; }
+      : taskHandleMethod(subscription, 'unsubscribe');
+    if (stopped) release();
+    else {
+      ready = true;
+      for (const task of buffered) emit(task);
+      buffered.length = 0;
+    }
+  } catch {
+    stop();
+    throw new TaskError('TASK_SUBSCRIPTION_FAILED');
+  }
+  return stop;
+}

package/src/theme.svelte.ts

@@ -1,14 +1,15 @@
+import { definedOptions } from './defined-options';
 // Theme — dark/light/system mode + color theme management (Svelte 5 runes)
 //
 // Supports two class strategies:
 //   - 'standard' (default): adds 'dark' class for dark mode (light-first)
 //   - 'dark-first': adds 'light' class for light mode (dark-first)
 
-export type ThemeMode = 'light' | 'dark' | 'system';
-export type ColorTheme = 'blue' | 'green' | 'rose' | 'orange' | 'violet' | 'neutral';
+export type ThemeMode='light'|'dark'|'system';
+export type ColorTheme='blue'|'green'|'rose'|'orange'|'violet'|'neutral';
 
 /** Controls how the theme class is applied to <html> */
-export type ThemeStrategy = 'standard' | 'dark-first';
+export type ThemeStrategy='standard'|'dark-first';
 
 // ── Color Preset System ──────────────────────────────────
 
@@ -21,13 +22,13 @@ export interface ColorPreset {
   /** Preview swatch color (hex) for UI pickers */
   color: string;
   /** CSS variable overrides for light mode */
-  light: Record<string, string>;
+  light: Record<string,string>;
   /** CSS variable overrides for dark mode */
-  dark: Record<string, string>;
+  dark: Record<string,string>;
 }
 
 /** Built-in color presets — consumers can extend via registerColorPreset(). */
-export const builtinPresets: Record<string, ColorPreset> = $state({
+export const builtinPresets: Record<string,ColorPreset>=$state({
   neutral: {
     name: 'neutral',
     label: 'Neutral',
@@ -193,12 +194,12 @@ export const builtinPresets: Record<string, ColorPreset> = $state({
 
 /** Register a custom color preset. Overwrites any built-in preset with the same name. */
 export function registerColorPreset(preset: ColorPreset): void {
-  builtinPresets[preset.name] = preset;
+  builtinPresets[preset.name]=preset;
 }
 
 /** Resolve a preset by name or return the preset object directly. */
-function resolvePreset(preset: ColorPreset | string): ColorPreset | undefined {
-  if (typeof preset === 'string') return builtinPresets[preset];
+function resolvePreset(preset: ColorPreset|string): ColorPreset|undefined {
+  if(typeof preset==='string') return builtinPresets[preset];
   return preset;
 }
 
@@ -211,13 +212,13 @@ export interface ThemeConfig {
   /** Class strategy: 'standard' toggles '.dark', 'dark-first' toggles '.light' */
   strategy?: ThemeStrategy;
   /** Custom CSS variables to inject as overrides on <html> */
-  cssOverrides?: Record<string, string>;
+  cssOverrides?: Record<string,string>;
   /** Whether to disable the built-in color-scheme attribute */
   disableColorScheme?: boolean;
   /** Built-in color preset name (e.g. 'indigo', 'blue') or a custom ColorPreset object */
-  colorPreset?: ColorPreset | string;
+  colorPreset?: ColorPreset|string;
   /** Layout style option: 'default' or 'clean-flat' for high-contrast flat panel design */
-  layoutPreset?: 'default' | 'clean-flat';
+  layoutPreset?: 'default'|'clean-flat';
 }
 
 /** Explicit document-level values contributed by one mounted AdminApp. */
@@ -227,22 +228,22 @@ export interface ThemeOwnerOptions {
 }
 
 /** Opaque identity used to update or unregister a mounted theme owner. */
-export type ThemeOwnerToken = symbol;
+export type ThemeOwnerToken=symbol;
 
-const STORAGE_KEY = 'svadmin-theme';
-const COLOR_STORAGE_KEY = 'svadmin-color-theme';
+const STORAGE_KEY='svadmin-theme';
+const COLOR_STORAGE_KEY='svadmin-color-theme';
 
 interface ThemeOwnerEntry {
   token: ThemeOwnerToken;
   options: ThemeOwnerOptions;
 }
 
-let legacyThemeConfig: ThemeConfig = {};
-let themeConfig: ThemeConfig = {};
-let themeOwners: ThemeOwnerEntry[] = [];
-let activePresetVars: string[] = [];
-let activeCssOverrideVars: string[] = [];
-let colorSelectionOverridesConfig = false;
+let legacyThemeConfig: ThemeConfig={};
+let themeConfig: ThemeConfig={};
+let themeOwners: ThemeOwnerEntry[]=[];
+let activePresetVars: string[]=[];
+let activeCssOverrideVars: string[]=[];
+let colorSelectionOverridesConfig=false;
 
 function cloneColorPreset(preset: ColorPreset): ColorPreset {
   return {
@@ -252,36 +253,36 @@ function cloneColorPreset(preset: ColorPreset): ColorPreset {
   };
 }
 
-function cloneThemeConfig(config: ThemeConfig = {}): ThemeConfig {
-  const cloned = { ...config };
-  if (config.cssOverrides) cloned.cssOverrides = { ...config.cssOverrides };
-  if (typeof config.colorPreset === 'object') cloned.colorPreset = cloneColorPreset(config.colorPreset);
+function cloneThemeConfig(config: ThemeConfig={}): ThemeConfig {
+  const cloned={ ...config };
+  if(config.cssOverrides) cloned.cssOverrides={ ...config.cssOverrides };
+  if(typeof config.colorPreset==='object') cloned.colorPreset=cloneColorPreset(config.colorPreset);
   return cloned;
 }
 
 function cloneOwnerOptions(options: ThemeOwnerOptions): ThemeOwnerOptions {
-  return {
+  return definedOptions({
     defaultTheme: options.defaultTheme,
-    themeConfig: options.themeConfig === undefined
+    themeConfig: options.themeConfig===undefined
       ? undefined
-      : cloneThemeConfig(options.themeConfig),
-  };
+      :cloneThemeConfig(options.themeConfig),
+  });
 }
 
 function isExplicitOwner(options: ThemeOwnerOptions): boolean {
-  return options.themeConfig !== undefined || options.defaultTheme !== undefined;
+  return options.themeConfig!==undefined||options.defaultTheme!==undefined;
 }
 
-function getActiveOwner(): ThemeOwnerEntry | undefined {
-  for (let index = themeOwners.length - 1; index >= 0; index -= 1) {
-    const owner = themeOwners[index];
-    if (isExplicitOwner(owner.options)) return owner;
+function getActiveOwner(): ThemeOwnerEntry|undefined {
+  for(let index=themeOwners.length-1;index>=0;index-=1) {
+    const owner=themeOwners[index];
+    if(owner&&isExplicitOwner(owner.options)) return owner;
   }
   return undefined;
 }
 
-function getStorage(): Storage | undefined {
-  if (typeof window === 'undefined') return undefined;
+function getStorage(): Storage|undefined {
+  if(typeof window==='undefined') return undefined;
   try {
     return window.localStorage;
   } catch {
@@ -289,115 +290,115 @@ function getStorage(): Storage | undefined {
   }
 }
 
-function readStoredTheme(): ThemeMode | undefined {
-  const stored = getStorage()?.getItem(STORAGE_KEY);
-  return stored === 'light' || stored === 'dark' || stored === 'system' ? stored : undefined;
+function readStoredTheme(): ThemeMode|undefined {
+  const stored=getStorage()?.getItem(STORAGE_KEY);
+  return stored==='light'||stored==='dark'||stored==='system'? stored:undefined;
 }
 
 function readStoredColorTheme(): ColorTheme {
-  const stored = getStorage()?.getItem(COLOR_STORAGE_KEY);
-  return stored && builtinPresets[stored] ? stored as ColorTheme : 'blue';
+  const stored=getStorage()?.getItem(COLOR_STORAGE_KEY);
+  return stored&&builtinPresets[stored]? stored as ColorTheme:'blue';
 }
 
-function persistSelection(key: string, value: string): void {
-  const storage = getStorage();
-  if (!storage || storage.getItem(key) === value) return;
-  storage.setItem(key, value);
+function persistSelection(key: string,value: string): void {
+  const storage=getStorage();
+  if(!storage||storage.getItem(key)===value) return;
+  storage.setItem(key,value);
 }
 
-let selectedMode = readStoredTheme();
-let mode = $state<ThemeMode>(selectedMode ?? 'system');
-const initialColorTheme = readStoredColorTheme();
-let selectedColorTheme = $state<ColorTheme>(initialColorTheme);
-let colorTheme = $state<ColorTheme>(initialColorTheme);
+let selectedMode=readStoredTheme();
+let mode=$state<ThemeMode>(selectedMode??'system');
+const initialColorTheme=readStoredColorTheme();
+let selectedColorTheme=$state<ColorTheme>(initialColorTheme);
+let colorTheme=$state<ColorTheme>(initialColorTheme);
 
-function getSystemPreference(): 'light' | 'dark' {
-  if (typeof window === 'undefined' || typeof window.matchMedia !== 'function') return 'light';
-  return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
+function getSystemPreference(): 'light'|'dark' {
+  if(typeof window==='undefined'||typeof window.matchMedia!=='function') return 'light';
+  return window.matchMedia('(prefers-color-scheme: dark)').matches? 'dark':'light';
 }
 
 function removeCssProperties(keys: string[]): void {
-  if (typeof document === 'undefined') return;
-  const root = document.documentElement;
-  for (const key of keys) root.style.removeProperty(key);
+  if(typeof document==='undefined') return;
+  const root=document.documentElement;
+  for(const key of keys) root.style.removeProperty(key);
 }
 
 function clearAppliedArtifacts(): void {
-  if (typeof document === 'undefined') return;
-  const root = document.documentElement;
+  if(typeof document==='undefined') return;
+  const root=document.documentElement;
 
   removeCssProperties(activeCssOverrideVars);
   removeCssProperties(activePresetVars);
-  activeCssOverrideVars = [];
-  activePresetVars = [];
-  root.classList.remove('layout-clean-flat', 'light', 'dark');
+  activeCssOverrideVars=[];
+  activePresetVars=[];
+  root.classList.remove('layout-clean-flat','light','dark');
   root.style.removeProperty('color-scheme');
   root.removeAttribute('data-theme');
 }
 
-function applyThemeClasses(themeMode: ThemeMode, config: ThemeConfig): void {
-  if (typeof document === 'undefined') return;
-  const resolved = themeMode === 'system' ? getSystemPreference() : themeMode;
-  const strategy = config.strategy ?? 'standard';
-  const root = document.documentElement;
+function applyThemeClasses(themeMode: ThemeMode,config: ThemeConfig): void {
+  if(typeof document==='undefined') return;
+  const resolved=themeMode==='system'? getSystemPreference():themeMode;
+  const strategy=config.strategy??'standard';
+  const root=document.documentElement;
 
-  root.classList.toggle('layout-clean-flat', config.layoutPreset === 'clean-flat');
-  if (strategy === 'dark-first') {
-    root.classList.toggle('light', resolved === 'light');
+  root.classList.toggle('layout-clean-flat',config.layoutPreset==='clean-flat');
+  if(strategy==='dark-first') {
+    root.classList.toggle('light',resolved==='light');
     root.classList.remove('dark');
   } else {
-    root.classList.toggle('dark', resolved === 'dark');
+    root.classList.toggle('dark',resolved==='dark');
     root.classList.remove('light');
   }
 
-  if (!config.disableColorScheme) root.style.colorScheme = resolved;
+  if(!config.disableColorScheme) root.style.colorScheme=resolved;
 }
 
-function applyColorPreset(preset: ColorPreset, themeMode: ThemeMode): void {
-  if (typeof document === 'undefined') return;
-  const resolved = themeMode === 'system' ? getSystemPreference() : themeMode;
-  const variables = resolved === 'dark' ? preset.dark : preset.light;
-  const root = document.documentElement;
+function applyColorPreset(preset: ColorPreset,themeMode: ThemeMode): void {
+  if(typeof document==='undefined') return;
+  const resolved=themeMode==='system'? getSystemPreference():themeMode;
+  const variables=resolved==='dark'? preset.dark:preset.light;
+  const root=document.documentElement;
 
-  for (const [key, value] of Object.entries(variables)) {
-    const cssVar = key.startsWith('--') ? key : '--' + key;
-    root.style.setProperty(cssVar, value);
+  for(const [key,value] of Object.entries(variables)) {
+    const cssVar=key.startsWith('--')? key:'--'+key;
+    root.style.setProperty(cssVar,value);
     activePresetVars.push(cssVar);
   }
 }
 
-function applyCssOverrides(overrides: Record<string, string>): void {
-  if (typeof document === 'undefined') return;
-  const root = document.documentElement;
+function applyCssOverrides(overrides: Record<string,string>): void {
+  if(typeof document==='undefined') return;
+  const root=document.documentElement;
 
-  for (const [key, value] of Object.entries(overrides)) {
-    const cssVar = key.startsWith('--') ? key : '--' + key;
-    root.style.setProperty(cssVar, value);
+  for(const [key,value] of Object.entries(overrides)) {
+    const cssVar=key.startsWith('--')? key:'--'+key;
+    root.style.setProperty(cssVar,value);
     activeCssOverrideVars.push(cssVar);
   }
 }
 
 function applyEffectiveTheme(): void {
-  const owner = getActiveOwner();
-  const nextConfig = owner
+  const owner=getActiveOwner();
+  const nextConfig=owner
     ? cloneThemeConfig(owner.options.themeConfig)
-    : cloneThemeConfig(legacyThemeConfig);
-  const nextMode = selectedMode ?? owner?.options.defaultTheme ?? 'system';
-  const configuredPreset = !colorSelectionOverridesConfig && nextConfig.colorPreset
+    :cloneThemeConfig(legacyThemeConfig);
+  const nextMode=selectedMode??owner?.options.defaultTheme??'system';
+  const configuredPreset=!colorSelectionOverridesConfig&&nextConfig.colorPreset
     ? resolvePreset(nextConfig.colorPreset)
-    : undefined;
-  const preset = configuredPreset ?? builtinPresets[selectedColorTheme];
+    :undefined;
+  const preset=configuredPreset??builtinPresets[selectedColorTheme];
 
-  themeConfig = nextConfig;
-  mode = nextMode;
-  colorTheme = (preset?.name ?? selectedColorTheme) as ColorTheme;
+  themeConfig=nextConfig;
+  mode=nextMode;
+  colorTheme=(preset?.name??selectedColorTheme) as ColorTheme;
 
-  if (typeof document === 'undefined') return;
+  if(typeof document==='undefined') return;
   clearAppliedArtifacts();
-  applyThemeClasses(mode, themeConfig);
-  document.documentElement.setAttribute('data-theme', colorTheme);
-  if (preset) applyColorPreset(preset, mode);
-  if (themeConfig.cssOverrides) applyCssOverrides(themeConfig.cssOverrides);
+  applyThemeClasses(mode,themeConfig);
+  document.documentElement.setAttribute('data-theme',colorTheme);
+  if(preset) applyColorPreset(preset,mode);
+  if(themeConfig.cssOverrides) applyCssOverrides(themeConfig.cssOverrides);
 }
 
 /**
@@ -405,9 +406,9 @@ function applyEffectiveTheme(): void {
  * mounted explicit owners continue to take precedence until they unregister.
  */
 export function configureTheme(config: ThemeConfig): void {
-  legacyThemeConfig = cloneThemeConfig(config);
-  colorSelectionOverridesConfig = false;
-  if (!getActiveOwner()) applyEffectiveTheme();
+  legacyThemeConfig=cloneThemeConfig(config);
+  colorSelectionOverridesConfig=false;
+  if(!getActiveOwner()) applyEffectiveTheme();
 }
 
 /** Get current effective theme configuration. */
@@ -417,18 +418,18 @@ export function getThemeConfig(): ThemeConfig {
 
 /** Remove previously applied CSS overrides. */
 export function clearCssOverrides(keys?: string[]): void {
-  if (typeof document === 'undefined') return;
-  const root = document.documentElement;
+  if(typeof document==='undefined') return;
+  const root=document.documentElement;
 
-  if (keys) {
-    for (const key of keys) {
-      const cssVar = key.startsWith('--') ? key : '--' + key;
+  if(keys) {
+    for(const key of keys) {
+      const cssVar=key.startsWith('--')? key:'--'+key;
       root.style.removeProperty(cssVar);
-      activeCssOverrideVars = activeCssOverrideVars.filter((activeKey) => activeKey !== cssVar);
+      activeCssOverrideVars=activeCssOverrideVars.filter((activeKey) => activeKey!==cssVar);
     }
   } else {
     removeCssProperties(activeCssOverrideVars);
-    activeCssOverrideVars = [];
+    activeCssOverrideVars=[];
   }
 }
 
@@ -445,19 +446,19 @@ export function getTheme(): ThemeMode {
 }
 
 export function setTheme(newMode: ThemeMode): void {
-  selectedMode = newMode;
-  persistSelection(STORAGE_KEY, newMode);
+  selectedMode=newMode;
+  persistSelection(STORAGE_KEY,newMode);
   applyEffectiveTheme();
 }
 
 export function toggleTheme(): void {
-  const resolved = mode === 'system' ? getSystemPreference() : mode;
-  setTheme(resolved === 'dark' ? 'light' : 'dark');
+  const resolved=mode==='system'? getSystemPreference():mode;
+  setTheme(resolved==='dark'? 'light':'dark');
 }
 
 /** Resolved theme (always 'light' or 'dark', never 'system'). */
-export function getResolvedTheme(): 'light' | 'dark' {
-  return mode === 'system' ? getSystemPreference() : mode;
+export function getResolvedTheme(): 'light'|'dark' {
+  return mode==='system'? getSystemPreference():mode;
 }
 
 export function getColorTheme(): ColorTheme {
@@ -465,9 +466,9 @@ export function getColorTheme(): ColorTheme {
 }
 
 export function setColorTheme(nextColorTheme: ColorTheme): void {
-  selectedColorTheme = nextColorTheme;
-  colorSelectionOverridesConfig = true;
-  persistSelection(COLOR_STORAGE_KEY, nextColorTheme);
+  selectedColorTheme=nextColorTheme;
+  colorSelectionOverridesConfig=true;
+  persistSelection(COLOR_STORAGE_KEY,nextColorTheme);
   applyEffectiveTheme();
 }
 
@@ -475,15 +476,15 @@ export function setColorTheme(nextColorTheme: ColorTheme): void {
  * Register a browser-only document owner. Owners with omitted values remain
  * inert, allowing a mounted AdminApp to activate the same token after prop updates.
  */
-export function registerThemeOwner(options: ThemeOwnerOptions): ThemeOwnerToken | undefined {
-  if (typeof window === 'undefined' || typeof document === 'undefined') return undefined;
+export function registerThemeOwner(options: ThemeOwnerOptions): ThemeOwnerToken|undefined {
+  if(typeof window==='undefined'||typeof document==='undefined') return undefined;
 
-  const token = Symbol('svadmin-theme-owner');
-  const entry = { token, options: cloneOwnerOptions(options) };
+  const token=Symbol('svadmin-theme-owner');
+  const entry={ token,options: cloneOwnerOptions(options) };
   themeOwners.push(entry);
 
-  if (isExplicitOwner(entry.options)) {
-    colorSelectionOverridesConfig = false;
+  if(isExplicitOwner(entry.options)) {
+    colorSelectionOverridesConfig=false;
     applyEffectiveTheme();
   }
 
@@ -492,52 +493,52 @@ export function registerThemeOwner(options: ThemeOwnerOptions): ThemeOwnerToken
 
 /** Update one mounted owner without changing its stack order. */
 export function updateThemeOwner(
-  token: ThemeOwnerToken | undefined,
+  token: ThemeOwnerToken|undefined,
   options: ThemeOwnerOptions,
 ): void {
-  if (!token || typeof window === 'undefined' || typeof document === 'undefined') return;
-  const owner = themeOwners.find((entry) => entry.token === token);
-  if (!owner) return;
-
-  const wasExplicit = isExplicitOwner(owner.options);
-  owner.options = cloneOwnerOptions(options);
-  if (wasExplicit || isExplicitOwner(owner.options)) {
-    colorSelectionOverridesConfig = false;
+  if(!token||typeof window==='undefined'||typeof document==='undefined') return;
+  const owner=themeOwners.find((entry) => entry.token===token);
+  if(!owner) return;
+
+  const wasExplicit=isExplicitOwner(owner.options);
+  owner.options=cloneOwnerOptions(options);
+  if(wasExplicit||isExplicitOwner(owner.options)) {
+    colorSelectionOverridesConfig=false;
     applyEffectiveTheme();
   }
 }
 
 /** Remove an owner safely regardless of its position in the stack. */
-export function unregisterThemeOwner(token: ThemeOwnerToken | undefined): void {
-  if (!token || typeof window === 'undefined' || typeof document === 'undefined') return;
-  const index = themeOwners.findIndex((entry) => entry.token === token);
-  if (index === -1) return;
-
-  const [removed] = themeOwners.splice(index, 1);
-  if (isExplicitOwner(removed.options)) {
-    colorSelectionOverridesConfig = false;
+export function unregisterThemeOwner(token: ThemeOwnerToken|undefined): void {
+  if(!token||typeof window==='undefined'||typeof document==='undefined') return;
+  const index=themeOwners.findIndex((entry) => entry.token===token);
+  if(index===-1) return;
+
+  const [removed]=themeOwners.splice(index,1);
+  if(removed&&isExplicitOwner(removed.options)) {
+    colorSelectionOverridesConfig=false;
     applyEffectiveTheme();
   }
 }
 
 export function resetTheme(): void {
-  selectedMode = readStoredTheme();
-  selectedColorTheme = readStoredColorTheme();
-  mode = selectedMode ?? 'system';
-  colorTheme = selectedColorTheme;
-  legacyThemeConfig = {};
-  themeConfig = {};
-  themeOwners = [];
-  colorSelectionOverridesConfig = false;
+  selectedMode=readStoredTheme();
+  selectedColorTheme=readStoredColorTheme();
+  mode=selectedMode??'system';
+  colorTheme=selectedColorTheme;
+  legacyThemeConfig={};
+  themeConfig={};
+  themeOwners=[];
+  colorSelectionOverridesConfig=false;
   applyEffectiveTheme();
 }
 
-if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+if(typeof window!=='undefined'&&typeof document!=='undefined') {
   applyEffectiveTheme();
 
-  if (typeof window.matchMedia === 'function') {
-    window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', () => {
-      if (mode === 'system') applyEffectiveTheme();
+  if(typeof window.matchMedia==='function') {
+    window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change',() => {
+      if(mode==='system') applyEffectiveTheme();
     });
   }
 }