dtwo 3.1.1 → 3.2.0

package/dist/app/compat/idle-callback.mjs

@@ -1,4 +1,5 @@
-export const requestIdleCallback = process.server ? void 0 : globalThis.requestIdleCallback || ((cb) => {
+export const requestIdleCallback = process.server ? () => {
+} : globalThis.requestIdleCallback || ((cb) => {
   const start = Date.now();
   const idleDeadline = {
     didTimeout: false,
@@ -8,6 +9,7 @@ export const requestIdleCallback = process.server ? void 0 : globalThis.requestI
     cb(idleDeadline);
   }, 1);
 });
-export const cancelIdleCallback = process.server ? null : globalThis.cancelIdleCallback || ((id) => {
+export const cancelIdleCallback = process.server ? () => {
+} : globalThis.cancelIdleCallback || ((id) => {
   clearTimeout(id);
 });

package/dist/app/components/dtwo-error-boundary.mjs

@@ -1,5 +1,5 @@
 import { defineComponent, ref, onErrorCaptured } from "kdu";
-import { useDtwoApp } from "#app";
+import { useDtwoApp } from "#app/dtwo";
 export default defineComponent({
   emits: {
     error(_error) {

package/dist/app/components/dtwo-island.mjs

@@ -2,7 +2,9 @@ import { defineComponent, createStaticKNode, computed, ref, watch } from "kdu";
 import { debounce } from "perfect-debounce";
 import { hash } from "ohash";
 import { appendHeader } from "h3";
-import { useHead, useDtwoApp, useRequestEvent } from "#app";
+import { useDtwoApp } from "#app/dtwo";
+import { useRequestEvent } from "#app/composables/ssr";
+import { useHead } from "#app/composables/head";
 const pKey = "_islandPromises";
 export default defineComponent({
   name: "DtwoIsland",

package/dist/app/components/dtwo-loading-indicator.mjs

@@ -1,5 +1,5 @@
 import { computed, defineComponent, h, onBeforeUnmount, ref } from "kdu";
-import { useDtwoApp } from "#app";
+import { useDtwoApp } from "#app/dtwo";
 export default defineComponent({
   name: "DtwoLoadingIndicator",
   props: {

package/dist/app/components/dtwo-root.kdu

@@ -8,7 +8,9 @@
 
 <script setup>
 import { defineAsyncComponent, onErrorCaptured, onServerPrefetch, provide } from 'kdu'
-import { callWithDtwo, isDtwoError, showError, useError, useRoute, useDtwoApp } from '#app'
+import { callWithDtwo, useDtwoApp } from '#app/dtwo'
+import { isDtwoError, showError, useError } from '#app/composables/error'
+import { useRoute } from '#app/composables/router'
 import AppComponent from '#build/app-component.mjs'
 
 const ErrorComponent = defineAsyncComponent(() => import('#build/error-component.mjs').then(r => r.default || r))

package/dist/app/components/island-renderer.mjs

@@ -1,6 +1,6 @@
 import { createBlock, defineComponent, h, Teleport } from "kdu";
 import * as islandComponents from "#build/components.islands.mjs";
-import { createError } from "#app";
+import { createError } from "#app/composables/error";
 export default defineComponent({
   props: {
     context: {

package/dist/app/components/layout.mjs

@@ -1,6 +1,6 @@
 import { computed, defineComponent, h, inject, nextTick, onMounted, Transition, unref } from "kdu";
 import { _wrapIf } from "./utils.mjs";
-import { useRoute } from "#app";
+import { useRoute } from "#app/composables/router";
 import { useRoute as useKduRouterRoute } from "#build/pages";
 import layouts from "#build/layouts";
 import { appLayoutTransition as defaultLayoutTransition } from "#build/dtwo.config.mjs";

package/dist/app/composables/component.mjs

@@ -2,7 +2,7 @@ import { getCurrentInstance, reactive, toRefs } from "kdu";
 import { useDtwoApp } from "../dtwo.mjs";
 import { useAsyncData } from "./asyncData.mjs";
 import { useRoute } from "./router.mjs";
-import { useHead } from "#head";
+import { useHead } from "./head.mjs";
 export const DtwoComponentIndicator = "__dtwo_component";
 async function runLegacyAsyncData(res, fn) {
   const dtwo = useDtwoApp();

package/dist/app/composables/fetch.d.ts

@@ -1,15 +1,16 @@
 import type { FetchError } from 'ofetch';
-import type { TypedInternalResponse, HoleFetchOptions, HoleFetchRequest } from 'holepack';
+import type { TypedInternalResponse, HoleFetchOptions, HoleFetchRequest, AvailableRouterMethod } from 'holepack';
 import type { Ref } from 'kdu';
 import type { AsyncDataOptions, _Transform, KeyOfRes, AsyncData, PickFrom } from './asyncData';
-export type FetchResult<ReqT extends HoleFetchRequest> = TypedInternalResponse<ReqT, unknown>;
+export type FetchResult<ReqT extends HoleFetchRequest, M extends AvailableRouterMethod<ReqT>> = TypedInternalResponse<ReqT, unknown, M>;
 type ComputedOptions<T extends Record<string, any>> = {
     [K in keyof T]: T[K] extends Function ? T[K] : T[K] extends Record<string, any> ? ComputedOptions<T[K]> | Ref<T[K]> | T[K] : Ref<T[K]> | T[K];
 };
-type ComputedFetchOptions<R extends HoleFetchRequest> = ComputedOptions<HoleFetchOptions<R>>;
-export interface UseFetchOptions<DataT, Transform extends _Transform<DataT, any> = _Transform<DataT, DataT>, PickKeys extends KeyOfRes<Transform> = KeyOfRes<Transform>, R extends HoleFetchRequest = string & {}> extends AsyncDataOptions<DataT, Transform, PickKeys>, ComputedFetchOptions<R> {
+type ComputedFetchOptions<R extends HoleFetchRequest, M extends AvailableRouterMethod<R>> = ComputedOptions<HoleFetchOptions<R, M>>;
+export interface UseFetchOptions<DataT, Transform extends _Transform<DataT, any> = _Transform<DataT, DataT>, PickKeys extends KeyOfRes<Transform> = KeyOfRes<Transform>, R extends HoleFetchRequest = string & {}, M extends AvailableRouterMethod<R> = AvailableRouterMethod<R>> extends AsyncDataOptions<DataT, Transform, PickKeys>, ComputedFetchOptions<R, M> {
     key?: string;
+    $fetch?: typeof globalThis.$fetch;
 }
-export declare function useFetch<ResT = void, ErrorT = FetchError, ReqT extends HoleFetchRequest = HoleFetchRequest, _ResT = ResT extends void ? FetchResult<ReqT> : ResT, Transform extends (res: _ResT) => any = (res: _ResT) => _ResT, PickKeys extends KeyOfRes<Transform> = KeyOfRes<Transform>>(request: Ref<ReqT> | ReqT | (() => ReqT), opts?: UseFetchOptions<_ResT, Transform, PickKeys, ReqT>): AsyncData<PickFrom<ReturnType<Transform>, PickKeys>, ErrorT | null>;
-export declare function useLazyFetch<ResT = void, ErrorT = FetchError, ReqT extends HoleFetchRequest = HoleFetchRequest, _ResT = ResT extends void ? FetchResult<ReqT> : ResT, Transform extends (res: _ResT) => any = (res: _ResT) => _ResT, PickKeys extends KeyOfRes<Transform> = KeyOfRes<Transform>>(request: Ref<ReqT> | ReqT | (() => ReqT), opts?: Omit<UseFetchOptions<_ResT, Transform, PickKeys>, 'lazy'>): AsyncData<PickFrom<ReturnType<Transform>, PickKeys>, ErrorT | null>;
+export declare function useFetch<ResT = void, ErrorT = FetchError, ReqT extends HoleFetchRequest = HoleFetchRequest, Method extends AvailableRouterMethod<ReqT> = 'get' extends AvailableRouterMethod<ReqT> ? 'get' : AvailableRouterMethod<ReqT>, _ResT = ResT extends void ? FetchResult<ReqT, Method> : ResT, Transform extends (res: _ResT) => any = (res: _ResT) => _ResT, PickKeys extends KeyOfRes<Transform> = KeyOfRes<Transform>>(request: Ref<ReqT> | ReqT | (() => ReqT), opts?: UseFetchOptions<_ResT, Transform, PickKeys, ReqT, Method>): AsyncData<PickFrom<ReturnType<Transform>, PickKeys>, ErrorT | null>;
+export declare function useLazyFetch<ResT = void, ErrorT = FetchError, ReqT extends HoleFetchRequest = HoleFetchRequest, Method extends AvailableRouterMethod<ReqT> = 'get' extends AvailableRouterMethod<ReqT> ? 'get' : AvailableRouterMethod<ReqT>, _ResT = ResT extends void ? FetchResult<ReqT, Method> : ResT, Transform extends (res: _ResT) => any = (res: _ResT) => _ResT, PickKeys extends KeyOfRes<Transform> = KeyOfRes<Transform>>(request: Ref<ReqT> | ReqT | (() => ReqT), opts?: Omit<UseFetchOptions<_ResT, Transform, PickKeys, Method>, 'lazy'>): AsyncData<PickFrom<ReturnType<Transform>, PickKeys>, ErrorT | null>;
 export {};

package/dist/app/composables/fetch.mjs

@@ -1,5 +1,6 @@
 import { computed, unref, reactive } from "kdu";
 import { hash } from "ohash";
+import { useRequestFetch } from "./ssr.mjs";
 import { useAsyncData } from "./asyncData.mjs";
 export function useFetch(request, arg1, arg2) {
   const [opts = {}, autoKey] = typeof arg1 === "string" ? [{}, arg1] : [arg1, arg2];
@@ -49,7 +50,12 @@ export function useFetch(request, arg1, arg2) {
   const asyncData = useAsyncData(key, () => {
     controller?.abort?.();
     controller = typeof AbortController !== "undefined" ? new AbortController() : {};
-    return $fetch(_request.value, { signal: controller.signal, ..._fetchOptions });
+    const isLocalFetch = typeof _request.value === "string" && _request.value.startsWith("/");
+    let _$fetch = opts.$fetch || globalThis.$fetch;
+    if (process.server && !opts.$fetch && isLocalFetch) {
+      _$fetch = useRequestFetch();
+    }
+    return _$fetch(_request.value, { signal: controller.signal, ..._fetchOptions });
   }, _asyncDataOptions);
   return asyncData;
 }

package/dist/app/composables/head.d.ts

@@ -0,0 +1,2 @@
+export type { MetaObject } from '#head';
+export { useHead, useSeoMeta, useServerSeoMeta } from '#head';

package/dist/app/composables/head.mjs

@@ -0,0 +1 @@
+export { useHead, useSeoMeta, useServerSeoMeta } from "#head";

package/dist/app/composables/index.d.ts

@@ -9,9 +9,11 @@ export { useFetch, useLazyFetch } from './fetch';
 export type { FetchResult, UseFetchOptions } from './fetch';
 export { useCookie } from './cookie';
 export type { CookieOptions, CookieRef } from './cookie';
-export { useRequestHeaders, useRequestEvent, setResponseStatus } from './ssr';
+export { useRequestHeaders, useRequestEvent, useRequestFetch, setResponseStatus } from './ssr';
 export { onDtwoReady } from './ready';
 export { abortNavigation, addRouteMiddleware, defineDtwoRouteMiddleware, onBeforeRouteLeave, onBeforeRouteUpdate, setPageLayout, navigateTo, useRoute, useRouter } from './router';
 export type { AddRouteMiddlewareOptions, RouteMiddleware } from './router';
 export { preloadComponents, prefetchComponents, preloadRouteComponents } from './preload';
 export { isPrerendered, loadPayload, preloadPayload } from './payload';
+export type { MetaObject } from './head';
+export { useHead, useSeoMeta, useServerSeoMeta } from './head';

package/dist/app/composables/index.mjs

@@ -5,8 +5,9 @@ export { useState } from "./state.mjs";
 export { clearError, createError, isDtwoError, showError, useError } from "./error.mjs";
 export { useFetch, useLazyFetch } from "./fetch.mjs";
 export { useCookie } from "./cookie.mjs";
-export { useRequestHeaders, useRequestEvent, setResponseStatus } from "./ssr.mjs";
+export { useRequestHeaders, useRequestEvent, useRequestFetch, setResponseStatus } from "./ssr.mjs";
 export { onDtwoReady } from "./ready.mjs";
 export { abortNavigation, addRouteMiddleware, defineDtwoRouteMiddleware, onBeforeRouteLeave, onBeforeRouteUpdate, setPageLayout, navigateTo, useRoute, useRouter } from "./router.mjs";
 export { preloadComponents, prefetchComponents, preloadRouteComponents } from "./preload.mjs";
 export { isPrerendered, loadPayload, preloadPayload } from "./payload.mjs";
+export { useHead, useSeoMeta, useServerSeoMeta } from "./head.mjs";

package/dist/app/composables/payload.mjs

@@ -1,6 +1,6 @@
 import { joinURL } from "ufo";
-import { useDtwoApp } from "../dtwo.mjs";
-import { useHead, useRuntimeConfig } from "../index.mjs";
+import { useDtwoApp, useRuntimeConfig } from "../dtwo.mjs";
+import { useHead } from "./head.mjs";
 export function loadPayload(url, opts = {}) {
   if (process.server) {
     return null;

package/dist/app/composables/preload.mjs

@@ -26,11 +26,11 @@ export async function preloadRouteComponents(to, router = useRouter()) {
   if (router._routePreloaded.has(to)) {
     return;
   }
-  router._routePreloaded.add(to);
   const promises = router._preloadPromises = router._preloadPromises || [];
   if (promises.length > 4) {
     return Promise.all(promises).then(() => preloadRouteComponents(to, router));
   }
+  router._routePreloaded.add(to);
   const components = router.resolve(to).matched.map((component) => component.components?.default).filter((component) => typeof component === "function");
   for (const component of components) {
     const promise = Promise.resolve(component()).catch(() => {

package/dist/app/composables/ready.mjs

@@ -1,6 +1,9 @@
 import { useDtwoApp } from "../dtwo.mjs";
 import { requestIdleCallback } from "../compat/idle-callback.mjs";
 export const onDtwoReady = (callback) => {
+  if (process.server) {
+    return;
+  }
   const dtwoApp = useDtwoApp();
   if (dtwoApp.isHydrating) {
     dtwoApp.hooks.hookOnce("app:suspense:resolve", () => {

package/dist/app/composables/ssr.d.ts

@@ -3,4 +3,5 @@ import type { DtwoApp } from '../dtwo';
 export declare function useRequestHeaders<K extends string = string>(include: K[]): Record<Lowercase<K>, string | undefined>;
 export declare function useRequestHeaders(): Readonly<Record<string, string | undefined>>;
 export declare function useRequestEvent(dtwoApp?: DtwoApp): H3Event;
+export declare function useRequestFetch(): typeof global.$fetch;
 export declare function setResponseStatus(code: number, message?: string): void;

package/dist/app/composables/ssr.mjs

@@ -12,6 +12,13 @@ export function useRequestHeaders(include) {
 export function useRequestEvent(dtwoApp = useDtwoApp()) {
   return dtwoApp.ssrContext?.event;
 }
+export function useRequestFetch() {
+  if (process.client) {
+    return globalThis.$fetch;
+  }
+  const event = useDtwoApp().ssrContext?.event;
+  return event?.$fetch || globalThis.$fetch;
+}
 export function setResponseStatus(code, message) {
   const event = process.server && useRequestEvent();
   if (event) {

package/dist/app/entry-spa.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => void;
+export default _default;

package/dist/app/entry-spa.mjs

@@ -0,0 +1,2 @@
+export default () => {
+};

package/dist/app/entry.mjs

@@ -1,7 +1,7 @@
 import { createSSRApp, createApp, nextTick } from "kdu";
 import { $fetch } from "ofetch";
 import { baseURL } from "#build/paths.mjs";
-import { createDtwoApp, applyPlugins, normalizePlugins } from "#app";
+import { createDtwoApp, applyPlugins, normalizePlugins } from "#app/dtwo";
 import "#build/css";
 import _plugins from "#build/plugins";
 import RootComponent from "#build/root-component.mjs";

package/dist/app/index.d.ts

@@ -4,7 +4,5 @@ export * from './composables';
 export * from './components';
 export * from './config';
 export type { PageMeta } from '../pages/runtime';
-export type { MetaObject } from '../head/runtime';
-export { useHead } from '#head';
 export declare const isKdu2 = false;
 export declare const isKdu3 = true;

package/dist/app/index.mjs

@@ -2,6 +2,5 @@ export * from "./dtwo.mjs";
 export * from "./composables/index.mjs";
 export * from "./components/index.mjs";
 export * from "./config.mjs";
-export { useHead } from "#head";
 export const isKdu2 = false;
 export const isKdu3 = true;

package/dist/app/plugins/cross-origin-prefetch.client.mjs

@@ -1,6 +1,7 @@
 import { ref } from "kdu";
 import { parseURL } from "ufo";
-import { defineDtwoPlugin, useHead } from "#app";
+import { defineDtwoPlugin } from "#app/dtwo";
+import { useHead } from "#app/composables/head";
 export default defineDtwoPlugin((dtwoApp) => {
   const externalURLs = ref(/* @__PURE__ */ new Set());
   function generateRules() {

package/dist/app/plugins/debug.mjs

@@ -1,5 +1,5 @@
 import { createDebugger } from "hookable";
-import { defineDtwoPlugin } from "#app";
+import { defineDtwoPlugin } from "#app/dtwo";
 export default defineDtwoPlugin((dtwoApp) => {
   createDebugger(dtwoApp.hooks, { tag: "dtwo-app" });
 });

package/dist/app/plugins/payload.client.mjs

@@ -1,5 +1,7 @@
 import { parseURL } from "ufo";
-import { defineDtwoPlugin, loadPayload, isPrerendered, useRouter } from "#app";
+import { defineDtwoPlugin } from "#app/dtwo";
+import { loadPayload, isPrerendered } from "#app/composables/payload";
+import { useRouter } from "#app/composables/router";
 export default defineDtwoPlugin((dtwoApp) => {
   if (!isPrerendered()) {
     return;

package/dist/app/plugins/preload.server.mjs

@@ -1,4 +1,4 @@
-import { defineDtwoPlugin } from "#app";
+import { defineDtwoPlugin } from "#app/dtwo";
 export default defineDtwoPlugin((dtwoApp) => {
   dtwoApp.kduApp.mixin({
     beforeCreate() {

package/dist/app/plugins/router.d.ts

@@ -46,7 +46,7 @@ interface Router {
     hasRoute: (name: string) => boolean;
     removeRoute: (name: string) => void;
 }
-declare const _default: import("..").Plugin<{
+declare const _default: import("../dtwo").Plugin<{
     route: Route;
     router: Router;
 }>;

package/dist/app/plugins/router.mjs

@@ -1,7 +1,11 @@
 import { reactive, h, isReadonly } from "kdu";
 import { parseURL, stringifyParsedURL, parseQuery, stringifyQuery, withoutBase, isEqual, joinURL } from "ufo";
 import { createError } from "h3";
-import { defineDtwoPlugin, clearError, navigateTo, showError, useRuntimeConfig, useState, useRequestEvent } from "../index.mjs";
+import { defineDtwoPlugin, useRuntimeConfig } from "../dtwo.mjs";
+import { clearError, showError } from "../composables/error.mjs";
+import { navigateTo } from "../composables/router.mjs";
+import { useState } from "../composables/state.mjs";
+import { useRequestEvent } from "../composables/ssr.mjs";
 import { callWithDtwo } from "../dtwo.mjs";
 import { globalMiddleware } from "#build/middleware";
 function getRouteFromPath(fullPath) {

package/dist/components/runtime/server-component.mjs

@@ -2,7 +2,10 @@ import { defineComponent, createStaticKNode, computed, h, watch } from "kdu";
 import { debounce } from "perfect-debounce";
 import { hash } from "ohash";
 import { appendHeader } from "h3";
-import { useAsyncData, useHead, useDtwoApp, useRequestEvent } from "#app";
+import { useDtwoApp } from "#app/dtwo";
+import { useRequestEvent } from "#app/composables/ssr";
+import { useAsyncData } from "#app/composables/asyncData";
+import { useHead } from "#app/composables/head";
 const pKey = "_islandPromises";
 export const createServerComponent = (name) => {
   return defineComponent({

package/dist/core/runtime/hole/renderer.mjs

@@ -13,7 +13,7 @@ globalThis.__publicAssetsURL = publicAssetsURL;
 const getClientManifest = () => import("#build/dist/server/client.manifest.mjs").then((r) => r.default || r).then((r) => typeof r === "function" ? r() : r);
 const getStaticRenderedHead = () => import("#head-static").then((r) => r.default || r);
 const getServerEntry = () => import("#build/dist/server/server.mjs").then((r) => r.default || r);
-const getSSRStyles = () => import("#build/dist/server/styles.mjs").then((r) => r.default || r);
+const getSSRStyles = lazyCachedFunction(() => import("#build/dist/server/styles.mjs").then((r) => r.default || r));
 const getSSRRenderer = lazyCachedFunction(async () => {
   const manifest = await getClientManifest();
   if (!manifest) {

package/dist/head/runtime/components.d.ts

@@ -48,7 +48,7 @@ export declare const NoScript: import("kdu").DefineComponent<{
     translate: StringConstructor;
 }, () => import("kdu").KNode<import("kdu").RendererNode, import("kdu").RendererElement, {
     [key: string]: any;
-}>[] | null | undefined, unknown, {}, {}, import("kdu").ComponentOptionsMixin, import("kdu").ComponentOptionsMixin, import("kdu").EmitsOptions, string, import("kdu").KNodeProps & import("kdu").AllowedComponentProps & import("kdu").ComponentCustomProps, Readonly<import("kdu").ExtractPropTypes<{
+}>[] | null | undefined, unknown, {}, {}, import("kdu").ComponentOptionsMixin, import("kdu").ComponentOptionsMixin, {}, string, import("kdu").KNodeProps & import("kdu").AllowedComponentProps & import("kdu").ComponentCustomProps, Readonly<import("kdu").ExtractPropTypes<{
     title: StringConstructor;
     body: BooleanConstructor;
     renderPriority: (StringConstructor | NumberConstructor)[];
@@ -172,7 +172,7 @@ export declare const Link: import("kdu").DefineComponent<{
     translate: StringConstructor;
 }, () => import("kdu").KNode<import("kdu").RendererNode, import("kdu").RendererElement, {
     [key: string]: any;
-}>[] | null | undefined, unknown, {}, {}, import("kdu").ComponentOptionsMixin, import("kdu").ComponentOptionsMixin, import("kdu").EmitsOptions, string, import("kdu").KNodeProps & import("kdu").AllowedComponentProps & import("kdu").ComponentCustomProps, Readonly<import("kdu").ExtractPropTypes<{
+}>[] | null | undefined, unknown, {}, {}, import("kdu").ComponentOptionsMixin, import("kdu").ComponentOptionsMixin, {}, string, import("kdu").KNodeProps & import("kdu").AllowedComponentProps & import("kdu").ComponentCustomProps, Readonly<import("kdu").ExtractPropTypes<{
     as: StringConstructor;
     crossorigin: PropType<CrossOrigin>;
     disabled: BooleanConstructor;
@@ -298,7 +298,7 @@ export declare const Base: import("kdu").DefineComponent<{
     translate: StringConstructor;
 }, () => import("kdu").KNode<import("kdu").RendererNode, import("kdu").RendererElement, {
     [key: string]: any;
-}>[] | null | undefined, unknown, {}, {}, import("kdu").ComponentOptionsMixin, import("kdu").ComponentOptionsMixin, import("kdu").EmitsOptions, string, import("kdu").KNodeProps & import("kdu").AllowedComponentProps & import("kdu").ComponentCustomProps, Readonly<import("kdu").ExtractPropTypes<{
+}>[] | null | undefined, unknown, {}, {}, import("kdu").ComponentOptionsMixin, import("kdu").ComponentOptionsMixin, {}, string, import("kdu").KNodeProps & import("kdu").AllowedComponentProps & import("kdu").ComponentCustomProps, Readonly<import("kdu").ExtractPropTypes<{
     href: StringConstructor;
     target: PropType<Target>;
     accesskey: StringConstructor;
@@ -355,7 +355,7 @@ export declare const Title: import("kdu").DefineComponent<{
     [x: string]: any;
 }, () => import("kdu").KNode<import("kdu").RendererNode, import("kdu").RendererElement, {
     [key: string]: any;
-}>[] | null | undefined, {}, {}, {}, import("kdu").ComponentOptionsMixin, import("kdu").ComponentOptionsMixin, import("kdu").EmitsOptions, string, import("kdu").KNodeProps & import("kdu").AllowedComponentProps & import("kdu").ComponentCustomProps, Readonly<import("kdu").ExtractPropTypes<{
+}>[] | null | undefined, {}, {}, {}, import("kdu").ComponentOptionsMixin, import("kdu").ComponentOptionsMixin, {}, string, import("kdu").KNodeProps & import("kdu").AllowedComponentProps & import("kdu").ComponentCustomProps, Readonly<import("kdu").ExtractPropTypes<{
     [x: string]: any;
 }>>, {
     [x: string]: any;
@@ -412,7 +412,7 @@ export declare const Meta: import("kdu").DefineComponent<{
     translate: StringConstructor;
 }, () => import("kdu").KNode<import("kdu").RendererNode, import("kdu").RendererElement, {
     [key: string]: any;
-}>[] | null | undefined, unknown, {}, {}, import("kdu").ComponentOptionsMixin, import("kdu").ComponentOptionsMixin, import("kdu").EmitsOptions, string, import("kdu").KNodeProps & import("kdu").AllowedComponentProps & import("kdu").ComponentCustomProps, Readonly<import("kdu").ExtractPropTypes<{
+}>[] | null | undefined, unknown, {}, {}, import("kdu").ComponentOptionsMixin, import("kdu").ComponentOptionsMixin, {}, string, import("kdu").KNodeProps & import("kdu").AllowedComponentProps & import("kdu").ComponentCustomProps, Readonly<import("kdu").ExtractPropTypes<{
     charset: StringConstructor;
     content: StringConstructor;
     httpEquiv: PropType<HTTPEquiv>;
@@ -525,7 +525,7 @@ export declare const Style: import("kdu").DefineComponent<{
     translate: StringConstructor;
 }, () => import("kdu").KNode<import("kdu").RendererNode, import("kdu").RendererElement, {
     [key: string]: any;
-}>[] | null | undefined, unknown, {}, {}, import("kdu").ComponentOptionsMixin, import("kdu").ComponentOptionsMixin, import("kdu").EmitsOptions, string, import("kdu").KNodeProps & import("kdu").AllowedComponentProps & import("kdu").ComponentCustomProps, Readonly<import("kdu").ExtractPropTypes<{
+}>[] | null | undefined, unknown, {}, {}, import("kdu").ComponentOptionsMixin, import("kdu").ComponentOptionsMixin, {}, string, import("kdu").KNodeProps & import("kdu").AllowedComponentProps & import("kdu").ComponentCustomProps, Readonly<import("kdu").ExtractPropTypes<{
     type: StringConstructor;
     media: StringConstructor;
     nonce: StringConstructor;
@@ -640,7 +640,7 @@ export declare const Html: import("kdu").DefineComponent<{
     translate: StringConstructor;
 }, () => import("kdu").KNode<import("kdu").RendererNode, import("kdu").RendererElement, {
     [key: string]: any;
-}>[] | null | undefined, unknown, {}, {}, import("kdu").ComponentOptionsMixin, import("kdu").ComponentOptionsMixin, import("kdu").EmitsOptions, string, import("kdu").KNodeProps & import("kdu").AllowedComponentProps & import("kdu").ComponentCustomProps, Readonly<import("kdu").ExtractPropTypes<{
+}>[] | null | undefined, unknown, {}, {}, import("kdu").ComponentOptionsMixin, import("kdu").ComponentOptionsMixin, {}, string, import("kdu").KNodeProps & import("kdu").AllowedComponentProps & import("kdu").ComponentCustomProps, Readonly<import("kdu").ExtractPropTypes<{
     manifest: StringConstructor;
     version: StringConstructor;
     xmlns: StringConstructor;
@@ -742,7 +742,7 @@ export declare const Body: import("kdu").DefineComponent<{
     translate: StringConstructor;
 }, () => import("kdu").KNode<import("kdu").RendererNode, import("kdu").RendererElement, {
     [key: string]: any;
-}>[] | null | undefined, unknown, {}, {}, import("kdu").ComponentOptionsMixin, import("kdu").ComponentOptionsMixin, import("kdu").EmitsOptions, string, import("kdu").KNodeProps & import("kdu").AllowedComponentProps & import("kdu").ComponentCustomProps, Readonly<import("kdu").ExtractPropTypes<{
+}>[] | null | undefined, unknown, {}, {}, import("kdu").ComponentOptionsMixin, import("kdu").ComponentOptionsMixin, {}, string, import("kdu").KNodeProps & import("kdu").AllowedComponentProps & import("kdu").ComponentCustomProps, Readonly<import("kdu").ExtractPropTypes<{
     renderPriority: (StringConstructor | NumberConstructor)[];
     accesskey: StringConstructor;
     autocapitalize: StringConstructor;

package/dist/head/runtime/composables.mjs

@@ -1,5 +1,5 @@
 import { useSeoMeta as _useSeoMeta } from "@kduse/head";
-import { useDtwoApp } from "#app";
+import { useDtwoApp } from "#app/dtwo";
 export function useHead(input, options) {
   return useDtwoApp()._useHead(input, options);
 }

package/dist/head/runtime/lib/kduse-head.plugin.mjs

@@ -1,6 +1,6 @@
 import { createHead, useHead } from "@kduse/head";
 import { renderSSRHead } from "@kdhead/ssr";
-import { defineDtwoPlugin } from "#app";
+import { defineDtwoPlugin } from "#app/dtwo";
 import { appHead } from "#build/dtwo.config.mjs";
 export default defineDtwoPlugin((dtwoApp) => {
   const head = createHead();

package/dist/index.mjs

@@ -7,6 +7,8 @@ import { encodePath, parseURL, stringifyQuery, parseQuery, joinURL, withTrailing
 import { existsSync, readdirSync, statSync, promises } from 'node:fs';
 import { genArrayFromRaw, genSafeVariableName, genImport, genDynamicImport, genObjectFromRawEntries, genString, genExport } from 'knitwork';
 import { fileURLToPath, pathToFileURL } from 'node:url';
+import { filename } from 'pathe/utils';
+import { hash } from 'ohash';
 import { kebabCase, splitByCase, pascalCase, camelCase } from 'scule';
 import { createUnplugin } from '@dtwo/unplugin';
 import { findStaticImports, findExports, parseStaticImport, resolvePath as resolvePath$1 } from 'mlly';
@@ -14,13 +16,12 @@ import { walk } from 'estree-walker';
 import MagicString from 'magic-string';
 import { globby } from 'globby';
 import { hyphenate } from '@kdujs/shared';
-import { parse, walk as walk$1, ELEMENT_NODE } from 'ultrahtml';
 import { defineKdimportPreset, createKdimport, scanDirExports } from 'kdimport';
 import { createRequire } from 'node:module';
 import { createTransformer } from 'unctx/transform';
 import { stripLiteral } from 'strip-literal';
 import { createHole, scanHandlers, writeTypes, build as build$1, prepare, copyPublicAssets, prerender, createDevServer } from 'holepack';
-import defu, { defu as defu$1 } from 'defu';
+import { defu } from 'defu';
 import { dynamicEventHandler } from 'h3';
 import { createHeadCore } from 'kdhead';
 import { renderSSRHead } from '@kdhead/ssr';
@@ -30,7 +31,6 @@ import { debounce } from 'perfect-debounce';
 import { resolveSchema, generateMarkdown, generateTypes } from 'untyped';
 import untypedPlugin from 'untyped/babel-plugin';
 import jiti from 'jiti';
-import { hash } from 'ohash';
 
 let _distDir = dirname(fileURLToPath(import.meta.url));
 if (_distDir.match(/(chunks|shared)$/)) {
@@ -195,12 +195,11 @@ function prepareRoutes(routes, parent) {
   return routes;
 }
 function normalizeRoutes(routes, metaImports = /* @__PURE__ */ new Set()) {
-  const dtwo = useDtwo();
   return {
     imports: metaImports,
     routes: genArrayFromRaw(routes.map((page) => {
       const file = normalize(page.file);
-      const metaImportName = genSafeVariableName(relative(dtwo.options.rootDir, file)) + "Meta";
+      const metaImportName = genSafeVariableName(filename(file) + hash(file)) + "Meta";
       metaImports.add(genImport(`${file}?macro=true`, [{ name: "default", as: metaImportName }]));
       let aliasCode = `${metaImportName}?.alias || []`;
       if (Array.isArray(page.alias) && page.alias.length) {
@@ -538,6 +537,9 @@ const pagesModule = defineDtwoModule({
     dtwo.options.wite.optimizeDeps = dtwo.options.wite.optimizeDeps || {};
     dtwo.options.wite.optimizeDeps.include = dtwo.options.wite.optimizeDeps.include || [];
     dtwo.options.wite.optimizeDeps.include.push("kdu-router");
+    dtwo.options.wite.resolve = dtwo.options.wite.resolve || {};
+    dtwo.options.wite.resolve.dedupe = dtwo.options.wite.resolve.dedupe || [];
+    dtwo.options.wite.resolve.dedupe.push("kdu-router");
     addTemplate({
       filename: "router.options.mjs",
       getContents: async () => {
@@ -635,7 +637,7 @@ const componentsPluginTemplate = {
   getContents({ options }) {
     const globalComponents = options.getComponents().filter((c) => c.global === true);
     return `import { defineAsyncComponent } from 'kdu'
-import { defineDtwoPlugin } from '#app'
+import { defineDtwoPlugin } from '#app/dtwo'
 
 const components = ${genObjectFromRawEntries(globalComponents.map((c) => {
       const exp = c.export === "default" ? "c.default || c" : `c['${c.export}']`;
@@ -897,44 +899,99 @@ function findComponent(components, name, mode) {
   return otherModeComponent;
 }
 
-const PLACEHOLDER_RE = /^(k-slot|#)(fallback|placeholder)/;
+const SSR_RENDER_RE = /ssrRenderComponent/;
+const PLACEHOLDER_EXACT_RE = /^(fallback|placeholder)$/;
 const TreeShakeTemplatePlugin = createUnplugin((options) => {
   const regexpMap = /* @__PURE__ */ new WeakMap();
   return {
     name: "dtwo:tree-shake-template",
-    enforce: "pre",
+    enforce: "post",
     transformInclude(id) {
       const { pathname } = parseURL(decodeURIComponent(pathToFileURL(id).href));
       return pathname.endsWith(".kdu");
     },
-    async transform(code, id) {
-      const template = code.match(/<template>([\s\S]*)<\/template>/);
-      if (!template) {
-        return;
-      }
+    transform(code, id) {
       const components = options.getComponents();
       if (!regexpMap.has(components)) {
-        const clientOnlyComponents2 = components.filter((c) => c.mode === "client" && !components.some((other) => other.mode !== "client" && other.pascalName === c.pascalName)).flatMap((c) => [c.pascalName, c.kebabName]).concat(["ClientOnly", "client-only"]);
-        const tags = clientOnlyComponents2.map((component) => `<(${component})[^>]*>[\\s\\S]*?<\\/(${component})>`);
-        regexpMap.set(components, [new RegExp(`(${tags.join("|")})`, "g"), clientOnlyComponents2]);
+        const clientOnlyComponents = components.filter((c) => c.mode === "client" && !components.some((other) => other.mode !== "client" && other.pascalName === c.pascalName && other.filePath !== resolve(distDir, "app/components/server-placeholder"))).flatMap((c) => [c.pascalName, c.kebabName.replaceAll("-", "_")]).concat(["ClientOnly", "client_only"]);
+        regexpMap.set(components, [new RegExp(`(${clientOnlyComponents.join("|")})`), new RegExp(`^(${clientOnlyComponents.map((c) => `(?:(?:_unref\\()?(?:_component_)?(?:Lazy|lazy_)?${c}\\)?)`).join("|")})$`), clientOnlyComponents]);
       }
-      const [COMPONENTS_RE, clientOnlyComponents] = regexpMap.get(components);
+      const s = new MagicString(code);
+      const importDeclarations = [];
+      const [COMPONENTS_RE, COMPONENTS_IDENTIFIERS_RE] = regexpMap.get(components);
       if (!COMPONENTS_RE.test(code)) {
         return;
       }
-      const s = new MagicString(code);
-      const ast = parse(template[0]);
-      await walk$1(ast, (node) => {
-        if (node.type !== ELEMENT_NODE || !clientOnlyComponents.includes(node.name) || !node.children?.length) {
-          return;
-        }
-        const fallback = node.children.find(
-          (n) => n.name === "template" && Object.entries(n.attributes)?.flat().some((attr) => PLACEHOLDER_RE.test(attr))
-        );
-        try {
-          const text = fallback ? code.slice(template.index + fallback.loc[0].start, template.index + fallback.loc[fallback.loc.length - 1].end) : "";
-          s.overwrite(template.index + node.loc[0].end, template.index + node.loc[node.loc.length - 1].start, text);
-        } catch (err) {
+      walk(this.parse(code, { sourceType: "module", ecmaVersion: "latest" }), {
+        enter: (_node) => {
+          const node = _node;
+          if (node.type === "ImportDeclaration") {
+            importDeclarations.push(node);
+          } else if (node.type === "CallExpression" && node.callee.type === "Identifier" && SSR_RENDER_RE.test(node.callee.name)) {
+            const [componentCall, _, children] = node.arguments;
+            if (componentCall.type === "Identifier" || componentCall.type === "MemberExpression" || componentCall.type === "CallExpression") {
+              const componentName = getComponentName(node);
+              const isClientComponent = COMPONENTS_IDENTIFIERS_RE.test(componentName);
+              const isClientOnlyComponent = /^(?:_unref\()?(?:_component_)?(?:Lazy|lazy_)?(?:client_only|ClientOnly\)?)$/.test(componentName);
+              if (isClientComponent && children?.type === "ObjectExpression") {
+                const slotsToRemove = isClientOnlyComponent ? children.properties.filter((prop) => prop.type === "Property" && prop.key.type === "Identifier" && !PLACEHOLDER_EXACT_RE.test(prop.key.name)) : children.properties;
+                for (const slot of slotsToRemove) {
+                  const componentsSet = /* @__PURE__ */ new Set();
+                  s.remove(slot.start, slot.end + 1);
+                  const removedCode = `({${code.slice(slot.start, slot.end + 1)}})`;
+                  const currentCode = s.toString();
+                  walk(this.parse(removedCode, { sourceType: "module", ecmaVersion: "latest" }), {
+                    enter: (_node2) => {
+                      const node2 = _node2;
+                      if (node2.type === "CallExpression" && node2.callee.type === "Identifier" && SSR_RENDER_RE.test(node2.callee.name)) {
+                        const componentNode = node2.arguments[0];
+                        if (componentNode.type === "CallExpression") {
+                          const identifier = componentNode.arguments[0];
+                          if (!isRenderedInCode(currentCode, removedCode.slice(componentNode.start, componentNode.end))) {
+                            componentsSet.add(identifier.name);
+                          }
+                        } else if (componentNode.type === "Identifier" && !isRenderedInCode(currentCode, componentNode.name)) {
+                          componentsSet.add(componentNode.name);
+                        } else if (componentNode.type === "MemberExpression") {
+                          const { start, end } = componentNode;
+                          if (!isRenderedInCode(currentCode, removedCode.slice(start, end))) {
+                            componentsSet.add(componentNode.property.value);
+                            walk(this.parse(code, { sourceType: "module", ecmaVersion: "latest" }), {
+                              enter: (node3) => {
+                                removeFromSetupReturnStatement(s, node3, componentNode.property.value);
+                              }
+                            });
+                          }
+                        }
+                      }
+                    }
+                  });
+                  const componentsToRemove = [...componentsSet];
+                  for (const componentName2 of componentsToRemove) {
+                    let removed = false;
+                    const VAR_RE = new RegExp(`(?:const|let|var) ${componentName2} = ([^;\\n]*);?`);
+                    s.replace(VAR_RE, () => {
+                      removed = true;
+                      return "";
+                    });
+                    if (!removed) {
+                      const declaration = findImportDeclaration(importDeclarations, componentName2);
+                      if (declaration) {
+                        if (declaration.specifiers.length > 1) {
+                          const componentSpecifier = declaration.specifiers.find((s2) => s2.local.name === componentName2);
+                          if (componentSpecifier) {
+                            s.remove(componentSpecifier.start, componentSpecifier.end + 1);
+                          }
+                        } else {
+                          s.remove(declaration.start, declaration.end);
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
         }
       });
       if (s.hasChanged()) {
@@ -946,6 +1003,46 @@ const TreeShakeTemplatePlugin = createUnplugin((options) => {
     }
   };
 });
+function findImportDeclaration(declarations, importName) {
+  const declaration = declarations.find((d) => {
+    const specifier = d.specifiers.find((s) => s.local.name === importName);
+    if (specifier) {
+      return true;
+    }
+    return false;
+  });
+  return declaration;
+}
+function isRenderedInCode(code, name) {
+  return new RegExp(`ssrRenderComponent\\(${escapeRE(name)}`).test(code);
+}
+function getComponentName(ssrRenderNode) {
+  const componentCall = ssrRenderNode.arguments[0];
+  if (componentCall.type === "Identifier") {
+    return componentCall.name;
+  } else if (componentCall.type === "MemberExpression") {
+    return componentCall.property.value;
+  }
+  return componentCall.arguments[0].name;
+}
+function removeFromSetupReturnStatement(s, node, name) {
+  if (node.type === "Property" && node.key.type === "Identifier" && node.key.name === "setup" && node.value.type === "FunctionExpression") {
+    const returnStatement = node.value.body.body.find((n) => n.type === "ReturnStatement");
+    if (returnStatement?.argument?.type === "Identifier") {
+      const returnIdentifier = returnStatement.argument.name;
+      const returnedDeclaration = node.value.body.body.find((n) => n.type === "VariableDeclaration" && n.declarations[0].id.name === returnIdentifier);
+      const componentProperty = returnedDeclaration?.declarations[0].init?.properties.find((p) => p.key.name === name);
+      if (componentProperty) {
+        s.remove(componentProperty.start, componentProperty.end + 1);
+      }
+    } else if (returnStatement?.argument?.type === "ObjectExpression") {
+      const componentProperty = returnStatement.argument?.properties.find((p) => p.key.name === name);
+      if (componentProperty) {
+        s.remove(componentProperty.start, componentProperty.end + 1);
+      }
+    }
+  }
+}
 
 const isPureObjectOrString = (val) => !Array.isArray(val) && typeof val === "object" || typeof val === "string";
 const isDirectory = (p) => {
@@ -1101,35 +1198,35 @@ const componentsModule = defineDtwoModule({
     dtwo.hook("wite:extendConfig", (config, { isClient, isServer }) => {
       const mode = isClient ? "client" : "server";
       config.plugins = config.plugins || [];
-      config.plugins.push(loaderPlugin.wite({
-        sourcemap: dtwo.options.sourcemap[mode],
-        getComponents,
-        mode,
-        experimentalComponentIslands: dtwo.options.experimental.componentIslands
-      }));
       if (dtwo.options.experimental.treeshakeClientOnly && isServer) {
         config.plugins.push(TreeShakeTemplatePlugin.wite({
           sourcemap: dtwo.options.sourcemap[mode],
           getComponents
         }));
       }
+      config.plugins.push(loaderPlugin.wite({
+        sourcemap: dtwo.options.sourcemap[mode],
+        getComponents,
+        mode,
+        experimentalComponentIslands: dtwo.options.experimental.componentIslands
+      }));
     });
     dtwo.hook("webpack:config", (configs) => {
       configs.forEach((config) => {
         const mode = config.name === "client" ? "client" : "server";
         config.plugins = config.plugins || [];
-        config.plugins.push(loaderPlugin.webpack({
-          sourcemap: dtwo.options.sourcemap[mode],
-          getComponents,
-          mode,
-          experimentalComponentIslands: dtwo.options.experimental.componentIslands
-        }));
         if (dtwo.options.experimental.treeshakeClientOnly && mode === "server") {
           config.plugins.push(TreeShakeTemplatePlugin.webpack({
             sourcemap: dtwo.options.sourcemap[mode],
             getComponents
           }));
         }
+        config.plugins.push(loaderPlugin.webpack({
+          sourcemap: dtwo.options.sourcemap[mode],
+          getComponents,
+          mode,
+          experimentalComponentIslands: dtwo.options.experimental.componentIslands
+        }));
       });
     });
   }
@@ -1173,15 +1270,6 @@ const TransformPlugin = createUnplugin(({ ctx, options, sourcemap }) => {
 });
 
 const commonPresets = [
-  // #head
-  defineKdimportPreset({
-    from: "#head",
-    imports: [
-      "useHead",
-      "useSeoMeta",
-      "useServerSeoMeta"
-    ]
-  }),
   // kdu-demi (mocked)
   defineKdimportPreset({
     from: "kdu-demi",
@@ -1194,6 +1282,9 @@ const commonPresets = [
 const appPreset = defineKdimportPreset({
   from: "#app",
   imports: [
+    "useHead",
+    "useSeoMeta",
+    "useServerSeoMeta",
     "useAsyncData",
     "useLazyAsyncData",
     "useDtwoData",
@@ -1209,6 +1300,7 @@ const appPreset = defineKdimportPreset({
     "useCookie",
     "useRequestHeaders",
     "useRequestEvent",
+    "useRequestFetch",
     "setResponseStatus",
     "setPageLayout",
     "onDtwoReady",
@@ -1309,11 +1401,25 @@ const kduPreset = defineKdimportPreset({
     "useTransitionState"
   ]
 });
+const kduTypesPreset = defineKdimportPreset({
+  from: "kdu",
+  type: true,
+  imports: [
+    "Component",
+    "ComponentPublicInstance",
+    "ComputedRef",
+    "InjectionKey",
+    "PropType",
+    "Ref",
+    "KNode"
+  ]
+});
 const defaultPresets = [
   ...commonPresets,
   appPreset,
   routerPreset,
-  kduPreset
+  kduPreset,
+  kduTypesPreset
 ];
 
 const importsModule = defineDtwoModule({
@@ -1427,7 +1533,7 @@ function addDeclarationTemplates(ctx, options) {
   });
 }
 
-const version = "3.1.1";
+const version = "3.2.0";
 
 const _require = createRequire(import.meta.url);
 const kduAppPatterns = (dtwo) => [
@@ -1597,6 +1703,11 @@ const addModuleTranspiles = (opts = {}) => {
 
 async function initHole(dtwo) {
   const _holeConfig = dtwo.options.hole || {};
+  const excludePaths = dtwo.options._layers.flatMap((l) => [
+    l.cwd.match(/(?<=\/)node_modules\/(.+)$/)?.[1],
+    l.cwd.match(/\.pnpm\/.+\/node_modules\/(.+)$/)?.[1]
+  ]).filter((dir) => Boolean(dir)).map((dir) => escapeRE(dir));
+  const excludePattern = excludePaths.length ? [new RegExp(`node_modules\\/(?!${excludePaths.join("|")})`)] : [/node_modules/];
   const holeConfig = defu(_holeConfig, {
     debug: dtwo.options.debug,
     rootDir: dtwo.options.rootDir,
@@ -1616,14 +1727,11 @@ async function initHole(dtwo) {
           name: "publicAssetsURL",
           from: resolve(distDir, "core/runtime/hole/paths")
         }
-      ]
+      ],
+      exclude: [...excludePattern, /[\\/]\.git[\\/]/]
     },
     esbuild: {
-      options: {
-        exclude: [
-          new RegExp(`node_modules\\/(?!${dtwo.options._layers.map((l) => l.cwd.match(/(?<=\/)node_modules\/(.+)$/)?.[1]).filter(Boolean).map((dir) => escapeRE(dir)).join("|")})`)
-        ]
-      }
+      options: { exclude: excludePattern }
     },
     analyze: dtwo.options.build.analyze && {
       template: "treemap",
@@ -1654,7 +1762,11 @@ async function initHole(dtwo) {
       generateTsConfig: false
     },
     publicAssets: [
-      { dir: resolve(dtwo.options.buildDir, "dist/client") },
+      dtwo.options.dev ? { dir: resolve(dtwo.options.buildDir, "dist/client") } : {
+        dir: join(dtwo.options.buildDir, "dist/client", dtwo.options.app.buildAssetsDir),
+        maxAge: 30 * 24 * 60 * 60,
+        baseURL: dtwo.options.app.buildAssetsDir
+      },
       ...dtwo.options._layers.map((layer) => join(layer.config.srcDir, layer.config.dir?.public || "public")).filter((dir) => existsSync(dir)).map((dir) => ({ dir }))
     ],
     prerender: {
@@ -1714,9 +1826,15 @@ async function initHole(dtwo) {
   holeConfig.virtual["#head-static"] = `export default ${JSON.stringify(headChunk)}`;
   if (!dtwo.options.ssr) {
     holeConfig.virtual["#build/dist/server/server.mjs"] = "export default () => {}";
+    if (process.platform === "win32") {
+      holeConfig.virtual["#build/dist/server/server.mjs".replace(/\//g, "\\")] = "export default () => {}";
+    }
   }
   if (!dtwo.options.experimental.inlineSSRStyles) {
     holeConfig.virtual["#build/dist/server/styles.mjs"] = "export default {}";
+    if (process.platform === "win32") {
+      holeConfig.virtual["#build/dist/server/styles.mjs".replace(/\//g, "\\")] = "export default {}";
+    }
   }
   holeConfig.rollupConfig.plugins = await holeConfig.rollupConfig.plugins || [];
   holeConfig.rollupConfig.plugins = Array.isArray(holeConfig.rollupConfig.plugins) ? holeConfig.rollupConfig.plugins : [holeConfig.rollupConfig.plugins];
@@ -1867,7 +1985,7 @@ const schemaModule = defineDtwoModule({
       const schemas = await Promise.all(
         schemaDefs.map((schemaDef) => resolveSchema(schemaDef))
       );
-      const schema2 = defu$1(...schemas);
+      const schema2 = defu(...schemas);
       await dtwo.hooks.callHook("schema:resolved", schema2);
       return schema2;
     }
@@ -2113,7 +2231,7 @@ const clientPluginTemplate = {
     const imports = [];
     for (const plugin of clientPlugins) {
       const path = relative(ctx.dtwo.options.rootDir, plugin.src);
-      const variable = genSafeVariableName(path).replace(/_(45|46|47)/g, "_") + "_" + hash(path);
+      const variable = genSafeVariableName(filename(plugin.src)).replace(/_(45|46|47)/g, "_") + "_" + hash(path);
       exports.push(variable);
       imports.push(genImport(plugin.src, variable));
     }
@@ -2131,7 +2249,7 @@ const serverPluginTemplate = {
     const imports = [];
     for (const plugin of serverPlugins) {
       const path = relative(ctx.dtwo.options.rootDir, plugin.src);
-      const variable = genSafeVariableName(path).replace(/_(45|46|47)/g, "_") + "_" + hash(path);
+      const variable = genSafeVariableName(filename(path)).replace(/_(45|46|47)/g, "_") + "_" + hash(path);
       exports.push(variable);
       imports.push(genImport(plugin.src, variable));
     }

package/dist/pages/runtime/page.mjs

@@ -2,7 +2,7 @@ import { computed, defineComponent, h, provide, reactive, onMounted, nextTick, S
 import { RouterView } from "kdu-router";
 import { defu } from "defu";
 import { generateRouteKey, wrapInKeepAlive } from "./utils.mjs";
-import { useDtwoApp } from "#app";
+import { useDtwoApp } from "#app/dtwo";
 import { _wrapIf } from "#app/components/utils";
 import { appPageTransition as defaultPageTransition, appKeepalive as defaultKeepaliveConfig } from "#build/dtwo.config.mjs";
 export default defineComponent({

package/dist/pages/runtime/plugins/prefetch.client.mjs

@@ -1,5 +1,6 @@
 import { hasProtocol } from "ufo";
-import { defineDtwoPlugin, useDtwoApp, useRouter } from "#app";
+import { defineDtwoPlugin, useDtwoApp } from "#app/dtwo";
+import { useRouter } from "#app/composables/router";
 import layouts from "#build/layouts";
 import { namedMiddleware } from "#build/middleware";
 export default defineDtwoPlugin(() => {

package/dist/pages/runtime/plugins/router.mjs

@@ -7,7 +7,11 @@ import {
 } from "kdu-router";
 import { createError } from "h3";
 import { withoutBase, isEqual } from "ufo";
-import { callWithDtwo, defineDtwoPlugin, useRuntimeConfig, showError, clearError, navigateTo, useError, useState, useRequestEvent } from "#app";
+import { callWithDtwo, defineDtwoPlugin, useRuntimeConfig } from "#app/dtwo";
+import { showError, clearError, useError } from "#app/composables/error";
+import { useRequestEvent } from "#app/composables/ssr";
+import { useState } from "#app/composables/state";
+import { navigateTo } from "#app/composables/router";
 import _routes from "#build/routes";
 import routerOptions from "#build/router.options";
 import { globalMiddleware, namedMiddleware } from "#build/middleware";

package/dist/pages/runtime/router.options.mjs

@@ -1,5 +1,5 @@
 import { nextTick } from "kdu";
-import { useDtwoApp } from "#app";
+import { useDtwoApp } from "#app/dtwo";
 import { appPageTransition as defaultPageTransition } from "#build/dtwo.config.mjs";
 export default {
   scrollBehavior(to, from, savedPosition) {

package/dist/pages/runtime/validate.mjs

@@ -1,4 +1,4 @@
-import { defineDtwoRouteMiddleware } from "#app";
+import { defineDtwoRouteMiddleware } from "#app/composables/router";
 export default defineDtwoRouteMiddleware(async (to) => {
   if (!to.meta?.validate) {
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dtwo",
-  "version": "3.1.1",
+  "version": "3.2.0",
   "repository": "d2js/dtwo",
   "license": "MIT",
   "type": "module",
@@ -13,9 +13,9 @@
   "exports": {
     ".": "./dist/index.mjs",
     "./config": {
+      "types": "./config.d.ts",
       "import": "./config.mjs",
-      "require": "./config.cjs",
-      "types": "./config.d.ts"
+      "require": "./config.cjs"
     },
     "./app": "./dist/app/index.mjs",
     "./package.json": "./package.json"
@@ -34,34 +34,34 @@
   ],
   "dependencies": {
     "@d2js/devalue": "2.0.2",
-    "@dtwo/kit": "3.1.1",
-    "@dtwo/schema": "3.1.1",
+    "@dtwo/kit": "3.2.0",
+    "@dtwo/schema": "3.2.0",
     "@dtwo/telemetry": "2.1.8",
-    "@dtwo/ui-templates": "1.1.0",
+    "@dtwo/ui-templates": "1.1.1",
     "@dtwo/unplugin": "1.0.0",
-    "@dtwo/wite-builder": "3.1.1",
-    "@kdhead/ssr": "1.0.19",
-    "@kdujs/reactivity": "3.2.45",
-    "@kdujs/shared": "3.2.45",
-    "@kduse/head": "1.0.15",
+    "@dtwo/wite-builder": "3.2.0",
+    "@kdhead/ssr": "1.0.21",
+    "@kdujs/reactivity": "3.2.48",
+    "@kdujs/shared": "3.2.48",
+    "@kduse/head": "1.0.25",
     "chokidar": "3.5.3",
     "cookie-es": "0.5.0",
     "defu": "6.1.2",
     "destr": "1.2.2",
-    "dtwc": "3.1.1",
+    "dtwc": "3.2.0",
     "escape-string-regexp": "5.0.0",
     "estree-walker": "3.0.3",
     "fs-extra": "11.1.0",
     "globby": "13.1.3",
-    "h3": "1.0.2",
+    "h3": "1.4.0",
     "hash-sum": "2.0.0",
-    "holepack": "2.0.0",
+    "holepack": "2.2.1",
     "hookable": "5.4.2",
-    "jiti": "1.16.2",
-    "kdhead": "1.0.19",
-    "kdimport": "2.0.1",
-    "kdu": "3.2.45",
-    "kdu-bundle-renderer": "1.0.0",
+    "jiti": "1.17.0",
+    "kdhead": "1.0.21",
+    "kdimport": "2.2.4",
+    "kdu": "3.2.48",
+    "kdu-bundle-renderer": "1.0.1",
     "kdu-devtools-stub": "0.1.0",
     "kdu-router": "4.1.6",
     "knitwork": "1.0.0",
@@ -72,11 +72,10 @@
     "pathe": "1.1.0",
     "perfect-debounce": "0.1.3",
     "scule": "1.0.0",
-    "strip-literal": "1.0.0",
+    "strip-literal": "1.0.1",
     "ufo": "1.0.1",
-    "ultrahtml": "1.2.0",
     "unctx": "2.1.1",
-    "unenv": "1.0.1",
+    "unenv": "1.1.1",
     "untyped": "1.2.2"
   },
   "devDependencies": {