@holo-js/cli 0.1.7 → 0.1.9

package/dist/{chunk-GEMG3HIO.mjs → chunk-IMOGEKB4.mjs}

@@ -342,22 +342,6 @@ function renderNuxtConfig() {
     ""
   ].join("\n");
 }
-function renderNuxtHealthRoute() {
-  return [
-    "export default defineEventHandler(async () => {",
-    "  const app = await holo.getApp()",
-    "",
-    "  return {",
-    "    ok: true,",
-    "    app: app.config.app.name,",
-    "    env: app.config.app.env,",
-    "    models: app.registry?.models.length ?? 0,",
-    "    commands: app.registry?.commands.length ?? 0,",
-    "  }",
-    "})",
-    ""
-  ].join("\n");
-}
 function renderNuxtCurrentAuthRoute() {
   return [
     "import auth, { check, isAuthError, provider, user } from '@holo-js/auth'",
@@ -535,44 +519,34 @@ function renderNextRouteBridge(modulePath, methods) {
 }
 function renderNextHoloHelper() {
   return [
-    "import { createNextHoloHelpers } from '@holo-js/adapter-next'",
+    "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()",
+    "export const holo = createNextHoloHelpers({ projectRoot })",
     ""
   ].join("\n");
 }
-function renderNextHealthRoute() {
-  return renderNextRouteBridge("../../../../.holo-js/generated/next/health-route", ["GET"]);
-}
-function renderNextGeneratedHealthRoute() {
+function renderNextRuntimeBootstrap() {
   return [
-    "import { holo } from '../../../server/holo'",
+    "import { dirname, resolve } from 'node:path'",
+    "import { fileURLToPath } from 'node:url'",
+    "import { createNextHoloHelpers } from '@holo-js/adapter-next/runtime'",
     "",
-    "export async function GET() {",
-    "  const app = await holo.getApp()",
+    "const projectRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../../..')",
+    "const holo = createNextHoloHelpers({ projectRoot })",
     "",
-    "  return Response.json({",
-    "    ok: true,",
-    "    app: app.config.app.name,",
-    "    env: app.config.app.env,",
-    "    models: app.registry?.models.length ?? 0,",
-    "    commands: app.registry?.commands.length ?? 0,",
-    "  })",
-    "}",
+    "await holo.getApp()",
     ""
   ].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 '../../../server/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",
@@ -605,7 +579,7 @@ function renderNextHostedAuthLoginRoute(spec) {
 function renderNextGeneratedHostedAuthLoginRoute(spec) {
   return [
     `import { ${spec.loginFunction} } from '${spec.packageName}'`,
-    "import { holo } from '../../../server/holo'",
+    "import { holo } from './holo'",
     "",
     "export async function GET(request: Request) {",
     "  await holo.getApp()",
@@ -621,7 +595,7 @@ function renderNextHostedAuthRegisterRoute(spec) {
 function renderNextGeneratedHostedAuthRegisterRoute(spec) {
   return [
     `import { ${spec.registerFunction} } from '${spec.packageName}'`,
-    "import { holo } from '../../../server/holo'",
+    "import { holo } from './holo'",
     "",
     "export async function GET(request: Request) {",
     "  await holo.getApp()",
@@ -637,7 +611,7 @@ function renderNextHostedAuthCallbackRoute(spec) {
 function renderNextGeneratedHostedAuthCallbackRoute(spec) {
   return [
     `import { ${spec.callbackFunction} } from '${spec.packageName}'`,
-    "import { holo } from '../../../server/holo'",
+    "import { holo } from './holo'",
     "",
     "export async function GET(request: Request) {",
     "  await holo.getApp()",
@@ -659,7 +633,7 @@ function renderNextGeneratedHostedAuthLogoutRoute(spec) {
   return [
     "import { provider } from '@holo-js/auth'",
     `import { ${spec.logoutFunction} } from '${spec.packageName}'`,
-    "import { holo } from '../../../server/holo'",
+    "import { holo } from './holo'",
     "",
     "export async function POST(request: Request) {",
     "  await holo.getApp()",
@@ -700,7 +674,7 @@ function renderNextStorageRoute() {
 function renderNextGeneratedStorageRoute() {
   return [
     "import { createPublicStorageResponse } from '@holo-js/storage'",
-    "import { holo } from '../../../server/holo'",
+    "import { holo } from './holo'",
     "",
     "export async function GET(request: Request) {",
     "  const app = await holo.getApp()",
@@ -715,7 +689,7 @@ function renderNextBroadcastAuthRoute() {
 function renderNextGeneratedBroadcastAuthRoute() {
   return [
     "import { renderBroadcastAuthResponse } from '@holo-js/broadcast/auth'",
-    "import { holo } from '../../../server/holo'",
+    "import { holo } from './holo'",
     "",
     "export async function POST(request: Request) {",
     "  const app = await holo.getApp()",
@@ -736,22 +710,35 @@ function renderNextGeneratedBroadcastAuthRoute() {
 }
 function renderNextManagedRouteFiles(options = {}) {
   return [
-    { path: ".holo-js/generated/next/health-route.ts", contents: renderNextGeneratedHealthRoute() },
-    ...options.authEnabled ? [{ path: ".holo-js/generated/next/auth-user-route.ts", contents: renderNextGeneratedCurrentAuthRoute() }] : [],
+    { path: ".holo-js/generated/next/holo.ts", contents: renderNextHoloHelper() },
+    { path: ".holo-js/generated/next/bootstrap.mjs", contents: renderNextRuntimeBootstrap() },
     ...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/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) }
-    ];
-  });
+  const providers = getRequestedHostedAuthProviders(features);
+  if (providers.length === 0) {
+    return [];
+  }
+  return [
+    { path: ".holo-js/generated/next/holo.ts", contents: renderNextHoloHelper() },
+    { path: ".holo-js/generated/next/bootstrap.mjs", contents: renderNextRuntimeBootstrap() },
+    ...providers.flatMap((provider) => {
+      const spec = HOSTED_AUTH_PROVIDERS[provider];
+      return [
+        { 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 [
@@ -896,108 +883,61 @@ function renderSveltePage(projectName) {
 }
 function renderSvelteHoloHelper() {
   return [
+    "import { dirname, resolve } from 'node:path'",
+    "import { fileURLToPath } from 'node:url'",
     "import { createSvelteKitHoloHelpers } from '@holo-js/adapter-sveltekit'",
     "",
-    "export const holo = createSvelteKitHoloHelpers()",
-    ""
-  ].join("\n");
-}
-function renderSvelteHealthRoute() {
-  return [
-    "import { json } from '@sveltejs/kit'",
-    "import { holo } from '$lib/server/holo'",
-    "",
-    "export async function GET() {",
-    "  const app = await holo.getApp()",
+    "const projectRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../../..')",
     "",
-    "  return json({",
-    "    ok: true,",
-    "    app: app.config.app.name,",
-    "    env: app.config.app.env,",
-    "    models: app.registry?.models.length ?? 0,",
-    "    commands: app.registry?.commands.length ?? 0,",
-    "  })",
-    "}",
-    ""
-  ].join("\n");
-}
-function renderSvelteCurrentAuthRoute() {
-  return [
-    "import { json } from '@sveltejs/kit'",
-    "import auth, { check, isAuthError, provider, user } from '@holo-js/auth'",
-    "",
-    "export async function GET({ url }: { url: URL }) {",
-    "  const guard = url.searchParams.get('guard') ?? undefined",
-    "  try {",
-    "    const guardAuth = guard ? auth.guard(guard) : undefined",
-    "",
-    "    return 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 json({",
-    "        authenticated: false,",
-    "        guard: guard ?? 'web',",
-    "        provider: null,",
-    "        user: null,",
-    "      }, { status: 400 })",
-    "    }",
-    "",
-    "    throw error",
-    "  }",
-    "}",
+    "export const holo = createSvelteKitHoloHelpers({ projectRoot })",
     ""
   ].join("\n");
 }
 function renderSvelteHostedAuthLoginRoute(spec) {
   return [
     `import { ${spec.loginFunction} } from '${spec.packageName}'`,
-    "import type { RequestHandler } from './$types'",
+    "import type { RequestEvent } from '@sveltejs/kit'",
     "",
-    "export const GET = (async (event) => {",
+    "export async function GET(event: RequestEvent) {",
     `  return await ${spec.loginFunction}(event)`,
-    "}) satisfies RequestHandler",
+    "}",
     ""
   ].join("\n");
 }
 function renderSvelteHostedAuthRegisterRoute(spec) {
   return [
     `import { ${spec.registerFunction} } from '${spec.packageName}'`,
-    "import type { RequestHandler } from './$types'",
+    "import type { RequestEvent } from '@sveltejs/kit'",
     "",
-    "export const GET = (async (event) => {",
+    "export async function GET(event: RequestEvent) {",
     `  return await ${spec.registerFunction}(event)`,
-    "}) satisfies RequestHandler",
+    "}",
     ""
   ].join("\n");
 }
 function renderSvelteHostedAuthCallbackRoute(spec) {
   return [
-    "import { redirect, type RequestHandler } from '@sveltejs/kit'",
+    "import { redirect, type RequestEvent } from '@sveltejs/kit'",
     `import { ${spec.callbackFunction} } from '${spec.packageName}'`,
     "",
-    "export const GET = (async (event) => {",
+    "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, '/')",
-    "}) satisfies RequestHandler",
+    "}",
     ""
   ].join("\n");
 }
 function renderSvelteHostedAuthLogoutRoute(spec) {
   return [
-    "import { redirect, type RequestHandler } from '@sveltejs/kit'",
+    "import { redirect, type RequestEvent } from '@sveltejs/kit'",
     "import { provider } from '@holo-js/auth'",
     `import { ${spec.logoutFunction} } from '${spec.packageName}'`,
     "",
-    "export const POST = (async (event) => {",
+    "export async function POST(event: RequestEvent) {",
     "  let currentProvider: string | null",
     "  try {",
     "    currentProvider = await provider()",
@@ -1015,7 +955,7 @@ function renderSvelteHostedAuthLogoutRoute(spec) {
     "  }",
     "",
     "  throw redirect(303, data.url)",
-    "}) satisfies RequestHandler",
+    "}",
     ""
   ].join("\n");
 }
@@ -1025,7 +965,8 @@ function renderSvelteHostedAuthRouteFiles(provider) {
     { 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) }
+    { path: `src/routes/api/auth/${provider}/logout/+server.ts`, contents: renderSvelteHostedAuthLogoutRoute(spec) },
+    ...renderSvelteManagedRuntimeFiles()
   ];
 }
 function renderAuthProviderRouteFiles(framework, features) {
@@ -1043,7 +984,8 @@ function renderAuthRouteFiles(framework) {
   if (framework === "next") {
     return [
       { path: "app/api/auth/user/route.ts", contents: renderNextCurrentAuthRoute() },
-      { path: ".holo-js/generated/next/auth-user-route.ts", contents: renderNextGeneratedCurrentAuthRoute() }
+      { path: ".holo-js/generated/next/holo.ts", contents: renderNextHoloHelper() },
+      { path: ".holo-js/generated/next/bootstrap.mjs", contents: renderNextRuntimeBootstrap() }
     ];
   }
   if (framework === "nuxt") {
@@ -1052,21 +994,9 @@ function renderAuthRouteFiles(framework) {
     ];
   }
   return [
-    { path: "src/routes/api/auth/user/+server.ts", contents: renderSvelteCurrentAuthRoute() }
+    ...renderSvelteManagedRuntimeFiles()
   ];
 }
-function renderSvelteStorageRoute() {
-  return [
-    "import { holo } from '$lib/server/holo'",
-    "import { createPublicStorageResponse } from '@holo-js/storage'",
-    "",
-    "export async function GET({ request }: { request: Request }) {",
-    "  const app = await holo.getApp()",
-    "  return createPublicStorageResponse(app.projectRoot, app.config.storage, request)",
-    "}",
-    ""
-  ].join("\n");
-}
 function renderFrameworkFiles(options) {
   const optionalPackages = normalizeScaffoldOptionalPackages(options.optionalPackages);
   const storageEnabled = optionalPackages.includes("storage");
@@ -1075,7 +1005,6 @@ function renderFrameworkFiles(options) {
     return [
       { path: "app/app.vue", contents: renderNuxtAppVue(options.projectName) },
       { path: "nuxt.config.ts", contents: renderNuxtConfig() },
-      { path: "server/api/holo/health.get.ts", contents: renderNuxtHealthRoute() },
       { path: "shared/.gitkeep", contents: "" },
       ...authEnabled ? renderAuthRouteFiles("nuxt") : []
     ];
@@ -1086,10 +1015,8 @@ function renderFrameworkFiles(options) {
       { path: "next-env.d.ts", contents: renderNextEnvDts() },
       { path: "app/layout.tsx", contents: renderNextLayout(options.projectName) },
       { path: "app/page.tsx", contents: renderNextPage(options.projectName) },
-      { path: "app/api/holo/health/route.ts", contents: renderNextHealthRoute() },
       ...authEnabled ? [{ path: "app/api/auth/user/route.ts", contents: renderNextCurrentAuthRoute() }] : [],
       ...storageEnabled ? [{ path: "app/storage/[[...path]]/route.ts", contents: renderNextStorageRoute() }] : [],
-      { path: "server/holo.ts", contents: renderNextHoloHelper() },
       ...renderNextManagedRouteFiles({ authEnabled, storageEnabled })
     ];
   }
@@ -1100,10 +1027,8 @@ function renderFrameworkFiles(options) {
     { path: "src/hooks.server.ts", contents: renderSvelteServerUserHooks() },
     { path: "src/app.html", contents: renderSvelteAppHtml() },
     { path: "src/routes/+page.svelte", contents: renderSveltePage(options.projectName) },
-    { path: "src/routes/api/holo/health/+server.ts", contents: renderSvelteHealthRoute() },
     ...authEnabled ? renderAuthRouteFiles("sveltekit") : [],
-    ...storageEnabled ? [{ path: "src/routes/storage/[...path]/+server.ts", contents: renderSvelteStorageRoute() }] : [],
-    { path: "src/lib/server/holo.ts", contents: renderSvelteHoloHelper() }
+    ...renderSvelteManagedRuntimeFiles()
   ];
 }
 function renderFrameworkRunner(options) {
@@ -1118,6 +1043,7 @@ function renderFrameworkRunner(options) {
     "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 nextRuntimeBootstrapPath = resolve(projectRoot, '.holo-js/generated/next/bootstrap.mjs')",
     "const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'))",
     "const framework = String(manifest.framework ?? '')",
     `const commandName = ${JSON.stringify(commandName)}`,
@@ -1337,8 +1263,15 @@ function renderFrameworkRunner(options) {
     "  while (true) {",
     "    const stderrLines = []",
     "    const childEnv = { ...process.env }",
-    "    if (existsSync(runtimeSchemaPath)) {",
-    "      const preload = `--import=${pathToFileURL(runtimeSchemaPath).href}`",
+    "    const preloads = [runtimeSchemaPath]",
+    "    if (framework === 'next') {",
+    "      preloads.push(nextRuntimeBootstrapPath)",
+    "    }",
+    "    const preloadOptions = preloads",
+    "      .filter(path => existsSync(path))",
+    "      .map(path => `--import=${pathToFileURL(path).href}`)",
+    "    if (preloadOptions.length > 0) {",
+    "      const preload = preloadOptions.join(' ')",
     "      childEnv.NODE_OPTIONS = childEnv.NODE_OPTIONS",
     "        ? `${childEnv.NODE_OPTIONS} ${preload}`",
     "        : preload",
@@ -1401,13 +1334,13 @@ function renderFrameworkRunner(options) {
 
 // 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 [
@@ -1454,22 +1387,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",
@@ -1484,9 +1546,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) {",
@@ -1531,6 +1598,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 {}",
@@ -1594,10 +1718,7 @@ 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;
@@ -1682,7 +1803,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);
@@ -1716,9 +1837,52 @@ 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"));
@@ -1739,6 +1903,79 @@ async function ensureNextManagedRoutes(projectRoot) {
   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;
@@ -1749,7 +1986,10 @@ 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);
@@ -2292,7 +2532,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()) {