From 4d2d140c3019d10d791e6ec0d70df5f08479ba23 Mon Sep 17 00:00:00 2001
From: Dave Jong <dave.jong@patchstack.com>
Date: Wed, 15 Jul 2026 17:17:16 +0200
Subject: [PATCH 1/2] feat(protect): Express + Next.js adapters
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two new per-stack adapters on the #81 interface, dependency-free (anchor + #region markers,
same approach as tanstack — no AST parser, keeping dependencies:{}).

- Express: detect (express dep + an `= express()` site), scaffold the generic guard, and wire
  `app.use(patchstackMiddleware)` right after the app is created (import + region-marked insert,
  idempotent). verify() checks the guard is scaffolded + the middleware is wired.
- Next.js: detect (next dep); scaffold `middleware.ts` (+ co-located patchstack.rules.json) from a
  new template running the request-phase guard as edge middleware. An EXISTING middleware is never
  overwritten — we scaffold the rules and print a plan instead. verify() checks the managed
  middleware + rules are present.
- Registered in the orchestrator (tanstack → next → express → generic fallback); AGENT-INSTALL
  lists the newly auto-wired stacks.

+4 tests. 451 tests pass, typecheck + build clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 AGENT-INSTALL.md                         |   2 +-
 src/protect/install/adapters/express.ts  | 130 +++++++++++++++++++++++
 src/protect/install/adapters/next.ts     |  91 ++++++++++++++++
 src/protect/install/index.ts             |   6 +-
 src/protect/templates/next-middleware.ts |  35 ++++++
 tests/protect/adapters.test.ts           |  81 ++++++++++++++
 6 files changed, 342 insertions(+), 3 deletions(-)
 create mode 100644 src/protect/install/adapters/express.ts
 create mode 100644 src/protect/install/adapters/next.ts
 create mode 100644 src/protect/templates/next-middleware.ts
 create mode 100644 tests/protect/adapters.test.ts

diff --git a/AGENT-INSTALL.md b/AGENT-INSTALL.md
index 7c72d2e..0aedf7e 100644
--- a/AGENT-INSTALL.md
+++ b/AGENT-INSTALL.md
@@ -8,7 +8,7 @@ This versioned reference ships inside `@patchstack/connect` and documents each s
 - It reads the project's **dependency list only** — from the lockfile (`package-lock.json`, `pnpm-lock.yaml`, `yarn.lock`) or, on bun projects (`bun.lock`/`bun.lockb`), by enumerating the installed packages under `node_modules/` — and sends package names + versions to Patchstack for vulnerability matching. No source code, no env var values, no file paths, no git history. (`mark-build` additionally stamps built HTML with a coarse stack descriptor that may include hosting-related env variable *names* — e.g. `VERCEL`, `CF_PAGES` — never their values.)
 - **`scan` makes one source edit, and only after a successful post:** it adds (or updates) the disclosure widget's `<script>` tag in the project's root HTML shell — the first of `index.html`, `public/index.html`, or `src/app.html` that exists. It touches no other file, never edits on `--dry-run` or after a failed post, leaves any pre-existing manual widget tag untouched, and is disabled entirely by `"widget": false` in `.patchstackrc.json`. `mark-build` writes to build output only (`dist/`, `build/`, `out/`, `.output/public`), never to source. `guide`, `status`, and `init` write nothing except `init`'s own `.patchstackrc.json`.
 - **`setup` runs `scan`, then edits only `package.json` build scripts:** it preserves existing commands, adds `scan` before builds and `mark-build` after builds, and uses a direct build chain for Bun. It never runs the project build or `protect`. If the widget needs a framework-specific source edit, it prints the exact remaining step instead of rewriting framework code.
-- The package also bundles an **opt-in** `protect` command (runtime exploit guard; its templates live under `dist/protect/`). It runs **only** when explicitly invoked; `scan`, `setup`, `guide`, `status`, and `mark-build` never invoke it, and it writes only local files. On a **TanStack Start + Supabase** app it auto-wires the guard (patches the Supabase client + `src/start.ts`). On **any other stack** it scaffolds a framework-agnostic guard under `src/patchstack/` and prints a wiring plan — then you finish the install by importing that guard into your server entry (`protectFetch(handler)` for a Web-Fetch server, or `app.use(patchstackMiddleware)` for Node/Express) and running `patchstack-connect protect --check` to confirm it is wired (exit 1 until it is). Passing `--demo` seeds a broad sample rule set (for demonstrations, not production).
+- The package also bundles an **opt-in** `protect` command (runtime exploit guard; its templates live under `dist/protect/`). It runs **only** when explicitly invoked; `scan`, `setup`, `guide`, `status`, and `mark-build` never invoke it, and it writes only local files. It auto-wires known stacks — **TanStack Start + Supabase** (patches the Supabase client + `src/start.ts`), **Next.js** (scaffolds `middleware.ts`), and **Express** (`app.use(patchstackMiddleware)`). On **any other stack** it scaffolds a framework-agnostic guard under `src/patchstack/` and prints a wiring plan — then you finish the install by importing that guard into your server entry (`protectFetch(handler)` for a Web-Fetch server, or `app.use(patchstackMiddleware)` for Node/Express) and running `patchstack-connect protect --check` to confirm it is wired (exit 1 until it is). Passing `--demo` seeds a broad sample rule set (for demonstrations, not production).
 - Patchstack is not WordPress-only. This connector monitors any JS/Node project — Vite, Next.js, plain vanilla JS, anything with a lockfile.
 
 ## Before you start — never install twice
