@sveltejs/adapter-netlify 6.0.3 → 7.0.0-next.0

package/files/edge.js

@@ -1,39 +1,28 @@
-import { Server } from '0SERVER';
-import { manifest } from 'MANIFEST';
-
+import { Server } from "0SERVER";
+import { manifest } from "MANIFEST";
+//#region src/edge.js
 const server = new Server(manifest);
-
 /**
- * We don't know the origin until we receive a request, but
- * that's guaranteed to happen before we call `read`
- * @type {string}
- */
+* We don't know the origin until we receive a request, but
+* that's guaranteed to happen before we call `read`
+* @type {string}
+*/
 let origin;
-
 const initialized = server.init({
-	// @ts-ignore
 	env: Deno.env.toObject(),
 	read: async (file) => {
 		const url = `${origin}/${file}`;
 		const response = await fetch(url);
-
-		if (!response.ok) {
-			throw new Error(
-				`read(...) failed: could not fetch ${url} (${response.status} ${response.statusText})`
-			);
-		}
-
+		if (!response.ok) throw new Error(`read(...) failed: could not fetch ${url} (${response.status} ${response.statusText})`);
 		return response.body;
 	}
 });
-
 /** @type {import('@netlify/edge-functions').EdgeFunction} */
 async function handler(request, context) {
 	if (!origin) {
 		origin = new URL(request.url).origin;
 		await initialized;
 	}
-
 	return server.respond(request, {
 		platform: { context },
 		getClientAddress() {
@@ -41,5 +30,5 @@ async function handler(request, context) {
 		}
 	});
 }
-
+//#endregion
 export { handler as default };

package/files/serverless.js

@@ -1,40 +1,35 @@
-import './shims.js';
-import { Server } from '0SERVER';
-import { createReadStream } from 'node:fs';
-import { Readable } from 'node:stream';
-import process from 'node:process';
-import 'node:buffer';
-import 'node:crypto';
-
+import { Server } from "0SERVER";
+import { createReadStream } from "node:fs";
+import { Readable } from "node:stream";
+import process from "node:process";
+//#region ../kit/src/exports/node/index.js
 /**
- * Converts a file on disk to a readable stream
- * @param {string} file
- * @returns {ReadableStream}
- * @since 2.4.0
- */
+* Converts a file on disk to a readable stream
+* @param {string} file
+* @returns {ReadableStream}
+* @since 2.4.0
+*/
 function createReadableStream(file) {
-	return /** @type {ReadableStream} */ (Readable.toWeb(createReadStream(file)));
+	return Readable.toWeb(createReadStream(file));
 }
-
+//#endregion
+//#region src/serverless.js
 /**
- * @param {import('@sveltejs/kit').SSRManifest} manifest
- * @returns {(request: Request, context: import('@netlify/functions').Context) => Promise<Response>}
- */
+* @param {import('@sveltejs/kit').SSRManifest} manifest
+* @returns {(request: Request, context: import('@netlify/functions').Context) => Promise<Response>}
+*/
 function init(manifest) {
 	const server = new Server(manifest);
-
 	/** @type {Promise<void> | null} */
 	let init_promise = server.init({
-		env: /** @type {Record<string, string>} */ (process.env),
+		env: process.env,
 		read: (file) => createReadableStream(`.netlify/server/${file}`)
 	});
-
 	return async (request, context) => {
 		if (init_promise !== null) {
 			await init_promise;
 			init_promise = null;
 		}
-
 		return server.respond(request, {
 			platform: { context },
 			getClientAddress() {
@@ -43,5 +38,5 @@ function init(manifest) {
 		});
 	};
 }
-
+//#endregion
 export { init };

package/index.js

@@ -1,11 +1,11 @@
-/** @import { BuildOptions } from 'esbuild' */
-import { appendFileSync, existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { join, resolve, posix } from 'node:path';
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, posix } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { builtinModules } from 'node:module';
 import process from 'node:process';
-import esbuild from 'esbuild';
 import toml from '@iarna/toml';
+import { build } from 'rolldown';
+import { matches, get_publish_directory, s } from './utils.js';
 
 /**
  * @typedef {{
@@ -14,6 +14,9 @@ import toml from '@iarna/toml';
  * } & toml.JsonMap} NetlifyConfig
  */
 
+const pkg = JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf-8'));
+const adapter_version = pkg.version;
+
 const name = '@sveltejs/adapter-netlify';
 const files = fileURLToPath(new URL('./files', import.meta.url).href);
 
@@ -21,13 +24,16 @@ const edge_set_in_env_var =
 	process.env.NETLIFY_SVELTEKIT_USE_EDGE === 'true' ||
 	process.env.NETLIFY_SVELTEKIT_USE_EDGE === '1';
 
+const netlify_framework_config_path = '.netlify/v1/config.json';
+const netlify_framework_serverless_path = '.netlify/v1/functions';
+const netlify_framework_edge_path = '.netlify/v1/edge-functions';
+
 const FUNCTION_PREFIX = 'sveltekit-';
 
 /** @type {import('./index.js').default} */
 export default function ({ split = false, edge = edge_set_in_env_var } = {}) {
 	return {
 		name,
-		/** @param {import('@sveltejs/kit').Builder} builder */
 		async adapt(builder) {
 			if (!builder.routes) {
 				throw new Error(
@@ -55,11 +61,14 @@ export default function ({ split = false, edge = edge_set_in_env_var } = {}) {
 
 			// empty out existing build directories
 			builder.rimraf(publish);
+			builder.rimraf('.netlify/v1');
+
+			// clean up legacy directories from older adapter versions to avoid
+			// gnarly edge cases when an existing project is upgraded to this version
 			builder.rimraf('.netlify/edge-functions');
 			builder.rimraf('.netlify/server');
 			builder.rimraf('.netlify/package.json');
 			builder.rimraf('.netlify/serverless.js');
-
 			if (existsSync('.netlify/functions-internal')) {
 				for (const file of readdirSync('.netlify/functions-internal')) {
 					if (file.startsWith(FUNCTION_PREFIX)) {
@@ -75,13 +84,13 @@ export default function ({ split = false, edge = edge_set_in_env_var } = {}) {
 			builder.writeClient(publish_dir);
 			builder.writePrerendered(publish_dir);
 
-			builder.log.minor('Writing custom headers...');
-			const headers_file = join(publish, '_headers');
-			builder.copy('_headers', headers_file);
-			appendFileSync(
-				headers_file,
-				`\n\n/${builder.getAppPath()}/immutable/*\n  cache-control: public\n  cache-control: immutable\n  cache-control: max-age=31536000\n`
-			);
+			// Copy user's custom _headers file if it exists
+			if (existsSync('_headers')) {
+				builder.copy('_headers', join(publish, '_headers'));
+			}
+
+			builder.log.minor('Writing Netlify config...');
+			write_frameworks_config({ builder });
 
 			if (edge) {
 				if (split) {
@@ -90,7 +99,7 @@ export default function ({ split = false, edge = edge_set_in_env_var } = {}) {
 
 				await generate_edge_functions({ builder });
 			} else {
-				generate_lambda_functions({ builder, split, publish });
+				generate_serverless_functions({ builder, split, publish });
 			}
 		},
 
@@ -100,131 +109,24 @@ export default function ({ split = false, edge = edge_set_in_env_var } = {}) {
 		}
 	};
 }
-/**
- * @param { object } params
- * @param {import('@sveltejs/kit').Builder} params.builder
- */
-async function generate_edge_functions({ builder }) {
-	const tmp = builder.getBuildDirectory('netlify-tmp');
-	builder.rimraf(tmp);
-	builder.mkdirp(tmp);
-
-	builder.mkdirp('.netlify/edge-functions');
-
-	builder.log.minor('Generating Edge Function...');
-	const relativePath = posix.relative(tmp, builder.getServerDirectory());
-
-	builder.copy(`${files}/edge.js`, `${tmp}/entry.js`, {
-		replace: {
-			'0SERVER': `${relativePath}/index.js`,
-			MANIFEST: './manifest.js'
-		}
-	});
-
-	const manifest = builder.generateManifest({
-		relativePath
-	});
-
-	writeFileSync(`${tmp}/manifest.js`, `export const manifest = ${manifest};\n`);
-
-	/** @type {{ assets: Set<string> }} */
-	// we have to prepend the file:// protocol because Windows doesn't support absolute path imports
-	const { assets } = (await import(`file://${tmp}/manifest.js`)).manifest;
-
-	const path = '/*';
-	// We only need to specify paths without the trailing slash because
-	// Netlify will handle the optional trailing slash for us
-	const excluded = [
-		// Contains static files
-		`/${builder.getAppPath()}/immutable/*`,
-		`/${builder.getAppPath()}/version.json`,
-		...builder.prerendered.paths,
-		...Array.from(assets).flatMap((asset) => {
-			if (asset.endsWith('/index.html')) {
-				const dir = asset.replace(/\/index\.html$/, '');
-				return [
-					`${builder.config.kit.paths.base}/${asset}`,
-					`${builder.config.kit.paths.base}/${dir}`
-				];
-			}
-			return `${builder.config.kit.paths.base}/${asset}`;
-		}),
-		// Should not be served by SvelteKit at all
-		'/.netlify/*'
-	];
-
-	/** @type {import('@netlify/edge-functions').Manifest} */
-	const edge_manifest = {
-		functions: [
-			{
-				function: 'render',
-				path,
-				excludedPath: /** @type {`/${string}`[]} */ (excluded)
-			}
-		],
-		version: 1
-	};
-
-	/** @type {BuildOptions} */
-	const esbuild_config = {
-		bundle: true,
-		format: 'esm',
-		platform: 'browser',
-		sourcemap: 'linked',
-		target: 'es2020',
-		loader: {
-			'.wasm': 'copy',
-			'.woff': 'copy',
-			'.woff2': 'copy',
-			'.ttf': 'copy',
-			'.eot': 'copy',
-			'.otf': 'copy'
-		},
-		// Node built-ins are allowed, but must be prefixed with `node:`
-		// https://docs.netlify.com/edge-functions/api/#runtime-environment
-		external: builtinModules.map((id) => `node:${id}`),
-		alias: Object.fromEntries(builtinModules.map((id) => [id, `node:${id}`]))
-	};
-	await Promise.all([
-		esbuild.build({
-			entryPoints: [`${tmp}/entry.js`],
-			outfile: '.netlify/edge-functions/render.js',
-			...esbuild_config
-		}),
-		builder.hasServerInstrumentationFile() &&
-			esbuild.build({
-				entryPoints: [`${builder.getServerDirectory()}/instrumentation.server.js`],
-				outfile: '.netlify/edge/instrumentation.server.js',
-				...esbuild_config
-			})
-	]);
 
-	if (builder.hasServerInstrumentationFile()) {
-		builder.instrument({
-			entrypoint: '.netlify/edge-functions/render.js',
-			instrumentation: '.netlify/edge/instrumentation.server.js',
-			start: '.netlify/edge/start.js'
-		});
-	}
-
-	writeFileSync('.netlify/edge-functions/manifest.json', JSON.stringify(edge_manifest));
-}
 /**
  * @param { object } params
  * @param {import('@sveltejs/kit').Builder} params.builder
  * @param { string } params.publish
  * @param { boolean } params.split
  */
-function generate_lambda_functions({ builder, publish, split }) {
-	builder.mkdirp('.netlify/functions-internal/.svelte-kit');
+function generate_serverless_functions({ builder, publish, split }) {
+	// https://docs.netlify.com/build/frameworks/frameworks-api/#netlifyv1functions
+	builder.mkdirp(netlify_framework_serverless_path);
 
-	builder.writeServer('.netlify/server');
+	builder.writeServer('.netlify/v1/server');
 
 	const replace = {
 		'0SERVER': './server/index.js' // digit prefix prevents CJS build from using this as a variable name, which would also get replaced
 	};
 
-	builder.copy(files, '.netlify', { replace, filter: (name) => !name.endsWith('edge.js') });
+	builder.copy(files, '.netlify/v1', { replace, filter: (file) => !file.endsWith('edge.js') });
 
 	builder.log.minor('Generating serverless functions...');
 
@@ -260,7 +162,9 @@ function generate_lambda_functions({ builder, publish, split }) {
 
 			// skip routes with identical patterns, they were already folded into another function
 			if (seen.has(pattern)) continue;
-			seen.add(pattern);
+
+			const patterns = [pattern, `${pattern === '/' ? '' : pattern}/__data.json`];
+			patterns.forEach((p) => seen.add(p));
 
 			// figure out which lower priority routes should be considered fallbacks
 			for (let j = i + 1; j < builder.routes.length; j += 1) {
@@ -275,12 +179,18 @@ function generate_lambda_functions({ builder, publish, split }) {
 			generate_serverless_function({
 				builder,
 				routes,
-				patterns: [pattern, `${pattern === '/' ? '' : pattern}/__data.json`],
+				patterns,
 				name
 			});
 		}
 
-		// TODO: add a catch-all to display a 404 page if no other functions are invoked, similar to the Vercel adapter
+		generate_serverless_function({
+			builder,
+			routes: [],
+			patterns: ['/*'],
+			name: `${FUNCTION_PREFIX}catch-all`,
+			exclude: Array.from(seen)
+		});
 	} else {
 		generate_serverless_function({
 			builder,
@@ -298,75 +208,43 @@ function generate_lambda_functions({ builder, publish, split }) {
 	}
 }
 
+/**
+ * @returns {NetlifyConfig | null}
+ */
 function get_netlify_config() {
 	if (!existsSync('netlify.toml')) return null;
 
 	try {
-		return /** @type {NetlifyConfig} */ (toml.parse(readFileSync('netlify.toml', 'utf-8')));
+		return toml.parse(readFileSync('netlify.toml', 'utf-8'));
 	} catch (err) {
-		err.message = `Error parsing netlify.toml: ${err.message}`;
-		throw err;
-	}
-}
-
-/**
- * @param {NetlifyConfig | null} netlify_config
- * @param {import('@sveltejs/kit').Builder} builder
- **/
-function get_publish_directory(netlify_config, builder) {
-	if (netlify_config) {
-		if (!netlify_config.build?.publish) {
-			builder.log.minor('No publish directory specified in netlify.toml, using default');
-			return;
+		if (err instanceof Error) {
+			throw new Error(`Failed to parse netlify.toml: ${err.message}`, { cause: err });
 		}
-
-		if (resolve(netlify_config.build.publish) === process.cwd()) {
-			throw new Error(
-				'The publish directory cannot be set to the site root. Please change it to another value such as "build" in netlify.toml.'
-			);
-		}
-		return netlify_config.build.publish;
+		throw err;
 	}
-
-	builder.log.warn(
-		'No netlify.toml found. Using default publish directory. Consult https://svelte.dev/docs/kit/adapter-netlify#usage for more details'
-	);
 }
 
 /**
- * @typedef {{ rest: boolean, dynamic: boolean, content: string }} RouteSegment
- */
-
-/**
- * @param {RouteSegment[]} a
- * @param {RouteSegment[]} b
- * @returns {boolean}
+ * Writes the Netlify Frameworks API config file
+ * https://docs.netlify.com/build/frameworks/frameworks-api/
+ * @param {{ builder: import('@sveltejs/kit').Builder }} params
  */
-function matches(a, b) {
-	if (a[0] && b[0]) {
-		if (b[0].rest) {
-			if (b.length === 1) return true;
-
-			const next_b = b.slice(1);
-
-			for (let i = 0; i < a.length; i += 1) {
-				if (matches(a.slice(i), next_b)) return true;
+function write_frameworks_config({ builder }) {
+	// https://docs.netlify.com/build/frameworks/frameworks-api/#headers
+	/** @type {{ headers: Array<{ for: string, values: Record<string, string> }> }} */
+	const config = {
+		headers: [
+			{
+				for: `/${builder.getAppPath()}/immutable/*`,
+				values: {
+					'cache-control': 'public, immutable, max-age=31536000'
+				}
 			}
+		]
+	};
 
-			return false;
-		}
-
-		if (!b[0].dynamic) {
-			if (!a[0].dynamic && a[0].content !== b[0].content) return false;
-		}
-
-		if (a.length === 1 && b.length === 1) return true;
-		return matches(a.slice(1), b.slice(1));
-	} else if (a[0]) {
-		return a.length === 1 && a[0].rest;
-	} else {
-		return b.length === 1 && b[0].rest;
-	}
+	builder.mkdirp('.netlify/v1');
+	writeFileSync(netlify_framework_config_path, s(config));
 }
 
 /**
@@ -375,30 +253,31 @@ function matches(a, b) {
  *   builder: import('@sveltejs/kit').Builder,
  *   routes: import('@sveltejs/kit').RouteDefinition[] | undefined,
  *   patterns: string[],
- *   name: string
+ *   name: string,
+ *   exclude?: string[]
  * }} opts
  */
-function generate_serverless_function({ builder, routes, patterns, name }) {
+function generate_serverless_function({ builder, routes, patterns, name, exclude }) {
 	const manifest = builder.generateManifest({
 		relativePath: '../server',
 		routes
 	});
 
 	const fn = generate_serverless_function_module(manifest);
-	const config = generate_config_export(patterns);
+	const config = generate_config_export(patterns, exclude);
 
 	if (builder.hasServerInstrumentationFile()) {
-		writeFileSync(`.netlify/functions-internal/${name}.mjs`, fn);
+		writeFileSync(`${netlify_framework_serverless_path}/${name}.mjs`, fn);
 		builder.instrument({
-			entrypoint: `.netlify/functions-internal/${name}.mjs`,
-			instrumentation: '.netlify/server/instrumentation.server.js',
-			start: `.netlify/functions-start/${name}.start.mjs`,
+			entrypoint: `${netlify_framework_serverless_path}/${name}.mjs`,
+			instrumentation: '.netlify/v1/server/instrumentation.server.js',
+			start: `.netlify/v1/server/${name}.start.mjs`,
 			module: {
 				generateText: generate_traced_module(config)
 			}
 		});
 	} else {
-		writeFileSync(`.netlify/functions-internal/${name}.mjs`, `${fn}\n${config}`);
+		writeFileSync(`${netlify_framework_serverless_path}/${name}.mjs`, `${fn}\n${config}`);
 	}
 }
 
@@ -414,16 +293,23 @@ export default init(${manifest});
 `;
 }
 
+const generator_string = `@sveltejs/adapter-netlify@${adapter_version}`;
+
 /**
  * @param {string[]} patterns
+ * @param {string[]} [exclude]
  * @returns {string}
  */
-function generate_config_export(patterns) {
+function generate_config_export(patterns, exclude = []) {
 	// TODO: add a human friendly name for the function https://docs.netlify.com/build/frameworks/frameworks-api/#configuration-options-2
+
+	// https://docs.netlify.com/build/frameworks/frameworks-api/#configuration-options-2
 	return `\
 export const config = {
-	path: [${patterns.map((s) => JSON.stringify(s)).join(', ')}],
-	excludedPath: "/.netlify/*",
+	name: 'SvelteKit server',
+	generator: '${generator_string}',
+	path: [${patterns.map(s).join(', ')}],
+	excludedPath: [${['/.netlify/*', ...exclude].map(s).join(', ')}],
 	preferStatic: true
 };
 `;
@@ -436,10 +322,135 @@ export const config = {
 function generate_traced_module(config) {
 	return ({ instrumentation, start }) => {
 		return `\
-import './${instrumentation}';
-const { default: _0 } = await import('./${start}');
+import '../server/${instrumentation}';
+const { default: _0 } = await import('../server/${start}');
 export { _0 as default };
 
 ${config}`;
 	};
 }
+
+/** @satisfies {import('rolldown').BuildOptions} */
+const rolldown_config = {
+	platform: 'browser',
+	output: {
+		sourcemap: true,
+		codeSplitting: false
+	},
+	transform: {
+		target: 'es2022'
+	},
+	// Node built-ins are allowed, but must be prefixed with `node:`
+	// https://docs.netlify.com/edge-functions/api/#runtime-environment
+	external: builtinModules.map((id) => `node:${id}`),
+	resolve: {
+		alias: Object.fromEntries(builtinModules.map((id) => [id, `node:${id}`]))
+	}
+};
+
+/**
+ * @param { object } params
+ * @param {import('@sveltejs/kit').Builder} params.builder
+ */
+async function generate_edge_functions({ builder }) {
+	const tmp = builder.getBuildDirectory('netlify-tmp');
+	builder.rimraf(tmp);
+	builder.mkdirp(tmp);
+
+	// https://docs.netlify.com/build/frameworks/frameworks-api/#edge-functions
+	builder.mkdirp('.netlify/v1/edge-functions');
+
+	builder.log.minor('Generating Edge Function...');
+	const relativePath = posix.relative(tmp, builder.getServerDirectory());
+
+	builder.copy(`${files}/edge.js`, `${tmp}/entry.js`, {
+		replace: {
+			'0SERVER': `${relativePath}/index.js`,
+			MANIFEST: './manifest.js'
+		}
+	});
+
+	const manifest = builder.generateManifest({
+		relativePath
+	});
+
+	writeFileSync(`${tmp}/manifest.js`, `export const manifest = ${manifest};\n`);
+
+	/** @type {{ assets: Set<string> }} */
+	// we have to prepend the file:// protocol because Windows doesn't support absolute path imports
+	const { assets } = (await import(`file://${tmp}/manifest.js`)).manifest;
+
+	const path = '/*';
+	// We only need to specify paths without the trailing slash because
+	// Netlify will handle the optional trailing slash for us
+	const excluded_paths = [
+		// Contains static files
+		`/${builder.getAppPath()}/immutable/*`,
+		`/${builder.getAppPath()}/version.json`,
+		...builder.prerendered.paths,
+		...Array.from(assets).flatMap((asset) => {
+			if (asset.endsWith('/index.html')) {
+				const dir = asset.replace(/\/index\.html$/, '');
+				return [
+					`${builder.config.kit.paths.base}/${asset}`,
+					`${builder.config.kit.paths.base}/${dir}`
+				];
+			}
+			return `${builder.config.kit.paths.base}/${asset}`;
+		}),
+		// Should not be served by SvelteKit at all
+		'/.netlify/*'
+	];
+
+	await Promise.all([
+		build({
+			...rolldown_config,
+			input: `${tmp}/entry.js`,
+			output: {
+				...rolldown_config.output,
+				file: `${netlify_framework_edge_path}/${FUNCTION_PREFIX}render.js`
+			}
+		}),
+		builder.hasServerInstrumentationFile() &&
+			build({
+				...rolldown_config,
+				input: `${builder.getServerDirectory()}/instrumentation.server.js`,
+				output: {
+					...rolldown_config.output,
+					file: `${netlify_framework_edge_path}/${FUNCTION_PREFIX}instrumentation.server.js`
+				}
+			})
+	]);
+
+	if (builder.hasServerInstrumentationFile()) {
+		builder.instrument({
+			entrypoint: `${netlify_framework_edge_path}/${FUNCTION_PREFIX}render.js`,
+			instrumentation: `${netlify_framework_edge_path}/${FUNCTION_PREFIX}instrumentation.server.js`,
+			start: `${netlify_framework_edge_path}/${FUNCTION_PREFIX}start.js`
+		});
+	}
+
+	add_edge_function_config({ builder, path, excluded_paths });
+}
+
+/**
+ * Adds edge function configuration to the Frameworks API config file `config.json`
+ * https://docs.netlify.com/build/frameworks/frameworks-api/#netlifyv1edge-functions
+ * @param {{ builder: import('@sveltejs/kit').Builder, path: string, excluded_paths: string[] }} params
+ */
+function add_edge_function_config({ path, excluded_paths }) {
+	const config = JSON.parse(readFileSync(netlify_framework_config_path, 'utf-8'));
+
+	// https://docs.netlify.com/build/frameworks/frameworks-api/#configuration-options-1
+	config.edge_functions = [
+		{
+			function: `${FUNCTION_PREFIX}render`,
+			name: 'SvelteKit server',
+			generator: generator_string,
+			path,
+			excludedPath: excluded_paths
+		}
+	];
+
+	writeFileSync(netlify_framework_config_path, s(config));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/adapter-netlify",
-  "version": "6.0.3",
+  "version": "7.0.0-next.0",
   "description": "A SvelteKit adapter that creates a Netlify app",
   "keywords": [
     "adapter",
@@ -34,7 +34,7 @@
   ],
   "dependencies": {
     "@iarna/toml": "^2.2.5",
-    "esbuild": "^0.25.4"
+    "rolldown": "^1.0.0-rc.6"
   },
   "devDependencies": {
     "@netlify/dev": "^4.11.2",
@@ -42,26 +42,21 @@
     "@netlify/functions": "^5.0.0",
     "@netlify/node-cookies": "^0.1.0",
     "@netlify/types": "^2.1.0",
-    "@rollup/plugin-commonjs": "^29.0.0",
-    "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-node-resolve": "^16.0.0",
-    "@sveltejs/vite-plugin-svelte": "^6.0.0-next.3",
-    "@types/node": "^18.19.119",
-    "rollup": "^4.14.2",
-    "typescript": "^5.3.3",
-    "vitest": "^4.0.0",
-    "@sveltejs/kit": "^2.53.0"
+    "@types/node": "^22.19.19",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.7",
+    "@sveltejs/kit": "^3.0.0-next.0"
   },
   "peerDependencies": {
     "@sveltejs/kit": "^2.31.0"
   },
   "scripts": {
-    "dev": "rollup -cw",
-    "build": "rollup -c",
+    "dev": "rolldown -cw",
+    "build": "rolldown -c",
     "check": "tsc",
     "lint": "prettier --check .",
     "format": "pnpm lint --write",
-    "test": "pnpm test:integration",
+    "test": "pnpm test:unit && pnpm test:integration",
     "test:unit": "vitest run",
     "test:integration": "pnpm build && pnpm -r --workspace-concurrency 1 --filter=\"./test/**\" test"
   }

package/files/shims.js

@@ -1,32 +0,0 @@
-import buffer from 'node:buffer';
-import { webcrypto } from 'node:crypto';
-
-// `buffer.File` was added in Node 18.13.0 while the `File` global was added in Node 20.0.0
-const File = /** @type {import('node:buffer') & { File?: File}} */ (buffer).File;
-
-/** @type {Record<string, any>} */
-const globals = {
-	crypto: webcrypto,
-	File
-};
-
-// exported for dev/preview and node environments
-/**
- * Make various web APIs available as globals:
- * - `crypto`
- * - `File`
- */
-function installPolyfills() {
-	for (const name in globals) {
-		if (name in globalThis) continue;
-
-		Object.defineProperty(globalThis, name, {
-			enumerable: true,
-			configurable: true,
-			writable: true,
-			value: globals[name]
-		});
-	}
-}
-
-installPolyfills();