@holo-js/cli 0.1.6 → 0.1.8

package/dist/{chunk-MXKNQACM.mjs → chunk-O6AXHL7Z.mjs}

@@ -30,7 +30,8 @@ import {
   SUPPORTED_CONFIG_EXTENSIONS,
   importProjectModule,
   isRecord,
-  makeProjectRelativePath
+  makeProjectRelativePath,
+  normalizeScaffoldOptionalPackages
 } from "./chunk-R6BWRY3E.mjs";
 
 // src/templates.ts
@@ -253,15 +254,1071 @@ function resolveArtifactPath(root, subdir, directory, fileName) {
   return resolve(root, subdir, directory, fileName);
 }
 
+// src/project/scaffold/framework-renderers.ts
+var HOSTED_AUTH_PROVIDERS = {
+  workos: {
+    provider: "workos",
+    packageName: "@holo-js/auth-workos",
+    loginFunction: "loginWithWorkos",
+    registerFunction: "registerWithWorkos",
+    callbackFunction: "completeWorkosAuth",
+    logoutFunction: "logoutWithWorkos"
+  },
+  clerk: {
+    provider: "clerk",
+    packageName: "@holo-js/auth-clerk",
+    loginFunction: "loginWithClerk",
+    registerFunction: "registerWithClerk",
+    callbackFunction: "completeClerkAuth",
+    logoutFunction: "logoutWithClerk"
+  }
+};
+function getRequestedHostedAuthProviders(features) {
+  return [
+    ...features.workos ? ["workos"] : [],
+    ...features.clerk ? ["clerk"] : []
+  ];
+}
+function renderNuxtAppVue(projectName) {
+  return [
+    "<template>",
+    '  <main class="shell">',
+    "    <h1>{{ appName }}</h1>",
+    "    <p>Nuxt renders the UI. Holo owns the backend runtime and canonical server directories.</p>",
+    "  </main>",
+    "</template>",
+    "",
+    '<script setup lang="ts">',
+    `const appName = ${JSON.stringify(projectName)}`,
+    "</script>",
+    "",
+    "<style scoped>",
+    ".shell {",
+    "  min-height: 100vh;",
+    "  display: grid;",
+    "  place-content: center;",
+    "  gap: 1rem;",
+    "  padding: 3rem;",
+    "  font-family: sans-serif;",
+    "}",
+    "h1 {",
+    "  margin: 0;",
+    "  font-size: clamp(2.5rem, 6vw, 4rem);",
+    "}",
+    "p {",
+    "  margin: 0;",
+    "  max-width: 40rem;",
+    "  line-height: 1.6;",
+    "}",
+    "</style>",
+    ""
+  ].join("\n");
+}
+function renderNuxtConfig() {
+  return [
+    "export default defineNuxtConfig({",
+    "  modules: ['@holo-js/adapter-nuxt'],",
+    "  sourcemap: {",
+    "    client: false,",
+    "    server: false,",
+    "  },",
+    "  vite: {",
+    "    build: {",
+    "      rollupOptions: {",
+    "        onwarn(warning, defaultHandler) {",
+    "          if (",
+    "            warning.message.includes('nuxt:module-preload-polyfill')",
+    "            && warning.message.includes('didn\\'t generate a sourcemap')",
+    "          ) {",
+    "            return",
+    "          }",
+    "",
+    "          defaultHandler(warning)",
+    "        },",
+    "      },",
+    "    },",
+    "  },",
+    "})",
+    ""
+  ].join("\n");
+}
+function renderNuxtCurrentAuthRoute() {
+  return [
+    "import auth, { check, isAuthError, provider, user } from '@holo-js/auth'",
+    "import { setResponseStatus } from 'h3'",
+    "",
+    "export default defineEventHandler(async (event) => {",
+    "  const query = getQuery(event)",
+    "  const guard = typeof query.guard === 'string' ? query.guard : undefined",
+    "  try {",
+    "    const guardAuth = guard ? auth.guard(guard) : undefined",
+    "",
+    "    return {",
+    "      authenticated: guardAuth ? await guardAuth.check() : await check(),",
+    "      guard: guard ?? 'web',",
+    "      provider: guardAuth ? await guardAuth.provider() : await provider(),",
+    "      user: guardAuth ? await guardAuth.user() : await user(),",
+    "    }",
+    "  } catch (error) {",
+    "    if (isAuthError(error) && error.code === 'guard_not_configured') {",
+    "      setResponseStatus(event, 400)",
+    "",
+    "      return {",
+    "        authenticated: false,",
+    "        guard: guard ?? 'web',",
+    "        provider: null,",
+    "        user: null,",
+    "      }",
+    "    }",
+    "",
+    "    throw error",
+    "  }",
+    "})",
+    ""
+  ].join("\n");
+}
+function renderNuxtHostedAuthLoginRoute(spec) {
+  return [
+    `import { ${spec.loginFunction} } from '${spec.packageName}'`,
+    "",
+    "export default defineEventHandler(async (event) => {",
+    `  return await ${spec.loginFunction}(event)`,
+    "})",
+    ""
+  ].join("\n");
+}
+function renderNuxtHostedAuthRegisterRoute(spec) {
+  return [
+    `import { ${spec.registerFunction} } from '${spec.packageName}'`,
+    "",
+    "export default defineEventHandler(async (event) => {",
+    `  return await ${spec.registerFunction}(event)`,
+    "})",
+    ""
+  ].join("\n");
+}
+function renderNuxtHostedAuthCallbackRoute(spec) {
+  return [
+    `import { ${spec.callbackFunction} } from '${spec.packageName}'`,
+    "import { sendRedirect } from 'h3'",
+    "",
+    "export default defineEventHandler(async (event) => {",
+    `  const { error } = await ${spec.callbackFunction}(event)`,
+    "  if (error) {",
+    "    return await sendRedirect(event, `/login?error=${encodeURIComponent(error.code)}`, 303)",
+    "  }",
+    "",
+    "  return await sendRedirect(event, '/', 303)",
+    "})",
+    ""
+  ].join("\n");
+}
+function renderNuxtHostedAuthLogoutRoute(spec) {
+  return [
+    "import { provider } from '@holo-js/auth'",
+    `import { ${spec.logoutFunction} } from '${spec.packageName}'`,
+    "import { createError, sendRedirect } from 'h3'",
+    "",
+    "export default defineEventHandler(async (event) => {",
+    "  let currentProvider: string | null",
+    "  try {",
+    "    currentProvider = await provider()",
+    "  } catch {",
+    "    return await sendRedirect(event, '/', 303)",
+    "  }",
+    "",
+    `  if (currentProvider !== '${spec.provider}') {`,
+    "    return await sendRedirect(event, '/', 303)",
+    "  }",
+    "",
+    `  const { data, error } = await ${spec.logoutFunction}(event)`,
+    "  if (error) {",
+    "    throw createError({",
+    "      statusCode: error.status,",
+    "      statusMessage: error.message,",
+    "    })",
+    "  }",
+    "",
+    "  return await sendRedirect(event, data.url, 303)",
+    "})",
+    ""
+  ].join("\n");
+}
+function renderNuxtHostedAuthRouteFiles(provider) {
+  const spec = HOSTED_AUTH_PROVIDERS[provider];
+  return [
+    { path: `server/api/auth/${provider}/login.get.ts`, contents: renderNuxtHostedAuthLoginRoute(spec) },
+    { path: `server/api/auth/${provider}/register.get.ts`, contents: renderNuxtHostedAuthRegisterRoute(spec) },
+    { path: `server/api/auth/${provider}/callback.get.ts`, contents: renderNuxtHostedAuthCallbackRoute(spec) },
+    { path: `server/api/auth/${provider}/logout.post.ts`, contents: renderNuxtHostedAuthLogoutRoute(spec) }
+  ];
+}
+function renderNextConfig() {
+  return [
+    "import type { NextConfig } from 'next'",
+    "import { withHolo } from '@holo-js/adapter-next/config'",
+    "",
+    "const nextConfig: NextConfig = withHolo({",
+    "  /* config options here */",
+    "})",
+    "",
+    "export default nextConfig",
+    ""
+  ].join("\n");
+}
+function renderNextLayout(projectName) {
+  return [
+    "import type { ReactNode } from 'react'",
+    "",
+    "export const metadata = {",
+    `  title: ${JSON.stringify(projectName)},`,
+    "  description: 'Holo on Next.js',",
+    "}",
+    "",
+    "export default function RootLayout({ children }: { children: ReactNode }) {",
+    "  return (",
+    '    <html lang="en">',
+    "      <body>{children}</body>",
+    "    </html>",
+    "  )",
+    "}",
+    ""
+  ].join("\n");
+}
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;").replaceAll("{", "&#123;").replaceAll("}", "&#125;");
+}
+function renderNextPage(projectName) {
+  const escapedProjectName = escapeHtml(projectName);
+  return [
+    "export default function HomePage() {",
+    "  return (",
+    "    <main style={{ padding: '3rem', fontFamily: 'sans-serif' }}>",
+    `      <h1>${escapedProjectName}</h1>`,
+    "      <p>Next.js handles rendering. Holo powers the backend runtime and discovered server resources.</p>",
+    "    </main>",
+    "  )",
+    "}",
+    ""
+  ].join("\n");
+}
+function renderNextEnvDts() {
+  return [
+    '/// <reference types="next" />',
+    '/// <reference types="next/image-types/global" />',
+    "",
+    "// Generated by Holo. Do not edit.",
+    ""
+  ].join("\n");
+}
+function renderNextRouteBridge(modulePath, methods) {
+  return [
+    `export { ${methods.join(", ")} } from '${modulePath}'`,
+    ""
+  ].join("\n");
+}
+function renderNextHoloHelper() {
+  return [
+    "import { dirname, resolve } from 'node:path'",
+    "import { fileURLToPath } from 'node:url'",
+    "import { createNextHoloHelpers } from '@holo-js/adapter-next/runtime'",
+    "",
+    "const projectRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../../..')",
+    "",
+    "export const holo = createNextHoloHelpers({ projectRoot })",
+    ""
+  ].join("\n");
+}
+function renderNextCurrentAuthRoute() {
+  return renderNextRouteBridge("../../../../.holo-js/generated/next/auth-user-route", ["GET"]);
+}
+function renderNextGeneratedCurrentAuthRoute() {
+  return [
+    "import auth, { check, isAuthError, provider, user } from '@holo-js/auth'",
+    "import { holo } from './holo'",
+    "",
+    "export async function GET(request: Request) {",
+    "  await holo.getApp()",
+    "",
+    "  const guard = new URL(request.url).searchParams.get('guard') ?? undefined",
+    "  try {",
+    "    const guardAuth = guard ? auth.guard(guard) : undefined",
+    "",
+    "    return Response.json({",
+    "      authenticated: guardAuth ? await guardAuth.check() : await check(),",
+    "      guard: guard ?? 'web',",
+    "      provider: guardAuth ? await guardAuth.provider() : await provider(),",
+    "      user: guardAuth ? await guardAuth.user() : await user(),",
+    "    })",
+    "  } catch (error) {",
+    "    if (isAuthError(error) && error.code === 'guard_not_configured') {",
+    "      return Response.json({",
+    "        authenticated: false,",
+    "        guard: guard ?? 'web',",
+    "        provider: null,",
+    "        user: null,",
+    "      }, { status: 400 })",
+    "    }",
+    "",
+    "    throw error",
+    "  }",
+    "}",
+    ""
+  ].join("\n");
+}
+function renderNextHostedAuthLoginRoute(spec) {
+  return renderNextRouteBridge(`../../../../../.holo-js/generated/next/auth-${spec.provider}-login-route`, ["GET"]);
+}
+function renderNextGeneratedHostedAuthLoginRoute(spec) {
+  return [
+    `import { ${spec.loginFunction} } from '${spec.packageName}'`,
+    "import { holo } from './holo'",
+    "",
+    "export async function GET(request: Request) {",
+    "  await holo.getApp()",
+    "",
+    `  return await ${spec.loginFunction}(request)`,
+    "}",
+    ""
+  ].join("\n");
+}
+function renderNextHostedAuthRegisterRoute(spec) {
+  return renderNextRouteBridge(`../../../../../.holo-js/generated/next/auth-${spec.provider}-register-route`, ["GET"]);
+}
+function renderNextGeneratedHostedAuthRegisterRoute(spec) {
+  return [
+    `import { ${spec.registerFunction} } from '${spec.packageName}'`,
+    "import { holo } from './holo'",
+    "",
+    "export async function GET(request: Request) {",
+    "  await holo.getApp()",
+    "",
+    `  return await ${spec.registerFunction}(request)`,
+    "}",
+    ""
+  ].join("\n");
+}
+function renderNextHostedAuthCallbackRoute(spec) {
+  return renderNextRouteBridge(`../../../../../.holo-js/generated/next/auth-${spec.provider}-callback-route`, ["GET"]);
+}
+function renderNextGeneratedHostedAuthCallbackRoute(spec) {
+  return [
+    `import { ${spec.callbackFunction} } from '${spec.packageName}'`,
+    "import { holo } from './holo'",
+    "",
+    "export async function GET(request: Request) {",
+    "  await holo.getApp()",
+    "",
+    `  const { error } = await ${spec.callbackFunction}(request)`,
+    "  if (error) {",
+    "    return Response.redirect(new URL(`/login?error=${encodeURIComponent(error.code)}`, request.url))",
+    "  }",
+    "",
+    "  return Response.redirect(new URL('/', request.url))",
+    "}",
+    ""
+  ].join("\n");
+}
+function renderNextHostedAuthLogoutRoute(spec) {
+  return renderNextRouteBridge(`../../../../../.holo-js/generated/next/auth-${spec.provider}-logout-route`, ["POST"]);
+}
+function renderNextGeneratedHostedAuthLogoutRoute(spec) {
+  return [
+    "import { provider } from '@holo-js/auth'",
+    `import { ${spec.logoutFunction} } from '${spec.packageName}'`,
+    "import { holo } from './holo'",
+    "",
+    "export async function POST(request: Request) {",
+    "  await holo.getApp()",
+    "",
+    "  let currentProvider: string | null",
+    "  try {",
+    "    currentProvider = await provider()",
+    "  } catch {",
+    "    return Response.redirect(new URL('/', request.url), 303)",
+    "  }",
+    "",
+    `  if (currentProvider !== '${spec.provider}') {`,
+    "    return Response.redirect(new URL('/', request.url), 303)",
+    "  }",
+    "",
+    `  const { data, error } = await ${spec.logoutFunction}(request)`,
+    "  if (error) {",
+    "    return Response.json({ data, error }, { status: error.status })",
+    "  }",
+    "",
+    "  return Response.redirect(data.url, 303)",
+    "}",
+    ""
+  ].join("\n");
+}
+function renderNextHostedAuthRouteFiles(provider) {
+  const spec = HOSTED_AUTH_PROVIDERS[provider];
+  return [
+    { path: `app/api/auth/${provider}/login/route.ts`, contents: renderNextHostedAuthLoginRoute(spec) },
+    { path: `app/api/auth/${provider}/register/route.ts`, contents: renderNextHostedAuthRegisterRoute(spec) },
+    { path: `app/api/auth/${provider}/callback/route.ts`, contents: renderNextHostedAuthCallbackRoute(spec) },
+    { path: `app/api/auth/${provider}/logout/route.ts`, contents: renderNextHostedAuthLogoutRoute(spec) }
+  ];
+}
+function renderNextStorageRoute() {
+  return renderNextRouteBridge("../../../.holo-js/generated/next/storage-route", ["GET"]);
+}
+function renderNextGeneratedStorageRoute() {
+  return [
+    "import { createPublicStorageResponse } from '@holo-js/storage'",
+    "import { holo } from './holo'",
+    "",
+    "export async function GET(request: Request) {",
+    "  const app = await holo.getApp()",
+    "  return createPublicStorageResponse(app.projectRoot, app.config.storage, request)",
+    "}",
+    ""
+  ].join("\n");
+}
+function renderNextBroadcastAuthRoute() {
+  return renderNextRouteBridge("../../../.holo-js/generated/next/broadcast-auth-route", ["POST"]);
+}
+function renderNextGeneratedBroadcastAuthRoute() {
+  return [
+    "import { renderBroadcastAuthResponse } from '@holo-js/broadcast/auth'",
+    "import { holo } from './holo'",
+    "",
+    "export async function POST(request: Request) {",
+    "  const app = await holo.getApp()",
+    "  const auth = await holo.getAuth()",
+    "",
+    "  return await renderBroadcastAuthResponse(request, {",
+    "    resolveUser: async () => await auth?.user(),",
+    "    channelAuth: {",
+    "      registry: {",
+    "        projectRoot: app.projectRoot,",
+    "        channels: app.registry?.channels ?? [],",
+    "      },",
+    "    },",
+    "  })",
+    "}",
+    ""
+  ].join("\n");
+}
+function renderNextManagedRouteFiles(options = {}) {
+  return [
+    { path: ".holo-js/generated/next/holo.ts", contents: renderNextHoloHelper() },
+    ...options.authEnabled ? [{ path: ".holo-js/generated/next/auth-user-route.ts", contents: renderNextGeneratedCurrentAuthRoute() }] : [],
+    ...options.storageEnabled ? [{ path: ".holo-js/generated/next/storage-route.ts", contents: renderNextGeneratedStorageRoute() }] : [],
+    ...options.broadcastAuthEnabled ? [{ path: ".holo-js/generated/next/broadcast-auth-route.ts", contents: renderNextGeneratedBroadcastAuthRoute() }] : []
+  ];
+}
+function renderNextManagedHostedAuthRouteFiles(features) {
+  return getRequestedHostedAuthProviders(features).flatMap((provider) => {
+    const spec = HOSTED_AUTH_PROVIDERS[provider];
+    return [
+      { path: ".holo-js/generated/next/holo.ts", contents: renderNextHoloHelper() },
+      { path: `.holo-js/generated/next/auth-${provider}-login-route.ts`, contents: renderNextGeneratedHostedAuthLoginRoute(spec) },
+      { path: `.holo-js/generated/next/auth-${provider}-register-route.ts`, contents: renderNextGeneratedHostedAuthRegisterRoute(spec) },
+      { path: `.holo-js/generated/next/auth-${provider}-callback-route.ts`, contents: renderNextGeneratedHostedAuthCallbackRoute(spec) },
+      { path: `.holo-js/generated/next/auth-${provider}-logout-route.ts`, contents: renderNextGeneratedHostedAuthLogoutRoute(spec) }
+    ];
+  });
+}
+function renderSvelteManagedRuntimeFiles() {
+  return [
+    { path: ".holo-js/generated/sveltekit/holo.ts", contents: renderSvelteHoloHelper() }
+  ];
+}
+function renderSvelteConfig() {
+  return [
+    "import adapter from '@sveltejs/adapter-node'",
+    "import { withHoloSvelteKit } from '@holo-js/adapter-sveltekit/config'",
+    "import { vitePreprocess } from '@sveltejs/vite-plugin-svelte'",
+    "",
+    "/** @type {import('@sveltejs/kit').Config} */",
+    "const config = withHoloSvelteKit({",
+    "  preprocess: vitePreprocess(),",
+    "  kit: {",
+    "    adapter: adapter(),",
+    "  },",
+    "})",
+    "",
+    "export default config",
+    ""
+  ].join("\n");
+}
+function renderSvelteUserHooks() {
+  return [
+    "export {}",
+    ""
+  ].join("\n");
+}
+function renderSvelteServerUserHooks() {
+  return [
+    "export {}",
+    ""
+  ].join("\n");
+}
+function renderSvelteViteConfig(_storageEnabled) {
+  const externals = [
+    "      '@holo-js/adapter-sveltekit',",
+    "      '@holo-js/auth',",
+    "      '@holo-js/auth-clerk',",
+    "      '@holo-js/auth-social',",
+    "      '@holo-js/auth-workos',",
+    "      '@holo-js/authorization',",
+    "      '@holo-js/broadcast',",
+    "      '@holo-js/cache',",
+    "      '@holo-js/cache-db',",
+    "      '@holo-js/cache-redis',",
+    "      '@holo-js/config',",
+    "      '@holo-js/core',",
+    "      '@holo-js/db',",
+    "      '@holo-js/db-mysql',",
+    "      '@holo-js/db-postgres',",
+    "      '@holo-js/db-sqlite',",
+    "      '@holo-js/events',",
+    "      '@holo-js/flux',",
+    "      '@holo-js/flux-svelte',",
+    "      '@holo-js/forms',",
+    "      '@holo-js/mail',",
+    "      '@holo-js/media',",
+    "      '@holo-js/notifications',",
+    "      '@holo-js/queue',",
+    "      '@holo-js/queue-db',",
+    "      '@holo-js/queue-redis',",
+    "      '@holo-js/security',",
+    "      '@holo-js/session',",
+    "      '@holo-js/storage',",
+    "      '@holo-js/storage/runtime',",
+    "      '@holo-js/storage-s3',",
+    "      '@holo-js/validation',",
+    "      'better-sqlite3',",
+    "      'ioredis',",
+    "      'mysql2',",
+    "      'pg',"
+  ];
+  return [
+    "import { sveltekit } from '@sveltejs/kit/vite'",
+    "import { defineConfig } from 'vite'",
+    "",
+    "export default defineConfig({",
+    "  plugins: [sveltekit()],",
+    "  server: {",
+    "    fs: {",
+    "      allow: ['.holo-js/generated'],",
+    "    },",
+    "  },",
+    "  ssr: {",
+    "    external: [",
+    ...externals,
+    "    ],",
+    "  },",
+    "})",
+    ""
+  ].join("\n");
+}
+function renderSvelteAppHtml() {
+  return [
+    "<!doctype html>",
+    '<html lang="en">',
+    "  <head>",
+    '    <meta charset="utf-8" />',
+    '    <meta name="viewport" content="width=device-width, initial-scale=1" />',
+    "    %sveltekit.head%",
+    "  </head>",
+    '  <body data-sveltekit-preload-data="hover">',
+    '    <div style="display: contents">%sveltekit.body%</div>',
+    "  </body>",
+    "</html>",
+    ""
+  ].join("\n");
+}
+function renderSveltePage(projectName) {
+  const escapedProjectName = escapeHtml(projectName);
+  return [
+    `<svelte:head><title>${escapedProjectName}</title></svelte:head>`,
+    "",
+    '<script lang="ts">',
+    `  const projectName = ${JSON.stringify(projectName)}`,
+    "</script>",
+    "",
+    '<main class="shell">',
+    "  <h1>{projectName}</h1>",
+    "  <p>SvelteKit owns rendering. Holo owns config, discovery, and backend runtime services.</p>",
+    "</main>",
+    "",
+    "<style>",
+    "  .shell {",
+    "    min-height: 100vh;",
+    "    display: grid;",
+    "    place-content: center;",
+    "    gap: 1rem;",
+    "    padding: 3rem;",
+    "    font-family: sans-serif;",
+    "  }",
+    "  h1 {",
+    "    margin: 0;",
+    "    font-size: clamp(2.5rem, 6vw, 4rem);",
+    "  }",
+    "  p {",
+    "    margin: 0;",
+    "    max-width: 40rem;",
+    "    line-height: 1.6;",
+    "  }",
+    "</style>",
+    ""
+  ].join("\n");
+}
+function renderSvelteHoloHelper() {
+  return [
+    "import { dirname, resolve } from 'node:path'",
+    "import { fileURLToPath } from 'node:url'",
+    "import { createSvelteKitHoloHelpers } from '@holo-js/adapter-sveltekit'",
+    "",
+    "const projectRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../../..')",
+    "",
+    "export const holo = createSvelteKitHoloHelpers({ projectRoot })",
+    ""
+  ].join("\n");
+}
+function renderSvelteHostedAuthLoginRoute(spec) {
+  return [
+    `import { ${spec.loginFunction} } from '${spec.packageName}'`,
+    "import type { RequestEvent } from '@sveltejs/kit'",
+    "",
+    "export async function GET(event: RequestEvent) {",
+    `  return await ${spec.loginFunction}(event)`,
+    "}",
+    ""
+  ].join("\n");
+}
+function renderSvelteHostedAuthRegisterRoute(spec) {
+  return [
+    `import { ${spec.registerFunction} } from '${spec.packageName}'`,
+    "import type { RequestEvent } from '@sveltejs/kit'",
+    "",
+    "export async function GET(event: RequestEvent) {",
+    `  return await ${spec.registerFunction}(event)`,
+    "}",
+    ""
+  ].join("\n");
+}
+function renderSvelteHostedAuthCallbackRoute(spec) {
+  return [
+    "import { redirect, type RequestEvent } from '@sveltejs/kit'",
+    `import { ${spec.callbackFunction} } from '${spec.packageName}'`,
+    "",
+    "export async function GET(event: RequestEvent) {",
+    `  const { error } = await ${spec.callbackFunction}(event)`,
+    "  if (error) {",
+    "    throw redirect(303, `/login?error=${encodeURIComponent(error.code)}`)",
+    "  }",
+    "",
+    "  throw redirect(303, '/')",
+    "}",
+    ""
+  ].join("\n");
+}
+function renderSvelteHostedAuthLogoutRoute(spec) {
+  return [
+    "import { redirect, type RequestEvent } from '@sveltejs/kit'",
+    "import { provider } from '@holo-js/auth'",
+    `import { ${spec.logoutFunction} } from '${spec.packageName}'`,
+    "",
+    "export async function POST(event: RequestEvent) {",
+    "  let currentProvider: string | null",
+    "  try {",
+    "    currentProvider = await provider()",
+    "  } catch {",
+    "    throw redirect(303, '/')",
+    "  }",
+    "",
+    `  if (currentProvider !== '${spec.provider}') {`,
+    "    throw redirect(303, '/')",
+    "  }",
+    "",
+    `  const { data, error } = await ${spec.logoutFunction}(event)`,
+    "  if (error) {",
+    "    return Response.json({ data, error }, { status: error.status })",
+    "  }",
+    "",
+    "  throw redirect(303, data.url)",
+    "}",
+    ""
+  ].join("\n");
+}
+function renderSvelteHostedAuthRouteFiles(provider) {
+  const spec = HOSTED_AUTH_PROVIDERS[provider];
+  return [
+    { path: `src/routes/api/auth/${provider}/login/+server.ts`, contents: renderSvelteHostedAuthLoginRoute(spec) },
+    { path: `src/routes/api/auth/${provider}/register/+server.ts`, contents: renderSvelteHostedAuthRegisterRoute(spec) },
+    { path: `src/routes/api/auth/${provider}/callback/+server.ts`, contents: renderSvelteHostedAuthCallbackRoute(spec) },
+    { path: `src/routes/api/auth/${provider}/logout/+server.ts`, contents: renderSvelteHostedAuthLogoutRoute(spec) },
+    ...renderSvelteManagedRuntimeFiles()
+  ];
+}
+function renderAuthProviderRouteFiles(framework, features) {
+  return getRequestedHostedAuthProviders(features).flatMap((provider) => {
+    if (framework === "nuxt") {
+      return renderNuxtHostedAuthRouteFiles(provider);
+    }
+    if (framework === "next") {
+      return renderNextHostedAuthRouteFiles(provider);
+    }
+    return renderSvelteHostedAuthRouteFiles(provider);
+  });
+}
+function renderAuthRouteFiles(framework) {
+  if (framework === "next") {
+    return [
+      { path: "app/api/auth/user/route.ts", contents: renderNextCurrentAuthRoute() },
+      { path: ".holo-js/generated/next/holo.ts", contents: renderNextHoloHelper() },
+      { path: ".holo-js/generated/next/auth-user-route.ts", contents: renderNextGeneratedCurrentAuthRoute() }
+    ];
+  }
+  if (framework === "nuxt") {
+    return [
+      { path: "server/api/auth/user.get.ts", contents: renderNuxtCurrentAuthRoute() }
+    ];
+  }
+  return [
+    ...renderSvelteManagedRuntimeFiles()
+  ];
+}
+function renderFrameworkFiles(options) {
+  const optionalPackages = normalizeScaffoldOptionalPackages(options.optionalPackages);
+  const storageEnabled = optionalPackages.includes("storage");
+  const authEnabled = optionalPackages.includes("auth");
+  if (options.framework === "nuxt") {
+    return [
+      { path: "app/app.vue", contents: renderNuxtAppVue(options.projectName) },
+      { path: "nuxt.config.ts", contents: renderNuxtConfig() },
+      { path: "shared/.gitkeep", contents: "" },
+      ...authEnabled ? renderAuthRouteFiles("nuxt") : []
+    ];
+  }
+  if (options.framework === "next") {
+    return [
+      { path: "next.config.ts", contents: renderNextConfig() },
+      { path: "next-env.d.ts", contents: renderNextEnvDts() },
+      { path: "app/layout.tsx", contents: renderNextLayout(options.projectName) },
+      { path: "app/page.tsx", contents: renderNextPage(options.projectName) },
+      ...authEnabled ? [{ path: "app/api/auth/user/route.ts", contents: renderNextCurrentAuthRoute() }] : [],
+      ...storageEnabled ? [{ path: "app/storage/[[...path]]/route.ts", contents: renderNextStorageRoute() }] : [],
+      ...renderNextManagedRouteFiles({ authEnabled, storageEnabled })
+    ];
+  }
+  return [
+    { path: "svelte.config.js", contents: renderSvelteConfig() },
+    { path: "vite.config.ts", contents: renderSvelteViteConfig(storageEnabled) },
+    { path: "src/hooks.ts", contents: renderSvelteUserHooks() },
+    { path: "src/hooks.server.ts", contents: renderSvelteServerUserHooks() },
+    { path: "src/app.html", contents: renderSvelteAppHtml() },
+    { path: "src/routes/+page.svelte", contents: renderSveltePage(options.projectName) },
+    ...authEnabled ? renderAuthRouteFiles("sveltekit") : [],
+    ...renderSvelteManagedRuntimeFiles()
+  ];
+}
+function renderFrameworkRunner(options) {
+  const commandName = options.framework === "nuxt" ? "nuxt" : options.framework === "next" ? "next" : "vite";
+  return [
+    "import { existsSync, readFileSync, readlinkSync } from 'node:fs'",
+    "import { dirname, resolve } from 'node:path'",
+    "import { fileURLToPath, pathToFileURL } from 'node:url'",
+    "import { execFileSync, spawn } from 'node:child_process'",
+    "",
+    "const mode = process.argv[2]",
+    "const manifestPath = fileURLToPath(new URL('./project.json', import.meta.url))",
+    "const projectRoot = resolve(dirname(manifestPath), '../..')",
+    "const runtimeSchemaPath = resolve(projectRoot, '.holo-js/generated/schema.mjs')",
+    "const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'))",
+    "const framework = String(manifest.framework ?? '')",
+    `const commandName = ${JSON.stringify(commandName)}`,
+    "const commandArgs = mode === 'dev'",
+    "  ? ['dev']",
+    "  : mode === 'build'",
+    "    ? framework === 'sveltekit' ? ['build', '--logLevel', 'error'] : ['build']",
+    "    : undefined",
+    "",
+    "if (!commandArgs) {",
+    "  console.error(`[holo] Unknown framework runner mode: ${String(mode)}`)",
+    "  process.exit(1)",
+    "}",
+    "",
+    "const binaryPath = resolve(",
+    "  projectRoot,",
+    "  'node_modules',",
+    "  '.bin',",
+    "  process.platform === 'win32' ? `${commandName}.cmd` : commandName,",
+    ")",
+    "",
+    "const suppressedOutput = framework === 'sveltekit'",
+    "  ? new Set([",
+    `      '"try_get_request_store" is imported from external module "@sveltejs/kit/internal/server" but never used in ".svelte-kit/adapter-node/index.js".',`,
+    "    ])",
+    "  : new Set()",
+    "",
+    "function shouldSuppressOutput(line) {",
+    "  if (suppressedOutput.has(line)) {",
+    "    return true",
+    "  }",
+    "",
+    "  return framework === 'sveltekit'",
+    "    && line.startsWith('Circular dependency: ')",
+    "    && line.includes('/node_modules/semver/')",
+    "}",
+    "",
+    "function pipeOutput(stream, target, onLine) {",
+    "  if (!stream) {",
+    "    return",
+    "  }",
+    "",
+    "  let buffered = ''",
+    "  stream.on('data', (chunk) => {",
+    "    buffered += chunk.toString()",
+    "    const lines = buffered.split(/\\r?\\n/)",
+    "    buffered = lines.pop() ?? ''",
+    "    for (const line of lines) {",
+    "      onLine?.(line)",
+    "      if (!shouldSuppressOutput(line)) {",
+    "        target.write(`${line}\\n`)",
+    "      }",
+    "    }",
+    "  })",
+    "",
+    "  stream.on('end', () => {",
+    "    if (buffered.length > 0) {",
+    "      onLine?.(buffered)",
+    "    }",
+    "    if (buffered.length > 0 && !shouldSuppressOutput(buffered)) {",
+    "      target.write(buffered)",
+    "    }",
+    "  })",
+    "}",
+    "",
+    "function extractNextConflictInfo(lines) {",
+    "  if (framework !== 'next' || mode !== 'dev') {",
+    "    return undefined",
+    "  }",
+    "",
+    "  if (!lines.some(line => line.includes('Another next dev server is already running.'))) {",
+    "    return undefined",
+    "  }",
+    "",
+    "  let pid",
+    "  let dir",
+    "",
+    "  for (const line of lines) {",
+    "    const match = line.match(/^- PID:\\s+(\\d+)\\s*$/)",
+    "    if (match) {",
+    "      pid = Number.parseInt(match[1], 10)",
+    "      continue",
+    "    }",
+    "",
+    "    const dirMatch = line.match(/^- Dir:\\s+(.+?)\\s*$/)",
+    "    if (dirMatch) {",
+    "      dir = dirMatch[1]",
+    "    }",
+    "  }",
+    "",
+    "  return typeof pid === 'number' ? { pid, dir } : undefined",
+    "}",
+    "",
+    "async function waitForProcessExit(pid, timeoutMs = 5000) {",
+    "  const deadline = Date.now() + timeoutMs",
+    "  while (Date.now() < deadline) {",
+    "    try {",
+    "      process.kill(pid, 0)",
+    "    } catch (error) {",
+    "      if (error && typeof error === 'object' && 'code' in error && error.code === 'ESRCH') {",
+    "        return true",
+    "      }",
+    "      throw error",
+    "    }",
+    "",
+    "    await new Promise(resolve => setTimeout(resolve, 100))",
+    "  }",
+    "",
+    "  return false",
+    "}",
+    "",
+    "function inspectProcess(pid) {",
+    "  try {",
+    "    if (process.platform === 'linux' && existsSync(`/proc/${pid}`)) {",
+    "      return {",
+    "        cwd: readlinkSync(`/proc/${pid}/cwd`),",
+    "        args: readFileSync(`/proc/${pid}/cmdline`, 'utf8').replaceAll('\\u0000', ' ').trim(),",
+    "      }",
+    "    }",
+    "  } catch {",
+    "    // Fall through to the portable process inspection path below.",
+    "  }",
+    "",
+    "  try {",
+    "    return {",
+    "      args: execFileSync('ps', ['-p', String(pid), '-o', 'args='], {",
+    "        encoding: 'utf8',",
+    "      }).trim(),",
+    "    }",
+    "  } catch {",
+    "    return undefined",
+    "  }",
+    "}",
+    "",
+    "function isOwnedNextDevServer(pid, reportedDir) {",
+    "  const expectedDir = typeof reportedDir === 'string' ? resolve(reportedDir) : undefined",
+    "  if (expectedDir && expectedDir !== projectRoot) {",
+    "    return false",
+    "  }",
+    "",
+    "  const details = inspectProcess(pid)",
+    "  if (!details) {",
+    "    return expectedDir === projectRoot",
+    "  }",
+    "",
+    "  const argsMatch = details.args.includes('next') && details.args.includes('dev')",
+    "  const cwdMatches = typeof details.cwd === 'string' && resolve(details.cwd) === projectRoot",
+    "  const argsReferenceProject = details.args.includes(projectRoot)",
+    "",
+    "  return argsMatch && (cwdMatches || argsReferenceProject || expectedDir === projectRoot)",
+    "}",
+    "",
+    "async function stopStaleNextDevServer(pid, reportedDir, force = false) {",
+    "  if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid) {",
+    "    return false",
+    "  }",
+    "",
+    "  if (!isOwnedNextDevServer(pid, reportedDir)) {",
+    "    return false",
+    "  }",
+    "",
+    "  if (!force) {",
+    "    return false",
+    "  }",
+    "",
+    "  try {",
+    "    process.kill(pid, 'SIGTERM')",
+    "  } catch (error) {",
+    "    if (error && typeof error === 'object' && 'code' in error && error.code === 'ESRCH') {",
+    "      return true",
+    "    }",
+    "    return false",
+    "  }",
+    "",
+    "  return waitForProcessExit(pid)",
+    "}",
+    "",
+    "if (!existsSync(binaryPath)) {",
+    '  console.error(`[holo] Missing framework binary "${commandName}" for "${framework}". Run your package manager install first.`)',
+    "  process.exit(1)",
+    "}",
+    "",
+    "let child = null",
+    "let forwardedSignal = null",
+    "",
+    "function detachSignalForwarders() {",
+    "  process.removeListener('SIGINT', onSigint)",
+    "  process.removeListener('SIGTERM', onSigterm)",
+    "}",
+    "",
+    "function forwardSignal(signal) {",
+    "  if (forwardedSignal || !child || child.exitCode !== null) {",
+    "    return",
+    "  }",
+    "",
+    "  forwardedSignal = signal",
+    "  child.kill(signal)",
+    "}",
+    "",
+    "function onSigint() {",
+    "  detachSignalForwarders()",
+    "  forwardSignal('SIGINT')",
+    "}",
+    "",
+    "function onSigterm() {",
+    "  detachSignalForwarders()",
+    "  forwardSignal('SIGTERM')",
+    "}",
+    "",
+    "process.on('SIGINT', onSigint)",
+    "process.on('SIGTERM', onSigterm)",
+    "",
+    "async function run() {",
+    "  let restartedAfterConflict = false",
+    "  const maxStderrLines = 200",
+    "",
+    "  while (true) {",
+    "    const stderrLines = []",
+    "    const childEnv = { ...process.env }",
+    "    if (existsSync(runtimeSchemaPath)) {",
+    "      const preload = `--import=${pathToFileURL(runtimeSchemaPath).href}`",
+    "      childEnv.NODE_OPTIONS = childEnv.NODE_OPTIONS",
+    "        ? `${childEnv.NODE_OPTIONS} ${preload}`",
+    "        : preload",
+    "    }",
+    "    child = spawn(binaryPath, commandArgs, {",
+    "      cwd: projectRoot,",
+    "      env: childEnv,",
+    "      stdio: ['inherit', 'pipe', 'pipe'],",
+    "    })",
+    "    forwardedSignal = null",
+    "",
+    "    pipeOutput(child.stdout, process.stdout)",
+    "    pipeOutput(child.stderr, process.stderr, line => {",
+    "      if (stderrLines.length >= maxStderrLines) {",
+    "        stderrLines.shift()",
+    "      }",
+    "      stderrLines.push(line)",
+    "    })",
+    "",
+    "    const result = await new Promise((resolve, reject) => {",
+    "      child.on('error', reject)",
+    "      child.on('close', (code, signal) => resolve({ code, signal }))",
+    "    })",
+    "",
+    "    if (result.code === 0) {",
+    "      process.exit(0)",
+    "    }",
+    "",
+    "    const conflictInfo = extractNextConflictInfo(stderrLines)",
+    "    if (!restartedAfterConflict && conflictInfo) {",
+    "      const stopped = await stopStaleNextDevServer(conflictInfo.pid, conflictInfo.dir)",
+    "      if (stopped) {",
+    "        restartedAfterConflict = true",
+    "        console.error(`[holo] Stopped stale Next dev server ${conflictInfo.pid}. Restarting dev server.`)",
+    "        continue",
+    "      }",
+    "",
+    "      // Another dev server is already running (possibly in a different directory).",
+    "      // Next.js already printed the conflict message with instructions to kill it.",
+    "      // Exit gracefully to avoid noisy npm/bun error cascades.",
+    "      process.exit(0)",
+    "    }",
+    "",
+    "    if (result.signal) {",
+    "      detachSignalForwarders()",
+    "      process.kill(process.pid, result.signal)",
+    "    } else {",
+    "      process.exit(result.code ?? 1)",
+    "    }",
+    "  }",
+    "}",
+    "",
+    "run().catch((error) => {",
+    "  console.error(error instanceof Error ? error.message : String(error))",
+    "  process.exit(1)",
+    "})",
+    ""
+  ].join("\n");
+}
+
 // src/project/registry.ts
 import { constants as fsConstants } from "fs";
