vitrify 0.24.2 → 0.25.1

package/src/node/bin/dev.ts

@@ -1,5 +1,4 @@
 import type { LogLevel, InlineConfig, ViteDevServer } from 'vite'
-import { searchForWorkspaceRoot } from 'vite'
 import { baseConfig } from '../index.js'
 import type { Server } from 'net'
 import fastify from 'fastify'
@@ -7,6 +6,7 @@ import type { FastifyServerOptions } from 'fastify'
 import { fastifySsrPlugin } from '../frameworks/vue/fastify-ssr-plugin.js'
 import type {
   OnTemplateRenderedHook,
+  OnAppRenderedHook,
   VitrifyConfig
 } from '../vitrify-config.js'
 import isPortReachable from 'is-port-reachable'
@@ -142,6 +142,7 @@ export async function createServer({
   let app: FastifyInstance | undefined
   let server: Server
   let onTemplateRendered: OnTemplateRenderedHook[]
+  let onAppRendered: OnAppRenderedHook[]
   let vitrifyConfig: VitrifyConfig
 
   console.log(`Development mode: ${ssr ? ssr : 'csr'}`)
@@ -152,11 +153,10 @@ export async function createServer({
         : fileURLToPath(new URL(`src/vite/${framework}/ssr/app.ts`, cliDir))
 
     const environment = vite.environments.ssr
-    ;({ setup, onTemplateRendered, vitrifyConfig } =
+    ;({ setup, onTemplateRendered, onAppRendered, vitrifyConfig } =
       // @ts-expect-error missing types
       await environment.runner.import(entryUrl))
-    // console.log(module)
-    // ;({ setup, onRendered, vitrifyConfig } = await vite.ssrLoadModule(entryUrl))
+
     app = fastify({
       logger: {
         transport: {
@@ -181,6 +181,7 @@ export async function createServer({
         appDir,
         mode: 'development',
         onTemplateRendered,
+        onAppRendered,
         host
       })
     }

package/src/node/frameworks/vue/fastify-ssr-plugin.ts

@@ -9,7 +9,7 @@ import {
 } from '../../helpers/utils.js'
 import type { ViteDevServer } from 'vite'
 import type {
-  OnRenderedHook,
+  OnAppRenderedHook,
   OnTemplateRenderedHook,
   SSRContext
 } from '../../vitrify-config.js'
@@ -28,7 +28,7 @@ export interface FastifySsrOptions {
   vitrifyDir?: URL
   vite?: ViteDevServer
   // frameworkDir?: URL
-  onRendered?: OnRenderedHook[]
+  onAppRendered?: OnAppRenderedHook[]
   onTemplateRendered?: OnTemplateRenderedHook[]
   appDir?: URL
   publicDir?: URL
@@ -103,7 +103,7 @@ const fastifySsrPlugin: FastifyPluginAsync<FastifySsrOptions> = async (
           res,
           url: url ?? '/',
           provide,
-          onRendered: options.onRendered,
+          onAppRendered: options.onAppRendered,
           onTemplateRendered: options.onTemplateRendered,
           template,
           manifest,
@@ -135,7 +135,7 @@ const fastifySsrPlugin: FastifyPluginAsync<FastifySsrOptions> = async (
       const url = req.raw.url?.replace(options.baseUrl!, '/')
       const provide = options.provide ? await options.provide(req, res) : {}
 
-      const { template, manifest, render, onRendered, onTemplateRendered } =
+      const { template, manifest, render, onAppRendered, onTemplateRendered } =
         await loadSSRAssets({
           distDir: new URL('./dist/', options.appDir)
         })
@@ -145,7 +145,7 @@ const fastifySsrPlugin: FastifyPluginAsync<FastifySsrOptions> = async (
         res,
         url: url ?? '/',
         provide,
-        onRendered,
+        onAppRendered,
         onTemplateRendered,
         template,
         manifest,
@@ -181,13 +181,13 @@ const renderHtml = async (options: {
   req: FastifyRequest | { headers: Record<string, unknown>; url: string }
   res: FastifyReply | Record<string, unknown>
   provide: Record<string, unknown>
-  onRendered?: OnRenderedHook[]
+  onAppRendered?: OnAppRenderedHook[]
   onTemplateRendered?: OnTemplateRenderedHook[]
   template: string
   manifest: Record<string, unknown>
   render: any
 }) => {
-  const ssrContextOnRendered: (() => unknown)[] = []
+  const ssrContextonAppRendered: (() => unknown)[] = []
   const ssrContext: SSRContext = {
     req: options.req,
     res: options.res,
@@ -196,13 +196,13 @@ const renderHtml = async (options: {
     _modules: new Set(),
     _meta: {},
     __qMetaList: [],
-    onRenderedList: ssrContextOnRendered,
+    onRenderedList: ssrContextonAppRendered,
     onRendered: (fn: () => unknown) => {
-      ssrContextOnRendered.push(fn)
+      ssrContextonAppRendered.push(fn)
     }
   }
 
-  const onRendered = options.onRendered ?? []
+  const onAppRendered = options.onAppRendered ?? []
   const onTemplateRendered = options.onTemplateRendered ?? []
 
   const {
@@ -211,14 +211,14 @@ const renderHtml = async (options: {
     app
   } = await options.render(options.url, options.manifest, ssrContext)
 
-  if (ssrContextOnRendered?.length) {
-    for (const ssrFunction of ssrContextOnRendered) {
+  if (ssrContextonAppRendered?.length) {
+    for (const ssrFunction of ssrContextonAppRendered) {
       await ssrFunction()
     }
   }
 
-  if (onRendered?.length) {
-    for (const ssrFunction of onRendered) {
+  if (onAppRendered?.length) {
+    for (const ssrFunction of onAppRendered) {
       await ssrFunction({ app, ssrContext })
     }
   }
@@ -307,14 +307,14 @@ const loadSSRAssets = async (
     const manifest = JSON.parse(readFileSync(manifestPath).toString())
     const entryServer = await import(entryServerPath)
     const { render, getRoutes } = entryServer
-    const { onTemplateRendered, onRendered } = await import(vitrifyHooksPath)
+    const { onTemplateRendered, onAppRendered } = await import(vitrifyHooksPath)
 
     return {
       template,
       manifest,
       render,
       getRoutes,
-      onRendered,
+      onAppRendered,
       onTemplateRendered
     }
   } catch (e) {

package/src/node/frameworks/vue/server.ts

@@ -2,7 +2,7 @@ import fastify from 'fastify'
 import type {
   OnTemplateRenderedHook,
   OnSetupHook,
-  OnRenderedHook
+  OnAppRenderedHook
 } from '../../vitrify-config.js'
 import type { FastifyCsrPlugin } from './fastify-csr-plugin.js'
 import type { FastifySsrPlugin } from './fastify-ssr-plugin.js'
@@ -12,7 +12,7 @@ export const createApp = ({
   appDir,
   baseUrl,
   fastifyPlugin,
-  onRendered,
+  onAppRendered,
   onTemplateRendered,
   vitrifyDir,
   mode
@@ -21,7 +21,7 @@ export const createApp = ({
   appDir: URL
   baseUrl?: string
   fastifyPlugin: FastifySsrPlugin | FastifyCsrPlugin
-  onRendered?: OnRenderedHook[]
+  onAppRendered?: OnAppRenderedHook[]
   onTemplateRendered?: OnTemplateRenderedHook[]
   vitrifyDir?: URL
   mode: string
@@ -39,7 +39,7 @@ export const createApp = ({
     baseUrl,
     appDir,
     vitrifyDir,
-    onRendered,
+    onAppRendered,
     onTemplateRendered,
     mode
   })

package/src/node/hooks/index.ts

@@ -1,19 +1,25 @@
 import type {
-  OnBootHook,
-  onAppCreatedHook,
+  OnAppCreatedHook,
+  OnAppCreatedHookFile,
   OnAppMountedHook,
-  OnRenderedHook,
+  OnAppMountedHookFile,
+  OnAppRenderedHook,
+  OnAppRenderedHookFile,
   OnTemplateRenderedHook,
-  OnSetupFile,
+  OnTemplateRenderedHookFile,
+  OnSetupHookFile,
   OnSetupHook
 } from '../vitrify-config.js'
 
 export {
-  OnBootHook,
-  onAppCreatedHook,
+  OnAppCreatedHook,
+  OnAppCreatedHookFile,
   OnAppMountedHook,
-  OnRenderedHook,
+  OnAppMountedHookFile,
+  OnAppRenderedHook,
+  OnAppRenderedHookFile,
   OnTemplateRenderedHook,
-  OnSetupFile,
+  OnTemplateRenderedHookFile,
+  OnSetupHookFile,
   OnSetupHook
 }

package/src/node/index.ts

@@ -24,11 +24,14 @@ import type {
   VitrifyModes,
   VitrifyUIFrameworks,
   VitrifySSRModes,
-  OnRenderedHook,
-  OnBootHook,
-  OnSetupFile,
-  onAppCreatedHook,
-  OnTemplateRenderedHook
+  OnAppRenderedHook,
+  OnSetupHookFile,
+  OnAppCreatedHook,
+  OnTemplateRenderedHook,
+  OnAppCreatedHookFile,
+  OnAppRenderedHookFile,
+  OnTemplateRenderedHookFile,
+  OnAppMountedHookFile
 } from './vitrify-config.js'
 import type { VitrifyContext } from './bin/run.js'
 import type { VitrifyPlugin } from './plugins/index.js'
@@ -278,12 +281,15 @@ export const baseConfig = async ({
     }
   }
 
-  let onBootHooks: OnBootHook[]
-  let onRenderedHooks: OnRenderedHook[]
+  let onAppRenderedHooks: OnAppRenderedHook[]
+  let onAppRenderedFiles: OnAppRenderedHookFile[]
   let onTemplateRenderedHooks: OnTemplateRenderedHook[]
+  let onTemplateRenderedFiles: OnTemplateRenderedHookFile[]
   let onAppMountedHooks: OnAppMountedHook[]
-  let onAppCreatedHooks: onAppCreatedHook[]
-  let onSetupFiles: OnSetupFile[]
+  let onAppMountedFiles: OnAppMountedHookFile[]
+  let OnAppCreatedHooks: OnAppCreatedHook[]
+  let onAppCreatedFiles: OnAppCreatedHookFile[]
+  let onSetupFiles: OnSetupHookFile[]
   let globalCss: string[] = []
   let staticImports: StaticImports
   let sassVariables: Record<string, string | undefined>
@@ -358,12 +364,16 @@ export const baseConfig = async ({
       name: 'vitrify-setup',
       enforce: 'post',
       config: (config: VitrifyConfig, env) => {
-        onBootHooks = config.vitrify?.hooks?.onBoot || []
-        onRenderedHooks = config.vitrify?.hooks?.onRendered || []
+        onAppRenderedHooks = config.vitrify?.hooks?.onAppRendered || []
+        onAppRenderedFiles = config.vitrify?.hooks?.onAppRenderedFiles || []
         onTemplateRenderedHooks =
           config.vitrify?.hooks?.onTemplateRendered || []
+        onTemplateRenderedFiles =
+          config.vitrify?.hooks?.onTemplateRenderedFiles || []
         onAppMountedHooks = config.vitrify?.hooks?.onAppMounted || []
-        onAppCreatedHooks = config.vitrify?.hooks?.onAppCreated || []
+        onAppMountedFiles = config.vitrify?.hooks?.onAppMountedFiles || []
+        OnAppCreatedHooks = config.vitrify?.hooks?.onAppCreated || []
+        onAppCreatedFiles = config.vitrify?.hooks?.onAppCreatedFiles || []
         onSetupFiles = config?.vitrify?.hooks?.onSetup || []
         globalCss = config.vitrify?.globalCss || []
         staticImports = config.vitrify?.staticImports || {}
@@ -392,21 +402,82 @@ export const baseConfig = async ({
       },
       load(id) {
         if (id === 'virtual:vitrify-hooks') {
-          return `export const onBoot = [${onBootHooks
+          return `export const onAppMounted = [${onAppMountedHooks
             .map((fn) => `${String(fn)}`)
             .join(', ')}]
-            export const onAppMounted = [${onAppMountedHooks
-              .map((fn) => `${String(fn)}`)
-              .join(', ')}]
-            export const onRendered = [${onRenderedHooks
+            ${onAppMountedFiles
+              .map((url, index) => {
+                const varName = fileURLToPath(url)
+                  .replaceAll('/', '')
+                  .replaceAll(':', '')
+                  .replaceAll('\\', '')
+                  .replaceAll('.', '')
+                  .replaceAll('-', '')
+                  .replaceAll('_', '')
+                  .replaceAll('+', '')
+
+                return `import ${varName} from '${
+                  new URL(url, appDir).pathname
+                }'; onAppMounted.push(${varName});`
+              })
+              .join('\n')}
+            export const onAppRendered = [${onAppRenderedHooks
               .map((fn) => `${String(fn)}`)
               .join(', ')}]
+            ${onAppRenderedFiles
+              .map((url, index) => {
+                const varName = fileURLToPath(url)
+                  .replaceAll('/', '')
+                  .replaceAll(':', '')
+                  .replaceAll('\\', '')
+                  .replaceAll('.', '')
+                  .replaceAll('-', '')
+                  .replaceAll('_', '')
+                  .replaceAll('+', '')
+
+                return `import ${varName} from '${
+                  new URL(url, appDir).pathname
+                }'; onAppRendered.push(${varName});`
+              })
+              .join('\n')}
             export const onTemplateRendered = [${onTemplateRenderedHooks
               .map((fn) => `${String(fn)}`)
               .join(', ')}]
-            export const onAppCreated = [${onAppCreatedHooks
-              .map((fn) => `${String(fn)}`)
-              .join(', ')}]
+            ${onTemplateRenderedFiles
+              .map((url, index) => {
+                const varName = fileURLToPath(url)
+                  .replaceAll('/', '')
+                  .replaceAll(':', '')
+                  .replaceAll('\\', '')
+                  .replaceAll('.', '')
+                  .replaceAll('-', '')
+                  .replaceAll('_', '')
+                  .replaceAll('+', '')
+
+                return `import ${varName} from '${
+                  new URL(url, appDir).pathname
+                }'; onTemplateRendered.push(${varName});`
+              })
+              .join('\n')}
+            export const onAppCreated = [${OnAppCreatedHooks.map(
+              (fn) => `${String(fn)}`
+            ).join(', ')}]
+            ${onAppCreatedFiles
+              .map((url, index) => {
+                const varName = fileURLToPath(url)
+                  .replaceAll('/', '')
+                  .replaceAll(':', '')
+                  .replaceAll('\\', '')
+                  .replaceAll('.', '')
+                  .replaceAll('-', '')
+                  .replaceAll('_', '')
+                  .replaceAll('+', '')
+
+                return `import ${varName} from '${
+                  new URL(url, appDir).pathname
+                }'; onAppCreated.push(${varName});`
+              })
+              .join('\n')}
             export const onSetup = []
             ${onSetupFiles
               .map((url, index) => {
@@ -421,7 +492,7 @@ export const baseConfig = async ({
 
                 return `import ${varName} from '${
                   new URL(url, appDir).pathname
-                }'; onSetup.push(${varName})`
+                }'; onSetup.push(${varName});`
               })
               .join('\n')}`
         } else if (id === 'virtual:static-imports') {
@@ -733,10 +804,4 @@ export const baseConfig = async ({
 export const vitrifyDir = new URL('..', import.meta.url)
 export { prerender } from './frameworks/vue/prerender.js'
 
-export type {
-  VitrifyConfig,
-  VitrifyConfigAsync,
-  VitrifyPlugin,
-  VitrifyContext,
-  OnBootHook
-}
+export type { VitrifyConfig, VitrifyConfigAsync, VitrifyPlugin, VitrifyContext }

package/src/node/plugins/pinia/index.ts

@@ -1,4 +1,7 @@
-import type { onAppCreatedHook, OnRenderedHook } from '../../vitrify-config.js'
+import type {
+  OnAppCreatedHook,
+  OnAppRenderedHook
+} from '../../vitrify-config.js'
 import type { VitrifyPlugin } from '../index.js'
 
 export type PiniaPluginOptions = {
@@ -6,7 +9,7 @@ export type PiniaPluginOptions = {
   colada?: boolean
 }
 
-const piniaOnAppCreated: onAppCreatedHook = async ({
+const piniaOnAppCreated: OnAppCreatedHook = async ({
   app,
   ctx,
   initialState,
@@ -23,14 +26,17 @@ const piniaOnAppCreated: onAppCreatedHook = async ({
   if (ssrContext) ssrContext.pinia = pinia
 }
 
-const piniaOnRenderedHook: OnRenderedHook = async ({ app, ssrContext }) => {
+const piniaonAppRenderedHook: OnAppRenderedHook = async ({
+  app,
+  ssrContext
+}) => {
   // SSR Server
   if (ssrContext?.initialState && ssrContext.pinia) {
     ssrContext.initialState.pinia = ssrContext.pinia.state.value
   }
 }
 
-const piniaColadaonAppCreated: onAppCreatedHook = async ({
+const piniaColadaonAppCreated: OnAppCreatedHook = async ({
   app,
   ctx,
   initialState
@@ -52,7 +58,7 @@ const piniaColadaonAppCreated: onAppCreatedHook = async ({
   }
 }
 
-const piniaColadaOnRenderedHook: OnRenderedHook = async ({
+const piniaColadaonAppRenderedHook: OnAppRenderedHook = async ({
   app,
   ssrContext
 }) => {
@@ -76,10 +82,10 @@ export const PiniaPlugin: VitrifyPlugin<PiniaPluginOptions> = async ({
   options = {}
 }) => {
   const onAppCreated = [piniaOnAppCreated]
-  const onRendered = [piniaOnRenderedHook]
+  const onAppRendered = [piniaonAppRenderedHook]
   if (options.colada) {
     onAppCreated.push(piniaColadaonAppCreated)
-    onRendered.push(piniaColadaOnRenderedHook)
+    onAppRendered.push(piniaColadaonAppRenderedHook)
   }
 
   return {
@@ -88,7 +94,7 @@ export const PiniaPlugin: VitrifyPlugin<PiniaPluginOptions> = async ({
       vitrify: {
         hooks: {
           onAppCreated,
-          onRendered
+          onAppRendered
         }
       }
     }

package/src/node/plugins/quasar/index.ts

@@ -1,9 +1,9 @@
 import { fileURLToPath } from 'url'
 import type {
-  OnBootHook,
   OnAppMountedHook,
   OnTemplateRenderedHook,
-  VitrifyConfig
+  VitrifyConfig,
+  OnAppCreatedHook
 } from '../../vitrify-config.js'
 import type { VitrifyPlugin } from '../index.js'
 import { findDepPkgJsonPath } from 'vitefu'
@@ -145,7 +145,7 @@ export const QuasarPlugin: VitrifyPlugin<QuasarPluginOptions> = async ({
             }
           ]
 
-          const onBootHooks: OnBootHook[] = [
+          const onAppCreatedHooks: OnAppCreatedHook[] = [
             async ({ app, ssrContext, staticImports }) => {
               // @ts-expect-error undefined
               const quasarPlugins = await import('virtual:quasar-plugins')
@@ -202,7 +202,7 @@ export const QuasarPlugin: VitrifyPlugin<QuasarPluginOptions> = async ({
                 quasar: ['Quasar']
               },
               hooks: {
-                onBoot: onBootHooks,
+                onAppCreated: onAppCreatedHooks,
                 onAppMounted: onAppMountedHooks,
                 onTemplateRendered: [injectSsrContext]
               },

package/src/node/vitrify-config.ts

@@ -49,12 +49,14 @@ export type SSRContext = {
   [key: string]: unknown
 }
 
-export type onAppCreatedHook = ({
+export type OnAppCreatedHookFile = URL
+export type OnAppCreatedHook = ({
   app,
   router,
   ctx,
   initialState,
-  ssrContext
+  ssrContext,
+  staticImports
 }: {
   app: App
   router: Router
@@ -69,18 +71,10 @@ export type onAppCreatedHook = ({
     [key: string]: unknown
   }
   ssrContext?: SSRContext
-}) => Promise<void> | void
-
-export type OnBootHook = ({
-  app,
-  ssrContext,
-  staticImports
-}: {
-  app: App
-  ssrContext: SSRContext
   staticImports?: Record<string, any>
 }) => Promise<void> | void
 
+export type OnAppMountedHookFile = URL
 export type OnAppMountedHook = ({
   instance
 }: {
@@ -88,7 +82,7 @@ export type OnAppMountedHook = ({
 }) => Promise<void> | void
 export type StaticImports = Record<string, string[]>
 
-export type OnSetupFile = URL
+export type OnSetupHookFile = URL
 export type OnSetupHook = (
   fastify: FastifyInstance,
   options?: {
@@ -107,7 +101,8 @@ export type Render = (
   app: App
 }>
 
-export type OnRenderedHook = ({
+export type OnAppRenderedHookFile = URL
+export type OnAppRenderedHook = ({
   app,
   ssrContext
 }: {
@@ -115,6 +110,7 @@ export type OnRenderedHook = ({
   ssrContext?: SSRContext
 }) => Promise<void> | void
 
+export type OnTemplateRenderedHookFile = URL
 export type OnTemplateRenderedHook = ({
   html,
   ssrContext
@@ -142,27 +138,39 @@ export interface VitrifyConfig extends ViteUserConfig {
       /**
        * setup() is called directly after instantiating fastify. Use it to register your own plugins, routes etc.
        */
-      onSetup?: OnSetupFile[]
+      onSetup?: OnSetupHookFile[]
+      /**
+       * Functions which run directly after initializing the application
+       */
+      onAppCreated?: OnAppCreatedHook[]
+      /**
+       * Functions which run directly after initializing the application
+       */
+      onAppCreatedFiles?: OnAppCreatedHookFile[]
       /**
        * Functions which run in the onMounted hook of the app
        */
       onAppMounted?: OnAppMountedHook[]
       /**
-       * Functions which run after initializing the app
+       * Files with functions which run in the onMounted hook of the app
        */
-      onBoot?: OnBootHook[]
+      onAppMountedFiles?: OnAppMountedHookFile[]
       /**
        * Functions which run after rendering the app (SSR)
        */
-      onRendered?: OnRenderedHook[]
+      onAppRendered?: OnAppRenderedHook[]
+      /**
+       * Files with functions which run after rendering the app (SSR)
+       */
+      onAppRenderedFiles?: OnAppRenderedHookFile[]
       /**
        * Functions which run after rendering the template (SSR)
        */
       onTemplateRendered?: OnTemplateRenderedHook[]
       /**
-       * Functions which run directly after initializing the application
+       * Files with functions which run after rendering the template (SSR)
        */
-      onAppCreated?: onAppCreatedHook[]
+      onTemplateRenderedFiles?: OnTemplateRenderedHookFile[]
     }
     /**
      * Global SASS variables
@@ -189,6 +197,9 @@ export interface VitrifyConfig extends ViteUserConfig {
      * SSR specific configuration
      */
     ssr?: {
+      /**
+       * Packages which should not be bundled but installed on the server instead.
+       */
       serverModules?: string[]
       fastify?: FastifyServerOptions
     }
@@ -215,7 +226,6 @@ export interface VitrifyConfig extends ViteUserConfig {
      */
     unpluginVueComponents?: unpluginVueComponentsOptions
   }
-  // quasar?: QuasarConf
 }
 
 export type VitrifyCommands = 'build' | 'dev' | 'test'

package/src/vite/vue/main.ts

@@ -70,7 +70,7 @@ export async function createApp(
   app.use(router)
 
   for (const fn of onAppCreated) {
-    await fn({ app, router, ctx, initialState, ssrContext })
+    await fn({ app, router, ctx, initialState, ssrContext, staticImports })
   }
 
   // Workaround to fix hydration errors when serving html files directly
@@ -95,9 +95,9 @@ export async function createApp(
     }
   }
 
-  for (const fn of onBoot) {
-    await fn({ app, ssrContext, staticImports })
-  }
+  // for (const fn of onBoot) {
+  //   await fn({ app, ssrContext, staticImports })
+  // }
 
   // @vitrify-pwa-only
   // @ts-expect-error undefined

package/src/vite/vue/ssr/app.ts

@@ -1,6 +1,10 @@
 import { createApp } from '../../../node/frameworks/vue/server.js'
 import { getAppDir } from '../../../node/app-urls.js'
-import { onSetup, onRendered, onTemplateRendered } from 'virtual:vitrify-hooks'
+import {
+  onSetup,
+  onAppRendered,
+  onTemplateRendered
+} from 'virtual:vitrify-hooks'
 import { fastifySsrPlugin } from './fastify-ssr-plugin.js'
 
 const getString = (str?: string) => str
@@ -13,11 +17,11 @@ export const setupApp = async () => {
     appDir,
     baseUrl,
     fastifyPlugin: fastifySsrPlugin,
-    onRendered,
+    onAppRendered,
     onTemplateRendered,
     mode: import.meta.env.MODE
   })
 }
 
 export { default as vitrifyConfig } from 'virtual:vitrify-config'
-export { onRendered, onTemplateRendered }
+export { onAppRendered, onTemplateRendered }