sveltekit-python-vercel 0.4.1 → 1.0.2

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,7 @@ 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
+- Deploy automatically to Vercel Serverless (Python 3.12 runtime)
 
 ## Installing
 
@@ -36,17 +36,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 +61,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 +74,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.
-
-- 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.
+Just push to your repository — no extra steps required.
 
-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 +146,12 @@ 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 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.
-
-See the example above.
+- `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.
 
 ## Fork of `sveltekit-modal`
 
@@ -231,8 +160,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\
+- [ ] Add helper functions to automatically call API endpoints in project

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.2",
   "description": "Write Sveltekit server endpoints in Python and seamlessly deploy to Vercel",
   "repository": {
     "type": "git",

package/esm/src/vite/mod.js

@@ -1,136 +0,0 @@
-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 }) => {
-        const headers = new Headers()
-        headers.append('content-type', request.headers.get('content-type'));
-        headers.append('accept', request.headers.get('accept'));
-
-        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;
-        }
-
-        console.log(\`PY: Reached python endpoint of \${method} \${fullURL}\`)
-        let requestBody = await request.clone().text();
-        console.log(\`PY: Body: \${requestBody}\`);
-
-        if (method === 'GET') {
-          requestBody = null;
-        }
-
-        return fetch(fullURL, { headers, method, body: requestBody, signal: request.signal, duplex: 'half' });
-    });
-    
-    export const GET = handle('GET');
-    export const POST = handle('POST');
-    export const PATCH = handle('PATCH');
-    export const PUT = handle('PUT');
-    export const DELETE = handle('DELETE');
-`;
-export async function sveltekit_python_vercel(opts = {}) {
-    const child_processes = [];
-    async function kill_all_process() {
-        for (const ps of child_processes) {
-            await ps.kill();
-            await ps.exitCode;
-        }
-    }
-    let sveltekit_url;
-    const plugin_python_serve = {
-        name: "vite-plugin-sveltekit-python-serve",
-        apply: "serve",
-        async closeBundle() {
-            await kill_all_process();
-        },
-        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);
-            const python_path = opts.python_path ?? (await which("python3"));
-            const host = opts.host ?? "0.0.0.0";
-            const port = opts.port ?? 8000;
-            const local_process = run$ `${python_path} -m sveltekit_python_vercel.serve --host ${host} --port ${port} --root ${config.root}`;
-            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
-            });
-            local_process.stderr.on("error", (s) => {
-                console.error(chalk.red("Error: Python Serve Failed"));
-                console.error(s.toString().trimEnd());
-            });
-            local_process.stdout.on("error", (s) => {
-                console.error(chalk.red("Error: Python Serve Failed"));
-                console.error(s.toString().trimEnd());
-            });
-        },
-    };
-    const plugin_python_build = {
-        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 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
-                };
-            }
-        },
-    };
-    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 [
-        plugin_python_serve,
-        plugin_python_build,
-        plugin_py_server_endpoint_serve,
-        plugin_py_server_endpoint_build,
-    ];
-}

package/esm/src/vite/sveltekit_python_vercel/bin.mjs

@@ -1,6 +0,0 @@
-#!/usr/bin/env zx --install
-
-import {$} from "zx";
-
-const python_path = await $`which python3`;
-await $`${python_path} ./node_modules/sveltekit-python-vercel/esm/src/vite/sveltekit_python_vercel/build.py --root . --packagedir ./node_modules/sveltekit-python-vercel/esm/src/vite/sveltekit_python_vercel`;

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

@@ -1,45 +0,0 @@
-import argparse
-import shutil
-import glob
-
-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()
-
-
-root_dir = Path(args.root).absolute()
-api_dir = root_dir / "api"
-
-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/esm/src/vite/sveltekit_python_vercel/deploy.py

@@ -1,55 +0,0 @@
-import glob
-import importlib
-import importlib.util
-import os
-from pathlib import Path, PurePosixPath
-
-from fastapi import FastAPI, Request
-from fastapi.responses import JSONResponse
-
-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}")
-
-@app.exception_handler(Exception)
-async def unicorn_exception_handler(request: Request, exc: Exception):
-    return JSONResponse(
-        status_code=500,
-        content={"error": f"{exc}"},
-    )

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

@@ -1,82 +0,0 @@
-import argparse
-import glob
-import importlib
-import importlib.util
-import shutil
-from pathlib import Path, PurePosixPath
-
-import uvicorn
-from fastapi import FastAPI
-
-parser = argparse.ArgumentParser(description="Run Sveltekit Python Server")
-parser.add_argument("--host", default="0.0.0.0", help="Server hostname")
-parser.add_argument("--port", type=int, default=8000, help="Server port")
-parser.add_argument("--root", default=".", help="Directory where the API is located")
-args = parser.parse_args()
-
-app = FastAPI()
-
-root_dir = Path(args.root).absolute()
-
-api_dir = Path("./sveltekit_python_vercel").absolute()
-
-route_dir = root_dir.joinpath("src/routes")
-
-watch_modules = []  # list of modules to watch for changes
-
-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"))
-
-    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)
-
-    module_name = api_route.stem
-
-    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)
-
-    # Convert the relative path to a string and remove the file extension
-    api_path = f"/{rel_path.parent}"
-
-    # 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(")")]))
-
-    # 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_path, getattr(mod, method), methods=[method])
-        elif hasattr(mod, method.lower()):
-            app.add_api_route(api_path, getattr(mod, method.lower()), methods=[method])
-
-
-if __name__ == "__main__":
-    uvicorn.run(
-        "sveltekit_python_vercel.serve:app",
-        host=args.host,
-        port=args.port,
-        log_level="info",
-        reload=True,
-        reload_includes=[*set(watch_modules)],
-        reload_excludes=[api_dir.as_posix()],
-    )

package/types/src/vite/mod.d.ts

@@ -1,8 +0,0 @@
-import { type Plugin } from "vite";
-export interface SveltekitPythonOptions {
-    python_path?: string;
-    log?: boolean;
-    host?: string;
-    port?: number;
-}
-export declare function sveltekit_python_vercel(opts?: SveltekitPythonOptions): Promise<Plugin[]>;