-import { access, mkdir as mkdir2, readFile as readFile2, readdir, writeFile as writeFile2 } from "fs/promises";
+import { access, mkdir as mkdir2, readFile as readFile2, readdir as readdir2, writeFile as writeFile2 } from "fs/promises";
 import { dirname as dirname3, extname, join, resolve as resolve3 } from "path";
 import { loadConfigDirectory } from "@holo-js/config";
 import { DEFAULT_HOLO_PROJECT_PATHS, renderGeneratedSchemaRuntimeModule } from "@holo-js/db";
 
 // src/project/registry-svelte.ts
-import { mkdir, readFile, unlink, writeFile } from "fs/promises";
+import { mkdir, readdir, readFile, rm, writeFile } from "fs/promises";
 import { dirname as dirname2, resolve as resolve2 } from "path";
 function renderManagedSvelteHooksModule() {
   return [
@@ -308,22 +1365,151 @@ function renderManagedSvelteHooksModule() {
     ""
   ].join("\n");
 }
-function renderManagedSvelteServerHooksModule() {
-  return [
+function renderManagedSvelteServerHooksModule(features) {
+  const imports = [
     "// Generated by holo prepare. Do not edit.",
     "",
-    "import { error as svelteKitError, type Handle, type HandleFetch, type HandleServerError } from '@sveltejs/kit'",
+    "import { error as svelteKitError, type Handle, type HandleFetch, type HandleServerError, type RequestEvent } from '@sveltejs/kit'",
     "import { adapterSvelteKitInternals, runWithSvelteKitRequestEvent } from '@holo-js/adapter-sveltekit'",
     "import { sequence } from '@sveltejs/kit/hooks'",
-    "import { holo } from '$lib/server/holo'",
+    ...features.authEnabled ? ["import auth, { check, isAuthError, provider, user } from '@holo-js/auth'"] : [],
+    ...features.broadcastEnabled ? ["import { renderBroadcastAuthResponse } from '@holo-js/broadcast/auth'"] : [],
+    ...features.storageEnabled ? ["import { createPublicStorageResponse } from '@holo-js/storage'"] : [],
+    ...features.clerkEnabled ? ["import { completeClerkAuth, loginWithClerk, logoutWithClerk, registerWithClerk } from '@holo-js/auth-clerk'"] : [],
+    ...features.workosEnabled ? ["import { completeWorkosAuth, loginWithWorkos, logoutWithWorkos, registerWithWorkos } from '@holo-js/auth-workos'"] : [],
+    "import { holo } from './sveltekit/holo'",
     "import * as userHooks from '../../src/hooks.server'",
-    "",
+    ""
+  ];
+  const routeHandlers = [
+    ...features.authEnabled ? ["handleHoloCurrentAuthRoute"] : [],
+    ...features.storageEnabled ? ["handleHoloStorageRoute"] : [],
+    ...features.broadcastEnabled ? ["handleHoloBroadcastAuthRoute"] : [],
+    ...features.clerkEnabled ? [
+      "handleHoloClerkLoginRoute",
+      "handleHoloClerkRegisterRoute",
+      "handleHoloClerkCallbackRoute",
+      "handleHoloClerkLogoutRoute"
+    ] : [],
+    ...features.workosEnabled ? [
+      "handleHoloWorkosLoginRoute",
+      "handleHoloWorkosRegisterRoute",
+      "handleHoloWorkosCallbackRoute",
+      "handleHoloWorkosLogoutRoute"
+    ] : []
+  ];
+  return [
+    ...imports,
     "const serverHooks = userHooks as {",
     "  handle?: Handle",
     "  handleError?: HandleServerError",
     "  handleFetch?: HandleFetch",
     "}",
     "",
+    "type HoloApp = Awaited<ReturnType<typeof holo.getApp>>",
+    "type HoloRouteHandler = (event: RequestEvent, app: HoloApp) => Promise<Response | undefined>",
+    "",
+    "function isRoute(event: RequestEvent, method: string, paths: readonly string[]): boolean {",
+    "  return event.request.method.toUpperCase() === method && paths.includes(event.url.pathname)",
+    "}",
+    "",
+    "function redirectResponse(event: RequestEvent, location: string): Response {",
+    "  return Response.redirect(new URL(location, event.url), 303)",
+    "}",
+    "",
+    "function normalizeRoutePrefix(value: string | undefined, fallback: string): string {",
+    "  const raw = value?.trim() ?? fallback",
+    "  if (!raw || raw === '/') {",
+    "    return fallback",
+    "  }",
+    "",
+    "  return `/${raw.replace(/^\\/+|\\/+$/g, '')}`",
+    "}",
+    "",
+    "function pathMatchesPrefix(pathname: string, prefix: string): boolean {",
+    "  return pathname === prefix || pathname.startsWith(`${prefix}/`)",
+    "}",
+    "",
+    ...features.authEnabled ? [
+      "async function handleHoloCurrentAuthRoute(event: RequestEvent): Promise<Response | undefined> {",
+      "  if (!isRoute(event, 'GET', ['/api/auth/user'])) {",
+      "    return undefined",
+      "  }",
+      "",
+      "  const guard = event.url.searchParams.get('guard') ?? undefined",
+      "  try {",
+      "    const guardAuth = guard ? auth.guard(guard) : undefined",
+      "",
+      "    return Response.json({",
+      "      authenticated: guardAuth ? await guardAuth.check() : await check(),",
+      "      guard: guard ?? 'web',",
+      "      provider: guardAuth ? await guardAuth.provider() : await provider(),",
+      "      user: guardAuth ? await guardAuth.user() : await user(),",
+      "    })",
+      "  } catch (error) {",
+      "    if (isAuthError(error) && error.code === 'guard_not_configured') {",
+      "      return Response.json({",
+      "        authenticated: false,",
+      "        guard: guard ?? 'web',",
+      "        provider: null,",
+      "        user: null,",
+      "      }, { status: 400 })",
+      "    }",
+      "",
+      "    throw error",
+      "  }",
+      "}",
+      ""
+    ] : [],
+    ...features.storageEnabled ? [
+      "async function handleHoloStorageRoute(event: RequestEvent, app: HoloApp): Promise<Response | undefined> {",
+      "  if (event.request.method.toUpperCase() !== 'GET') {",
+      "    return undefined",
+      "  }",
+      "",
+      "  const prefix = normalizeRoutePrefix(app.config.storage.routePrefix, '/storage')",
+      "  if (!pathMatchesPrefix(event.url.pathname, prefix)) {",
+      "    return undefined",
+      "  }",
+      "",
+      "  return createPublicStorageResponse(app.projectRoot, app.config.storage, event.request)",
+      "}",
+      ""
+    ] : [],
+    ...features.broadcastEnabled ? [
+      "async function handleHoloBroadcastAuthRoute(event: RequestEvent, app: HoloApp): Promise<Response | undefined> {",
+      "  if (!isRoute(event, 'POST', ['/broadcasting/auth'])) {",
+      "    return undefined",
+      "  }",
+      "",
+      "  const auth = await holo.getAuth()",
+      "  return await renderBroadcastAuthResponse(event.request, {",
+      "    resolveUser: async () => await auth?.user(),",
+      "    channelAuth: {",
+      "      registry: {",
+      "        projectRoot: app.projectRoot,",
+      "        channels: app.registry?.channels ?? [],",
+      "      },",
+      "    },",
+      "  })",
+      "}",
+      ""
+    ] : [],
+    ...features.clerkEnabled ? renderSvelteHostedAuthHookRoutes("clerk", "Clerk") : [],
+    ...features.workosEnabled ? renderSvelteHostedAuthHookRoutes("workos", "Workos") : [],
+    `const holoRouteHandlers: readonly HoloRouteHandler[] = [${routeHandlers.join(", ")}]`,
+    "",
+    "async function handleHoloRoute(event: RequestEvent, app: HoloApp): Promise<Response | undefined> {",
+    "  for (const handler of holoRouteHandlers) {",
+    "    const response = await handler(event, app)",
+    "    if (response) {",
+    "      return response",
+    "    }",
+    "  }",
+    "",
+    "  return undefined",
+    "}",
+    "",
     "function isHoloAuthorizationHttpError(cause: unknown): cause is Error & { readonly decision: { readonly status: 403 | 404 } } {",
     "  if (!(cause instanceof Error) || cause.name !== 'AuthorizationError') {",
     "    return false",
@@ -338,9 +1524,14 @@ function renderManagedSvelteServerHooksModule() {
     "}",
     "",
     "const holoHandle: Handle = ({ event, resolve }) => runWithSvelteKitRequestEvent(event, async () => {",
-    "  await holo.getApp()",
+    "  const app = await holo.getApp()",
     "",
     "  try {",
+    "    const holoRouteResponse = await handleHoloRoute(event, app)",
+    "    if (holoRouteResponse) {",
+    "      return holoRouteResponse",
+    "    }",
+    "",
     "    const response = await resolve(event)",
     "    return await adapterSvelteKitInternals.mapValidationActionResponse(event, response)",
     "  } catch (cause) {",
@@ -385,6 +1576,63 @@ function renderManagedSvelteServerHooksModule() {
     ""
   ].join("\n");
 }
+function renderSvelteHostedAuthHookRoutes(providerName, functionSuffix) {
+  return [
+    `async function handleHolo${functionSuffix}LoginRoute(event: RequestEvent): Promise<Response | undefined> {`,
+    `  if (!isRoute(event, 'GET', ['/api/auth/${providerName}/login'])) {`,
+    "    return undefined",
+    "  }",
+    "",
+    `  return await loginWith${functionSuffix}(event)`,
+    "}",
+    "",
+    `async function handleHolo${functionSuffix}RegisterRoute(event: RequestEvent): Promise<Response | undefined> {`,
+    `  if (!isRoute(event, 'GET', ['/api/auth/${providerName}/register'])) {`,
+    "    return undefined",
+    "  }",
+    "",
+    `  return await registerWith${functionSuffix}(event)`,
+    "}",
+    "",
+    `async function handleHolo${functionSuffix}CallbackRoute(event: RequestEvent): Promise<Response | undefined> {`,
+    `  if (!isRoute(event, 'GET', ['/api/auth/${providerName}/callback'])) {`,
+    "    return undefined",
+    "  }",
+    "",
+    `  const { error } = await complete${functionSuffix}Auth(event)`,
+    "  if (error) {",
+    "    return redirectResponse(event, `/login?error=${encodeURIComponent(error.code)}`)",
+    "  }",
+    "",
+    "  return redirectResponse(event, '/')",
+    "}",
+    "",
+    `async function handleHolo${functionSuffix}LogoutRoute(event: RequestEvent): Promise<Response | undefined> {`,
+    `  if (!isRoute(event, 'POST', ['/api/auth/${providerName}/logout'])) {`,
+    "    return undefined",
+    "  }",
+    "",
+    "  let currentProvider: string | null",
+    "  try {",
+    "    currentProvider = await provider()",
+    "  } catch {",
+    "    return redirectResponse(event, '/')",
+    "  }",
+    "",
+    `  if (currentProvider !== '${providerName}') {`,
+    "    return redirectResponse(event, '/')",
+    "  }",
+    "",
+    `  const { data, error } = await logoutWith${functionSuffix}(event)`,
+    "  if (error) {",
+    "    return Response.json({ data, error }, { status: error.status })",
+    "  }",
+    "",
+    "  return redirectResponse(event, data.url)",
+    "}",
+    ""
+  ];
+}
 function renderSvelteDefaultHooksModule() {
   return [
     "export {}",
@@ -448,10 +1696,10 @@ async function readFileIfPresent(path) {
   }
 }
 async function unlinkIfPresent(path) {
-  try {
-    await unlink(path);
-  } catch {
-  }
+  await rm(path, { force: true });
+}
+async function pathExists(path) {
+  return await readFileIfPresent(path) !== void 0;
 }
 var SVELTE_HOOKS_OVERRIDE_BLOCK = [
   "    files: {",
@@ -533,7 +1781,7 @@ async function writeFileIfChanged(path, contents) {
   await mkdir(dirname2(path), { recursive: true });
   await writeFile(path, contents, "utf8");
 }
-async function ensureSvelteManagedHooks(projectRoot) {
+async function ensureSvelteManagedHooks(projectRoot, features) {
   const hooksPath = resolve2(projectRoot, "src/hooks.ts");
   const hooksServerPath = resolve2(projectRoot, "src/hooks.server.ts");
   const generatedHooksPath = resolve2(projectRoot, GENERATED_SVELTE_HOOKS_PATH);
@@ -567,9 +1815,146 @@ async function ensureSvelteManagedHooks(projectRoot) {
     await writeFileIfChanged(hooksServerPath, renderSvelteDefaultServerHooksModule());
   }
   await writeFileIfChanged(generatedHooksPath, renderManagedSvelteHooksModule());
-  await writeFileIfChanged(generatedServerHooksPath, renderManagedSvelteServerHooksModule());
+  await writeFileIfChanged(generatedServerHooksPath, renderManagedSvelteServerHooksModule(features));
   await ensureSvelteConfigHooksOverride(projectRoot);
 }
+async function removeLegacyManagedHoloHelper(path, managedContents) {
+  const contents = await readFileIfPresent(path);
+  const trimmedContents = contents?.trim();
+  const trimmedManagedContents = managedContents.trim();
+  const isLegacyManagedHelper = trimmedContents === [
+    "import { createNextHoloHelpers } from '@holo-js/adapter-next'",
+    "",
+    "export const holo = createNextHoloHelpers()"
+  ].join("\n") || trimmedContents === [
+    "import { createSvelteKitHoloHelpers } from '@holo-js/adapter-sveltekit'",
+    "",
+    "export const holo = createSvelteKitHoloHelpers()"
+  ].join("\n");
+  if (trimmedContents === trimmedManagedContents || isLegacyManagedHelper) {
+    await unlinkIfPresent(path);
+  }
+}
+async function removeLegacyManagedRoute(path, markerGroups) {
+  const contents = await readFileIfPresent(path);
+  if (contents && markerGroups.some((markers) => markers.every((marker) => contents.includes(marker)))) {
+    await unlinkIfPresent(path);
+  }
+}
+async function directoryContainsText(path, pattern) {
+  const entries = await readdir(path, { withFileTypes: true }).catch(() => []);
+  for (const entry of entries) {
+    const entryPath = resolve2(path, entry.name);
+    if (entry.isDirectory()) {
+      if (await directoryContainsText(entryPath, pattern)) {
+        return true;
+      }
+      continue;
+    }
+    if (!entry.isFile() || !/\.[cm]?[jt]s$/.test(entry.name)) {
+      continue;
+    }
+    const contents = await readFileIfPresent(entryPath);
+    if (contents?.includes(pattern)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function ensureNextManagedRoutes(projectRoot) {
+  const authEnabled = await pathExists(resolve2(projectRoot, "app/api/auth/user/route.ts"));
+  const storageEnabled = await pathExists(resolve2(projectRoot, "app/storage/[[...path]]/route.ts"));
+  const broadcastAuthEnabled = await pathExists(resolve2(projectRoot, "app/broadcasting/auth/route.ts"));
+  const clerkEnabled = await pathExists(resolve2(projectRoot, "app/api/auth/clerk/login/route.ts"));
+  const workosEnabled = await pathExists(resolve2(projectRoot, "app/api/auth/workos/login/route.ts"));
+  const files = [
+    ...renderNextManagedRouteFiles({
+      authEnabled,
+      storageEnabled,
+      broadcastAuthEnabled
+    }),
+    ...renderNextManagedHostedAuthRouteFiles({
+      clerk: clerkEnabled,
+      workos: workosEnabled
+    })
+  ];
+  for (const file of files) {
+    await writeFileIfChanged(resolve2(projectRoot, file.path), file.contents);
+  }
+  await removeLegacyManagedHoloHelper(resolve2(projectRoot, "server/holo.ts"), renderNextHoloHelper());
+}
+function isRecord2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+async function readProjectDependencies(projectRoot) {
+  const contents = await readFileIfPresent(resolve2(projectRoot, "package.json"));
+  if (!contents) {
+    return /* @__PURE__ */ new Set();
+  }
+  const manifest = JSON.parse(contents);
+  if (!isRecord2(manifest)) {
+    return /* @__PURE__ */ new Set();
+  }
+  const dependencies = isRecord2(manifest.dependencies) ? Object.keys(manifest.dependencies) : [];
+  const devDependencies = isRecord2(manifest.devDependencies) ? Object.keys(manifest.devDependencies) : [];
+  return /* @__PURE__ */ new Set([...dependencies, ...devDependencies]);
+}
+async function resolveSvelteManagedFeatures(projectRoot) {
+  const dependencies = await readProjectDependencies(projectRoot);
+  return {
+    authEnabled: dependencies.has("@holo-js/auth"),
+    broadcastEnabled: dependencies.has("@holo-js/broadcast"),
+    storageEnabled: dependencies.has("@holo-js/storage"),
+    clerkEnabled: dependencies.has("@holo-js/auth-clerk"),
+    workosEnabled: dependencies.has("@holo-js/auth-workos")
+  };
+}
+async function ensureSvelteManagedRuntime(projectRoot) {
+  const files = renderSvelteManagedRuntimeFiles();
+  for (const file of files) {
+    await writeFileIfChanged(resolve2(projectRoot, file.path), file.contents);
+  }
+}
+async function ensureSvelteManagedRoutes(projectRoot) {
+  await removeLegacyManagedRoute(
+    resolve2(projectRoot, "src/routes/api/holo/health/+server.ts"),
+    [
+      ["app.registry?.models.length ?? 0", "app.registry?.commands.length ?? 0"],
+      [".holo-js/generated/sveltekit/health-route"]
+    ]
+  );
+  await removeLegacyManagedRoute(
+    resolve2(projectRoot, "src/routes/api/holo/+server.ts"),
+    [
+      ["app.registry?.models.length ?? 0", "app.registry?.commands.length ?? 0"],
+      [".holo-js/generated/sveltekit/health-route"]
+    ]
+  );
+  await removeLegacyManagedRoute(
+    resolve2(projectRoot, "src/routes/api/auth/user/+server.ts"),
+    [
+      ["authenticated:", "guard:", "provider:", "user:"],
+      [".holo-js/generated/sveltekit/auth-user-route"]
+    ]
+  );
+  await removeLegacyManagedRoute(
+    resolve2(projectRoot, "src/routes/storage/[...path]/+server.ts"),
+    [
+      ["createPublicStorageResponse", "app.config.storage"],
+      [".holo-js/generated/sveltekit/storage-route"]
+    ]
+  );
+  await removeLegacyManagedRoute(
+    resolve2(projectRoot, "src/routes/broadcasting/auth/+server.ts"),
+    [
+      ["renderBroadcastAuthResponse", "channelAuth"],
+      [".holo-js/generated/sveltekit/broadcast-auth-route"]
+    ]
+  );
+  if (!await directoryContainsText(resolve2(projectRoot, "src"), "$lib/server/holo")) {
+    await removeLegacyManagedHoloHelper(resolve2(projectRoot, "src/lib/server/holo.ts"), renderSvelteHoloHelper());
+  }
+}
 async function syncManagedFrameworkArtifacts(projectRoot) {
   let manifest;
   try {
@@ -579,7 +1964,13 @@ async function syncManagedFrameworkArtifacts(projectRoot) {
     return;
   }
   if (manifest.framework === "sveltekit") {
-    await ensureSvelteManagedHooks(projectRoot);
+    const features = await resolveSvelteManagedFeatures(projectRoot);
+    await ensureSvelteManagedRuntime(projectRoot);
+    await ensureSvelteManagedHooks(projectRoot, features);
+    await ensureSvelteManagedRoutes(projectRoot);
+  }
+  if (manifest.framework === "next") {
+    await ensureNextManagedRoutes(projectRoot);
   }
 }
 
@@ -1119,7 +2510,7 @@ function getConfigExtensionPriority(fileName) {
 }
 async function collectProjectConfigEntries(projectRoot) {
   const configDir = resolve3(projectRoot, "config");
-  const entries = await readdir(configDir, { withFileTypes: true }).catch(() => []);
+  const entries = await readdir2(configDir, { withFileTypes: true }).catch(() => []);
   const selectedByName = /* @__PURE__ */ new Map();
   for (const entry of entries) {
     if (!entry.isFile()) {
@@ -1305,6 +2696,15 @@ export {
   renderMarkdownMailTemplate,
   resolveNameInfo,
   resolveArtifactPath,
+  renderNextHoloHelper,
+  renderNextBroadcastAuthRoute,
+  renderNextGeneratedBroadcastAuthRoute,
+  renderNextManagedHostedAuthRouteFiles,
+  renderSvelteHoloHelper,
+  renderAuthProviderRouteFiles,
+  renderAuthRouteFiles,
+  renderFrameworkFiles,
+  renderFrameworkRunner,
   renderGeneratedModelTypes,
   writeGeneratedProjectRegistry,
   loadGeneratedProjectRegistry