duto 0.261011.0 → 0.261012.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duto",
   "description": "All-in-one serverless framework for web artisans",
-  "version": "0.261011.0",
+  "version": "0.261012.0",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.d.ts",
@@ -25,46 +25,42 @@
     "./length": "./src/server/utils/length.ts"
   },
   "dependencies": {
-    "@inquirer/confirm": "^5.1.8",
-    "@inquirer/input": "^4.1.8",
-    "@inquirer/select": "^4.1.0",
+    "@inquirer/confirm": "^5.1.21",
+    "@inquirer/input": "^4.3.1",
+    "@inquirer/select": "^4.4.2",
     "nanospinner": "^1.2.2",
-    "@hono/node-server": "^1.19.11",
-    "@hono/standard-validator": "^0.2.2",
+    "@hono/node-server": "^1.19.17",
+    "@hono/standard-validator": "^0.2.3",
     "@hono/zod-validator": "^0.7.6",
-    "@scalar/hono-api-reference": "^0.12.0",
+    "@scalar/hono-api-reference": "^0.12.11",
     "@minify-html/node": "^0.18.1",
-    "@preact/signals": "^2.9.2",
-    "@swc/core": "^1.15.21",
-    "chokidar": "^3.5.2",
+    "@preact/signals": "^2.11.3",
+    "bun-plugin-tailwind": "^0.1.2",
+    "chokidar": "^3.6.0",
     "citty": "^0.2.2",
     "consola": "^3.4.2",
     "cripta": "0.x",
-    "dotenv": "^16.5.0",
-    "esbuild": "^0.25.2",
+    "dotenv": "^16.6.1",
+    "esbuild": "^0.25.12",
     "forj": "0.x",
-    "hono": "^4.13.7",
-    "hono-openapi": "^1.3.0",
+    "hono": "^4.13.13",
+    "hono-openapi": "^1.3.5",
     "localflare-api": "^0.5.0",
     "localflare-core": "^0.5.0",
     "miniflare": "^4.20260730.0",
-    "pathe": "^2.0",
-    "preact": "^10.29.7",
-    "preact-render-to-string": "^6.6.6",
+    "pathe": "^2.0.3",
+    "preact": "^11.0.1",
+    "preact-render-to-string": "^6.8.0",
     "quansync": "^0.2.11",
     "t0n": "0.x",
-    "vite": "^8.0.0",
-    "wouter-preact": "^3.10.0",
-    "wrangler": "^4.128.0",
-    "zod": "^4.3.6",
+    "wouter-preact": "^3.13.0",
+    "wrangler": "^4.149.0",
+    "zod": "^4.6.6",
     "zod-openapi": "^5.4.6"
   },
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20260113.0",
-    "@minify-html/node": "^0.18.1",
-    "@preact/preset-vite": "^2.10.5",
-    "@tailwindcss/vite": "^4.3.1",
-    "bun-types": "^1.4.0",
+    "@cloudflare/workers-types": "^4.20260702.1",
+    "bun-types": "^1.4.3",
     "typescript": "^5.9.3"
   },
   "resolutions": {

package/src/pages/cli/commands/build.ts

@@ -1,9 +1,8 @@
-import { build } from 'vite'
 import { setEnv } from 't0n'
 import { command } from 't0n/cli'
 import { dim, underline } from 't0n/color'
 import { wait, error, rn, event } from 't0n/log'
-import { meta } from '#/compiler/vite-plugin'
+import { meta, build } from '#/compiler/bun-plugin'
 import type { SummaryMetadata } from '#/compiler/types'
 import { getConfig } from '../utils'
 import { filesize } from '@/utils'

package/src/pages/cli/utils.ts

@@ -1,17 +1,16 @@
 import { IMPORT, Datte } from 't0n'
 import { join } from 'pathe'
 import { gray, green, yellow, red, cyan } from 't0n/color'
-import type { UserConfig } from 'vite'
 
 import { resolveExtension } from '#/compiler/file'
-import config from '#/compiler/vite-plugin'
+import config, { type DutoOptions } from '#/compiler/bun-plugin'
 import { _root } from '@/utils'
 import { match, match404 } from '#/compiler/routes'
 import type { Metadata, PluginOptions } from '#/compiler/types'
 import { EXTENSIONS_LIST, NF_NAMES } from '#/compiler/constants'
 
-export async function getConfig(name = 'config'): Promise<UserConfig & PluginOptions> {
-  let opts = {} as UserConfig
+export async function getConfig(name = 'config'): Promise<DutoOptions> {
+  let opts = {} as DutoOptions
   const file = resolveExtension(name)
   if (file) opts = await IMPORT(join(_root, file), 'default')
   return config(opts)

package/src/pages/client/app.tsx

@@ -106,7 +106,7 @@ async function resolveRoute(
     sProps = null
 
   if (typeof Component === 'string') {
-    const mod = await import(/* @vite-ignore */ Component)
+    const mod = await import((Component[0] == '/' ? '' : '/')+ Component)
     Component = mod.default
     getProps = getProps === 1 ? mod.getProps : 0
     sProps = mod.props ?? null

package/src/pages/compiler/ast.ts

@@ -1,6 +1,19 @@
 import { resolve } from 'node:path'
 import { resolveAlias } from './aliases'
 
+const IMPORT_RE = /(?:\/\/[^\n]*|\/\*[\s\S]*?\*\/)|import\s*(?:type\s*)?(?:[^'"]*?from\s*)?['"]([^'"]+)['"]/g
+export function getImports(str: string) {
+  const found: string[] = []
+  let match: RegExpExecArray | null
+  while ((match = IMPORT_RE.exec(str))) {
+    if (match[0].includes('import type') || !match[1]) continue
+
+    found.push(match[1])
+  }
+
+  return found
+}
+
 const resolveImportCache = new Map<string, string>()
 export const resolveImport = (lib: string, importer: string, aliases: Record<string, string>) => {
   if (resolveImportCache.has(lib))

package/src/pages/compiler/bun-plugin.ts

@@ -0,0 +1,245 @@
+import { existsSync, rmSync } from 'node:fs'
+import { cp, mkdir } from 'node:fs/promises'
+import { dirname, extname, join, relative } from 'node:path'
+
+import tailwind from 'bun-plugin-tailwind'
+import { JSJSON } from 't0n'
+
+import { EXT_RE } from './constants'
+import { getChunk, setAsset, setChunk, setEntry } from './assets'
+import { renderPage } from '.'
+import { getImports, removeExports } from './ast'
+import { getMetadata } from './meta'
+import { _pages, _root } from '@/utils'
+
+import type { BunPlugin, BuildArtifact } from 'bun'
+import type { Metadata } from './types'
+
+const VIRTUAL_ID = ':duto'
+const NAMESPACE = 'duto'
+const APP_ID = ':duto/client/app.tsx'
+
+export type DutoOptions = {
+  root: string
+  pagesDir: string
+  outDir: string
+  plugins: BunPlugin[]
+}
+
+export const config = (opts: DutoOptions): DutoOptions => {
+  opts.root ||= _root
+  opts.pagesDir ||= 'pages'
+  opts.outDir ||= 'dist'
+  opts.plugins = [...(opts.plugins || [])]
+  return opts
+}
+
+let metadata: Metadata
+export function meta() {
+  return metadata
+}
+
+const CSS_CANDIDATES = [
+  'style.css',
+  'styles.css',
+  'styles/index.css',
+  'style/index.css',
+  'tailwind.css',
+  'tailwindcss.css',
+  'styles/tailwind.css',
+  'styles/tailwindcss.css',
+]
+
+const REACT_ALIAS: Record<string, string> = {
+  'react': 'preact/compat',
+  'react-dom': 'preact/compat',
+  'react-dom/client': 'preact/compat/client',
+  'react-dom/test-utils': 'preact/test-utils',
+  'react/jsx-runtime': 'preact/jsx-runtime',
+  'react/jsx-dev-runtime': 'preact/jsx-dev-runtime',
+}
+
+const stripExt = (p: string) => p.slice(0, p.length - extname(p).length)
+
+export async function build(opts: DutoOptions) {
+  const conf = config(opts)
+  const outPath = join(conf.root, conf.outDir)
+
+  const PAGES_RE = new RegExp(`/${conf.pagesDir}/.*\\.(tsx?|jsx?)$`, 'i')
+  const stripTarget = new Set(['getStaticProps'])
+
+  metadata = await getMetadata(conf.root, conf.pagesDir)
+
+  const appEntry = join(_pages, 'client', 'app.tsx')
+  setEntry(APP_ID, relative(conf.root, appEntry))
+
+  const routes = metadata.routes.filter(r => !r.is404)
+  const entrypoints = [...routes.map(r => r.fullFilePath), appEntry]
+
+  const sources = new Map(entrypoints.map(e => [relative(conf.root, stripExt(e)), e]))
+
+  const prefix = metadata.minify ? '' : '[name].'
+
+  rmSync(outPath, { recursive: true, force: true })
+  await mkdir(outPath, { recursive: true })
+
+  const result = await Bun.build({
+    entrypoints,
+    root: conf.root,
+    target: 'browser',
+    format: 'esm',
+    splitting: true,
+    minify: metadata.minify,
+    sourcemap: 'none',
+    naming: {
+      entry: '[dir]/[name]-[hash6].[ext]', // used to map output to source
+      chunk: prefix + '[hash6].[ext]',
+      asset: prefix + '[hash6].[ext]',
+    },
+    define: {
+      'process.env.NODE_ENV': '"production"',
+    },
+    plugins: [
+      ...(conf.plugins || []),
+      tailwind,
+      {
+        name: 'duto',
+        setup(build) {
+          build.onResolve({ filter: /^react(-dom)?(\/|$)/ }, args => {
+            const target = REACT_ALIAS[args.path]
+            if (!target) return
+            return { path: Bun.resolveSync(target, conf.root) }
+          })
+
+          build.onResolve({ filter: /^:root/ }, args => {
+            for (const f of CSS_CANDIDATES) {
+              const path = join(conf.root, f)
+              if (existsSync(path)) return { path }
+            }
+          })
+
+          build.onResolve({ filter: /^:duto/ }, args => {
+            const id = args.path
+
+            if (EXT_RE.test(id) && id.includes('/')) {
+              const path = join(_pages, id.replace(VIRTUAL_ID, ''))
+              return { path }
+            }
+
+            if (id.endsWith('/hmr') && metadata.hmr)
+              return { path: join(_pages, 'client', id.replace(VIRTUAL_ID, '') + '.ts') }
+
+            return { path: id, namespace: NAMESPACE }
+          })
+
+          build.onLoad({ filter: /.*/, namespace: NAMESPACE }, args => ({
+            contents: args.path.endsWith('/i18n') ? metadata.i18n.string : metadata.string,
+            loader: 'ts',
+          }))
+
+          build.onLoad({ filter: PAGES_RE }, async args => {
+            if (args.path.includes('node_modules')) return
+
+            const code = await Bun.file(args.path).text()
+            const stripped = removeExports(args.path, code, stripTarget)
+            if (!stripped || stripped === code) return
+
+            const ext = extname(args.path).slice(1) as 'ts' | 'tsx' | 'js' | 'jsx'
+            return { contents: stripped, loader: ext }
+          })
+        },
+      },
+    ],
+  })
+
+  if (!result.success)
+    throw new AggregateError(result.logs, 'duto: build failed')
+
+  const keyOf = (a: BuildArtifact, fileName: string) => {
+    let noExt = stripExt(fileName).replaceAll('_.._', '..')
+    if (a.hash) noExt = noExt.replace(new RegExp(`-${a.hash}$`), '')
+    return noExt
+  }
+
+  const dirs = new Set<string>()
+  for (const out of result.outputs) {
+    const fileName = out.path.replace(/^\.\//, '').replaceAll('_.._', '..')
+    const dest = metadata.minify ? fileName.split('/').at(-1)!.split('-').at(-1)! : fileName.replace('../../packages/duto/src/pages', '')
+    const filePath = join(outPath, dest)
+    const key = keyOf(out, fileName)
+    const owner = sources.get(key)
+
+    const fileDir = dirname(filePath)
+    if (fileDir !== outPath && !dirs.has(fileDir)) {
+      dirs.add(fileDir)
+      await mkdir(fileDir, { recursive: true })
+    }
+
+    let content = await out.text()
+    if (fileName.endsWith('.css')) {
+      if (owner === appEntry) content += 'i-i{display:contents}'
+      content = content.replace(/\/\*!\s*tailwindcss[^*]*\*\/\s*/g, '')
+
+      setAsset(relative(conf.root, owner ?? fileName), '/'+ dest)
+    } else if (out.kind === 'entry-point' && owner) {
+      setChunk(relative(conf.root, owner),'/'+  dest)
+      // o lookup original usa o caminho relativo ao root
+      // if (owner !== appEntry) setChunk(owner.replace(conf.root, ''), name)
+    }
+
+    const imports = getImports(content)
+    for (const path of imports) {
+      content = content.replaceAll(path, '/'+ path.split('/').at(-1))
+    }
+
+    await Bun.write(filePath, content)
+  }
+
+  for (const [_filePath, page] of metadata.pages)
+    await renderPage(metadata, conf, page)
+
+  rmSync(join(conf.root, 'tmp'), { recursive: true, force: true })
+
+  if (existsSync(join(conf.root, 'public')))
+    await cp(join(conf.root, 'public'), outPath, { recursive: true, force: true })
+
+  const entryPath = join(outPath, getChunk(APP_ID))
+  const entry = Bun.file(entryPath)
+
+  if (await entry.exists()) {
+    let entryContent = await entry.text()
+
+    for (const r of routes) {
+      const rPath = getChunk(r.fullFilePath.replace(conf.root, ''))
+
+      if (r.props) {
+        const rFilePath = join(outPath, rPath)
+        const rText = await Bun.file(rFilePath).text()
+        await Bun.write(rFilePath, `export const props=${JSJSON(r.props)};${rText}`)
+      }
+
+      entryContent = entryContent.replace(r.fullFilePath, rPath)
+    }
+
+    await Bun.write(entryPath, entryContent)
+  }
+
+  // i18n
+  for (const locale of metadata.i18n.locales) {
+    const intlPath = join(conf.root, 'i18n', locale + '.ts')
+    if (!existsSync(intlPath)) continue
+
+    const intlMod = await import(intlPath)
+    await Bun.write(
+      join(outPath, locale + '.js'),
+      `var a=${JSJSON({
+        routes: intlMod.routes ?? intlMod.default?.routes,
+        messages: intlMod.messages ?? intlMod.default?.messages,
+      })};export{a as default}`,
+    )
+  }
+
+  return result
+}
+
+export default config

package/src/pages/compiler/index.ts

@@ -12,15 +12,15 @@ import { getAsset, getChunk } from './assets'
 import { resolveStaticOutputPath } from './meta'
 import { setLocale } from '../i18n/client'
 
-import type { ResolvedConfig } from 'vite'
 import type { IRoute, Metadata, RouteParams, StaticProps, SummaryMetadata } from './types'
+import type { DutoOptions } from './bun-plugin'
 
 
 const brCompress = promisify(brotliCompress)
 
 export async function renderPage(
   meta: Metadata,
-  config: ResolvedConfig,
+  config: DutoOptions,
   page: IRoute
  ) {
   const {
@@ -117,7 +117,7 @@ export async function renderPage(
 
     html = buildHtml(page, html, Object.keys(allProps).length ? allProps : undefined)
 
-    const outFile = join(config.root, config.build.outDir, pathname +'.html')
+    const outFile = join(config.root, config.outDir, pathname +'.html')
     const outHTML = meta.minify ? minify.minify(Buffer.from(html), {}) : html
     await mkdir(dirname(outFile), {recursive: true})
     await Bun.write(outFile, outHTML)

package/src/pages/compiler/types.ts

@@ -3,7 +3,6 @@ import type { Platform } from '$/cli/types'
 
 export type PluginOptions = {
   root?: string,
-  // Directory to scan for pages, relative to Vite root. Default: "./pages"
   pagesDir?: string,
 }
 

package/src/pages/compiler/vite-plugin.ts

@@ -1,336 +0,0 @@
-// REF: https://github.com/tailwindlabs/tailwindcss/blob/main/packages/%40tailwindcss-vite/src/index.ts
-
-import { existsSync, rmSync } from 'node:fs'
-import { join } from 'node:path'
-import { defineConfig } from 'vite'
-
-import preact from '@preact/preset-vite'
-import tailwind from '@tailwindcss/vite'
-import { JSJSON } from 't0n'
-
-import { EXT_RE } from './constants'
-import { getChunk, setAsset, setChunk, setEntry } from './assets'
-import { renderPage } from '.'
-import { removeExports, resolveImport } from './ast'
-import { getMetadata } from './meta'
-
-import type {
-  UserConfig, ConfigEnv, ResolvedConfig,
-  // PreviewServer,
-  // ViteDevServer,
-  EnvironmentOptions,
-  PluginOption,
-} from 'vite'
-import type { Metadata, PluginOptions } from './types'
-import { _pages, _root } from '@/utils'
-import { cp } from 'node:fs/promises'
-
-const VIRTUAL_ID = ':duto'
-const RESOLVED_ID = '\0'+ VIRTUAL_ID
-
-export const config = (opts: UserConfig & PluginOptions) => { // @ts-ignore
-  if (!opts.root) opts.root = _root
-  if (!opts.pagesDir) opts.pagesDir = 'pages',
-
-  opts.logLevel = 'silent'
-  opts.plugins = [
-    ...(opts.plugins || []),
-    preact(),
-    tailwind(),
-    plugin(opts),
-  ]
-
-  return defineConfig(opts)
-}
-
-// TODO: remover..
-export default config
-
-let metadata: Metadata
-export function meta() {
-  return metadata
-}
-
-export function plugin(options: PluginOptions = {}): PluginOption[] {
-  let config: ResolvedConfig
-  const {
-    root = _root,
-    pagesDir = 'pages',
-  } = options
-
-  const PAGES_RE = new RegExp(`\/${pagesDir}\/.*\.(tsx?|jsx?)$`, 'i')
-  const stripTarget = new Set(['getStaticProps'])
-
-  return [
-    {
-      name: 'duto:preact-environment',
-
-      configEnvironment(name, options) {
-        const opts: EnvironmentOptions = {optimizeDeps: {}, resolve: {}}
-
-        if (name === 'client') {
-          opts.optimizeDeps!.include = [
-            'preact',
-            'preact/jsx-runtime',
-          ]
-        }
-
-        opts.resolve = {dedupe: ['preact/compat', 'preact']}
-
-        if (name === 'client')
-          opts.optimizeDeps!.include!.push(
-            'preact/compat',
-            // 'preact/test-utils',
-            'preact/compat/jsx-runtime',
-          )
-
-        if (
-          !options.resolve?.noExternal &&
-          (name === 'ssr' || name === 'prerender')
-        ) {
-          // noExternal React entrypoints to be bundled, resolved, and aliased by Vite
-          opts.resolve!.noExternal = [
-            'react',
-            'react-dom',
-            'react-dom/test-utils',
-            'react/jsx-runtime',
-          ]
-        }
-
-        return opts
-      },
-    },
-
-    {
-      name: 'duto:scan',
-      enforce: 'pre',
-
-      async config(conf: UserConfig, env: ConfigEnv) {
-        metadata = await getMetadata(root as string, pagesDir)
-
-        if (conf.build) {
-          // conf.build.emptyOutDir = false
-          conf.build.copyPublicDir = false
-          conf.build.manifest = false
-          conf.build.modulePreload = { polyfill: false }
-
-          conf.build.minify = metadata.minify
-          conf.build.cssMinify = metadata.minify
-
-          conf.build.rolldownOptions = conf.build.rolldownOptions || {}
-          conf.build.rolldownOptions.preserveEntrySignatures = 'exports-only' ///
-          conf.build.rolldownOptions.input = [
-            ...metadata.routes.map(r => r.is404 ? '' : r.fullFilePath).filter(Boolean),
-            ':duto/client/app.tsx',
-            // ':duto/not-found.tsx',
-            // ...Object.keys(metadata.pages),
-            // ...metadata.assets,
-          ]
-
-          const filePrefix = metadata.minify ? '' : '[name].'
-          // conf.build.rolldownOptions.input = ':duto/client/app.tsx'
-          conf.build.rolldownOptions.output = {
-            hoistTransitiveImports: false,
-            format: 'esm',
-            minifyInternalExports: metadata.minify,
-            preserveModulesRoot: '/',
-            assetFileNames: filePrefix +'[hash][extname]',
-            entryFileNames: filePrefix +'[hash].js',
-            chunkFileNames: filePrefix +'[hash].js',
-
-            // chunkFileNames: '[name].[hash].js',
-            // entryFileNames: 'assets/[name].js',
-            // chunkFileNames: 'assets/chunks/[name]-[hash].js',
-            // assetFileNames: 'assets/[name][extname]',
-
-            // manualChunks: {
-            //   vendor: ['preact', '@preact/signals', 'wouter-preact'],
-            // },
-            // preserveModules: true,
-          }
-        }
-
-        return conf
-      },
-
-      async configResolved(c) {
-        config = c
-      },
-
-      resolveId(id) {
-        if (id === VIRTUAL_ID) return RESOLVED_ID
-
-        if (id.startsWith(':root')) {
-          for (const f of [
-            'style.css',
-            'styles.css',
-            'styles/index.css',
-            'style/index.css',
-            'tailwind.css',
-            'tailwindcss.css',
-            'styles/tailwind.css',
-            'styles/tailwindcss.css',
-          ]) {
-            const path = join(config.root, f)
-            if (existsSync(path)) {
-              setEntry(id, path)
-              return path
-            }
-          }
-
-          return null
-        }
-
-        if (!id.startsWith(VIRTUAL_ID)) return null
-
-        if (EXT_RE.test(id) && id.includes('/')) {
-          const path = join(_pages, id.replace(VIRTUAL_ID, ''))
-          setEntry(id, path)
-          return path
-        }
-
-        if (id.endsWith('/hmr') && metadata.hmr)
-          return join(_pages, 'client', id.replace(VIRTUAL_ID, '') + '.ts')
-
-        return id.replace(VIRTUAL_ID, RESOLVED_ID)
-      },
-
-      async load(id) {
-        if (!id.startsWith(RESOLVED_ID)) return
-
-        if (id.endsWith('/i18n'))
-          return metadata.i18n.string
-
-        return metadata.string
-      },
-
-      generateBundle(_, bundle) {
-        // const moduleIds = this.getModuleIds()
-        // for (const id of moduleIds)
-        // console.error(id)
-
-        // TODO: rever isso...
-        for (const key in bundle) {
-          const file = bundle[key]
-
-          if (file.type === 'chunk' && file.isEntry) {
-            setChunk(file.facadeModuleId, '/'+ file.fileName)
-            continue
-          }
-
-          if (file.type === 'asset' && file?.originalFileName?.endsWith('duto/pages/client/app.tsx'))
-            file.source += 'i-i{display:contents}'
-
-          if (file.type === 'asset' && file.fileName.endsWith('.css')) {
-            setAsset(resolveImport(file.originalFileName as string, metadata.root, metadata.aliases), '/'+ file.fileName)
-
-            const css = typeof file.source === 'string'
-              ? file.source
-              : Buffer.from(file.source).toString('utf-8')
-
-            file.source = css.replace(/\/\*!\s*tailwindcss[^*]*\*\/\s*/g, '')
-            continue
-          }
-
-          // console.error(file.fileName)
-          // console.error(file.type)
-          // console.error(file.viteMetadata)
-          // if (file.type !== 'chunk' || !file.isEntry) continue
-        }
-      },
-
-    },
-
-    {
-      name: 'duto:build',
-      enforce: 'pre',
-      apply: 'build',
-
-      async buildStart() {
-        // if (!server) {
-        //   const { createServer } = await import('vite')
-        //   server = await createServer({ server: {middlewareMode: true} })
-        // }
-
-
-        // teste de import de assets
-      //   for (const file of metadata.assets) {
-      //   const id = await this.resolve(file)
-      //   if (!id) continue
-
-      //   console.error(id)
-      //   console.error(relative(metadata.root, file).replace(/\.(ts|tsx)$/, '.js'),)
-
-      //   this.emitFile({
-      //     type: 'chunk',
-      //     id: id.id,
-      //     implicitlyLoadedAfterOneOf: [
-      //       ':duto/app.tsx',
-      //     ]
-      //     // fileName: 'assets/[name]-[hash][extname]',
-      //     // fileName: relative(metadata.root, file).replace(/\.(ts|tsx)$/, '.js'),
-      //   })
-      // }
-
-      },
-
-      async closeBundle() {
-        for (const [_filePath, page] of metadata.pages)
-          await renderPage(metadata, config, page)
-          // const mod = await server.ssrLoadModule(_filePath)
-
-        rmSync(join(metadata.root, 'tmp'), {recursive: true, force: true})
-        // await server.close()
-
-        const outPath = join(config.root, config.build.outDir)
-
-        await cp(join(config.root, 'public'), outPath, { recursive: true, force: true })
-
-        const entry = Bun.file(join(outPath, getChunk(':duto/client/app.tsx')))
-        if (await entry.exists()) {
-          let entryContent = await entry.text()
-
-          for (const r of metadata.routes.filter(r => !r.is404)) {
-            const rPath = getChunk(r.fullFilePath.replace(config.root, ''))
-
-            if (r.props) {
-              const rFile = Bun.file(join(outPath, rPath))
-              await rFile.write((await rFile.text()).replace('}export{', `}export const props=${JSJSON(r.props)};export{`))
-            }
-
-            entryContent = entryContent.replace(r.fullFilePath, rPath)
-          }
-
-          await entry.write(entryContent)
-        }
-
-        // i18n
-        for (const locale of metadata.i18n.locales) {
-          const intlPath = join(metadata.root, 'i18n', locale + '.ts')
-          if (existsSync(intlPath)) {
-            const intlMod = await import(intlPath)
-            await Bun.write(
-              join(outPath, locale +'.js'),
-              `var a=${JSJSON({
-                routes: intlMod.routes ?? intlMod.default?.routes,
-                messages: intlMod.messages ?? intlMod.default?.messages,
-              })};export { a as default }`
-            )
-          }
-        }
-
-      },
-
-      // TODO: precisa ser aqui mesmo pois se a pagina for importada no entry, pode incluir codigo nao usado no chunck/bundle
-      async transform(code, id) {
-        if (!PAGES_RE.test(id) || id.includes('node_modules')) return null
-        // console.log(this.getModuleInfo(id))
-
-        const stripped = removeExports(id, code, stripTarget)
-
-        return (!stripped || stripped === code) ? null : { code: stripped, map: null }
-      },
-
-    },
-  ]
-}