zova-core 5.1.89 → 5.1.90

package/dist/index.js

@@ -927,7 +927,7 @@ class BeanBase extends BeanBaseSimple {
   }
   $controllerMounted(fn) {
     return this.ctx.util.instanceScope(() => {
-      return this.ctx.meta.hooks.onMounted(fn);
+      return this.ctx.meta.hooks.onMounted(fn, this);
     });
   }
   $customRef(factory) {
@@ -1187,26 +1187,64 @@ class BeanContainer {
   /** @internal */
   dispose() {
     const beanInstances = this[SymbolBeanContainerInstances];
-    for (const prop in beanInstances) {
-      if (prop.startsWith('$$')) continue;
-      const beanInstance = cast(beanInstances[prop]);
-      if (beanInstance && !(beanInstance instanceof BeanAopBase) && beanInstance.__dispose__) {
-        if (this.containerType === 'sys') {
-          this.sys.meta.module._monkeyModuleSync(false, 'beanDispose', undefined, this, beanInstance);
-          beanInstance.__dispose__();
-          this.sys.meta.module._monkeyModuleSync(false, 'beanDisposed', undefined, this, beanInstance);
-        } else {
-          this.app.meta.module._monkeyModuleSync(false, 'beanDispose', undefined, this, beanInstance);
+    let error;
+    try {
+      for (const prop in beanInstances) {
+        if (prop.startsWith('$$')) continue;
+        const beanInstance = cast(beanInstances[prop]);
+        if (!beanInstance || beanInstance instanceof BeanAopBase || !beanInstance.__dispose__) continue;
+        try {
+          if (this.containerType === 'sys') {
+            this.sys.meta.module._monkeyModuleSync(false, 'beanDispose', undefined, this, beanInstance);
+            beanInstance.__dispose__();
+            this.sys.meta.module._monkeyModuleSync(false, 'beanDisposed', undefined, this, beanInstance);
+          } else {
+            this.app.meta.module._monkeyModuleSync(false, 'beanDispose', undefined, this, beanInstance);
+            this.runWithInstanceScopeOrAppContext(() => {
+              return beanInstance.__dispose__();
+            });
+            this.app.meta.module._monkeyModuleSync(false, 'beanDisposed', undefined, this, beanInstance);
+          }
+        } catch (err) {
+          error ??= err;
+        }
+      }
+    } finally {
+      this[SymbolBeanContainerInstances] = shallowReactive({});
+      this[SymbolBeanContainerParent] = undefined;
+      this[SymbolGetBeanSelectorInnerPromises] = {};
+    }
+    // eslint-disable no-throw-literal
+    if (error) throw error;
+  }
+
+  /** @internal */
+  retryReset(ownedBeans) {
+    const beanInstances = this[SymbolBeanContainerInstances];
+    let error;
+    try {
+      for (const prop in beanInstances) {
+        const beanInstance = cast(beanInstances[prop]);
+        if (!ownedBeans.has(beanInstance)) continue;
+        if (!beanInstance || beanInstance instanceof BeanAopBase || !beanInstance.__dispose__) continue;
+        try {
           this.runWithInstanceScopeOrAppContext(() => {
             return beanInstance.__dispose__();
           });
-          this.app.meta.module._monkeyModuleSync(false, 'beanDisposed', undefined, this, beanInstance);
+        } catch (err) {
+          error ??= err;
+        }
+      }
+    } finally {
+      for (const prop in beanInstances) {
+        if (ownedBeans.has(cast(beanInstances[prop]))) {
+          delete beanInstances[prop];
         }
       }
+      this[SymbolGetBeanSelectorInnerPromises] = {};
     }
-    this[SymbolBeanContainerInstances] = shallowReactive({});
-    this[SymbolBeanContainerParent] = undefined;
-    this[SymbolGetBeanSelectorInnerPromises] = {};
+    // eslint-disable no-throw-literal
+    if (error) throw error;
   }
   get containerType() {
     if (!this.ctx) return 'sys';
@@ -1348,7 +1386,7 @@ class BeanContainer {
     return this[SymbolBeanContainerInstances][key];
   }
   async _getBeanSelectorInnerPromise(recordProp, fullName, markReactive, withSelector, ...args) {
-    return await this._newBeanInner(true, recordProp, null, fullName, markReactive, withSelector, ...args);
+    return await this._newBeanInner(true, recordProp, null, fullName, markReactive, withSelector, undefined, ...args);
   }
   _newBeanSimple(A, markReactive, ...args) {
     // prepare
@@ -1362,7 +1400,7 @@ class BeanContainer {
   }
   // async _newBean<T>(beanFullName: string, markReactive?: boolean, ...args): Promise<T>;
   async _newBean(beanFullName, markReactive, ...args) {
-    return await this._newBeanInner(false, null, null, beanFullName, markReactive, false, ...args);
+    return await this._newBeanInner(false, null, null, beanFullName, markReactive, false, undefined, ...args);
   }
   // async _newBeanSelector<T>(beanFullName: string, markReactive?: boolean, selector?: string, ...args): Promise<T>;
   async _newBeanSelector(beanFullName, markReactive, selector, ...args) {
@@ -1370,13 +1408,13 @@ class BeanContainer {
   }
 
   /** @internal */
-  async _newBeanInner(record, recordProp, controllerData, beanFullName, markReactive, withSelector, ...args) {
+  async _newBeanInner(record, recordProp, controllerData, beanFullName, markReactive, withSelector, onBeanRecorded, ...args) {
     // bean options
     const beanOptions = await this._getBeanOptionsForce(beanFullName);
     if (!beanOptions) {
       // class
       if (typeof beanFullName === 'function' && isClass(beanFullName)) {
-        return await this._createBeanInstance(record, recordProp, controllerData, undefined, beanFullName, args, false, markReactive, withSelector);
+        return await this._createBeanInstance(record, recordProp, controllerData, undefined, beanFullName, args, false, markReactive, withSelector, onBeanRecorded);
       }
       // throw new Error(`bean not found: ${beanFullName}`);
       return null;
@@ -1384,7 +1422,7 @@ class BeanContainer {
     // beanFullName
     return await this._createBeanInstance(record, recordProp, controllerData, beanOptions.beanFullName, beanOptions.beanClass, args, cast(beanOptions.scene) === 'aop',
     // default is true: same as inject prop
-    markReactive ?? beanOptions.markReactive ?? true, withSelector);
+    markReactive ?? beanOptions.markReactive ?? true, withSelector, onBeanRecorded);
   }
   _getBeanFullNameByComposableOrClassSync(beanFullName) {
     // bean options
@@ -1424,7 +1462,7 @@ class BeanContainer {
     // get
     return appResource.getBean(beanFullName);
   }
-  async _createBeanInstance(record, recordProp, controllerData, beanFullName, beanClass, args, aop, markReactive, withSelector) {
+  async _createBeanInstance(record, recordProp, controllerData, beanFullName, beanClass, args, aop, markReactive, withSelector, onBeanRecorded) {
     // prepare
     const beanInstance = await this._prepareBeanInstance(beanFullName, beanClass, args, markReactive, aop);
     // special for controller
@@ -1444,6 +1482,7 @@ class BeanContainer {
       if (recordProp) {
         this.__recordProp(recordProp, fullName, beanInstance, true);
       }
+      onBeanRecorded?.(beanInstance);
     }
     // init
     await this._initBeanInstance(beanFullName, beanInstance, args);
@@ -1640,7 +1679,7 @@ class BeanContainer {
       targetInstance = await this._getBeanSelectorInner(true, recordProp, targetBeanFullName, markReactive, selectorInfo.withSelector, ...selectorInfo.args);
     } else if (injectionScope === 'new') {
       // not record prop
-      targetInstance = await this._newBeanInner(false, null, null, targetBeanFullName, markReactive, selectorInfo.withSelector, ...selectorInfo.args);
+      targetInstance = await this._newBeanInner(false, null, null, targetBeanFullName, markReactive, selectorInfo.withSelector, undefined, ...selectorInfo.args);
     }
     return targetInstance;
   }
@@ -2448,7 +2487,8 @@ function configDefault(env) {
       flavor: env.META_FLAVOR,
       mode: env.META_MODE,
       appMode: env.META_APP_MODE
-    }
+    },
+    boundary: {}
   };
   return config;
 }
@@ -3476,6 +3516,112 @@ const ClientOnly = defineComponent({
   }
 });
 
+class AppError extends ErrorClass {
+  /** @internal */
+  async initialize() {
+    await super.initialize();
+    // errorHandler
+    this.app.vue.config.errorHandler = (err, instance, info) => {
+      return this._handleError(err, instance, info);
+    };
+    // unhandledrejection
+    if (process.env.CLIENT) {
+      window.addEventListener('unhandledrejection', event => {
+        event.preventDefault();
+        this._handleUnhandledError(event.reason, 'unhandledrejection');
+        return false;
+      });
+      window.addEventListener('error', event => {
+        event.preventDefault();
+        this._handleUnhandledError(event.error, 'unhandlederror');
+        return false;
+      });
+    }
+  }
+
+  /** @internal */
+  createScopeError(moduleScope, errorCode) {
+    const self = this;
+    return {
+      throw: (...args) => {
+        return self.throw(moduleScope, errorCode, ...args);
+      },
+      parseFail: (...args) => {
+        return self.parseFail(moduleScope, errorCode, ...args);
+      }
+    };
+  }
+  handleLoadError(originalError, ctx, instance) {
+    const err = normalizeError(originalError);
+    const load = {
+      kind: 'controller-load',
+      ctx,
+      originalError,
+      disposition: 'fallback'
+    };
+    this._handleError(err, instance, 'useController:load', load);
+    return {
+      err,
+      disposition: load.disposition
+    };
+  }
+  _handleUnhandledError(error, infoDefault) {
+    if (error instanceof Error) {
+      const errorInfo = error[SymbolErrorInstanceInfo];
+      if (errorInfo) {
+        delete error[SymbolErrorInstanceInfo];
+      }
+      // should not catch error
+      this.app.vue.config.errorHandler(error, errorInfo?.instance, errorInfo?.info || infoDefault);
+    }
+  }
+  _handleError(err, instance, info, load) {
+    if (!this.app) {
+      // means destroyed
+      console.error(err);
+      return;
+    }
+    const err2 = this.app.meta.event.emitSync('app:errorHandler', {
+      err: err,
+      instance,
+      info,
+      load
+    }, data => {
+      return data.err;
+    });
+    // only log error in client
+    if (process.env.CLIENT) {
+      if (!err2 || !(err2 instanceof Error)) return err2;
+      console.error(err2);
+    }
+    return err2;
+  }
+}
+function normalizeError(error) {
+  if (error instanceof Error) return error;
+  const normalized = new Error(getErrorMessage(error));
+  if (error && (typeof error === 'object' || typeof error === 'function')) {
+    for (const key of ['code', 'status', 'pagePath', 'url']) {
+      const descriptor = Object.getOwnPropertyDescriptor(error, key);
+      if (!descriptor || !('value' in descriptor)) continue;
+      const value = descriptor.value;
+      if ((key === 'code' || key === 'status') && (typeof value === 'number' || typeof value === 'string')) {
+        normalized[key] = value;
+      }
+      if ((key === 'pagePath' || key === 'url') && typeof value === 'string') {
+        normalized[key] = value;
+      }
+    }
+  }
+  return normalized;
+}
+function getErrorMessage(error) {
+  if (error === null || error === undefined || typeof error === 'string' || typeof error === 'number' || typeof error === 'boolean' || typeof error === 'bigint' || typeof error === 'symbol') {
+    return String(error);
+  }
+  return 'Unknown error';
+}
+
 const SymbolTypeSSRRenderOriginal = Symbol('SymbolTypeSSRRenderOriginal');
 const SymbolTypeSSRRenderResetCount = Symbol('SymbolTypeSSRRenderResetCount');
 class CtxComponent extends BeanSimple {
@@ -3494,8 +3640,12 @@ class CtxComponent extends BeanSimple {
     const self = this;
     instance[renderMethod] = function (...args) {
       if (instance.isUnmounted) return;
-      if (!self.ctx.meta.state.inited.state) {
-        return self._bean_render_original.call(this, ...args);
+      const loadStatus = self.ctx.meta.state.loadStatus;
+      if (loadStatus === 'loading') {
+        return self.ctx.meta.state.loadLoadingVisible ? self._renderLoading() : null;
+      }
+      if (loadStatus === 'error') {
+        return self._renderError(self.ctx.meta.state.loadError);
       }
       const render = self._getRender();
       if (!render) {
@@ -3549,6 +3699,28 @@ class CtxComponent extends BeanSimple {
     this._renderPatched = false;
     this._ssrRenderReset = false;
   }
+  _renderLoading() {
+    const renderMode = this.ctx.meta.state.loadRenderMode;
+    const controller = this.ctx.meta.state.loadController;
+    if (controller?.renderLoading) {
+      return controller.renderLoading(renderMode);
+    }
+    const renderLoading = this.sys.config.boundary.renderLoading;
+    return renderLoading?.(this.ctx, renderMode) ?? null;
+  }
+  _renderError(error) {
+    const renderMode = this.ctx.meta.state.loadRenderMode;
+    const retry = this.ctx.meta.state.loadRetry;
+    const controller = this.ctx.meta.state.loadController;
+    if (controller?.renderError) {
+      return controller.renderError(error, renderMode, retry);
+    }
+    const renderError = this.sys.config.boundary.renderError;
+    if (renderError) {
+      return renderError(this.ctx, error, renderMode, retry);
+    }
+    return _renderErrorDefault(error);
+  }
   _getRender() {
     const render = this.bean._getBeanSyncOnly(BeanControllerIdentifier);
     if (!render) return;
@@ -3557,6 +3729,12 @@ class CtxComponent extends BeanSimple {
     return this.bean._getBeanSyncOnly(BeanRenderIdentifier);
   }
 }
+function _renderErrorDefault(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
 
 const SymbolHooksFns = Symbol('SymbolHooksFns');
 const SymbolHooksState = Symbol('SymbolHooksState');
@@ -3573,9 +3751,19 @@ class CtxHooks extends BeanSimple {
   onCreated(fn) {
     this._onHook('created', fn);
   }
-  onMounted(fn) {
+  onMounted(fn, owner) {
+    if (owner && !this.ctx.meta.state.isLoadBeanActive(owner)) return;
     this._onHook('mounted', fn);
   }
+
+  /** @internal */
+  onHydrated(fn) {
+    this._onHook('hydrated', fn);
+  }
+  clearMounted() {
+    if (this[SymbolHooksState].mounted) return;
+    this[SymbolHooksFns].mounted = undefined;
+  }
   _onHook(type, fn) {
     if (this[SymbolHooksState][type]) {
       this.ctx.util.instanceScope(fn);
@@ -3605,17 +3793,142 @@ class CtxState extends BeanSimple {
     super(...args);
     this._id = void 0;
     this._inited = void 0;
+    this._loadStatus = 'loading';
+    this._loadRenderMode = 'block';
+    this._loadRetryEnabled = false;
+    this._loadRetryReady = false;
+    this._loadRetry = void 0;
+    this._loadAttemptId = 0;
+    this._loadBeanAttempts = new WeakMap();
+    this._loadError = void 0;
+    this._loadController = void 0;
+    /** @internal SSR hydration protocol key. */
+    this.controllerLoadKey = void 0;
+    this._loadLoadingVisible = false;
+    this._loadLoadingTimer = void 0;
   }
   __init__() {
     this._id = ++__id;
     this._inited = StateLock.create();
   }
+
+  /** @internal */
+  dispose() {
+    this._clearLoadLoadingTimer();
+  }
   get id() {
     return this._id;
   }
   get inited() {
     return this._inited;
   }
+  get loadStatus() {
+    return this._loadStatus;
+  }
+  get loadRenderMode() {
+    return this._loadRenderMode;
+  }
+  get loadRetry() {
+    if (!this.isLoadRetryAvailable) return undefined;
+    return this._loadRetry;
+  }
+  get isLoadRetryAvailable() {
+    return this._loadRetryEnabled && this._loadRetryReady && this._loadStatus === 'error' && !this.ctx.disposed && !!this._loadRetry;
+  }
+  get loadAttemptId() {
+    return this._loadAttemptId;
+  }
+  get loadError() {
+    return this._loadError;
+  }
+  get loadController() {
+    return this._loadController;
+  }
+  get loadLoadingVisible() {
+    return this._loadLoadingVisible;
+  }
+  setLoadController(controller) {
+    this._loadController = controller;
+  }
+  setLoadRenderMode(renderMode) {
+    this._loadRenderMode = renderMode === 'inline' ? 'inline' : 'block';
+  }
+  setLoadRetryEnabled(retryEnabled) {
+    this._loadRetryEnabled = retryEnabled === true;
+  }
+  setLoadRetry(retry) {
+    this._loadRetry = retry;
+  }
+  setLoadRetryReady() {
+    this._loadRetryReady = true;
+  }
+  beginLoadAttempt(delay) {
+    this._clearLoadLoadingTimer();
+    this._loadAttemptId++;
+    this._loadStatus = 'loading';
+    this._loadError = undefined;
+    this._loadController = undefined;
+    this._loadLoadingVisible = false;
+    if (delay !== undefined) {
+      this.startLoadLoading(delay);
+    }
+    return this._loadAttemptId;
+  }
+  isLoadAttemptActive(attemptId) {
+    return !this.ctx.disposed && this._loadAttemptId === attemptId;
+  }
+  setLoadBeanAttempt(bean, attemptId) {
+    this._loadBeanAttempts.set(bean, attemptId);
+  }
+  getLoadBeanAttempt(bean) {
+    return this._loadBeanAttempts.get(bean);
+  }
+  isLoadBeanActive(bean) {
+    const attemptId = this._loadBeanAttempts.get(bean);
+    return attemptId === undefined || this.isLoadAttemptActive(attemptId);
+  }
+  startLoadLoading(delay) {
+    this._clearLoadLoadingTimer();
+    if (delay === 0) {
+      this._loadLoadingVisible = true;
+      return;
+    }
+    this._loadLoadingTimer = setTimeout(() => {
+      this._loadLoadingTimer = undefined;
+      if (this.ctx.disposed || this._loadStatus !== 'loading') return;
+      this._loadLoadingVisible = true;
+    }, delay);
+  }
+
+  /**
+   * Resolves the Controller-load terminal lock consumed by the custom SSR hydration runtime.
+   * A settled load is not necessarily a successful load: error and handled control-flow paths
+   * must also allow the rendered boundary subtree to hydrate.
+   */
+  settleLoad() {
+    this._inited.touch();
+  }
+  setLoadReady() {
+    this._clearLoadLoadingTimer();
+    this._loadError = undefined;
+    this._loadStatus = 'ready';
+    this.settleLoad();
+  }
+  setLoadError(error) {
+    this._clearLoadLoadingTimer();
+    this._loadError = error;
+    this._loadStatus = 'error';
+    this.settleLoad();
+  }
+  setLoadHandled() {
+    this._clearLoadLoadingTimer();
+    this.settleLoad();
+  }
+  _clearLoadLoadingTimer() {
+    if (this._loadLoadingTimer === undefined) return;
+    clearTimeout(this._loadLoadingTimer);
+    this._loadLoadingTimer = undefined;
+  }
 }
 
 class CtxMeta extends BeanSimple {
@@ -3638,6 +3951,7 @@ class CtxMeta extends BeanSimple {
 
   /** @internal */
   dispose() {
+    this.state.dispose();
     this.component.dispose();
     this.hooks.dispose();
   }
@@ -3758,6 +4072,7 @@ function useController(controllerBeanFullName, renderBeanFullName, styleBeanFull
 async function _useController(controllerData, controllerBeanFullName, renderBeanFullName, styleBeanFullName) {
   // ctx
   const ctx = new ZovaContext(getCurrentInstance());
+  setLoadBoundaryOptions(controllerBeanFullName);
   // ctx: monkey
   if (ctx.app) {
     ctx.app.meta.module._monkeyModuleSync(true, 'appContextInitialize', undefined, ctx);
@@ -3768,54 +4083,159 @@ async function _useController(controllerData, controllerBeanFullName, renderBean
   if (ctx.app) {
     ctx.app.meta.module._monkeyModuleSync(true, 'controllerDataPrepare', undefined, controllerData, ctx);
   }
-  if (process.env.CLIENT) {
-    // dispose
-    onBeforeUnmount(() => {
-      if (ctx.disposed) return;
-      // undefined better than null
-      setControllerRef(ctx, false);
-      if (ctx.bean !== ctx.app.bean) {
-        ctx.bean.dispose();
-      }
-    });
-    onUnmounted(() => {
-      ctx.dispose();
-    });
+  let retryPromise;
+  let loadBeans = new Set();
+  function setLoadBoundaryOptions(controllerBeanFullName) {
+    const boundary = controllerBeanFullName.$componentOptions?.boundary;
+    ctx.meta.state.setLoadRenderMode(boundary?.renderMode);
+    ctx.meta.state.setLoadRetryEnabled(boundary?.retry);
+  }
+  function isAttemptActive(attemptId) {
+    return ctx.meta.state.isLoadAttemptActive(attemptId);
   }
-  async function __load() {
+  function getLoadLoadingDelay() {
+    const delay = controllerBeanFullName.$componentOptions?.boundary?.loading?.delay ?? sys.config.boundary.loading?.delay;
+    const delayNumber = Number(delay);
+    return Number.isFinite(delayNumber) && delayNumber > 0 ? delayNumber : 0;
+  }
+  async function __loadBeans(attemptId) {
     // controller
-    if (ctx.disposed) return;
-    await ctx.bean._newBeanInner(true, BeanControllerIdentifier, controllerData, controllerBeanFullName, true, false);
+    if (!isAttemptActive(attemptId)) return false;
+    await ctx.bean._newBeanInner(true, BeanControllerIdentifier, controllerData, controllerBeanFullName, true, false, controller => {
+      loadBeans.add(controller);
+      ctx.meta.state.setLoadBeanAttempt(controller, attemptId);
+      if (!isAttemptActive(attemptId)) return;
+      ctx.meta.state.setLoadController(controller);
+      setLoadBoundaryOptions(controller.constructor);
+    });
+    if (!isAttemptActive(attemptId)) return false;
+    // style
     if (styleBeanFullName) {
-      if (ctx.disposed) return;
-      await ctx.bean._newBeanInner(true, BeanStyleIdentifier, undefined, styleBeanFullName, true, false);
+      await ctx.bean._newBeanInner(true, BeanStyleIdentifier, undefined, styleBeanFullName, true, false, style => {
+        loadBeans.add(style);
+        ctx.meta.state.setLoadBeanAttempt(style, attemptId);
+      });
     }
+    if (!isAttemptActive(attemptId)) return false;
+    // render
     if (renderBeanFullName) {
-      if (ctx.disposed) return;
-      await ctx.bean._newBeanInner(true, BeanRenderIdentifier, undefined, renderBeanFullName, true, false);
+      await ctx.bean._newBeanInner(true, BeanRenderIdentifier, undefined, renderBeanFullName, true, false, render => {
+        loadBeans.add(render);
+        ctx.meta.state.setLoadBeanAttempt(render, attemptId);
+      });
     }
-    // must touch inited on server/client, force router.use effect
-    if (ctx.disposed) return;
-    ctx.meta.state.inited.touch();
+    return isAttemptActive(attemptId);
+  }
+  async function __load(attemptId) {
+    if (!(await __loadBeans(attemptId))) return;
+    if (!isAttemptActive(attemptId)) return;
+    ctx.meta.state.setLoadReady();
     if (process.env.CLIENT) {
       ctx.util.instanceScope(() => {
         queuePostFlushCb(() => {
+          if (!isAttemptActive(attemptId)) return;
           setControllerRef(ctx, true);
           ctx.meta.hooks.invokeHook('mounted');
         });
       });
     }
   }
+  async function runLoadAttempt(attemptId, beforeLoad) {
+    try {
+      await beforeLoad?.();
+      if (!isAttemptActive(attemptId)) return;
+      await __load(attemptId);
+    } catch (err) {
+      if (!isAttemptActive(attemptId)) return;
+      const result = ctx.app?.meta.error.handleLoadError(err, ctx, ctx.instance) ?? {
+        err: normalizeError(err),
+        disposition: 'fallback'
+      };
+      if (!isAttemptActive(attemptId)) return;
+      if (result.disposition === 'handled') {
+        ctx.meta.state.setLoadHandled();
+        return;
+      }
+      ctx.app?.meta.module._monkeyModuleSync(true, 'controllerLoad', undefined, {
+        phase: 'fallback',
+        ctx,
+        controllerBeanFullName,
+        controllerBeanName: typeof controllerBeanFullName === 'string' ? controllerBeanFullName : controllerBeanFullName.name,
+        error: result.err,
+        controllerRecorded: !!ctx.meta.state.loadController
+      });
+      if (!isAttemptActive(attemptId)) return;
+      ctx.meta.state.setLoadError(result.err);
+    }
+  }
+  function retry() {
+    if (!ctx.meta.state.isLoadRetryAvailable) return Promise.resolve();
+    if (retryPromise) return retryPromise;
+    const promise = (async () => {
+      const attemptId = ctx.meta.state.beginLoadAttempt(getLoadLoadingDelay());
+      const previousLoadBeans = loadBeans;
+      loadBeans = new Set();
+      ctx.meta.hooks.clearMounted();
+      setControllerRef(ctx, false);
+      await runLoadAttempt(attemptId, () => {
+        ctx.bean.retryReset(previousLoadBeans);
+      });
+    })();
+    retryPromise = promise;
+    void promise.finally(() => {
+      if (retryPromise === promise) {
+        retryPromise = undefined;
+      }
+    });
+    return promise;
+  }
+  ctx.meta.state.setLoadRetry(retry);
+  if (process.env.CLIENT) {
+    ctx.meta.hooks.onHydrated(() => {
+      if (!ctx.disposed) {
+        ctx.meta.state.setLoadRetryReady();
+      }
+    });
+    // dispose
+    onBeforeUnmount(() => {
+      if (ctx.disposed) return;
+      // undefined better than null
+      setControllerRef(ctx, false);
+      if (ctx.bean !== ctx.app.bean) {
+        ctx.bean.dispose();
+      }
+    });
+    onUnmounted(() => {
+      ctx.dispose();
+    });
+  }
 
   // load
   ctx.meta.hooks.onCreated(async () => {
     if (ctx.disposed) return;
-    try {
-      return await __load();
-    } catch (err) {
-      if (ctx.disposed) return;
-      throw err;
+    const loadEvent = {
+      phase: 'prepare',
+      ctx,
+      controllerBeanFullName,
+      controllerBeanName: typeof controllerBeanFullName === 'string' ? controllerBeanFullName : controllerBeanFullName.name
+    };
+    ctx.app?.meta.module._monkeyModuleSync(true, 'controllerLoad', undefined, loadEvent);
+    if (loadEvent.replayError) {
+      const attemptId = ctx.meta.state.beginLoadAttempt();
+      if (loadEvent.replayControllerRecorded) {
+        try {
+          await __loadBeans(attemptId);
+        } catch {
+          // The server's fallback decision is authoritative during initial hydration.
+        }
+      }
+      if (!ctx.disposed) {
+        ctx.meta.state.setLoadError(loadEvent.replayError);
+      }
+      return;
     }
+    const attemptId = ctx.meta.state.beginLoadAttempt(getLoadLoadingDelay());
+    await runLoadAttempt(attemptId);
   });
   if (process.env.SERVER) {
     onServerPrefetch(() => {
@@ -3836,11 +4256,11 @@ function setControllerRef(ctx, on) {
   }
 }
 
-function createZovaComponentPage(controller, render, style) {
+function createZovaComponentPage(controller, render, style, componentOptions) {
   return defineComponent(() => {
     useControllerPage(controller, render, style);
     return () => {};
-  });
+  }, prepareComponentOptions(componentOptions));
 }
 function prepareComponentOptions(componentOptions) {
   return Object.assign({
@@ -3882,75 +4302,6 @@ class AppComponent extends BeanSimple {
   }
 }
 
-class AppError extends ErrorClass {
-  /** @internal */
-  async initialize() {
-    await super.initialize();
-    // errorHandler
-    this.app.vue.config.errorHandler = (err, instance, info) => {
-      return this._handleError(err, instance, info);
-    };
-    // unhandledrejection
-    if (process.env.CLIENT) {
-      window.addEventListener('unhandledrejection', event => {
-        event.preventDefault();
-        this._handleUnhandledError(event.reason, 'unhandledrejection');
-        return false;
-      });
-      window.addEventListener('error', event => {
-        event.preventDefault();
-        this._handleUnhandledError(event.error, 'unhandlederror');
-        return false;
-      });
-    }
-  }
-
-  /** @internal */
-  createScopeError(moduleScope, errorCode) {
-    const self = this;
-    return {
-      throw: (...args) => {
-        return self.throw(moduleScope, errorCode, ...args);
-      },
-      parseFail: (...args) => {
-        return self.parseFail(moduleScope, errorCode, ...args);
-      }
-    };
-  }
-  _handleUnhandledError(error, infoDefault) {
-    if (error instanceof Error) {
-      const errorInfo = error[SymbolErrorInstanceInfo];
-      if (errorInfo) {
-        delete error[SymbolErrorInstanceInfo];
-      }
-      // should not catch error
-      this.app.vue.config.errorHandler(error, errorInfo?.instance, errorInfo?.info || infoDefault);
-    }
-  }
-  _handleError(err, instance, info) {
-    if (!this.app) {
-      // means destroyed
-      console.error(err);
-      return;
-    }
-    const err2 = this.app.meta.event.emitSync('app:errorHandler', {
-      err: err,
-      instance,
-      info
-    }, data => {
-      return data.err;
-    });
-    // only log error in client
-    if (process.env.CLIENT) {
-      if (!err2 || !(err2 instanceof Error)) return err2;
-      if (!info || !['useMutationData'].includes(info)) {
-        console.error(err2);
-      }
-    }
-    return err2;
-  }
-}
-
 class AppModule extends BeanSimple {
   constructor(...args) {
     super(...args);
@@ -4437,5 +4788,5 @@ function $protocolKey(key) {
   return key;
 }
 
-export { $getBeanName, $protocolKey, AppError, AppLocale, AppMeta, AppMetadata, AppModule, AppResource, BeanAopBase, BeanAopMethodBase, BeanBase, BeanBaseSimple, BeanContainer, BeanControllerBase, BeanControllerIdentifier, BeanControllerLike, BeanControllerPageBase, BeanInfo, BeanRenderBase, BeanRenderIdentifier, BeanRenderLike, BeanScopeBase, BeanScopeError, BeanScopeLocale, BeanScopeUtil, BeanSimple, BeanStyleBase, BeanStyleIdentifier, ClientOnly, CtxComponent, CtxMeta, CtxState, CtxUtil, DecoratorBeanFullName, ErrorClass, LocaleModuleNameSeparator, LocalePattern, MixinClass, OmitClass, PartialClass, PickClass, PluginBean, PluginZova, Preload, ProxyDisable, StateLock, SymbolBeanContainerInstances, SymbolBeanFullName, SymbolBeanInstanceKey, SymbolController, SymbolControllerRefDisable, SymbolDecoratorBeanInfo, SymbolDecoratorPreload, SymbolDecoratorProxyDisable, SymbolDecoratorUse, SymbolDecoratorVirtual, SymbolDecoratorVueElements, SymbolErrorInstanceInfo, SymbolInited, SymbolInstalled, SymbolMappedClassMetadataKeys, SymbolModuleBelong, SymbolModuleName, SysComponent, SysError, SysLocale, SysLogger, SysMeta, SysModule, SysUtil, Use, UseScope, Virtual, ZovaApplication, ZovaContext, ZovaSys, __prepareInjectSelectorInfo, appMetadata, appResource, beanFullNameFromOnionName, bootstrap, cast, configDefault, constantDefault, convertToUnit, copyMetadataOfClasses, copyProperties, copyPropertiesOfClasses, createBeanDecorator, createVueDecorator, createZovaComponentAsync, createZovaComponentPage, deepEqual, deepExtend, disposeInstance, errorsInternal, formatLoggerConsole, formatLoggerFilter, functionNoop, getLoggerFilterLevel, getMappedClassMetadataKeys, isHttpUrl, isUuid, localeDefault, modelGet, modelSet, objectAssignReactive, onionNameFromBeanFullName, polyfillDispose, prepareComponentOptions, registerMappedClassMetadataKey, setLoggerFilterLevel, ssr_load_local, sys, throwErrorComponentUnmounted, useApp, useComputed, useContext, useController, useControllerPage, usePrepareArg, usePrepareArgs, uuid };
+export { $getBeanName, $protocolKey, AppError, AppLocale, AppMeta, AppMetadata, AppModule, AppResource, BeanAopBase, BeanAopMethodBase, BeanBase, BeanBaseSimple, BeanContainer, BeanControllerBase, BeanControllerIdentifier, BeanControllerLike, BeanControllerPageBase, BeanInfo, BeanRenderBase, BeanRenderIdentifier, BeanRenderLike, BeanScopeBase, BeanScopeError, BeanScopeLocale, BeanScopeUtil, BeanSimple, BeanStyleBase, BeanStyleIdentifier, ClientOnly, CtxComponent, CtxMeta, CtxState, CtxUtil, DecoratorBeanFullName, ErrorClass, LocaleModuleNameSeparator, LocalePattern, MixinClass, OmitClass, PartialClass, PickClass, PluginBean, PluginZova, Preload, ProxyDisable, StateLock, SymbolBeanContainerInstances, SymbolBeanFullName, SymbolBeanInstanceKey, SymbolController, SymbolControllerRefDisable, SymbolDecoratorBeanInfo, SymbolDecoratorPreload, SymbolDecoratorProxyDisable, SymbolDecoratorUse, SymbolDecoratorVirtual, SymbolDecoratorVueElements, SymbolErrorInstanceInfo, SymbolInited, SymbolInstalled, SymbolMappedClassMetadataKeys, SymbolModuleBelong, SymbolModuleName, SysComponent, SysError, SysLocale, SysLogger, SysMeta, SysModule, SysUtil, Use, UseScope, Virtual, ZovaApplication, ZovaContext, ZovaSys, __prepareInjectSelectorInfo, appMetadata, appResource, beanFullNameFromOnionName, bootstrap, cast, configDefault, constantDefault, convertToUnit, copyMetadataOfClasses, copyProperties, copyPropertiesOfClasses, createBeanDecorator, createVueDecorator, createZovaComponentAsync, createZovaComponentPage, deepEqual, deepExtend, disposeInstance, errorsInternal, formatLoggerConsole, formatLoggerFilter, functionNoop, getLoggerFilterLevel, getMappedClassMetadataKeys, isHttpUrl, isUuid, localeDefault, modelGet, modelSet, normalizeError, objectAssignReactive, onionNameFromBeanFullName, polyfillDispose, prepareComponentOptions, registerMappedClassMetadataKey, setLoggerFilterLevel, ssr_load_local, sys, throwErrorComponentUnmounted, useApp, useComputed, useContext, useController, useControllerPage, usePrepareArg, usePrepareArgs, uuid };
 //# sourceMappingURL=index.js.map