livemark 0.10.5 → 0.11.1

package/source/components/SiteTitle.tsx

@@ -1,20 +1,15 @@
+import { config } from "livemark:virtual"
 import defaultLogo from "../assets/logo.svg"
 
 /** Renders the site logo, title, and description in the sidebar header */
 export function SiteTitle() {
-  const logo = import.meta.env.CONFIG.logo ?? defaultLogo
+  const logo = config.logo ?? defaultLogo
   return (
     <div className="flex items-end gap-2.5 text-sm">
-      <img
-        src={logo}
-        alt={import.meta.env.CONFIG.title}
-        className="size-6.5 mb-1.25"
-      />
+      <img src={logo} alt={config.title} className="size-6.5 mb-1.25" />
       <div className="flex flex-col gap-0.5 leading-none">
-        <span className="font-semibold">{import.meta.env.CONFIG.title}</span>
-        <span className="text-xs opacity-80">
-          {import.meta.env.CONFIG.description}
-        </span>
+        <span className="font-semibold">{config.title}</span>
+        <span className="text-xs opacity-80">{config.description}</span>
       </div>
     </div>
   )

package/source/content/article.ts

@@ -1,3 +1,4 @@
+import { config } from "livemark:virtual"
 import { allArticles } from "content-collections"
 import type { ArticleGroup } from "../models/article.ts"
 import {
@@ -39,7 +40,7 @@ function orderKey(order?: number) {
   return order
 }
 
-const configSections = import.meta.env.CONFIG.sections
+const configSections = config.sections
 
 /** Per-section article groups, keyed by section prefix */
 export const sectionArticleGroups = new Map<string, ArticleGroup[]>()

package/source/content/tag.ts

@@ -1,6 +1,7 @@
+import { config } from "livemark:virtual"
 import { sectionFlatArticles, sortedArticles } from "./article.ts"
 
-const configSections = import.meta.env.CONFIG.sections
+const configSections = config.sections
 
 /** Per-section tag → article paths mapping. Articles sorted by date descending. */
 export const sectionTags = new Map<string, Map<string, string[]>>()

package/source/content-collections.ts

@@ -64,7 +64,7 @@ const configInclude = Array.isArray(config.include)
   ? config.include
   : [config.include]
 const include = changelogSections.length
-  ? [...configInclude, cacheIncludeGlob()]
+  ? [...configInclude, cacheIncludeGlob(config)]
   : configInclude
 
 const userExclude = config.exclude

package/source/env.d.ts

@@ -1,5 +1,5 @@
-interface ImportMetaEnv {
-  readonly CONFIG: import("./models/config.ts").WebsiteConfig
+declare module "livemark:virtual" {
+  export const config: import("./models/config.ts").WebsiteConfig
 }
 
 declare module "content-collections" {

package/source/models/config.ts

@@ -1,13 +1,26 @@
 import { z } from "zod"
+import type { ConfigEnv, UserConfig as ViteUserConfig } from "vite"
 import { Link } from "./link.ts"
 import { Patch } from "./patch.ts"
 import { Section } from "./section.ts"
 import { CodeThemeDark, CodeThemeLight } from "./theme.ts"
 
+/** Escape hatch for arbitrary Vite config — accepts either a config
+ *  object (simple overrides) or a function form (`(env) => config`,
+ *  matching Vite's own `defineConfig`). Merged on top of livemark's
+ *  defaults via `mergeConfig`, so plugin arrays concatenate, defines
+ *  merge, etc. Use this for deployment-target tweaks (e.g. CF Workers
+ *  via `environments.ssr.resolve.conditions: ["workerd", ...]`). */
+export type ViteOverride =
+  | ViteUserConfig
+  | ((env: ConfigEnv) => ViteUserConfig | Promise<ViteUserConfig>)
+
 /**
  * User-provided configuration for Livemark.
  */
-export type UserConfig = z.infer<typeof UserConfig>
+export type UserConfig = Omit<z.infer<typeof UserConfig>, "vite"> & {
+  vite?: ViteOverride
+}
 export const UserConfig = z.object({
   site: z.string().optional(),
   favicon: z.string().optional(),
@@ -21,6 +34,10 @@ export const UserConfig = z.object({
   links: z.array(Link).optional(),
   sections: z.array(Section).optional(),
   patches: z.array(Patch).optional(),
+  // Stored as `unknown` in the schema (zod can't type a Vite UserConfig
+  // or a function returning one meaningfully); the public TypeScript
+  // surface above lifts it back to ViteOverride for editor support.
+  vite: z.unknown().optional(),
 })
 
 /** Website configuration injected at build time via Vite define */
@@ -46,6 +63,10 @@ export const SystemConfig = z.object({
 
 /**
  * Fully resolved Livemark configuration.
+ *
+ * `vite` stays `unknown` here because that's what the runtime schema
+ * produces — consumer-facing typing happens via {@link UserConfig} so
+ * `defineConfig` shows the right shape in editors.
  */
 export type Config = z.infer<typeof Config>
 export const Config = UserConfig.merge(SystemConfig)

package/source/plugins/vite-livemark.ts

@@ -1,119 +1,193 @@
-import { existsSync } from "node:fs"
-import { join } from "node:path"
-import type { Plugin } from "vite"
+import { cpSync, existsSync, rmSync } from "node:fs"
+import { join, sep } from "node:path"
+import type {
+  ConfigEnv,
+  Plugin,
+  UserConfig as ViteUserConfig,
+  ViteDevServer,
+} from "vite"
+import { mergeConfig } from "vite"
+import { buildTarget } from "../actions/target/build.ts"
+import type { Config } from "../models/config.ts"
+import { WebsiteConfig } from "../models/config.ts"
+import { ESCAPABLE_FILES, ESCAPABLE_FOLDERS } from "../settings.ts"
 
 export interface LivemarkOptions {
-  defaultsRoot: string
-  overridesRoot: string
-  subdirs: string[]
-  configPath: string
+  config: Config
 }
 
-/** Match bare specifiers (`react`, `@scope/pkg`, `react/jsx-runtime`) but
- *  not relative (`./foo`), absolute (`/foo`), URL, or virtual (`\0...`)
- *  paths. */
-const BARE_SPECIFIER_RE = /^(@[^/]+\/)?[a-z0-9_][^?#]*$/i
+const SOURCE_DIR = join(import.meta.dirname, "..")
 
-/** Livemark dev/build integration:
- * - Anchors every bare-specifier resolution at livemark's own location so
- *   the entire build pipeline runs inside livemark's package boundary,
- *   regardless of which file (consumer override, transitive package,
- *   livemark source) issues the import. Removes pnpm-isolation hazards
- *   without forcing peerDependencies on the consumer.
- * - Redirects imports that land in `<defaultsRoot>/<subdir>/` to the matching
- *   user file under `<overridesRoot>/<subdir>/` when it exists.
- * - Watches `livemark.config.ts` and `.livemark/**` so edits, additions and
- *   deletions trigger the right reload without manual restart. */
+/** Single virtual module exposing livemark's runtime values to consumer
+ *  override files via named exports:
+ *
+ *      import { config } from "livemark:virtual"
+ *
+ *  Currently exports `config` (validated `WebsiteConfig`); future
+ *  additions (e.g. `articles`, `sections`) land here as new named
+ *  exports without consumers changing their import statements.
+ *
+ *  The `\0` prefix on the resolved id is Vite's convention to signal
+ *  "this is a virtual module — no other plugin should try to resolve
+ *  or load it from disk". */
+const VIRTUAL_ID = "livemark:virtual"
+const VIRTUAL_RESOLVED_ID = `\0${VIRTUAL_ID}`
+
+/** Owns the per-consumer `targets/<hash>/` mount: synthesizes it via
+ *  `buildTarget()`, returns the Vite config that anchors there, and
+ *  watches the consumer's `.livemark/` (plus livemark's `source/` in
+ *  dev) for changes that need to be re-copied into the target. The
+ *  override mechanism is pure file-system (full copies) — no resolveId
+ *  redirection, no realpath surprises. */
 export function livemark(opts: LivemarkOptions): Plugin {
-  const EXT_RE = /\.(tsx|ts|jsx|js|css)(\?|$)/
-  const livemarkAnchor = join(opts.defaultsRoot, "index.ts")
+  const overridesRoot = join(opts.config.root, ".livemark")
+  let targetDir = ""
   return {
     name: "livemark",
     enforce: "pre",
-    async resolveId(id, importer, options) {
-      // Encapsulation bridge: if the importer can resolve `id` itself
-      // (its own subtree has the right version), use that — preserves
-      // version isolation between transitive packages (e.g. recharts and
-      // mermaid both pulling different d3 majors). Only when the importer
-      // *can't* resolve do we fall back to livemark's own location, which
-      // covers React, the @tanstack/react-* cluster, and anything else
-      // that lives only inside livemark's tree but gets requested from a
-      // file that doesn't declare it (consumer overrides, foreign
-      // packages compiled by TanStack's transforms, etc.).
-      if (BARE_SPECIFIER_RE.test(id)) {
-        const fromImporter = importer
-          ? await this.resolve(id, importer, {
-              ...options,
-              skipSelf: true,
-            })
-          : null
-        if (fromImporter) return fromImporter
-        const fromLivemark = await this.resolve(id, livemarkAnchor, {
-          ...options,
-          skipSelf: true,
-        })
-        if (fromLivemark) return fromLivemark
-      }
-
-      if (!importer || !EXT_RE.test(id)) return null
-      const resolved = await this.resolve(id, importer, {
-        ...options,
-        skipSelf: true,
-      })
-      if (!resolved) return null
-      const queryIdx = resolved.id.indexOf("?")
-      const path =
-        queryIdx === -1 ? resolved.id : resolved.id.slice(0, queryIdx)
-      const query = queryIdx === -1 ? "" : resolved.id.slice(queryIdx)
-      for (const subdir of opts.subdirs) {
-        const defaultsSubdir = `${join(opts.defaultsRoot, subdir)}/`
-        if (!path.startsWith(defaultsSubdir)) continue
-        const rel = path.slice(defaultsSubdir.length)
-        const userPath = join(opts.overridesRoot, subdir, rel)
-        if (existsSync(userPath)) return userPath + query
-        return null
+    async config(_, env) {
+      targetDir = buildTarget(opts.config.configPath)
+      const base: ViteUserConfig = {
+        root: targetDir,
+        // outDir lives outside the target root (in the consumer's
+        // .livemark/) so the consumer can find their deployable output
+        // without digging into node_modules. Vite's default refusal to
+        // empty out-of-root directories doesn't apply here because the
+        // target/ root is livemark's, not the consumer's.
+        build: { outDir: join(overridesRoot, "build"), emptyOutDir: true },
+        resolve: { dedupe: ["react", "react-dom"] },
       }
+      const override = await resolveViteOverride(opts.config.vite, env)
+      return override ? mergeConfig(base, override) : base
+    },
+    resolveId(id) {
+      if (id === VIRTUAL_ID) return VIRTUAL_RESOLVED_ID
       return null
     },
+    load(id) {
+      if (id !== VIRTUAL_RESOLVED_ID) return null
+      const config = WebsiteConfig.parse(opts.config)
+      return `export const config = ${JSON.stringify(config)}`
+    },
     configureServer(server) {
-      server.watcher.add(opts.configPath)
-      server.watcher.add(join(opts.overridesRoot, "**/*"))
+      server.watcher.add(opts.config.configPath)
+      server.watcher.add(join(overridesRoot, "**", "*"))
+      server.watcher.add(join(SOURCE_DIR, "**", "*"))
 
-      const overrideRoots = opts.subdirs.map(
-        subdir => `${join(opts.overridesRoot, subdir)}/`,
-      )
-      const routesRoot = `${join(opts.overridesRoot, "routes")}/`
+      server.watcher.on("change", file => onChange(file, "change"))
+      server.watcher.on("add", file => onChange(file, "add"))
+      server.watcher.on("unlink", file => onChange(file, "unlink"))
 
-      const onChange = (file: string) => {
-        if (file === opts.configPath) {
+      function onChange(file: string, kind: "change" | "add" | "unlink") {
+        if (file === opts.config.configPath) {
           server.restart()
           return
         }
-
-        if (file.startsWith(routesRoot)) {
-          server.restart()
+        const overlayHit = matchOverlay(file, overridesRoot)
+        if (overlayHit) {
+          syncOverlay(overlayHit, kind, targetDir, overridesRoot)
+          if (kind !== "change") fullReload(server)
           return
         }
-
-        for (let i = 0; i < opts.subdirs.length; i++) {
-          const root = overrideRoots[i]
-          if (!root || !file.startsWith(root)) continue
-          const rel = file.slice(root.length)
-          const subdir = opts.subdirs[i]
-          if (!subdir) continue
-          const defaultPath = join(opts.defaultsRoot, subdir, rel)
-          const mod = server.moduleGraph.getModuleById(defaultPath)
-          if (mod) server.moduleGraph.invalidateModule(mod)
-          server.ws.send({ type: "full-reload" })
-          return
+        const sourceHit = matchSource(file)
+        if (sourceHit) {
+          syncSource(sourceHit, kind, targetDir, overridesRoot)
+          if (kind !== "change") fullReload(server)
         }
       }
-
-      server.watcher.on("add", onChange)
-      server.watcher.on("unlink", onChange)
-      server.watcher.on("change", file => {
-        if (file === opts.configPath) server.restart()
-      })
     },
   }
 }
+
+interface Hit {
+  rel: string
+  category: "folder" | "file" | null
+}
+
+function matchOverlay(file: string, overridesRoot: string): Hit | null {
+  const prefix = `${overridesRoot}${sep}`
+  if (!file.startsWith(prefix)) return null
+  const rel = file.slice(prefix.length)
+  return { rel, category: classify(rel) }
+}
+
+function matchSource(file: string): Hit | null {
+  const prefix = `${SOURCE_DIR}${sep}`
+  if (!file.startsWith(prefix)) return null
+  // Skip the targets/ output dir itself (sibling of source/) and any
+  // `.gen.ts` files that downstream tools regenerate inside the target.
+  const rel = file.slice(prefix.length)
+  if (rel === "" || rel.includes("routeTree.gen.ts")) return null
+  return { rel, category: classify(rel) }
+}
+
+function classify(rel: string): "folder" | "file" | null {
+  const [head] = rel.split(sep)
+  if (head && ESCAPABLE_FOLDERS.includes(head)) return "folder"
+  if (ESCAPABLE_FILES.includes(rel)) return "file"
+  // Non-escapable source files still need to flow into target during
+  // livemark's own dev — the user is editing the canonical source.
+  return null
+}
+
+function syncOverlay(
+  hit: Hit,
+  kind: "change" | "add" | "unlink",
+  targetDir: string,
+  overridesRoot: string,
+) {
+  if (!hit.category) return
+  const dest = join(targetDir, hit.rel)
+  const source = join(SOURCE_DIR, hit.rel)
+  if (kind === "unlink") {
+    rmSync(dest, { force: true, recursive: true })
+    if (existsSync(source))
+      cpSync(source, dest, { recursive: true, force: true })
+    return
+  }
+  const overlay = join(overridesRoot, hit.rel)
+  if (existsSync(overlay))
+    cpSync(overlay, dest, { recursive: true, force: true })
+}
+
+function syncSource(
+  hit: Hit,
+  kind: "change" | "add" | "unlink",
+  targetDir: string,
+  overridesRoot: string,
+) {
+  // If the consumer has an overlay for this file (and it's escapable),
+  // the overlay wins — ignore source changes.
+  if (hit.category && existsSync(join(overridesRoot, hit.rel))) return
+  const dest = join(targetDir, hit.rel)
+  const source = join(SOURCE_DIR, hit.rel)
+  if (kind === "unlink") {
+    rmSync(dest, { force: true, recursive: true })
+    return
+  }
+  if (existsSync(source)) cpSync(source, dest, { recursive: true, force: true })
+}
+
+function fullReload(server: ViteDevServer) {
+  server.ws.send({ type: "full-reload" })
+}
+
+/** Resolve livemark.config.ts's `vite` field — either a config object
+ *  or a function `(env) => config` (matching Vite's own `defineConfig`).
+ *  Schema stores it as `unknown`; typing for the consumer's editor
+ *  lives on {@link ViteOverride}. */
+async function resolveViteOverride(
+  vite: unknown,
+  env: ConfigEnv,
+): Promise<Record<string, unknown> | null> {
+  if (!vite) return null
+  if (typeof vite === "function") {
+    const result = await Reflect.apply(vite, undefined, [env])
+    return isObject(result) ? result : null
+  }
+  return isObject(vite) ? vite : null
+}
+
+function isObject(v: unknown): v is Record<string, unknown> {
+  return v !== null && typeof v === "object"
+}

package/source/routeTree.gen.ts

@@ -0,0 +1,86 @@
+/* eslint-disable */
+
+// @ts-nocheck
+
+// noinspection JSUnusedGlobalSymbols
+
+// This file was automatically generated by TanStack Router.
+// You should NOT make any changes in this file as it will be overwritten.
+// Additionally, you should also exclude this file from your linter and/or formatter to prevent it from being checked or modified.
+
+import { Route as rootRouteImport } from './routes/__root'
+import { Route as splatRouteImport } from './routes/$'
+import { Route as IndexRouteImport } from './../.livemark/routes/index'
+
+const splatRoute = splatRouteImport.update({
+  id: '/$',
+  path: '/$',
+  getParentRoute: () => rootRouteImport,
+} as any)
+const IndexRoute = IndexRouteImport.update({
+  id: '/',
+  path: '/',
+  getParentRoute: () => rootRouteImport,
+} as any)
+
+export interface FileRoutesByFullPath {
+  '/': typeof IndexRoute
+  '/$': typeof splatRoute
+}
+export interface FileRoutesByTo {
+  '/': typeof IndexRoute
+  '/$': typeof splatRoute
+}
+export interface FileRoutesById {
+  __root__: typeof rootRouteImport
+  '/': typeof IndexRoute
+  '/$': typeof splatRoute
+}
+export interface FileRouteTypes {
+  fileRoutesByFullPath: FileRoutesByFullPath
+  fullPaths: '/' | '/$'
+  fileRoutesByTo: FileRoutesByTo
+  to: '/' | '/$'
+  id: '__root__' | '/' | '/$'
+  fileRoutesById: FileRoutesById
+}
+export interface RootRouteChildren {
+  IndexRoute: typeof IndexRoute
+  splatRoute: typeof splatRoute
+}
+
+declare module '@tanstack/react-router' {
+  interface FileRoutesByPath {
+    '/$': {
+      id: '/$'
+      path: '/$'
+      fullPath: '/$'
+      preLoaderRoute: typeof splatRouteImport
+      parentRoute: typeof rootRouteImport
+    }
+    '/': {
+      id: '/'
+      path: '/'
+      fullPath: '/'
+      preLoaderRoute: typeof IndexRouteImport
+      parentRoute: typeof rootRouteImport
+    }
+  }
+}
+
+const rootRouteChildren: RootRouteChildren = {
+  IndexRoute: IndexRoute,
+  splatRoute: splatRoute,
+}
+export const routeTree = rootRouteImport
+  ._addFileChildren(rootRouteChildren)
+  ._addFileTypes<FileRouteTypes>()
+
+import type { getRouter } from './router.tsx'
+import type { createStart } from '@tanstack/react-start'
+declare module '@tanstack/react-start' {
+  interface Register {
+    ssr: true
+    router: Awaited<ReturnType<typeof getRouter>>
+  }
+}

package/source/routes/__root.tsx

@@ -1,3 +1,4 @@
+import { config } from "livemark:virtual"
 import { TanStackDevtools } from "@tanstack/react-devtools"
 import { ReactQueryDevtoolsPanel } from "@tanstack/react-query-devtools"
 import {
@@ -19,21 +20,18 @@ import generalCss from "../styles/general.css?url"
 
 export const Route = createRootRoute({
   head: () => {
-    const favicon =
-      import.meta.env.CONFIG.favicon ??
-      import.meta.env.CONFIG.logo ??
-      defaultFavicon
+    const favicon = config.favicon ?? config.logo ?? defaultFavicon
     return {
       meta: [
         { charSet: "utf-8" },
-        { title: import.meta.env.CONFIG.title },
-        { name: "description", content: import.meta.env.CONFIG.description },
-        { property: "og:title", content: import.meta.env.CONFIG.title },
+        { title: config.title },
+        { name: "description", content: config.description },
+        { property: "og:title", content: config.title },
         {
           property: "og:description",
-          content: import.meta.env.CONFIG.description,
+          content: config.description,
         },
-        { property: "og:site_name", content: import.meta.env.CONFIG.title },
+        { property: "og:site_name", content: config.title },
         { property: "og:type", content: "website" },
         {
           name: "viewport",

package/source/settings.ts

@@ -1,8 +1,19 @@
-/** Sub-directories of `website/` that participate in the override mechanism. */
-export const OVERRIDE_SUBDIRS: readonly string[] = [
+/** Subdirs of source/ where consumer files in `.livemark/<folder>/` are
+ *  merged per-file into the runtime mount, with `.livemark` winning on
+ *  conflict. */
+export const ESCAPABLE_FOLDERS: readonly string[] = [
   "components",
   "elements",
   "styles",
+  "routes",
+  "public",
+]
+
+/** Top-level source files that `.livemark/<file>` can replace atomically. */
+export const ESCAPABLE_FILES: readonly string[] = [
+  "client.tsx",
+  "server.ts",
+  "router.tsx",
 ]
 
 /** Glob patterns auto-excluded from content scanning when the consumer's

package/source/vite.config.ts

@@ -1,103 +1,29 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs"
-import { join, relative } from "node:path"
 import contentCollections from "@content-collections/vite"
 import tailwind from "@tailwindcss/vite"
 import { devtools } from "@tanstack/devtools-vite"
 import { tanstackStart } from "@tanstack/react-start/plugin/vite"
-import {
-  physical,
-  rootRoute,
-  route,
-  type VirtualRouteNode,
-} from "@tanstack/virtual-file-routes"
 import react from "@vitejs/plugin-react"
 import { defineConfig } from "vite"
 import svgr from "vite-plugin-svgr"
 import { loadConfig } from "./actions/config/load.ts"
-import { WebsiteConfig } from "./models/config.ts"
-import { OVERRIDE_SUBDIRS } from "./settings.ts"
 import { livemark } from "./plugins/vite-livemark.ts"
 
 const config = await loadConfig()
-const sourceDir = import.meta.dirname
-const sourceRelative = relative(config.root, sourceDir)
-const overridesRoot = join(config.root, ".livemark")
-
-// Seed `.livemark/.gitignore` on first run so Vite's build/cache
-// artifacts never get committed by accident. On the same first-run
-// trigger, also seed an `.npmrc` when pnpm is in use: pnpm's strict
-// isolation hides livemark's transitive deps (react, @tanstack/*) from
-// Vite's optimizer, which walks from config.root rather than livemark's
-// subtree. The public-hoist-pattern entries make those deps reachable
-// from the consumer's top-level node_modules. Skip when the consumer
-// already authored their own `.npmrc` — never overwrite user config.
-const gitignorePath = join(overridesRoot, ".gitignore")
-if (!existsSync(gitignorePath)) {
-  mkdirSync(overridesRoot, { recursive: true })
-  writeFileSync(gitignorePath, "/build\n/cache\n")
-
-  const npmrcPath = join(config.root, ".npmrc")
-  const usingPnpm = existsSync(join(config.root, "pnpm-lock.yaml"))
-  if (usingPnpm && !existsSync(npmrcPath)) {
-    writeFileSync(
-      npmrcPath,
-      "public-hoist-pattern[]=react\n" +
-        "public-hoist-pattern[]=react-*\n" +
-        "public-hoist-pattern[]=@tanstack/*\n",
-    )
-    console.log(
-      "Created .npmrc with hoist patterns for pnpm. Run `pnpm install` to apply.",
-    )
-  }
-}
-
-const routeChildren: VirtualRouteNode[] = [route("/$", "$.tsx")]
-if (existsSync(join(overridesRoot, "routes"))) {
-  // physical(dir) resolves `dir` relative to the routes directory
-  // (`srcDirectory/routes`). A hardcoded "../../.livemark/routes" only
-  // works when source/ sits one level under config.root — it lands at
-  // node_modules/.livemark/routes once livemark is installed. Compute
-  // the path dynamically from the consumer's actual layout.
-  const routesDir = join(sourceDir, "routes")
-  routeChildren.push(
-    physical(relative(routesDir, join(overridesRoot, "routes"))),
-  )
-}
 
 export default defineConfig({
-  root: config.root,
-  publicDir: join(config.root, ".livemark", "public"),
-  build: { outDir: ".livemark/build" },
-  define: {
-    "import.meta.env.CONFIG": JSON.stringify(WebsiteConfig.parse(config)),
-  },
-  // peerDependencies guarantee one canonical react/react-dom in the pnpm
-  // store. dedupe collapses any transitive resolutions to that copy.
-  resolve: {
-    dedupe: ["react", "react-dom"],
-  },
   plugins: [
-    livemark({
-      defaultsRoot: sourceDir,
-      overridesRoot,
-      subdirs: [...OVERRIDE_SUBDIRS],
-      configPath: config.configPath,
-    }),
+    livemark({ config }),
     devtools(),
     tailwind(),
-    contentCollections({
-      configPath: join(sourceRelative, "content-collections.ts"),
-    }),
+    contentCollections({ configPath: "content-collections.ts" }),
     tanstackStart({
-      srcDirectory: sourceRelative,
+      srcDirectory: ".",
       pages: [{ path: "/" }],
       prerender: { enabled: true, crawlLinks: true },
       sitemap: config.site
         ? { enabled: true, host: config.site }
         : { enabled: false },
-      router: {
-        virtualRouteConfig: rootRoute("__root.tsx", routeChildren),
-      },
+      router: { generatedRouteTree: "routeTree.gen.ts" },
     }),
     react(),
     svgr(),