sveltekit-python-vercel 0.4.1 → 1.0.3-beta.53c34c5

package/README.md

@@ -1,7 +1,7 @@
 <p align="middle">
 <img width="100" alt="image" src="https://user-images.githubusercontent.com/20548516/218344678-d41f4c4a-6b1b-48cc-8553-2b9fbe2169d6.png"/>
-<img width="100" alt="image" src="https://camo.githubusercontent.com/f1ac9955f30176e6183aeeeac1b77354c7a132696fdc77c06ef0f0bec30f258c/68747470733a2f2f6861636b616461792e636f6d2f77702d636f6e74656e742f75706c6f6164732f323031392f30392f707974686f6e2d6c6f676f2e706e67"/>
-<img width="100" alt="image" src="https://camo.githubusercontent.com/add2c9721e333f0043ac938f3dadbc26a282776e01b95b308fcaba5afaf74ae3/68747470733a2f2f6173736574732e76657263656c2e636f6d2f696d6167652f75706c6f61642f76313538383830353835382f7265706f7369746f726965732f76657263656c2f6c6f676f2e706e67"/>
+<img width="100" alt="image" src="https://avatars.githubusercontent.com/u/1525981?s=200&v=4"/>
+<img width="100" alt="image" src="https://avatars.githubusercontent.com/u/14985020?s=200&v=4"/>
 </p>
 
 # sveltekit-python-vercel