diff --git a/src/protect/install/adapters/express.ts b/src/protect/install/adapters/express.ts
new file mode 100644
index 0000000..dade25b
--- /dev/null
+++ b/src/protect/install/adapters/express.ts
@@ -0,0 +1,130 @@
+// Adapter: Express (Node). Scaffolds the framework-agnostic guard and wires it as the first
+// middleware — `app.use(patchstackMiddleware)` right after the `express()` app is created.
+// Dependency-free anchor + #region-marker patching (same approach as the tanstack adapter).
+
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from 'node:fs';
+import { join, dirname, relative } from 'node:path';
+import { read, log } from '../util.js';
+import { scaffoldGeneric } from '../generic.js';
+import type { Adapter, WireOptions, WireResult, VerifyResult } from '../types.js';
+
+const APP_RE = /(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*express\(\)/;
+const REGION = '// #region patchstack (managed by patchstack-connect protect — do not edit)';
+
+function hasExpressDep(cwd: string): boolean {
+  try {
+    const pkg = JSON.parse(read(join(cwd, 'package.json')));
+    return Boolean({ ...pkg.dependencies, ...pkg.devDependencies }.express);
+  } catch {
+    return false;
+  }
+}
+
+// Find the source file + variable where the Express app is created (`const app = express()`).
+function findExpressApp(cwd: string): { relPath: string; appVar: string } | null {
+  const root = existsSync(join(cwd, 'src')) ? join(cwd, 'src') : cwd;
+  let hit: { relPath: string; appVar: string } | null = null;
+  const walk = (dir: string): void => {
+    if (hit) return;
+    let entries: string[];
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const name of entries) {
+      if (hit) return;
+      if (name === 'node_modules' || name === 'patchstack' || name.startsWith('.')) continue;
+      const p = join(dir, name);
+      let st;
+      try {
+        st = statSync(p);
+      } catch {
+        continue;
+      }
+      if (st.isDirectory()) walk(p);
+      else if (/\.(?:ts|js|mjs|cjs)$/.test(name)) {
+        let src: string;
+        try {
+          src = readFileSync(p, 'utf8');
+        } catch {
+          continue;
+        }
+        const m = APP_RE.exec(src);
+        if (m) hit = { relPath: relative(cwd, p).replace(/\\/g, '/'), appVar: m[1]! };
+      }
+    }
+  };
+  walk(root);
+  return hit;
+}
+
+function detect(cwd: string): boolean {
+  return hasExpressDep(cwd) && findExpressApp(cwd) !== null;
+}
+
+function importSpecifier(fromRel: string, toRel: string): string {
+  let spec = relative(dirname(fromRel), toRel).replace(/\\/g, '/').replace(/\.(?:ts|js)$/, '');
+  if (!spec.startsWith('.')) spec = `./${spec}`;
+  return spec;
+}
+
+function wire(cwd: string, opts: WireOptions): WireResult {
+  const { changed, dir } = scaffoldGeneric(cwd, opts);
+  const entry = findExpressApp(cwd);
+  if (!entry) {
+    log('express detected but no `= express()` site found — scaffolded guard; add app.use(patchstackMiddleware) yourself');
+    return { ok: true, changed };
+  }
+
+  const p = join(cwd, entry.relPath);
+  let s = read(p);
+  if (s.includes('patchstackMiddleware')) {
+    log(`express entry ${entry.relPath} already wired`);
+    return { ok: true, changed };
+  }
+
+  const spec = importSpecifier(entry.relPath, `${dir}/guard`);
+  const importLine = `import { patchstackMiddleware } from "${spec}";`;
+  // add the import after the last existing import (else at top)
+  const lines = s.split('\n');
+  let lastImport = -1;
+  for (let i = 0; i < lines.length; i++) if (/^\s*import\b/.test(lines[i] ?? '')) lastImport = i;
+  lines.splice(lastImport + 1, 0, importLine);
+  // insert `app.use(patchstackMiddleware)` right after the express() app line
+  const appIdx = lines.findIndex((l) => APP_RE.test(l));
+  if (appIdx !== -1) {
+    lines.splice(appIdx + 1, 0, REGION, `${entry.appVar}.use(patchstackMiddleware);`, '// #endregion patchstack');
+  }
+  s = lines.join('\n');
+  writeFileSync(p, s);
+  changed.push(entry.relPath);
+  log(`patched ${entry.relPath} (${entry.appVar}.use(patchstackMiddleware))`);
+  return { ok: true, changed: [...new Set(changed)] };
+}
+
+function verify(cwd: string): VerifyResult {
+  const dir = existsSync(join(cwd, 'src')) ? 'src/patchstack' : 'patchstack';
+  const scaffolded = existsSync(join(cwd, dir, 'guard.ts'));
+  const entry = findExpressApp(cwd);
+  const wired = entry ? read(join(cwd, entry.relPath)).includes('patchstackMiddleware') : false;
+  return {
+    wired: scaffolded && wired,
+    checks: [
+      { label: 'generic guard scaffolded', ok: scaffolded, hint: 'run `patchstack-connect protect`' },
+      {
+        label: 'app.use(patchstackMiddleware) wired into the Express app',
+        ok: wired,
+        hint: 'add `app.use(patchstackMiddleware)` right after you create your express() app',
+      },
+    ],
+  };
+}
+
+export const expressAdapter: Adapter = {
+  name: 'express',
+  label: 'Express (Node)',
+  detect,
+  wire,
+  verify,
+};
diff --git a/src/protect/install/adapters/next.ts b/src/protect/install/adapters/next.ts
new file mode 100644
index 0000000..14b75bd
--- /dev/null
+++ b/src/protect/install/adapters/next.ts
@@ -0,0 +1,91 @@
+// Adapter: Next.js. Wires the guard as edge middleware (request-phase WAF + egress SSRF).
+// If the app has no middleware yet, scaffolds `middleware.ts` (+ patchstack.rules.json). If a
+// middleware file already exists, we do NOT clobber it — we scaffold the rules and print a plan
+// (add the guard to your middleware), so an existing middleware is never silently overwritten.
+
+import { writeFileSync, existsSync, mkdirSync, copyFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { read, log, templatesDir } from '../util.js';
+import type { Adapter, WireOptions, WireResult, VerifyResult } from '../types.js';
+
+function hasNextDep(cwd: string): boolean {
+  try {
+    const pkg = JSON.parse(read(join(cwd, 'package.json')));
+    return Boolean({ ...pkg.dependencies, ...pkg.devDependencies }.next);
+  } catch {
+    return false;
+  }
+}
+
+// Next reads middleware from `middleware.ts` at the project root, or `src/middleware.ts` when the
+// app uses a `src/` dir. Return the existing one if present, else the conventional target.
+function middlewareInfo(cwd: string): { relDir: string; relFile: string; exists: boolean } {
+  const candidates = ['middleware.ts', 'middleware.js', 'src/middleware.ts', 'src/middleware.js'];
+  for (const rel of candidates) {
+    if (existsSync(join(cwd, rel))) return { relDir: rel.includes('/') ? 'src' : '.', relFile: rel, exists: true };
+  }
+  const useSrc = existsSync(join(cwd, 'src'));
+  return { relDir: useSrc ? 'src' : '.', relFile: useSrc ? 'src/middleware.ts' : 'middleware.ts', exists: false };
+}
+
+function detect(cwd: string): boolean {
+  return hasNextDep(cwd);
+}
+
+function rulesFile(relDir: string): string {
+  return relDir === '.' ? 'patchstack.rules.json' : `${relDir}/patchstack.rules.json`;
+}
+
+function wire(cwd: string, opts: WireOptions): WireResult {
+  const templates = templatesDir();
+  const mw = middlewareInfo(cwd);
+  const dir = join(cwd, mw.relDir === '.' ? '' : mw.relDir);
+  mkdirSync(dir, { recursive: true });
+
+  // Co-locate the rules next to the middleware (the template imports ./patchstack.rules.json).
+  const rulesDst = join(dir, 'patchstack.rules.json');
+  const changed: string[] = [];
+  if (opts.demo || !existsSync(rulesDst)) {
+    copyFileSync(join(templates, opts.demo ? 'demo-rules.json' : 'rules.json'), rulesDst);
+    changed.push(rulesFile(mw.relDir));
+  }
+
+  const mwPath = join(cwd, mw.relFile);
+  const existing = mw.exists ? read(mwPath) : '';
+  if (mw.exists && !existing.includes('patchstack-next')) {
+    // Don't overwrite the app's own middleware — leave it, and tell the user how to add the guard.
+    log(
+      `existing ${mw.relFile} left untouched — scaffolded ${rulesFile(mw.relDir)}; add the guard to your ` +
+        `middleware: import { createProtection } from "@patchstack/connect/protect", run fetchGuard() on the ` +
+        `request, and return the block Response. Then: npx patchstack-connect protect --check`,
+    );
+    return { ok: true, changed };
+  }
+
+  // Fresh (or already-ours) → write the managed middleware.
+  copyFileSync(join(templates, 'next-middleware.ts'), mwPath);
+  changed.push(mw.relFile);
+  log(mw.exists ? `refreshed ${mw.relFile} (Patchstack middleware)` : `scaffolded ${mw.relFile} (Patchstack middleware)`);
+  return { ok: true, changed: [...new Set(changed)] };
+}
+
+function verify(cwd: string): VerifyResult {
+  const mw = middlewareInfo(cwd);
+  const present = mw.exists && read(join(cwd, mw.relFile)).includes('patchstack-next');
+  const rulesPresent = existsSync(join(cwd, rulesFile(mw.relDir)));
+  return {
+    wired: present && rulesPresent,
+    checks: [
+      { label: 'Patchstack middleware present', ok: present, hint: `run \`patchstack-connect protect\` (writes ${mw.relFile})` },
+      { label: 'rules co-located with the middleware', ok: rulesPresent, hint: 'run `patchstack-connect protect`' },
+    ],
+  };
+}
+
+export const nextAdapter: Adapter = {
+  name: 'nextjs',
+  label: 'Next.js',
+  detect,
+  wire,
+  verify,
+};
diff --git a/src/protect/install/index.ts b/src/protect/install/index.ts
index 7fcf3e9..0ac155b 100644
--- a/src/protect/install/index.ts
+++ b/src/protect/install/index.ts
@@ -8,11 +8,13 @@
 
 import { log } from './util.js';
 import { tanstackSupabaseAdapter } from './adapters/tanstack-supabase.js';
+import { nextAdapter } from './adapters/next.js';
+import { expressAdapter } from './adapters/express.js';
 import { scaffoldGeneric, wiringPlan, genericVerify } from './generic.js';
 import type { Adapter, WireOptions, ProtectResult, VerifyReport } from './types.js';
 
-// Registry — order = match priority. Add new stacks here.
-const ADAPTERS: Adapter[] = [tanstackSupabaseAdapter];
+// Registry — order = match priority (most specific first). Add new stacks here.
+const ADAPTERS: Adapter[] = [tanstackSupabaseAdapter, nextAdapter, expressAdapter];
 
 /** Scaffold + wire the runtime guard into the app at `cwd`. Best-effort — never throws. */
 export function runProtect(cwd: string, opts: WireOptions = {}): ProtectResult {
diff --git a/src/protect/templates/next-middleware.ts b/src/protect/templates/next-middleware.ts
new file mode 100644
index 0000000..f3f7758
--- /dev/null
+++ b/src/protect/templates/next-middleware.ts
@@ -0,0 +1,35 @@
+// Patchstack runtime guard for Next.js — edge middleware. Managed by `patchstack-connect protect`.
+// Runs the request-phase WAF (+ egress SSRF) on every request before it reaches your route.
+// Note: response-body redaction isn't available in Next middleware (it runs before the response);
+// wire the connect runtime in your route handlers if you also need response screening there.
+import { createProtection } from "@patchstack/connect/protect";
+import fallbackRules from "./patchstack.rules.json";
+
+let _protection: Awaited<ReturnType<typeof createProtection>> | undefined;
+async function getProtection() {
+  if (!_protection) {
+    const mode = process.env.PATCHSTACK_MODE === "dry-run" ? "dry-run" : "block";
+    const token = process.env.PATCHSTACK_WAF_TOKEN;
+    const siteUuid = process.env.PATCHSTACK_SITE_UUID;
+    const common = { mode, egress: true } as const;
+    _protection = await createProtection(
+      siteUuid
+        ? { ...common, siteUuid, rules: fallbackRules as never, cacheDir: ".patchstack" }
+        : token
+          ? { ...common, token, cacheDir: ".patchstack" }
+          : { ...common, rules: fallbackRules as never },
+    );
+  }
+  return _protection;
+}
+
+// #region patchstack-next (managed by patchstack-connect protect — do not edit)
+export async function middleware(request: Request) {
+  const protection = await getProtection();
+  const blocked = await protection.fetchGuard()(request);
+  if (blocked) return blocked; // 403 — blocked before it reaches your route
+  // otherwise fall through (Next continues to the route)
+}
+
+export const config = { matcher: "/:path*" };
+// #endregion patchstack-next
diff --git a/tests/protect/adapters.test.ts b/tests/protect/adapters.test.ts
new file mode 100644
index 0000000..d0803bb
--- /dev/null
+++ b/tests/protect/adapters.test.ts
@@ -0,0 +1,81 @@
+import { describe, expect, it } from 'vitest';
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { runProtect, runVerify } from '../../src/protect/install/index.js';
+
+const read = (dir: string, rel: string) => readFileSync(path.join(dir, rel), 'utf8');
+const count = (hay: string, needle: string) => hay.split(needle).length - 1;
+const tmp = (p: string) => mkdtempSync(path.join(tmpdir(), p));
+
+describe('Express adapter', () => {
+  function expressApp(): string {
+    const dir = tmp('ps-express-');
+    writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ name: 'x', dependencies: { express: '^4.19.0' } }));
+    mkdirSync(path.join(dir, 'src'), { recursive: true });
+    writeFileSync(path.join(dir, 'src/server.ts'), "import express from 'express';\nconst app = express();\napp.listen(3000);\n");
+    return dir;
+  }
+
+  it('scaffolds the guard and wires app.use(patchstackMiddleware) after the express() app', () => {
+    const dir = expressApp();
+    try {
+      const res: any = runProtect(dir);
+      expect(res.status).toBe('wired');
+      expect(res.adapter).toBe('express');
+      expect(existsSync(path.join(dir, 'src/patchstack/guard.ts'))).toBe(true);
+      const server = read(dir, 'src/server.ts');
+      expect(server).toContain('import { patchstackMiddleware } from "./patchstack/guard";');
+      expect(server).toContain('app.use(patchstackMiddleware);');
+      expect(server.indexOf('const app = express()')).toBeLessThan(server.indexOf('app.use(patchstackMiddleware)'));
+      expect(runVerify(dir).wired).toBe(true);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('is idempotent (re-run does not duplicate the middleware)', () => {
+    const dir = expressApp();
+    try {
+      runProtect(dir);
+      runProtect(dir);
+      expect(count(read(dir, 'src/server.ts'), 'app.use(patchstackMiddleware)')).toBe(1);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('Next.js adapter', () => {
+  it('scaffolds middleware.ts + co-located rules when none exists', () => {
+    const dir = tmp('ps-next-');
+    writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ name: 'x', dependencies: { next: '^14.0.0' } }));
+    try {
+      const res: any = runProtect(dir);
+      expect(res.status).toBe('wired');
+      expect(res.adapter).toBe('nextjs');
+      const mw = read(dir, 'middleware.ts');
+      expect(mw).toContain('patchstack-next');
+      expect(mw).toContain('config = { matcher:');
+      expect(existsSync(path.join(dir, 'patchstack.rules.json'))).toBe(true);
+      expect(runVerify(dir).wired).toBe(true);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('does NOT overwrite an existing middleware (scaffolds rules + leaves it, verify not wired)', () => {
+    const dir = tmp('ps-next2-');
+    writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ name: 'x', dependencies: { next: '^14.0.0' } }));
+    const ownMiddleware = 'export function middleware() { /* my own */ }\n';
+    writeFileSync(path.join(dir, 'middleware.ts'), ownMiddleware);
+    try {
+      runProtect(dir);
+      expect(read(dir, 'middleware.ts')).toBe(ownMiddleware); // untouched
+      expect(existsSync(path.join(dir, 'patchstack.rules.json'))).toBe(true); // rules still scaffolded
+      expect(runVerify(dir).wired).toBe(false); // guard not in their middleware
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

From 1616ab8b44e1b8dd2ee116eeee8ffd2652fdc86a Mon Sep 17 00:00:00 2001
From: Dave Jong <dave.jong@patchstack.com>
Date: Wed, 15 Jul 2026 17:35:30 +0200
Subject: [PATCH 2/2] feat(protect): SvelteKit, Astro, Fastify adapters
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Three more per-stack adapters (Arcjet-parity for the JS frameworks, minus NestJS/Python),
dependency-free — same anchor + #region approach, no AST parser, dependencies:{} unchanged.

- SvelteKit + Astro: seam-file-is-the-guard. New shared `seam.ts` (wireSeam/verifySeam) scaffolds
  the framework's server hook from a template (`src/hooks.server.ts` → handle, `src/middleware.ts`
  → onRequest) + co-located patchstack.rules.json. An EXISTING hook is never overwritten — scaffold
  rules + print a compose-with-sequence() plan instead.
- Fastify: register-into-app (like express). scaffoldGeneric now takes a guard-template arg so the
  Fastify plugin (builds a Request from the parsed fastify request → fetchGuard) lands as the guard;
  wire `app.register(patchstackFastify)` after the fastify() instance.
- Registered most-specific-first (tanstack → next → sveltekit → astro → fastify → express → generic).
- AGENT-INSTALL lists the newly auto-wired stacks.

+5 tests. 456 pass, typecheck + build clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 AGENT-INSTALL.md                          |   2 +-
 src/protect/install/adapters/astro.ts     |  39 +++++++
 src/protect/install/adapters/fastify.ts   | 128 ++++++++++++++++++++++
 src/protect/install/adapters/sveltekit.ts |  39 +++++++
 src/protect/install/generic.ts            |   4 +-
 src/protect/install/index.ts              |  15 ++-
 src/protect/install/seam.ts               |  63 +++++++++++
 src/protect/templates/astro-middleware.ts |  33 ++++++
 src/protect/templates/fastify-plugin.ts   |  46 ++++++++
 src/protect/templates/sveltekit-hooks.ts  |  33 ++++++
 tests/protect/adapters.test.ts            |  92 ++++++++++++++++
 11 files changed, 489 insertions(+), 5 deletions(-)
 create mode 100644 src/protect/install/adapters/astro.ts
 create mode 100644 src/protect/install/adapters/fastify.ts
 create mode 100644 src/protect/install/adapters/sveltekit.ts
 create mode 100644 src/protect/install/seam.ts
 create mode 100644 src/protect/templates/astro-middleware.ts
 create mode 100644 src/protect/templates/fastify-plugin.ts
 create mode 100644 src/protect/templates/sveltekit-hooks.ts

diff --git a/AGENT-INSTALL.md b/AGENT-INSTALL.md
index 0aedf7e..3a59db9 100644
--- a/AGENT-INSTALL.md
+++ b/AGENT-INSTALL.md
@@ -8,7 +8,7 @@ This versioned reference ships inside `@patchstack/connect` and documents each s
 - It reads the project's **dependency list only** — from the lockfile (`package-lock.json`, `pnpm-lock.yaml`, `yarn.lock`) or, on bun projects (`bun.lock`/`bun.lockb`), by enumerating the installed packages under `node_modules/` — and sends package names + versions to Patchstack for vulnerability matching. No source code, no env var values, no file paths, no git history. (`mark-build` additionally stamps built HTML with a coarse stack descriptor that may include hosting-related env variable *names* — e.g. `VERCEL`, `CF_PAGES` — never their values.)
 - **`scan` makes one source edit, and only after a successful post:** it adds (or updates) the disclosure widget's `<script>` tag in the project's root HTML shell — the first of `index.html`, `public/index.html`, or `src/app.html` that exists. It touches no other file, never edits on `--dry-run` or after a failed post, leaves any pre-existing manual widget tag untouched, and is disabled entirely by `"widget": false` in `.patchstackrc.json`. `mark-build` writes to build output only (`dist/`, `build/`, `out/`, `.output/public`), never to source. `guide`, `status`, and `init` write nothing except `init`'s own `.patchstackrc.json`.
 - **`setup` runs `scan`, then edits only `package.json` build scripts:** it preserves existing commands, adds `scan` before builds and `mark-build` after builds, and uses a direct build chain for Bun. It never runs the project build or `protect`. If the widget needs a framework-specific source edit, it prints the exact remaining step instead of rewriting framework code.
-- The package also bundles an **opt-in** `protect` command (runtime exploit guard; its templates live under `dist/protect/`). It runs **only** when explicitly invoked; `scan`, `setup`, `guide`, `status`, and `mark-build` never invoke it, and it writes only local files. It auto-wires known stacks — **TanStack Start + Supabase** (patches the Supabase client + `src/start.ts`), **Next.js** (scaffolds `middleware.ts`), and **Express** (`app.use(patchstackMiddleware)`). On **any other stack** it scaffolds a framework-agnostic guard under `src/patchstack/` and prints a wiring plan — then you finish the install by importing that guard into your server entry (`protectFetch(handler)` for a Web-Fetch server, or `app.use(patchstackMiddleware)` for Node/Express) and running `patchstack-connect protect --check` to confirm it is wired (exit 1 until it is). Passing `--demo` seeds a broad sample rule set (for demonstrations, not production).
+- The package also bundles an **opt-in** `protect` command (runtime exploit guard; its templates live under `dist/protect/`). It runs **only** when explicitly invoked; `scan`, `setup`, `guide`, `status`, and `mark-build` never invoke it, and it writes only local files. It auto-wires known stacks — **TanStack Start + Supabase** (patches the Supabase client + `src/start.ts`), **Next.js** (scaffolds `middleware.ts`), **SvelteKit** (`src/hooks.server.ts`), **Astro** (`src/middleware.ts`), **Fastify** (`app.register(patchstackFastify)`), and **Express** (`app.use(patchstackMiddleware)`). On **any other stack** it scaffolds a framework-agnostic guard under `src/patchstack/` and prints a wiring plan — then you finish the install by importing that guard into your server entry (`protectFetch(handler)` for a Web-Fetch server, or `app.use(patchstackMiddleware)` for Node/Express) and running `patchstack-connect protect --check` to confirm it is wired (exit 1 until it is). Passing `--demo` seeds a broad sample rule set (for demonstrations, not production).
 - Patchstack is not WordPress-only. This connector monitors any JS/Node project — Vite, Next.js, plain vanilla JS, anything with a lockfile.
 
 ## Before you start — never install twice
diff --git a/src/protect/install/adapters/astro.ts b/src/protect/install/adapters/astro.ts
new file mode 100644
index 0000000..467452b
--- /dev/null
+++ b/src/protect/install/adapters/astro.ts
@@ -0,0 +1,39 @@
+// Adapter: Astro. Wires the guard as middleware (`src/middleware.ts` → `onRequest`).
+import { join } from 'node:path';
+import { read } from '../util.js';
+import { wireSeam, verifySeam, type SeamSpec } from '../seam.js';
+import type { Adapter, WireOptions, WireResult, VerifyResult } from '../types.js';
+
+const SPEC: SeamSpec = {
+  templateName: 'astro-middleware.ts',
+  candidates: ['src/middleware.ts', 'src/middleware.js', 'src/middleware/index.ts', 'src/middleware/index.js'],
+  target: 'src/middleware.ts',
+  marker: 'patchstack-astro',
+  planHint: 'add the guard to your `onRequest` (compose with `sequence()` from "astro:middleware"), then: npx patchstack-connect protect --check',
+  seamLabel: 'Astro middleware',
+};
+
+function detect(cwd: string): boolean {
+  try {
+    const pkg = JSON.parse(read(join(cwd, 'package.json')));
+    return Boolean({ ...pkg.dependencies, ...pkg.devDependencies }.astro);
+  } catch {
+    return false;
+  }
+}
+
+function wire(cwd: string, opts: WireOptions): WireResult {
+  return wireSeam(cwd, opts, SPEC);
+}
+
+function verify(cwd: string): VerifyResult {
+  return verifySeam(cwd, SPEC);
+}
+
+export const astroAdapter: Adapter = {
+  name: 'astro',
+  label: 'Astro',
+  detect,
+  wire,
+  verify,
+};
diff --git a/src/protect/install/adapters/fastify.ts b/src/protect/install/adapters/fastify.ts
new file mode 100644
index 0000000..8b5fe4a
--- /dev/null
+++ b/src/protect/install/adapters/fastify.ts
@@ -0,0 +1,128 @@
+// Adapter: Fastify (Node). Scaffolds the Fastify guard plugin and registers it on the app —
+// `app.register(patchstackFastify)` right after the `fastify()` instance is created.
+// Dependency-free anchor + #region-marker patching (same approach as the express adapter).
+
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from 'node:fs';
+import { join, dirname, relative } from 'node:path';
+import { read, log } from '../util.js';
+import { scaffoldGeneric } from '../generic.js';
+import type { Adapter, WireOptions, WireResult, VerifyResult } from '../types.js';
+
+const APP_RE = /(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:fastify|Fastify)\(/;
+const REGION = '// #region patchstack (managed by patchstack-connect protect — do not edit)';
+
+function hasFastifyDep(cwd: string): boolean {
+  try {
+    const pkg = JSON.parse(read(join(cwd, 'package.json')));
+    return Boolean({ ...pkg.dependencies, ...pkg.devDependencies }.fastify);
+  } catch {
+    return false;
+  }
+}
+
+// Find the source file + variable where the Fastify app is created (`const app = fastify()`).
+function findFastifyApp(cwd: string): { relPath: string; appVar: string } | null {
+  const root = existsSync(join(cwd, 'src')) ? join(cwd, 'src') : cwd;
+  let hit: { relPath: string; appVar: string } | null = null;
+  const walk = (dir: string): void => {
+    if (hit) return;
+    let entries: string[];
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const name of entries) {
+      if (hit) return;
+      if (name === 'node_modules' || name === 'patchstack' || name.startsWith('.')) continue;
+      const p = join(dir, name);
+      let st;
+      try {
+        st = statSync(p);
+      } catch {
+        continue;
+      }
+      if (st.isDirectory()) walk(p);
+      else if (/\.(?:ts|js|mjs|cjs)$/.test(name)) {
+        let src: string;
+        try {
+          src = readFileSync(p, 'utf8');
+        } catch {
+          continue;
+        }
+        const m = APP_RE.exec(src);
+        if (m) hit = { relPath: relative(cwd, p).replace(/\\/g, '/'), appVar: m[1]! };
+      }
+    }
+  };
+  walk(root);
+  return hit;
+}
+
+function detect(cwd: string): boolean {
+  return hasFastifyDep(cwd) && findFastifyApp(cwd) !== null;
+}
+
+function importSpecifier(fromRel: string, toRel: string): string {
+  let spec = relative(dirname(fromRel), toRel).replace(/\\/g, '/').replace(/\.(?:ts|js)$/, '');
+  if (!spec.startsWith('.')) spec = `./${spec}`;
+  return spec;
+}
+
+function wire(cwd: string, opts: WireOptions): WireResult {
+  const { changed, dir } = scaffoldGeneric(cwd, opts, 'fastify-plugin.ts');
+  const entry = findFastifyApp(cwd);
+  if (!entry) {
+    log('fastify detected but no `= fastify()` site found — scaffolded plugin; register it yourself: app.register(patchstackFastify)');
+    return { ok: true, changed };
+  }
+
+  const p = join(cwd, entry.relPath);
+  let s = read(p);
+  if (s.includes('patchstackFastify')) {
+    log(`fastify entry ${entry.relPath} already wired`);
+    return { ok: true, changed };
+  }
+
+  const spec = importSpecifier(entry.relPath, `${dir}/guard`);
+  const importLine = `import { patchstackFastify } from "${spec}";`;
+  const lines = s.split('\n');
+  let lastImport = -1;
+  for (let i = 0; i < lines.length; i++) if (/^\s*import\b/.test(lines[i] ?? '')) lastImport = i;
+  lines.splice(lastImport + 1, 0, importLine);
+  const appIdx = lines.findIndex((l) => APP_RE.test(l));
+  if (appIdx !== -1) {
+    lines.splice(appIdx + 1, 0, REGION, `${entry.appVar}.register(patchstackFastify);`, '// #endregion patchstack');
+  }
+  s = lines.join('\n');
+  writeFileSync(p, s);
+  changed.push(entry.relPath);
+  log(`patched ${entry.relPath} (${entry.appVar}.register(patchstackFastify))`);
+  return { ok: true, changed: [...new Set(changed)] };
+}
+
+function verify(cwd: string): VerifyResult {
+  const dir = existsSync(join(cwd, 'src')) ? 'src/patchstack' : 'patchstack';
+  const scaffolded = existsSync(join(cwd, dir, 'guard.ts'));
+  const entry = findFastifyApp(cwd);
+  const wired = entry ? read(join(cwd, entry.relPath)).includes('patchstackFastify') : false;
+  return {
+    wired: scaffolded && wired,
+    checks: [
+      { label: 'Fastify guard plugin scaffolded', ok: scaffolded, hint: 'run `patchstack-connect protect`' },
+      {
+        label: 'app.register(patchstackFastify) wired into the Fastify app',
+        ok: wired,
+        hint: 'add `app.register(patchstackFastify)` right after you create your fastify() app',
+      },
+    ],
+  };
+}
+
+export const fastifyAdapter: Adapter = {
+  name: 'fastify',
+  label: 'Fastify (Node)',
+  detect,
+  wire,
+  verify,
+};
diff --git a/src/protect/install/adapters/sveltekit.ts b/src/protect/install/adapters/sveltekit.ts
new file mode 100644
index 0000000..fee53e4
--- /dev/null
+++ b/src/protect/install/adapters/sveltekit.ts
@@ -0,0 +1,39 @@
+// Adapter: SvelteKit. Wires the guard as a server hook (`src/hooks.server.ts` → `handle`).
+import { join } from 'node:path';
+import { read } from '../util.js';
+import { wireSeam, verifySeam, type SeamSpec } from '../seam.js';
+import type { Adapter, WireOptions, WireResult, VerifyResult } from '../types.js';
+
+const SPEC: SeamSpec = {
+  templateName: 'sveltekit-hooks.ts',
+  candidates: ['src/hooks.server.ts', 'src/hooks.server.js'],
+  target: 'src/hooks.server.ts',
+  marker: 'patchstack-sveltekit',
+  planHint: 'add the guard to your `handle` (compose with `sequence()` from "@sveltejs/kit/hooks"), then: npx patchstack-connect protect --check',
+  seamLabel: 'SvelteKit server hook',
+};
+
+function detect(cwd: string): boolean {
+  try {
+    const pkg = JSON.parse(read(join(cwd, 'package.json')));
+    return Boolean({ ...pkg.dependencies, ...pkg.devDependencies }['@sveltejs/kit']);
+  } catch {
+    return false;
+  }
+}
+
+function wire(cwd: string, opts: WireOptions): WireResult {
+  return wireSeam(cwd, opts, SPEC);
+}
+
+function verify(cwd: string): VerifyResult {
+  return verifySeam(cwd, SPEC);
+}
+
+export const sveltekitAdapter: Adapter = {
+  name: 'sveltekit',
+  label: 'SvelteKit',
+  detect,
+  wire,
+  verify,
+};
diff --git a/src/protect/install/generic.ts b/src/protect/install/generic.ts
index 70178f7..685a7fd 100644
--- a/src/protect/install/generic.ts
+++ b/src/protect/install/generic.ts
@@ -14,12 +14,12 @@ function genericDir(cwd: string): string {
   return existsSync(join(cwd, 'src')) ? 'src/patchstack' : 'patchstack';
 }
 
-export function scaffoldGeneric(cwd: string, opts: WireOptions): { changed: string[]; dir: string } {
+export function scaffoldGeneric(cwd: string, opts: WireOptions, guardTemplate = 'generic-guard.ts'): { changed: string[]; dir: string } {
   const templates = templatesDir();
   const dir = genericDir(cwd);
   const dst = join(cwd, dir);
   mkdirSync(dst, { recursive: true });
-  copyFileSync(join(templates, 'generic-guard.ts'), join(dst, 'guard.ts'));
+  copyFileSync(join(templates, guardTemplate), join(dst, 'guard.ts'));
   const changed = [`${dir}/guard.ts`];
   const rulesDst = join(dst, 'rules.json');
   if (opts.demo || !existsSync(rulesDst)) {
diff --git a/src/protect/install/index.ts b/src/protect/install/index.ts
index 0ac155b..a8da0fd 100644
--- a/src/protect/install/index.ts
+++ b/src/protect/install/index.ts
@@ -9,12 +9,23 @@
 import { log } from './util.js';
 import { tanstackSupabaseAdapter } from './adapters/tanstack-supabase.js';
 import { nextAdapter } from './adapters/next.js';
+import { sveltekitAdapter } from './adapters/sveltekit.js';
+import { astroAdapter } from './adapters/astro.js';
+import { fastifyAdapter } from './adapters/fastify.js';
 import { expressAdapter } from './adapters/express.js';
 import { scaffoldGeneric, wiringPlan, genericVerify } from './generic.js';
 import type { Adapter, WireOptions, ProtectResult, VerifyReport } from './types.js';
 
-// Registry — order = match priority (most specific first). Add new stacks here.
-const ADAPTERS: Adapter[] = [tanstackSupabaseAdapter, nextAdapter, expressAdapter];
+// Registry — order = match priority (most specific first): framework meta-frameworks before the
+// bare server libraries (a SvelteKit/Astro app may also carry express/fastify as a transitive dep).
+const ADAPTERS: Adapter[] = [
+  tanstackSupabaseAdapter,
+  nextAdapter,
+  sveltekitAdapter,
+  astroAdapter,
+  fastifyAdapter,
+  expressAdapter,
+];
 
 /** Scaffold + wire the runtime guard into the app at `cwd`. Best-effort — never throws. */
 export function runProtect(cwd: string, opts: WireOptions = {}): ProtectResult {
diff --git a/src/protect/install/seam.ts b/src/protect/install/seam.ts
new file mode 100644
index 0000000..67fa152
--- /dev/null
+++ b/src/protect/install/seam.ts
@@ -0,0 +1,63 @@
+// Shared "seam-file is the guard" wiring, used by adapters whose framework has a single server hook
+// that IS the guard (SvelteKit `hooks.server.ts`, Astro `src/middleware.ts`). Scaffold the seam from
+// a template + co-locate patchstack.rules.json. An EXISTING seam file is never clobbered — we scaffold
+// the rules and print a plan instead (so a hand-written hook is preserved).
+
+import { existsSync, mkdirSync, copyFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { read, log, templatesDir } from './util.js';
+import type { WireOptions, WireResult, VerifyResult } from './types.js';
+
+export interface SeamSpec {
+  templateName: string; // template copied to the seam target when none exists
+  candidates: string[]; // existing seam files to look for, in order (repo-relative)
+  target: string; // where to create the seam if none exists (repo-relative)
+  marker: string; // #region marker id proving it's ours (e.g. 'patchstack-sveltekit')
+  planHint: string; // guidance when an existing seam file can't be safely edited
+  seamLabel: string; // human label for the check (e.g. 'SvelteKit hook')
+}
+
+function rulesRel(seamRel: string): string {
+  const d = dirname(seamRel);
+  return (d === '.' ? 'patchstack.rules.json' : `${d}/patchstack.rules.json`).replace(/\\/g, '/');
+}
+
+export function wireSeam(cwd: string, opts: WireOptions, spec: SeamSpec): WireResult {
+  const templates = templatesDir();
+  const existing = spec.candidates.find((c) => existsSync(join(cwd, c)));
+  const seamRel = existing ?? spec.target;
+  mkdirSync(dirname(join(cwd, seamRel)), { recursive: true });
+
+  // Rules co-locate next to the seam (the templates import ./patchstack.rules.json).
+  const rulesDst = join(cwd, rulesRel(seamRel));
+  const changed: string[] = [];
+  if (opts.demo || !existsSync(rulesDst)) {
+    copyFileSync(join(templates, opts.demo ? 'demo-rules.json' : 'rules.json'), rulesDst);
+    changed.push(rulesRel(seamRel));
+  }
+
+  const current = existing ? read(join(cwd, existing)) : '';
+  if (existing && !current.includes(spec.marker)) {
+    log(`existing ${existing} left untouched — scaffolded ${rulesRel(seamRel)}; ${spec.planHint}`);
+    return { ok: true, changed };
+  }
+
+  copyFileSync(join(templates, spec.templateName), join(cwd, seamRel));
+  changed.push(seamRel);
+  log(existing ? `refreshed ${seamRel}` : `scaffolded ${seamRel}`);
+  return { ok: true, changed: [...new Set(changed)] };
+}
+
+export function verifySeam(cwd: string, spec: SeamSpec): VerifyResult {
+  const existing = spec.candidates.find((c) => existsSync(join(cwd, c)));
+  const seamRel = existing ?? spec.target;
+  const present = existing ? read(join(cwd, existing)).includes(spec.marker) : false;
+  const rulesPresent = existsSync(join(cwd, rulesRel(seamRel)));
+  return {
+    wired: present && rulesPresent,
+    checks: [
+      { label: `${spec.seamLabel} present`, ok: present, hint: `run \`patchstack-connect protect\` (writes ${spec.target})` },
+      { label: 'rules co-located with the guard', ok: rulesPresent, hint: 'run `patchstack-connect protect`' },
+    ],
+  };
+}
diff --git a/src/protect/templates/astro-middleware.ts b/src/protect/templates/astro-middleware.ts
new file mode 100644
index 0000000..a03f784
--- /dev/null
+++ b/src/protect/templates/astro-middleware.ts
@@ -0,0 +1,33 @@
+// Patchstack runtime guard for Astro — middleware. Managed by `patchstack-connect protect`.
+// Runs the request-phase WAF (+ egress SSRF) and screens the response body/headers for every request.
+// If you already have middleware, compose them with `sequence()` from "astro:middleware".
+import type { MiddlewareHandler } from "astro";
+import { createProtection } from "@patchstack/connect/protect";
+import fallbackRules from "./patchstack.rules.json";
+
+let _protection: Awaited<ReturnType<typeof createProtection>> | undefined;
+async function getProtection() {
+  if (!_protection) {
+    const mode = process.env.PATCHSTACK_MODE === "dry-run" ? "dry-run" : "block";
+    const token = process.env.PATCHSTACK_WAF_TOKEN;
+    const siteUuid = process.env.PATCHSTACK_SITE_UUID;
+    const common = { mode, egress: true } as const;
+    _protection = await createProtection(
+      siteUuid
+        ? { ...common, siteUuid, rules: fallbackRules as never, cacheDir: ".patchstack" }
+        : token
+          ? { ...common, token, cacheDir: ".patchstack" }
+          : { ...common, rules: fallbackRules as never },
+    );
+  }
+  return _protection;
+}
+
+// #region patchstack-astro (managed by patchstack-connect protect — do not edit)
+export const onRequest: MiddlewareHandler = async (context, next) => {
+  const protection = await getProtection();
+  const blocked = await protection.fetchGuard()(context.request);
+  if (blocked) return blocked; // 403 — blocked before it reaches your route
+  return protection.screenResponse(await next());
+};
+// #endregion patchstack-astro
diff --git a/src/protect/templates/fastify-plugin.ts b/src/protect/templates/fastify-plugin.ts
new file mode 100644
index 0000000..d8d949a
--- /dev/null
+++ b/src/protect/templates/fastify-plugin.ts
@@ -0,0 +1,46 @@
+// Patchstack runtime guard for Fastify — plugin. Managed by `patchstack-connect protect`.
+// Register it once (`app.register(patchstackFastify)`); it adds a preHandler hook that runs the
+// request-phase WAF (+ egress SSRF) on every request. Fastify's request/reply aren't Web-Fetch
+// shaped, so we reconstruct a Request from the parsed fastify request and run the fetch guard.
+import { createProtection } from "@patchstack/connect/protect";
+import fallbackRules from "./rules.json";
+
+let _protection: Awaited<ReturnType<typeof createProtection>> | undefined;
+async function getProtection() {
+  if (!_protection) {
+    const mode = process.env.PATCHSTACK_MODE === "dry-run" ? "dry-run" : "block";
+    const token = process.env.PATCHSTACK_WAF_TOKEN;
+    const siteUuid = process.env.PATCHSTACK_SITE_UUID;
+    const common = { mode, egress: true } as const;
+    _protection = await createProtection(
+      siteUuid
+        ? { ...common, siteUuid, rules: fallbackRules as never, cacheDir: ".patchstack" }
+        : token
+          ? { ...common, token, cacheDir: ".patchstack" }
+          : { ...common, rules: fallbackRules as never },
+    );
+  }
+  return _protection;
+}
+
+// #region patchstack-fastify (managed by patchstack-connect protect — do not edit)
+export async function patchstackFastify(fastify: any) {
+  const protection = await getProtection();
+  const guard = protection.fetchGuard();
+  fastify.addHook("preHandler", async (request: any, reply: any) => {
+    const method = (request.method ?? "GET").toUpperCase();
+    const host = request.headers?.host ?? "localhost";
+    const url = `http://${host}${request.url ?? "/"}`;
+    const hasBody = method !== "GET" && method !== "HEAD" && request.body != null;
+    const body = hasBody ? (typeof request.body === "string" ? request.body : JSON.stringify(request.body)) : undefined;
+    const blocked = await guard(new Request(url, { method, headers: request.headers as HeadersInit, body }));
+    if (blocked) {
+      const contentType = blocked.headers.get("content-type");
+      reply.code(blocked.status);
+      if (contentType) reply.header("content-type", contentType);
+      reply.send(await blocked.text());
+      return reply; // stop the request here
+    }
+  });
+}
+// #endregion patchstack-fastify
diff --git a/src/protect/templates/sveltekit-hooks.ts b/src/protect/templates/sveltekit-hooks.ts
new file mode 100644
index 0000000..7fcfeac
--- /dev/null
+++ b/src/protect/templates/sveltekit-hooks.ts
@@ -0,0 +1,33 @@
+// Patchstack runtime guard for SvelteKit — server hook. Managed by `patchstack-connect protect`.
+// Runs the request-phase WAF (+ egress SSRF) and screens the response body/headers for every request.
+// If you already have a `handle`, compose them with `sequence()` from "@sveltejs/kit/hooks".
+import type { Handle } from "@sveltejs/kit";
+import { createProtection } from "@patchstack/connect/protect";
+import fallbackRules from "./patchstack.rules.json";
+
+let _protection: Awaited<ReturnType<typeof createProtection>> | undefined;
+async function getProtection() {
+  if (!_protection) {
+    const mode = process.env.PATCHSTACK_MODE === "dry-run" ? "dry-run" : "block";
+    const token = process.env.PATCHSTACK_WAF_TOKEN;
+    const siteUuid = process.env.PATCHSTACK_SITE_UUID;
+    const common = { mode, egress: true } as const;
+    _protection = await createProtection(
+      siteUuid
+        ? { ...common, siteUuid, rules: fallbackRules as never, cacheDir: ".patchstack" }
+        : token
+          ? { ...common, token, cacheDir: ".patchstack" }
+          : { ...common, rules: fallbackRules as never },
+    );
+  }
+  return _protection;
+}
+
+// #region patchstack-sveltekit (managed by patchstack-connect protect — do not edit)
+export const handle: Handle = async ({ event, resolve }) => {
+  const protection = await getProtection();
+  const blocked = await protection.fetchGuard()(event.request);
+  if (blocked) return blocked; // 403 — blocked before it reaches your route
+  return protection.screenResponse(await resolve(event));
+};
+// #endregion patchstack-sveltekit
diff --git a/tests/protect/adapters.test.ts b/tests/protect/adapters.test.ts
index d0803bb..95cb717 100644
--- a/tests/protect/adapters.test.ts
+++ b/tests/protect/adapters.test.ts
@@ -79,3 +79,95 @@ describe('Next.js adapter', () => {
     }
   });
 });
+
+describe('SvelteKit adapter', () => {
+  it('scaffolds src/hooks.server.ts + co-located rules when none exists', () => {
+    const dir = tmp('ps-svelte-');
+    writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ name: 'x', devDependencies: { '@sveltejs/kit': '^2.0.0' } }));
+    try {
+      const res: any = runProtect(dir);
+      expect(res.status).toBe('wired');
+      expect(res.adapter).toBe('sveltekit');
+      const hooks = read(dir, 'src/hooks.server.ts');
+      expect(hooks).toContain('patchstack-sveltekit');
+      expect(hooks).toContain('export const handle');
+      expect(existsSync(path.join(dir, 'src/patchstack.rules.json'))).toBe(true);
+      expect(runVerify(dir).wired).toBe(true);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('does NOT overwrite an existing hooks.server.ts (verify not wired)', () => {
+    const dir = tmp('ps-svelte2-');
+    writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ name: 'x', devDependencies: { '@sveltejs/kit': '^2.0.0' } }));
+    mkdirSync(path.join(dir, 'src'), { recursive: true });
+    const own = 'export const handle = async ({ event, resolve }) => resolve(event);\n';
+    writeFileSync(path.join(dir, 'src/hooks.server.ts'), own);
+    try {
+      runProtect(dir);
+      expect(read(dir, 'src/hooks.server.ts')).toBe(own); // untouched
+      expect(existsSync(path.join(dir, 'src/patchstack.rules.json'))).toBe(true);
+      expect(runVerify(dir).wired).toBe(false);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('Astro adapter', () => {
+  it('scaffolds src/middleware.ts + co-located rules when none exists', () => {
+    const dir = tmp('ps-astro-');
+    writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ name: 'x', dependencies: { astro: '^4.0.0' } }));
+    try {
+      const res: any = runProtect(dir);
+      expect(res.status).toBe('wired');
+      expect(res.adapter).toBe('astro');
+      const mw = read(dir, 'src/middleware.ts');
+      expect(mw).toContain('patchstack-astro');
+      expect(mw).toContain('export const onRequest');
+      expect(existsSync(path.join(dir, 'src/patchstack.rules.json'))).toBe(true);
+      expect(runVerify(dir).wired).toBe(true);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('Fastify adapter', () => {
+  function fastifyApp(): string {
+    const dir = tmp('ps-fastify-');
+    writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ name: 'x', dependencies: { fastify: '^4.26.0' } }));
+    mkdirSync(path.join(dir, 'src'), { recursive: true });
+    writeFileSync(path.join(dir, 'src/server.ts'), "import Fastify from 'fastify';\nconst app = fastify();\napp.listen({ port: 3000 });\n");
+    return dir;
+  }
+
+  it('scaffolds the plugin and registers app.register(patchstackFastify) after the fastify() app', () => {
+    const dir = fastifyApp();
+    try {
+      const res: any = runProtect(dir);
+      expect(res.status).toBe('wired');
+      expect(res.adapter).toBe('fastify');
+      expect(read(dir, 'src/patchstack/guard.ts')).toContain('patchstackFastify');
+      const server = read(dir, 'src/server.ts');
+      expect(server).toContain('import { patchstackFastify } from "./patchstack/guard";');
+      expect(server).toContain('app.register(patchstackFastify);');
+      expect(server.indexOf('const app = fastify()')).toBeLessThan(server.indexOf('app.register(patchstackFastify)'));
+      expect(runVerify(dir).wired).toBe(true);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('is idempotent (re-run does not duplicate the registration)', () => {
+    const dir = fastifyApp();
+    try {
+      runProtect(dir);
+      runProtect(dir);
+      expect(count(read(dir, 'src/server.ts'), 'app.register(patchstackFastify)')).toBe(1);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});