@@ -22,7 +22,8 @@ Write Python endpoints in [SvelteKit](https://kit.svelte.dev/) and seamlessly de
 ## Current Features
 
 - Write `+server.py` files nearly the same way you would write `+server.js` files
-- Deploy (quasi) automatically to Vercel Serverless
+- Write server `load` functions in `+page.server.py` and `+layout.server.py`
+- Deploy automatically to Vercel Serverless (Python 3.12 runtime)
 
 ## Installing
 
@@ -36,17 +37,15 @@ Write Python endpoints in [SvelteKit](https://kit.svelte.dev/) and seamlessly de
   import { sveltekit } from "@sveltejs/kit/vite";
   import { sveltekit_python_vercel } from "sveltekit-python-vercel/vite";
 
-  export default defineConfig(({ command, mode }) => {
-    return {
-      plugins: [sveltekit_python_vercel(), sveltekit()],
-    };
+  export default defineConfig({
+    plugins: [sveltekit(), ...(await sveltekit_python_vercel())],
   });
   ```
 
 - Update your `svelte.config.js`:
 
   ```javascript
-  import adapter from "@sveltejs/adapter-vercel"; // Use the vercel adapter
+  import adapter from "@sveltejs/adapter-vercel";
   import { vitePreprocess } from "@sveltejs/kit/vite";
 
   /** @type {import('@sveltejs/kit').Config} */
@@ -63,23 +62,12 @@ Write Python endpoints in [SvelteKit](https://kit.svelte.dev/) and seamlessly de
 
 - Update your `vercel.json`
 
-  - The build command prepares all your endpoints and copies them to the `/api` directory where Vercel looks for functions
-  - Functions and Routes tell Vercel how to run and redirect function calls
+  - The build command first runs `vite build` (which generates `.vercel/output/` via the SvelteKit adapter), then runs our script to write the Python function into that same output directory and patch the routing config.
+  - No `routes` or `functions` keys are needed — routing is handled automatically via the [Vercel Build Output API](https://vercel.com/docs/build-output-api/v3).
 
   ```json
   {
-    "buildCommand": "node ./node_modules/sveltekit-python-vercel/esm/src/vite/sveltekit_python_vercel/bin.mjs; vite build",
-    "functions": {
-      "api/**/*.py": {
-        "runtime": "@vercel/python@3.0.7"
-      }
-    },
-    "routes": [
-      {
-        "src": "/api/(.*)",
-        "dest": "api/index.py"
-      }
-    ]
+    "buildCommand": "vite build; node ./node_modules/sveltekit-python-vercel/esm/src/vite/sveltekit_python_vercel/bin.mjs"
   }
   ```
 
@@ -87,112 +75,59 @@ Write Python endpoints in [SvelteKit](https://kit.svelte.dev/) and seamlessly de
 
 ## Testing Locally
 
-Using [Poetry](https://python-poetry.org/) to manage your virtual environments with this package is recommended.
-
-- Run `poetry init` to create a new virtual environment, and follow the steps. Or simply create a `pyproject.toml` like the one below.
-
-  ```toml
-  [tool.poetry]
-  name = "sveltekit-python-example"
-  version = "0.1.0"
-  description = ""
-  authors = ["Your Name <email@gmail.com>"]
-  readme = "README.md"
-
-  [tool.poetry.dependencies]
-  python = "^3.9"
-  fastapi = "^0.95.2"
-  uvicorn = "^0.22.0"
-  
-  [tool.poetry.group.dev.dependencies]
-  watchfiles = "^0.19.0"
-
-  [build-system]
-  requires = ["poetry-core"]
-  build-backend = "poetry.core.masonry.api"
-  ```
-
-- Required packages are python3.9 (that is what Vercel's runtime uses), `fastapi`, and `uvicorn`.
-- Install whatever other dependencies you need from pypi using `poetry add package-name`
+[uv](https://docs.astral.sh/uv/) is recommended for managing your Python environment.
 
-- Enter your virtual env with `poetry shell`
-- Run `pnpm dev` or `npm dev`
-  - You should see both the usual SvelteKit server start as well as the unvicorn server (by default on `http://0.0.0.0:8000`) in the console.
+- Run `uv init --python 3.12` to create a `pyproject.toml` pinned to Python 3.12 (the same version Vercel's runtime uses).
+- Add the required packages: `uv add fastapi uvicorn`
+- Add any other dependencies you need: `uv add numpy pandas ...`
+- Run your dev server inside uv:
+  - `uv run pnpm dev`
+- You should see both the usual SvelteKit server start and the uvicorn server (by default on `http://0.0.0.0:8000`) in the console.
 
 ## Deploying to Vercel
 
-- At the moment this requires a tiny bit of extra labor besides just pushing to your repository. I believe this is because of the way Vercel looks for serverless functions, but I hope to make this a bit easier in the future.
+Just push to your repository — no extra steps required.
 
-- When you make changes to your python endpoints, you have to manually regenerate the `/api` folder by running:
-  1. `poetry export -f requirements.txt --output requirements.txt --without-hashes`
-  2. `node ./node_modules/sveltekit-python-vercel/esm/src/vite/sveltekit_python_vercel/bin.mjs`
-- Then commit `requirements.txt` and the changes in `/api` and push.
-
-Note:
-
-- To make this a bit smoother, you can add a script to you `package.json`:
-  ```json
-  "scripts": {
-    ...
-    "py-update": "poetry export -f requirements.txt --output requirements.txt --without-hashes; node ./node_modules/sveltekit-python-vercel/esm/src/vite/sveltekit_python_vercel/bin.mjs"
-  }
-  ```
-  - and then just run `pnpm py-update`
+- The `buildCommand` in `vercel.json` handles everything automatically:
+  1. `vite build` runs the SvelteKit build and writes `.vercel/output/` via `@sveltejs/adapter-vercel`
+  2. `bin.mjs` then writes your Python endpoints into `.vercel/output/functions/` using the [Build Output API](https://vercel.com/docs/build-output-api/v3) and patches the routing config
+- Your `+server.py` files and dependency declarations (`requirements.txt`, `pyproject.toml`, `Pipfile`, etc.) are bundled automatically — there is no need to commit an `/api` folder or manually generate a `requirements.txt`.
+- Python packages are pre-installed into the function bundle at build time using `pip install --target`, so they are available in Vercel's raw Python 3.12 Lambda environment without any extra configuration.
 
 ## Example
 
 - Frontend: `/src/routes/py/+page.svelte`
 
   ```html
-  <script lang="ts">
-    let a = 0;
-    let b = 0;
-    let total = 0;
+  <script>
+    let a = $state(0);
+    let b = $state(0);
+    let total = $state(0);
 
     async function pyAddPost() {
-      const response = await fetch("/py", {
+      const res = await fetch("/py", {
         method: "POST",
         body: JSON.stringify({ a, b }),
-        headers: {
-          "content-type": "application/json",
-        },
+        headers: { "content-type": "application/json" },
       });
-      let res = await response.json();
-      total = res.sum;
+      total = (await res.json()).sum;
     }
 
     async function pyAddGet() {
-      const response = await fetch(`/py?a=${a}&b=${b}`, {
-        method: "GET",
-        headers: {
-          "content-type": "application/json",
-        },
-      });
-
-      let res = await response.json();
-      total = res.sum;
+      const res = await fetch(`/py?a=${a}&b=${b}`);
+      total = (await res.json()).sum;
     }
   </script>
 
-  <h1>This is a SvelteKit page with a python backend.</h1>
-
-  <h3>POST Example</h3>
-  <form>
-    <input type="number" name="a" placeholder="Number 1" bind:value="{a}" />
-    <input type="number" name="b" placeholder="Number 2" bind:value="{b}" />
-    <button on:click|preventDefault="{pyAddPost}">Add</button>
-  </form>
-  <h4>Total: {total}</h4>
-
-  <br />
-
-  <h3>GET Example</h3>
-  <form>
-    <input type="number" name="a" placeholder="Number 1" bind:value="{a}" />
-    <input type="number" name="b" placeholder="Number 2" bind:value="{b}" />
-    <button on:click|preventDefault="{pyAddGet}">Add</button>
-  </form>
-  <h4>Total: {total}</h4>
+  <h1>SvelteKit page with a Python backend</h1>
+
+  <label>a: <input type="number" bind:value={a} /></label>
+  <label>b: <input type="number" bind:value={b} /></label>
+
+  <button type="button" onclick={pyAddPost}>POST</button>
+  <button type="button" onclick={pyAddGet}>GET</button>
+
+  <p>Total: {total}</p>
   ```
 
 - Backend: `/src/routes/py/+server.py`
@@ -212,17 +147,65 @@ Note:
 
   async def GET(a: float, b: float):
       return {"sum": a + b}
-
   ```
 
 ### Backend Caveats
 
-There are currently a few things that have to be worked around.
+- `GET` endpoints receive query parameters directly as function arguments. Type annotations are used for coercion (e.g. `a: float` parses `?a=3` as `3.0`).
+- All other HTTP methods receive the request body as JSON. The recommended pattern is a Pydantic model as the single argument — FastAPI handles validation and parsing automatically.
+
+### Python load functions
+
+Server-side `load` functions work in `+page.server.py` and `+layout.server.py`. No extra Python package install is required — the runtime is bundled automatically like `+server.py`.
+
+```python
+async def load(event):
+    if event.params["id"] == "secret":
+        return ("redirect", 307, "/demo/public")
+
+    if event.params["id"] not in ("public", "1", "2"):
+        return ("error", 404, "Not found")
+
+    return {
+        "title": f"Item {event.params['id']}",
+        "parent_theme": event.parent.theme if event.parent else None,
+    }
+```
+
+Errors and redirects can also use injected helpers (no import needed):
+
+```python
+async def load(event):
+    if not event.cookies.get("session"):
+        redirect(307, "/login")
+    return {"ok": True}
+```
+
+Available on `event`: `params`, `url`, `route`, `parent` (layout data), `data` (from a sibling universal load), `cookies`.
+
+**Current limitations:** no `event.fetch`, `setHeaders`, `depends`, or page options (`prerender`, etc.) in `.py` files yet.
+
+## npm channels
+
+| Tag | When it updates | Install |
+|-----|-----------------|---------|
+| `latest` | GitHub Release created | `pnpm add -D sveltekit-python-vercel` |
+| `beta` | Every push to `main` | `pnpm add -D sveltekit-python-vercel@beta` |
+| `pr-<n>` | Open/update PR `#n` (same-repo only) | `pnpm add -D sveltekit-python-vercel@pr-15` |
+
+Beta versions look like `1.0.3-beta.abc1234` (main) or `1.0.3-beta.pr15.abc1234` (PRs).
+
+All publishes run through `.github/workflows/publish.yml` because npm trusted publishing only allows one workflow filename per package.
+
+### Developing the package locally
+
+If you work on this repo and a consumer app side by side (e.g. `test-skpv-deploy`):
 
-- `GET` endpoints are directly fed the parameters from the url, so when you define an endpoint
-- All other endpoints are fed the body as a JSON. The recommended way to deal with this is to use a pydantic model and pass it as the singular input to the function.
+1. Build: `deno run -A dnt.ts $(npm view sveltekit-python-vercel version)` (or any version string)
+2. In the consumer: `pnpm add -D sveltekit-python-vercel@link:../sveltekit-python-vercel/npm`
+3. Rebuild and restart the consumer dev server after library changes
 
-See the example above.
+Commit `^x.y.z` or `@beta` in the consumer for Vercel — `link:` only works on your machine.
 
 ## Fork of `sveltekit-modal`
 
@@ -231,8 +214,8 @@ Check out the awesome [sveltekit-modal](https://github.com/semicognitive/sveltek
 ## Possible future plans
 
 - [X] Add hot reloading in dev mode
-- [ ] Generate endpoints (/api folder) automatically during build
-  - [ ] Auto create requirements.txt from pyproject.toml (both related to vercel functions being checked/handled before build)
+- [X] Generate endpoints automatically during build (via Vercel Build Output API)
+  - [X] Auto-bundle requirements.txt / pyproject.toml / Pipfile at build time
 - [ ] Add form actions
-- [ ] Add load functions
-- [ ] Add helper functions to automatically call API endpoints in project\
+- [X] Add load functions
+- [ ] Add helper functions to automatically call API endpoints in project

package/esm/src/vite/mod.js

@@ -1,4 +1,3 @@
-import { loadEnv } from "vite";
 import { $ as run$, cd as cd$, which, path, chalk, } from "zx";
 const get_pyServerEndpointAsString = (app_url, serve = false) => `
     const handle = (method) => (async ({ request, fetch, url }) => {
@@ -9,9 +8,9 @@ const get_pyServerEndpointAsString = (app_url, serve = false) => `
         let fullURL;
 
         if (${serve}) {
-          fullURL = new URL(url.pathname, new URL('${app_url}')) + url.search;
-        } else {
           fullURL = new URL('/api' + url.pathname, new URL('${app_url}')) + url.search;
+        } else {
+          fullURL = new URL('/api' + url.pathname, url.origin) + url.search;
         }
 
         console.log(\`PY: Reached python endpoint of \${method} \${fullURL}\`)
@@ -31,6 +30,72 @@ const get_pyServerEndpointAsString = (app_url, serve = false) => `
     export const PUT = handle('PUT');
     export const DELETE = handle('DELETE');
 `;
+function getLoadRouteTemplate(id) {
+    const marker = "/src/routes/";
+    const idx = id.indexOf(marker);
+    if (idx === -1) {
+        throw new Error(`Cannot derive load route from ${id}`);
+    }
+    let routePart = id.slice(idx + marker.length);
+    routePart = routePart.replace(/\/\+(?:page|layout)\.server\.py$/, "");
+    if (!routePart) {
+        return "/api/_load";
+    }
+    const segments = routePart
+        .split("/")
+        .filter((part) => !(part.startsWith("(") && part.endsWith(")")))
+        .map((part) => part.replace(/^\[(.+)\]$/, "{$1}"));
+    return `/api/_load/${segments.join("/")}`;
+}
+const get_pyLoadAsString = (loadRouteTemplate, app_url, serve = false) => `
+    import { error, redirect } from '@sveltejs/kit';
+
+    const LOAD_ROUTE_TEMPLATE = ${JSON.stringify(loadRouteTemplate)};
+
+    function buildLoadPath(params) {
+        let path = LOAD_ROUTE_TEMPLATE;
+        for (const [key, value] of Object.entries(params)) {
+            path = path.replaceAll(\`{\${key}}\`, encodeURIComponent(String(value)));
+        }
+        return path;
+    }
+
+    export async function load(event) {
+        const parent = event.parent ? await event.parent() : undefined;
+
+        const body = JSON.stringify({
+            params: event.params,
+            route: { id: event.route.id },
+            url: event.url.href,
+            parent,
+            data: event.data ?? undefined,
+            cookies: Object.fromEntries(event.cookies.getAll().map((c) => [c.name, c.value])),
+        });
+
+        const apiPath = buildLoadPath(event.params);
+        const fullURL = ${serve}
+            ? new URL(apiPath, new URL('${app_url}'))
+            : new URL(apiPath, event.url.origin);
+
+        const res = await event.fetch(fullURL, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body,
+        });
+
+        const result = await res.json();
+
+        if (result.type === 'redirect') redirect(result.status, result.location);
+        if (result.type === 'error') error(result.status, result.body);
+        return result.data;
+    }
+`;
+function isPyServerFile(id) {
+    return /\+server\.py$/.test(id);
+}
+function isPyLoadFile(id) {
+    return /\+(?:page|layout)\.server\.py$/.test(id);
+}
 export async function sveltekit_python_vercel(opts = {}) {
     const child_processes = [];
     async function kill_all_process() {
@@ -48,7 +113,6 @@ export async function sveltekit_python_vercel(opts = {}) {
         },
         async configureServer({ config }) {
             const packagelocation = path.join(config.root, "node_modules", "sveltekit-python-vercel", "esm/src/vite");
-            // copy asll +server.py files to package directory
             run$.verbose = false;
             run$.env.PYTHONDONTWRITEBYTECODE = "1";
             cd$(packagelocation);
@@ -59,10 +123,9 @@ export async function sveltekit_python_vercel(opts = {}) {
             child_processes.push(local_process);
             sveltekit_url ??= new URL(`http://${host}:${port}`);
             cd$(config.root);
-            // local_process.quiet();  // let it be loud for now
             local_process.nothrow();
             local_process.stderr.on("data", (s) => {
-                console.log(s.toString().trimEnd()); //Logs stderr always and all of stdout if 'log': True
+                console.log(s.toString().trimEnd());
             });
             local_process.stderr.on("error", (s) => {
                 console.error(chalk.red("Error: Python Serve Failed"));
@@ -78,53 +141,42 @@ export async function sveltekit_python_vercel(opts = {}) {
         name: "vite-plugin-sveltekit_python-build",
         apply: "build",
         async configResolved(config) {
-            console.log("PY: BUILD DEBUG");
             console.log("PY: ROOT PATH: " + config.root);
-            console.log("PY: LOADED VERCEL URL: " + loadEnv("", config.root, "").VERCEL_URL);
-            const packagelocation = path.join(config.root, "node_modules", "sveltekit-python-vercel", "esm/src/vite");
-            console.log("PY: PACKAGE LOCATION: " + packagelocation);
-            const python_path = opts.python_path ?? (await which("python3"));
-            await run$ `cd ${packagelocation}`;
-            await run$ `${python_path} ${packagelocation}/sveltekit_python_vercel/build.py --root ${config.root}`;
-            // check if env var starts with http
-            let httpPrefix = "";
-            if (!loadEnv("", config.root, "").VERCEL_URL.startsWith("http")) {
-                httpPrefix = "https://";
-            }
-            const api_url = path.join(httpPrefix + loadEnv("", config.root, "").VERCEL_URL);
-            // get current Vercel deploy URL
-            sveltekit_url = new URL(api_url);
-            console.log("PY: Build API URL: " + sveltekit_url.toString());
         },
     };
+    const transformPyFile = (id, serve, app_url) => {
+        if (!/\.py$/.test(id))
+            return undefined;
+        if (isPyServerFile(id)) {
+            return {
+                code: get_pyServerEndpointAsString(app_url, serve),
+                map: null,
+            };
+        }
+        if (isPyLoadFile(id)) {
+            const loadRouteTemplate = getLoadRouteTemplate(id);
+            return {
+                code: get_pyLoadAsString(loadRouteTemplate, app_url, serve),
+                map: null,
+            };
+        }
+        return undefined;
+    };
     const plugin_py_server_endpoint_serve = {
         name: "vite-plugin-sveltekit_python-server-endpoint",
         apply: "serve",
         transform(src, id) {
-            // console.log("Transform function called for", id); // Add this line
-            if (/\.py$/.test(id)) {
-                if (sveltekit_url === undefined)
-                    throw new Error(`${plugin_python_serve.name} failed to produce a sveltekit_url`);
-                return {
-                    code: get_pyServerEndpointAsString(sveltekit_url, true),
-                    map: null, // provide source map if available
-                };
+            if (sveltekit_url === undefined) {
+                throw new Error(`${plugin_python_serve.name} failed to produce a sveltekit_url`);
             }
+            return transformPyFile(id, true, sveltekit_url);
         },
     };
     const plugin_py_server_endpoint_build = {
         name: "vite-plugin-sveltekit_python-server-endpoint",
         apply: "build",
         transform(src, id) {
-            // console.log("Transform function called for", id); // Add this line
-            if (/\.py$/.test(id)) {
-                if (sveltekit_url === undefined)
-                    throw new Error(`${plugin_python_serve.name} failed to produce a sveltekit_url`);
-                return {
-                    code: get_pyServerEndpointAsString(sveltekit_url, false),
-                    map: null, // provide source map if available
-                };
-            }
+            return transformPyFile(id, false, new URL("http://localhost"));
         },
     };
     return [

package/esm/src/vite/sveltekit_python_vercel/__init__.py

@@ -0,0 +1,3 @@
+from .load_runtime import error, redirect
+
+__all__ = ["error", "redirect"]

package/esm/src/vite/sveltekit_python_vercel/build.py

@@ -1,45 +1,114 @@
 import argparse
-import shutil
 import glob
-
+import json
+import shutil
+import subprocess
+import sys
 from pathlib import Path, PurePosixPath
 
-parser = argparse.ArgumentParser(description="Run Sveltekit Python Deployment")
-parser.add_argument("--root", default=".", help="Root directory of Vercel project")
-parser.add_argument("--packagedir", default=None, help="Root directory of Vercel project")
-args = parser.parse_args()
+sys.path.insert(0, str(Path(__file__).parent))
+from routes import api_route, load_route, rel_path_from_routes, route_parent
 
+parser = argparse.ArgumentParser(description="Run SvelteKit Python Deployment")
+parser.add_argument("--root", default=".", help="Root directory of the SvelteKit project")
+parser.add_argument("--packagedir", default=None, help="Directory of the sveltekit-python-vercel package")
+args = parser.parse_args()
 
 root_dir = Path(args.root).absolute()
-api_dir = root_dir / "api"
+routes_root = root_dir / "src/routes"
+
+func_dir = root_dir / ".vercel" / "output" / "functions" / "api" / "index.func"
+func_dir.mkdir(parents=True, exist_ok=True)
 
-if not api_dir.exists():
-    api_dir.mkdir()
-    
 if args.packagedir:
-    shutil.copy(Path(args.packagedir).absolute() / "deploy.py", api_dir / "index.py")
-    
-
-# Add all +server.py routes to web_app
-for module_path in glob.glob(str(root_dir / 'src/routes/**/+server.py'), recursive=True):
-    
-    # replace the root_dir with api_dir
-    api_route = api_dir / Path(module_path).absolute().relative_to(root_dir / "src/routes")
-    
-    # replace square brackets with curly brackets
-    api_route = Path(str(api_route).replace('[', '{').replace(']', '}'))
-    
-    # remove any groups from the URL
-    api_route = Path(str(PurePosixPath(*[part for part in PurePosixPath(api_route).parts if not part.startswith("(") and not part.endswith(")")])))
-
-    if not api_route.parent.exists():
-        api_route.parent.mkdir(parents=True)
-    
-    # copy module path to api_route
-    shutil.copy(module_path, api_route.parent)
-    
-    # create __init__.py if it doesn't exist
-    if not (api_route.parent / "__init__.py").exists():
-        (api_route.parent / "__init__.py").touch()
-    
-    print(f"PYTHON ENDPOINT: Copied {module_path} to {api_route.parent}")
+    package_dir = Path(args.packagedir).absolute()
+    shutil.copy(package_dir / "deploy.py", func_dir / "index.py")
+    for helper in ("load_runtime.py", "routes.py"):
+        src = package_dir / helper
+        if src.exists():
+            shutil.copy(src, func_dir / helper)
+
+manifest = []
+
+
+def _bundle_route_module(module_path: str, *, kind: str) -> None:
+    abs_path = Path(module_path).absolute()
+    rel = rel_path_from_routes(abs_path, routes_root)
+    target_dir = func_dir / route_parent(rel)
+    target_dir.mkdir(parents=True, exist_ok=True)
+    shutil.copy(abs_path, target_dir / rel.name)
+
+    parent = route_parent(rel)
+    if kind == "load":
+        route = load_route(parent)
+    else:
+        route = api_route(parent)
+
+    entry = {"file": str(PurePosixPath(rel)), "route": route, "kind": kind}
+    manifest.append(entry)
+    print(f"PYTHON {'LOAD' if kind == 'load' else 'ENDPOINT'}: {module_path} → {route}")
+
+
+for module_path in glob.glob(str(routes_root / "**/+server.py"), recursive=True):
+    _bundle_route_module(module_path, kind="server")
+
+for pattern in ("**/+page.server.py", "**/+layout.server.py"):
+    for module_path in glob.glob(str(routes_root / pattern), recursive=True):
+        _bundle_route_module(module_path, kind="load")
+
+(func_dir / "_manifest.json").write_text(json.dumps(manifest, indent=2))
+
+dep_files = ["requirements.txt", "pyproject.toml", "uv.lock", "Pipfile", "Pipfile.lock"]
+found_dep = False
+for dep_file in dep_files:
+    src = root_dir / dep_file
+    if src.exists():
+        shutil.copy(src, func_dir / dep_file)
+        print(f"PYTHON ENDPOINT: Bundled {dep_file}")
+        found_dep = True
+
+if not found_dep:
+    (func_dir / "requirements.txt").write_text("fastapi\nuvicorn\n")
+    print("PYTHON ENDPOINT: No dependency file found, created minimal requirements.txt")
+
+dep_dir = func_dir / "_deps"
+dep_dir.mkdir(exist_ok=True)
+pip_cmd = [sys.executable, "-m", "pip", "install", "--target", str(dep_dir), "--quiet"]
+if (func_dir / "requirements.txt").exists():
+    pip_cmd += ["-r", str(func_dir / "requirements.txt")]
+    subprocess.run(pip_cmd, check=True)
+    print("PYTHON ENDPOINT: Installed deps from requirements.txt")
+elif (func_dir / "pyproject.toml").exists():
+    try:
+        import tomllib
+    except ImportError:
+        import tomli as tomllib  # type: ignore
+    with open(func_dir / "pyproject.toml", "rb") as _f:
+        _pyproject = tomllib.load(_f)
+    _deps_list = _pyproject.get("project", {}).get("dependencies", [])
+    if _deps_list:
+        subprocess.run(pip_cmd + _deps_list, check=True)
+        print(f"PYTHON ENDPOINT: Installed {len(_deps_list)} deps from pyproject.toml")
+
+vc_config = {"runtime": "python3.12", "handler": "index.handler"}
+(func_dir / ".vc-config.json").write_text(json.dumps(vc_config, indent=2))
+print("PYTHON ENDPOINT: Created .vc-config.json")
+
+config_path = root_dir / ".vercel" / "output" / "config.json"
+if config_path.exists():
+    config = json.loads(config_path.read_text())
+    routes = config.get("routes", [])
+    python_route = {"src": "^/api(/.*)?$", "dest": "api/index"}
+    fs_idx = next(
+        (i for i, r in enumerate(routes) if r.get("handle") == "filesystem"),
+        0,
+    )
+    routes.insert(fs_idx, python_route)
+    config["routes"] = routes
+    config_path.write_text(json.dumps(config, indent=2))
+    print("PYTHON ENDPOINT: Patched .vercel/output/config.json")
+else:
+    print(
+        "WARNING: .vercel/output/config.json not found. "
+        "Make sure to run `vite build` before this script."
+    )

package/esm/src/vite/sveltekit_python_vercel/deploy.py

@@ -1,55 +1,160 @@
-import glob
-import importlib
+import asyncio
+import base64
 import importlib.util
-import os
-from pathlib import Path, PurePosixPath
+import json
+import sys
+from pathlib import Path
+from urllib.parse import urlsplit
+
+_base = Path(__file__).parent
+_deps = _base / "_deps"
+if _deps.exists() and str(_deps) not in sys.path:
+    sys.path.insert(0, str(_deps))
+if str(_base) not in sys.path:
+    sys.path.insert(0, str(_base))
 
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse
 
+from load_runtime import run_load
+from routes import route_registration_order
+
 app = FastAPI()
 
-async def hello_world():
-    return {"message": "Hello World!"}
-
-app.add_api_route("/api", hello_world, methods=["GET"])
-
-# Add all +server.py routes to web_app
-for module_path in glob.glob('./**/+server.py', recursive=True):
-
-    module_name_joined = module_path[2:].replace(os.path.sep, '.')
-    module_name, module_package = module_name_joined.rsplit('.', maxsplit=1)
-    
-    api_route = module_path[1:] if module_path.startswith('./') else module_path
-    api_route = str(Path(api_route).parent)
-    
-    # Replace square brackets with curly brackets
-    api_route = api_route.replace('[', '{').replace(']', '}')
-    
-    # remove any groups from the URL
-    api_route = str(PurePosixPath(*[part for part in PurePosixPath(api_route).parts if not part.startswith("(") and not part.endswith(")")]))
-
-    mod = importlib.import_module(module_name, module_package)
-    
-    # Add endpoints
-    for method in ["GET", "POST", "PATCH", "PUT", "DELETE"]:
-        
-        # Check for duplicate methods
-        if hasattr(mod, method) and hasattr(mod, method.lower()):
-            raise Exception(
-                f"Duplicate method {method} and {method.lower()} in {api_route}"
-            )
-            
-        elif hasattr(mod, method):
-            app.add_api_route(api_route, getattr(mod, method), methods=[method])
-            print(f"PYTHON ENDPOINT: Added {module_path} [{method}] at {api_route}")
-        elif hasattr(mod, method.lower()):
-            app.add_api_route(api_route, getattr(mod, method.lower()), methods=[method])
-            print(f"PYTHON ENDPOINT: Added {module_path} [{method}] at {api_route}")
+
+def _load_module(file_path: Path):
+    spec = importlib.util.spec_from_file_location("_route_module", file_path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def _make_load_handler(mod):
+    async def handler(request: Request):
+        payload = await request.json()
+        return JSONResponse(await run_load(mod, payload))
+
+    return handler
+
+
+_manifest_path = _base / "_manifest.json"
+if _manifest_path.exists():
+    _manifest = json.loads(_manifest_path.read_text())
+    _load_entries = [e for e in _manifest if e.get("kind") == "load"]
+    _server_entries = [e for e in _manifest if e.get("kind", "server") != "load"]
+
+    for _entry in sorted(_load_entries, key=lambda e: route_registration_order(e["route"])):
+        _mod = _load_module(_base / _entry["file"])
+        _route = _entry["route"]
+        app.add_api_route(_route, _make_load_handler(_mod), methods=["POST"])
+        print(f"PYTHON LOAD: Registered POST {_route}")
+
+    for _entry in _server_entries:
+        _mod = _load_module(_base / _entry["file"])
+        _route = _entry["route"]
+
+        for _method in ["GET", "POST", "PATCH", "PUT", "DELETE"]:
+            _has_upper = hasattr(_mod, _method)
+            _has_lower = hasattr(_mod, _method.lower())
+
+            if _has_upper and _has_lower:
+                raise Exception(
+                    f"Duplicate method {_method} and {_method.lower()} in {_route}"
+                )
+            elif _has_upper:
+                app.add_api_route(_route, getattr(_mod, _method), methods=[_method])
+                print(f"PYTHON ENDPOINT: Registered {_method} {_route}")
+            elif _has_lower:
+                app.add_api_route(_route, getattr(_mod, _method.lower()), methods=[_method])
+                print(f"PYTHON ENDPOINT: Registered {_method} {_route}")
+
 
 @app.exception_handler(Exception)
-async def unicorn_exception_handler(request: Request, exc: Exception):
-    return JSONResponse(
-        status_code=500,
-        content={"error": f"{exc}"},
-    )
+async def _exception_handler(request: Request, exc: Exception):
+    return JSONResponse(status_code=500, content={"error": str(exc)})
+
+
+async def _dispatch(scope: dict, body: bytes) -> tuple[int, dict, bytes]:
+    """Run FastAPI for one HTTP request and collect the response."""
+    queue: asyncio.Queue = asyncio.Queue()
+    queue.put_nowait({"type": "http.request", "body": body, "more_body": False})
+
+    status = 500
+    resp_headers: dict = {}
+    resp_body = b""
+
+    async def receive():
+        return await queue.get()
+
+    async def send(message):
+        nonlocal status, resp_body
+        if message["type"] == "http.response.start":
+            status = message["status"]
+            for k, v in message.get("headers", []):
+                if isinstance(k, bytes):
+                    k = k.decode()
+                if isinstance(v, bytes):
+                    v = v.decode()
+                k = k.lower()
+                if k in resp_headers:
+                    existing = resp_headers[k]
+                    resp_headers[k] = (existing if isinstance(existing, list) else [existing]) + [v]
+                else:
+                    resp_headers[k] = v
+        elif message["type"] == "http.response.body":
+            resp_body += message.get("body", b"")
+
+    await app(scope, receive, send)
+    return status, resp_headers, resp_body
+
+
+def handler(event, context):
+    payload = json.loads(event.get("body") or "{}")
+
+    parsed = urlsplit(payload.get("path", "/"))
+    path = parsed.path or "/"
+    query = (parsed.query or "").encode()
+
+    raw_headers: dict = payload.get("headers") or {}
+    headers_list = []
+    host = payload.get("host", "localhost")
+    scheme = "https"
+    for k, v in raw_headers.items():
+        k_lower = k.lower()
+        if k_lower == "host":
+            host = v
+        if k_lower == "x-forwarded-proto":
+            scheme = v
+        headers_list.append((k_lower.encode(), str(v).encode()))
+
+    scope = {
+        "type": "http",
+        "http_version": "1.1",
+        "method": payload.get("method", "GET").upper(),
+        "path": path,
+        "raw_path": path.encode(),
+        "query_string": query,
+        "root_path": "",
+        "headers": headers_list,
+        "server": (host, 443 if scheme == "https" else 80),
+        "client": (raw_headers.get("x-real-ip", "127.0.0.1"), 0),
+        "scheme": scheme,
+    }
+
+    body = payload.get("body") or b""
+    if payload.get("encoding") == "base64":
+        body = base64.b64decode(body)
+    elif isinstance(body, str):
+        body = body.encode()
+
+    status, resp_headers, resp_body = asyncio.run(_dispatch(scope, body))
+
+    result: dict = {"statusCode": status, "headers": resp_headers}
+    if resp_body:
+        try:
+            result["body"] = resp_body.decode("utf-8")
+        except UnicodeDecodeError:
+            result["body"] = base64.b64encode(resp_body).decode()
+            result["encoding"] = "base64"
+
+    return result

package/esm/src/vite/sveltekit_python_vercel/load_runtime.py

@@ -0,0 +1,91 @@
+import inspect
+import types
+from typing import Any, Optional
+
+
+class SKPVError(Exception):
+    def __init__(self, status: int, body: Any):
+        self.status = status
+        self.body = body
+        super().__init__(body)
+
+
+class SKPVRedirect(Exception):
+    def __init__(self, status: int, location: str):
+        self.status = status
+        self.location = location
+        super().__init__(location)
+
+
+def error(status: int, body: Any) -> None:
+    raise SKPVError(status, body)
+
+
+def redirect(status: int, location: str) -> None:
+    raise SKPVRedirect(status, location)
+
+
+def inject_load_helpers(mod) -> None:
+    if not hasattr(mod, "error"):
+        mod.error = error
+    if not hasattr(mod, "redirect"):
+        mod.redirect = redirect
+
+
+def _to_namespace(value: Any) -> Any:
+    if value is None:
+        return None
+    if isinstance(value, dict):
+        ns = types.SimpleNamespace()
+        for key, val in value.items():
+            setattr(ns, key, _to_namespace(val))
+        return ns
+    if isinstance(value, list):
+        return [_to_namespace(item) for item in value]
+    return value
+
+
+class _Cookies:
+    def __init__(self, data: Optional[dict]):
+        self._data = data or {}
+
+    def get(self, name: str, default: Optional[str] = None) -> Optional[str]:
+        return self._data.get(name, default)
+
+
+def wrap_event(payload: dict) -> types.SimpleNamespace:
+    event = types.SimpleNamespace()
+    event.params = payload.get("params") or {}
+    event.route = _to_namespace(payload.get("route") or {})
+    event.url = payload.get("url", "")
+    event.parent = _to_namespace(payload.get("parent"))
+    event.data = payload.get("data")
+    event.cookies = _Cookies(payload.get("cookies"))
+    return event
+
+
+def parse_load_result(result: Any) -> dict:
+    if (
+        isinstance(result, tuple)
+        and len(result) == 3
+        and result[0] in ("error", "redirect")
+    ):
+        kind, status, payload = result
+        if kind == "error":
+            return {"type": "error", "status": status, "body": payload}
+        return {"type": "redirect", "status": status, "location": payload}
+    return {"type": "data", "data": result}
+
+
+async def run_load(mod, payload: dict) -> dict:
+    inject_load_helpers(mod)
+    event = wrap_event(payload)
+    try:
+        result = mod.load(event)
+        if inspect.iscoroutine(result):
+            result = await result
+        return parse_load_result(result)
+    except SKPVRedirect as exc:
+        return {"type": "redirect", "status": exc.status, "location": exc.location}
+    except SKPVError as exc:
+        return {"type": "error", "status": exc.status, "body": exc.body}

package/esm/src/vite/sveltekit_python_vercel/routes.py

@@ -0,0 +1,39 @@
+from pathlib import Path, PurePosixPath
+
+
+def rel_path_from_routes(module_path: Path, routes_root: Path) -> PurePosixPath:
+    """Route file path relative to src/routes, with groups stripped and [param] → {param}."""
+    rel = module_path.absolute().relative_to(routes_root)
+    rel = Path(str(rel).replace("[", "{").replace("]", "}"))
+    parts = [
+        p
+        for p in PurePosixPath(rel).parts
+        if not (p.startswith("(") and p.endswith(")"))
+    ]
+    return PurePosixPath(*parts)
+
+
+def route_parent(rel: PurePosixPath) -> PurePosixPath:
+    return PurePosixPath(rel).parent
+
+
+def api_route(rel_parent: PurePosixPath, *, prefix: str = "/api") -> str:
+    if str(rel_parent) == ".":
+        return prefix
+    return f"{prefix}/{rel_parent}"
+
+
+def load_route(rel_parent: PurePosixPath) -> str:
+    return api_route(rel_parent, prefix="/api/_load")
+
+
+def resolve_route_path(template: str, params: dict) -> str:
+    path = template
+    for key, value in params.items():
+        path = path.replace(f"{{{key}}}", str(value))
+    return path
+
+
+def route_registration_order(route: str) -> tuple:
+    """Static routes before dynamic; longer paths before shorter."""
+    return ("{" in route, -len(route), route)

package/esm/src/vite/sveltekit_python_vercel/serve.py

@@ -1,12 +1,23 @@
 import argparse
 import glob
-import importlib
 import importlib.util
 import shutil
-from pathlib import Path, PurePosixPath
+import sys
+from pathlib import Path
 
 import uvicorn
-from fastapi import FastAPI
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+
+sys.path.insert(0, str(Path(__file__).parent))
+from load_runtime import run_load
+from routes import (
+    api_route,
+    load_route,
+    rel_path_from_routes,
+    route_parent,
+    route_registration_order,
+)
 
 parser = argparse.ArgumentParser(description="Run Sveltekit Python Server")
 parser.add_argument("--host", default="0.0.0.0", help="Server hostname")
@@ -17,58 +28,75 @@ args = parser.parse_args()
 app = FastAPI()
 
 root_dir = Path(args.root).absolute()
-
 api_dir = Path("./sveltekit_python_vercel").absolute()
+routes_root = root_dir / "src/routes"
+watch_modules = []
 
-route_dir = root_dir.joinpath("src/routes")
 
-watch_modules = []  # list of modules to watch for changes
+def _copy_module(module_path: Path) -> Path:
+    api_route_path = api_dir.joinpath(module_path.relative_to(routes_root))
+    api_route_path.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy(module_path, api_route_path.parent / api_route_path.name)
+    return api_route_path.parent / api_route_path.name
 
-for module_path in glob.glob(
-    route_dir.joinpath("**/+server.py").as_posix(), recursive=True
-):
-    abs_module_path = Path(module_path).absolute()
-
-    watch_modules.append(abs_module_path.parent.as_posix())
 
-    api_route = api_dir.joinpath(abs_module_path.relative_to(root_dir / "src/routes"))
+def _load_module(api_route_path: Path):
+    spec = importlib.util.spec_from_file_location(api_route_path.stem, api_route_path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
 
-    if not api_route.parent.exists():
-        api_route.parent.mkdir(parents=True)
 
-    # copy module path to api_route
-    shutil.copy(module_path, api_route.parent)
+def _make_load_handler(mod):
+    async def handler(request: Request):
+        payload = await request.json()
+        return JSONResponse(await run_load(mod, payload))
 
-    module_name = api_route.stem
+    return handler
 
-    spec = importlib.util.spec_from_file_location(module_name, api_route)
-    mod = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(mod)
 
-    # Get the relative path of the module from the API directory
-    rel_path = api_route.relative_to(api_dir)
+for module_path in glob.glob(routes_root.joinpath("**/+server.py").as_posix(), recursive=True):
+    abs_module_path = Path(module_path).absolute()
+    watch_modules.append(abs_module_path.parent.as_posix())
 
-    # Convert the relative path to a string and remove the file extension
-    api_path = f"/{rel_path.parent}"
+    api_route_path = _copy_module(abs_module_path)
+    mod = _load_module(api_route_path)
 
-    # Replace square brackets with curly brackets
-    api_path = api_path.replace("[", "{").replace("]", "}")
-    
-    # remove any groups from the URL
-    api_path = str(PurePosixPath(*[part for part in PurePosixPath(api_path).parts if not part.startswith("(") and not part.endswith(")")]))
+    rel = rel_path_from_routes(abs_module_path, routes_root)
+    api_path = api_route(rel.parent)
 
-    # Add endpoints
     for method in ["GET", "POST", "PATCH", "PUT", "DELETE"]:
-        # Check for duplicate methods
         if hasattr(mod, method) and hasattr(mod, method.lower()):
             raise Exception(
-                f"Duplicate method {method} and {method.lower()} in {api_route}"
+                f"Duplicate method {method} and {method.lower()} in {api_route_path}"
             )
         elif hasattr(mod, method):
             app.add_api_route(api_path, getattr(mod, method), methods=[method])
         elif hasattr(mod, method.lower()):
             app.add_api_route(api_path, getattr(mod, method.lower()), methods=[method])
 
+load_entries = []
+for pattern in ("**/+page.server.py", "**/+layout.server.py"):
+    for module_path in glob.glob(routes_root.joinpath(pattern).as_posix(), recursive=True):
+        abs_module_path = Path(module_path).absolute()
+        watch_modules.append(abs_module_path.parent.as_posix())
+
+        api_route_path = _copy_module(abs_module_path)
+        mod = _load_module(api_route_path)
+
+        if not hasattr(mod, "load"):
+            raise Exception(f"Missing load function in {abs_module_path}")
+
+        rel = rel_path_from_routes(abs_module_path, routes_root)
+        load_path = load_route(route_parent(rel))
+        load_entries.append((load_path, mod, abs_module_path))
+
+for load_path, mod, abs_module_path in sorted(
+    load_entries, key=lambda entry: route_registration_order(entry[0])
+):
+    app.add_api_route(load_path, _make_load_handler(mod), methods=["POST"])
+    print(f"PYTHON LOAD: Registered POST {load_path} ← {abs_module_path}")
+
 
 if __name__ == "__main__":
     uvicorn.run(

package/esm/src/vite/sveltekit_python_vercel/test_load_runtime.py

@@ -0,0 +1,119 @@
+import types
+import unittest
+
+from load_runtime import (
+    SKPVError,
+    inject_load_helpers,
+    parse_load_result,
+    redirect,
+    run_load,
+    wrap_event,
+)
+
+
+class ParseLoadResultTests(unittest.TestCase):
+    def test_data(self):
+        self.assertEqual(
+            parse_load_result({"ok": True}),
+            {"type": "data", "data": {"ok": True}},
+        )
+
+    def test_error_tuple(self):
+        self.assertEqual(
+            parse_load_result(("error", 404, "Not found")),
+            {"type": "error", "status": 404, "body": "Not found"},
+        )
+
+    def test_redirect_tuple(self):
+        self.assertEqual(
+            parse_load_result(("redirect", 307, "/login")),
+            {"type": "redirect", "status": 307, "location": "/login"},
+        )
+
+    def test_tuple_data_not_misread(self):
+        self.assertEqual(
+            parse_load_result(("items", 1, 2)),
+            {"type": "data", "data": ("items", 1, 2)},
+        )
+
+
+class RunLoadTests(unittest.IsolatedAsyncioTestCase):
+    async def test_injected_error(self):
+        mod = types.ModuleType("test")
+        exec(
+            compile(
+                "async def load(event):\n    error(403, 'denied')\n",
+                "<test>",
+                "exec",
+            ),
+            mod.__dict__,
+        )
+        result = await run_load(mod, {"params": {}})
+        self.assertEqual(result["type"], "error")
+        self.assertEqual(result["status"], 403)
+
+    async def test_injected_redirect(self):
+        mod = types.ModuleType("test")
+        exec(
+            compile(
+                "async def load(event):\n    redirect(307, '/home')\n",
+                "<test>",
+                "exec",
+            ),
+            mod.__dict__,
+        )
+        result = await run_load(mod, {"params": {}})
+        self.assertEqual(result["type"], "redirect")
+        self.assertEqual(result["location"], "/home")
+
+    async def test_return_tuple_error(self):
+        mod = types.ModuleType("test")
+
+        async def load(event):
+            return ("error", 404, "missing")
+
+        mod.load = load
+        result = await run_load(mod, {"params": {}})
+        self.assertEqual(result, {"type": "error", "status": 404, "body": "missing"})
+
+    async def test_wrap_event_parent_and_cookies(self):
+        mod = types.ModuleType("test")
+        captured = {}
+
+        async def load(event):
+            captured["theme"] = event.parent.theme
+            captured["session"] = event.cookies.get("session")
+            return {"ok": True}
+
+        mod.load = load
+        await run_load(
+            mod,
+            {
+                "params": {"id": "1"},
+                "parent": {"theme": "dark"},
+                "cookies": {"session": "abc"},
+            },
+        )
+        self.assertEqual(captured["theme"], "dark")
+        self.assertEqual(captured["session"], "abc")
+
+    async def test_user_error_helper_not_overwritten(self):
+        mod = types.ModuleType("test")
+
+        def custom_error(status, body):
+            raise SKPVError(418, "teapot")
+
+        mod.error = custom_error
+
+        async def load(event):
+            custom_error(404, "ignored")
+
+        mod.load = load
+        inject_load_helpers(mod)
+        with self.assertRaises(SKPVError) as ctx:
+            await mod.load(wrap_event({}))
+        self.assertEqual(ctx.exception.status, 418)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/package.json

@@ -2,7 +2,7 @@
   "module": "./esm/mod.js",
   "types": "./types/mod.d.ts",
   "name": "sveltekit-python-vercel",
-  "version": "v0.4.1",
+  "version": "1.0.3-beta.53c34c5",
   "description": "Write Sveltekit server endpoints in Python and seamlessly deploy to Vercel",
   "repository": {
     "type": "git",