@sveltejs/kit 3.0.0-next.2 → 3.0.0-next.21

package/src/runtime/server/sourcemaps.js

@@ -0,0 +1,183 @@
+/* eslint-disable n/prefer-global/process */
+
+// using `getBuiltinModule` rather than `import` makes this safe to run in non-Node-compatible environments
+const fs = globalThis.process?.getBuiltinModule?.('node:fs');
+const url = globalThis.process?.getBuiltinModule?.('node:url');
+const path = globalThis.process?.getBuiltinModule?.('node:path');
+const module = globalThis.process?.getBuiltinModule?.('node:module');
+
+const cwd = globalThis.process?.cwd?.();
+
+/** @type {(file: string) => string} */
+const relative = cwd ? (file) => path.relative(cwd, file) : (file) => file;
+
+/**
+ * Applies sourcemaps, makes paths relative to the cwd, and truncates
+ * non-user code from the bottom of the stack
+ * @param {Error} error
+ * @returns void
+ */
+export let fix_stack_trace = (error) => {
+	if (!error.stack || !fs) return;
+
+	let end = 0;
+
+	error.stack = error.stack
+		.split('\n')
+		.map((line, i) => {
+			const match = line.match(/^ {4}at.+(file:\/\/\/.*):(\d+):(\d+)(\)?)$/);
+
+			if (!match) {
+				if (!line.includes('node:internal/')) {
+					end = i + 1;
+				}
+
+				return line;
+			}
+
+			const file = url.fileURLToPath(match[1]);
+			const traced = trace(file, Number(match[2]) - 1, Number(match[3]) - 1);
+
+			// truncate non-user code from the bottom of the stack (but leave it in otherwise)
+			if (!/[\\/]node_modules[\\/]/.test(traced?.file ?? file)) {
+				end = i + 1;
+			}
+
+			if (traced?.line) {
+				const location = `${match[1]}:${match[2]}:${match[3]}`;
+				const original = `${relative(traced.file)}:${traced.line}:${traced.column}`;
+
+				return line.replace(location, original);
+			}
+
+			if (traced) {
+				return `${line.replace(match[1], relative(file))} [${traced.file}]`;
+			}
+
+			return line;
+		})
+		.slice(0, end)
+		.join('\n');
+};
+
+/**
+ * Override the implementation of fix_stack_trace (for using during dev)
+ * @param {(error: Error) => void} fn
+ */
+export function set_fix_stack_trace(fn) {
+	fix_stack_trace = fn;
+}
+
+/** @type {Map<string, { map: import('node:module').SourceMap; directory: string } | null>} */
+const source_maps = new Map();
+
+/** @type {Map<string, Array<string | undefined>>} */
+const source_regions = new Map();
+
+/** @param {string} file */
+function get_source_map(file) {
+	if (source_maps.has(file)) {
+		return source_maps.get(file);
+	}
+
+	try {
+		let source;
+		let directory = path.dirname(file);
+
+		const code = fs.readFileSync(file, 'utf8');
+		const matches = Array.from(code.matchAll(/\/\/[#@]\s*sourceMappingURL=(\S+)/g));
+		const url = matches.at(-1)?.[1];
+
+		if (url?.startsWith('data:')) {
+			const comma = url.indexOf(',');
+			const metadata = url.slice(5, comma);
+			const data = url.slice(comma + 1);
+			source = metadata.endsWith(';base64')
+				? Buffer.from(data, 'base64').toString()
+				: decodeURIComponent(data);
+		} else {
+			const map_file = url
+				? path.resolve(path.dirname(file), decodeURIComponent(url))
+				: `${file}.map`;
+			if (fs.existsSync(map_file)) {
+				directory = path.dirname(map_file);
+				source = fs.readFileSync(map_file, 'utf8');
+			}
+		}
+
+		if (source) {
+			const source_map = { map: new module.SourceMap(JSON.parse(source)), directory };
+			source_maps.set(file, source_map);
+
+			return source_map;
+		}
+	} catch {
+		// failure could be for any reason and this is best-effort, ignore
+	}
+
+	source_maps.set(file, null);
+	return null;
+}
+
+/**
+ *
+ * @param {string} file
+ * @param {number} line
+ * @param {number} column
+ * @returns {null | { file: string, line?: number, column?: number }}
+ */
+function trace(file, line, column) {
+	const source_map = get_source_map(file);
+	if (!source_map) return null;
+
+	const entry = source_map.map.findEntry(line, column);
+
+	if (
+		entry &&
+		'originalSource' in entry &&
+		entry.originalSource &&
+		typeof entry.originalLine === 'number' &&
+		typeof entry.originalColumn === 'number'
+	) {
+		const source = entry.originalSource.startsWith('file:')
+			? url.fileURLToPath(entry.originalSource)
+			: path.resolve(source_map.directory, entry.originalSource);
+
+		const traced = {
+			file: source,
+			line: entry.originalLine + 1,
+			column: entry.originalColumn + 1
+		};
+
+		// keep going, in case we are running code that was bundled a second time by an adapter
+		return trace(traced.file, traced.line - 1, traced.column - 1) ?? traced;
+	}
+
+	let regions = source_regions.get(file);
+	if (!regions) {
+		/** @type {string | undefined} */
+		let source;
+		regions = fs
+			.readFileSync(file, 'utf8')
+			.split('\n')
+			.map((line) => {
+				// Vite will merge multiple files into one but add region markers
+				// with the original file names, which we try to extract here.
+				const start = line.match(/^\/\/#region (.+)$/);
+				if (start) source = start[1];
+				if (line === '//#endregion') source = undefined;
+				return source;
+			});
+		source_regions.set(file, regions);
+	}
+
+	const source = regions[line];
+
+	if (source) {
+		return {
+			file: source
+		};
+	}
+
+	return null;
+}

package/src/runtime/server/state.js

@@ -0,0 +1,53 @@
+/** @import { InternalRequestOptions, RequestState } from 'types' */
+
+/** Per-request caches and context flags — never carried into a fork. */
+function transient_fields() {
+	return {
+		remote: {
+			data: null,
+			explicit: null,
+			implicit: null,
+			forms: null,
+			requested: null,
+			batches: null,
+			live_iterators: null
+		},
+		is_in_remote_function: false,
+		is_in_remote_form_or_command: false,
+		is_in_remote_query: false,
+		is_in_remote_prerender: false,
+		is_in_render: false
+	};
+}
+
+/**
+ * @param {InternalRequestOptions} options
+ * @returns {RequestState}
+ */
+export function create_request_state(options) {
+	// every field is initialized up front so the object shape stays stable
+	return {
+		getClientAddress: options.getClientAddress,
+		platform: options.platform,
+		read: options.read,
+		before_handle: options.before_handle,
+		emulator: options.emulator,
+		prerendering: options.prerendering,
+		prerender_default: undefined,
+		error: false,
+		depth: 0,
+		...transient_fields()
+	};
+}
+
+/**
+ * @param {RequestState} state
+ * @returns {RequestState}
+ */
+export function fork_state_for_subrequest(state) {
+	return {
+		...state,
+		...transient_fields(),
+		depth: state.depth + 1
+	};
+}

package/src/runtime/server/utils.js

@@ -1,15 +1,5 @@
-/** @import { ServerHooks } from 'types' */
-import * as devalue from 'devalue';
-import { DEV } from 'esm-env';
-import { json, text } from '@sveltejs/kit';
-import { HttpError } from '@sveltejs/kit/internal';
-import { with_request_store } from '@sveltejs/kit/internal/server';
-import { coalesce_to_error, get_message, get_status } from '../../utils/error.js';
-import { negotiate } from '../../utils/http.js';
-import { fix_stack_trace } from '../shared-server.js';
+import { text } from '@sveltejs/kit';
 import { ENDPOINT_METHODS } from '../../constants.js';
-import { escape_html } from '../../utils/escape.js';
-import * as path from '../../utils/path.js';
 
 /**
  * @param {Partial<Record<import('types').HttpMethod, any>>} mod
@@ -46,80 +36,6 @@ export function get_global_name(options) {
 	return __SVELTEKIT_DEV__ ? '__sveltekit_dev' : `__sveltekit_${options.version_hash}`;
 }
 
-/**
- * Return as a response that renders the error.html
- *
- * @param {import('types').SSROptions} options
- * @param {number} status
- * @param {string} message
- */
-export function static_error_page(options, status, message) {
-	let page = options.templates.error({ status, message: escape_html(message) });
-
-	if (__SVELTEKIT_DEV__) {
-		// inject Vite HMR client, for easier debugging
-		page = page.replace('</head>', '<script type="module" src="/@vite/client"></script></head>');
-	}
-
-	return text(page, {
-		headers: { 'content-type': 'text/html; charset=utf-8' },
-		status
-	});
-}
-
-/**
- * @param {import('@sveltejs/kit').RequestEvent} event
- * @param {import('types').RequestState} state
- * @param {import('types').SSROptions} options
- * @param {unknown} error
- */
-export async function handle_fatal_error(event, state, options, error) {
-	error = error instanceof HttpError ? error : coalesce_to_error(error);
-	const status = get_status(error);
-	const body = await handle_error_and_jsonify(event, state, options, error);
-
-	// ideally we'd use sec-fetch-dest instead, but Safari — quelle surprise — doesn't support it
-	const type = negotiate(event.request.headers.get('accept') || 'text/html', [
-		'application/json',
-		'text/html'
-	]);
-
-	if (event.isDataRequest || type === 'application/json') {
-		return json(body, {
-			status
-		});
-	}
-
-	return static_error_page(options, status, body.message);
-}
-
-/**
- * @param {import('@sveltejs/kit').RequestEvent} event
- * @param {import('types').RequestState} state
- * @param {import('types').SSROptions} options
- * @param {any} error
- * @returns {Promise<App.Error>}
- */
-export async function handle_error_and_jsonify(event, state, options, error) {
-	if (error instanceof HttpError) {
-		// @ts-expect-error custom user errors may not have a message field if App.Error is overwritten
-		return { message: 'Unknown Error', ...error.body };
-	}
-
-	if (__SVELTEKIT_DEV__ && typeof error == 'object') {
-		fix_stack_trace(error);
-	}
-
-	const status = get_status(error);
-	const message = get_message(error);
-
-	return (
-		(await with_request_store({ event, state }, () =>
-			options.hooks.handleError({ error, event, status, message })
-		)) ?? { message }
-	);
-}
-
 /**
  * @param {number} status
  * @param {string} location
@@ -133,14 +49,24 @@ export function redirect_response(status, location) {
 }
 
 /**
- * @param {import('@sveltejs/kit').RequestEvent} event
+ * @param {Response} response
+ */
+export function with_version_header(response) {
+	if (__SVELTEKIT_APP_VERSION_CHECKS_ENABLED__) {
+		response.headers.set('x-sveltekit-version', __SVELTEKIT_APP_VERSION__);
+	}
+	return response;
+}
+
+/**
+ * @param {import('$app/server').RequestEvent} event
  * @param {Error & { path: string }} error
  */
 export function clarify_devalue_error(event, error) {
 	if (error.path) {
 		return (
 			`Data returned from \`load\` while rendering ${event.route.id} is not serializable: ${error.message} (${error.path}). ` +
-			`If you need to serialize/deserialize custom types, use transport hooks: https://svelte.dev/docs/kit/hooks#Universal-hooks-transport.`
+			`If you need to serialize/deserialize custom types, use transport hooks: https://svelte.dev/docs/kit/hooks#transport.`
 		);
 	}
 
@@ -189,56 +115,6 @@ export function has_prerendered_path(manifest, pathname) {
 	);
 }
 
-/**
- * Formats the error into a nice message with sanitized stack trace
- * @param {number} status
- * @param {Error} error
- * @param {import('@sveltejs/kit').RequestEvent} event
- */
-export function format_server_error(status, error, event) {
-	const formatted_text = `\n\x1b[1;31m[${status}] ${event.request.method} ${event.url.pathname}\x1b[0m`;
-
-	if (status === 404) {
-		return formatted_text;
-	}
-
-	return `${formatted_text}\n${DEV ? clean_up_stack_trace(error) : error.stack}`;
-}
-
-/**
- * In dev, tidy up stack traces by making paths relative to the current project directory
- * @param {string} file
- */
-let relative = (file) => file;
-
-if (DEV) {
-	try {
-		relative = (file) => path.relative(__SVELTEKIT_ROOT__, file);
-	} catch {
-		// do nothing
-	}
-}
-
-/**
- * Provides a refined stack trace by excluding lines following the last occurrence of a line containing +page. +layout. or +server.
- * @param {Error} error
- */
-export function clean_up_stack_trace(error) {
-	const stack_trace = (error.stack?.split('\n') ?? []).map((line) => {
-		return line.replace(/\((.+)(:\d+:\d+)\)$/, (_, file, loc) => `(${relative(file)}${loc})`);
-	});
-
-	// progressive enhancement for people who haven't configured kit.files.src to something else
-	const last_line_from_src_code = stack_trace.findLastIndex((line) => /\(src[\\/]/.test(line));
-
-	if (last_line_from_src_code === -1) {
-		// default to the whole stack trace
-		return error.stack;
-	}
-
-	return stack_trace.slice(0, last_line_from_src_code + 1).join('\n');
-}
-
 /**
  * Returns the filename without the extension. e.g., `+page.server`, `+page`, etc.
  * @param {string | undefined} node_id
@@ -261,21 +137,3 @@ export function get_node_type(node_id) {
 export function count_non_ssi_comments(str) {
 	return (str.match(/<!--(?!#)/g) ?? []).length;
 }
-
-/**
- * Creates a serialiser for non-arbitrary POJOs using the app's transport hook
- * @param {ServerHooks['transport']} transport
- * @returns {(thing: unknown) => string | undefined}
- */
-export function create_replacer(transport) {
-	/** @param {unknown} thing */
-	const replacer = (thing) => {
-		for (const key in transport) {
-			const encoded = transport[key].encode(thing);
-			if (encoded) {
-				return `app.decode('${key}', ${devalue.uneval(encoded, replacer)})`;
-			}
-		}
-	};
-	return replacer;
-}

package/src/runtime/shared.js

@@ -1,6 +1,6 @@
-/** @import { Transport } from '@sveltejs/kit' */
 import * as devalue from 'devalue';
-import { base64_decode, base64_encode, text_encoder } from './utils.js';
+import { base64_decode, base64_encode, text_decoder, text_encoder } from './utils.js';
+import { decoders, encoders } from '#app/internal/transport';
 
 /**
  * @param {string} route_id
@@ -39,17 +39,6 @@ export function validate_load_response(data, location_description) {
 	}
 }
 
-/**
- * Try to `devalue.stringify` the data object using the provided transport encoders.
- * @param {any} data
- * @param {Transport} transport
- */
-export function stringify(data, transport) {
-	const encoders = Object.fromEntries(Object.entries(transport).map(([k, v]) => [k, v.encode]));
-
-	return devalue.stringify(data, encoders);
-}
-
 const object_proto_names = /* @__PURE__ */ Object.getOwnPropertyNames(Object.prototype)
 	.sort()
 	.join('\0');
@@ -102,11 +91,9 @@ const remote_regex_guard = '__skrag';
 const remote_arg_marker = Symbol(remote_object);
 
 /**
- * @param {Transport} transport
  * @param {boolean} sort
- * @param {Map<any, any>} remote_arg_clones
  */
-function create_remote_arg_reducers(transport, sort, remote_arg_clones) {
+function create_remote_arg_reducers(sort) {
 	/** @type {Record<string, (value: unknown) => unknown>} */
 	const remote_fns_reducers = {
 		/** @param {unknown} value */
@@ -118,6 +105,8 @@ function create_remote_arg_reducers(transport, sort, remote_arg_clones) {
 	};
 
 	if (sort) {
+		const clones = new Map();
+
 		/** @type {(value: unknown) => Array<[unknown, unknown]> | undefined} */
 		remote_fns_reducers[remote_map] = (value) => {
 			if (!(value instanceof Map)) {
@@ -167,18 +156,15 @@ function create_remote_arg_reducers(transport, sort, remote_arg_clones) {
 				return;
 			}
 
-			if (remote_arg_clones.has(value)) {
-				return remote_arg_clones.get(value);
+			if (clones.has(value)) {
+				return clones.get(value);
 			}
 
-			return to_sorted(value, remote_arg_clones);
+			return to_sorted(value, clones);
 		};
 	}
 
-	const user_reducers = Object.fromEntries(
-		Object.entries(transport).map(([k, v]) => [k, v.encode])
-	);
-	const all_reducers = { ...user_reducers, ...remote_fns_reducers };
+	const all_reducers = { ...encoders, ...remote_fns_reducers };
 
 	/** @type {(value: unknown) => string} */
 	const stringify = (value) => devalue.stringify(value, all_reducers);
@@ -186,8 +172,7 @@ function create_remote_arg_reducers(transport, sort, remote_arg_clones) {
 	return all_reducers;
 }
 
-/** @param {Transport} transport */
-function create_remote_arg_revivers(transport) {
+function create_remote_arg_revivers() {
 	const remote_fns_revivers = {
 		/** @type {(value: unknown) => unknown} */
 		[remote_object]: (value) => value,
@@ -251,11 +236,7 @@ function create_remote_arg_revivers(transport) {
 		}
 	};
 
-	const user_revivers = Object.fromEntries(
-		Object.entries(transport).map(([k, v]) => [k, v.decode])
-	);
-
-	const all_revivers = { ...user_revivers, ...remote_fns_revivers };
+	const all_revivers = { ...decoders, ...remote_fns_revivers };
 
 	/** @type {(data: string) => unknown} */
 	const parse = (data) => devalue.parse(data, all_revivers);
@@ -267,13 +248,12 @@ function create_remote_arg_revivers(transport) {
  * Stringifies the argument (if any) for a remote function in such a way that
  * it is both a valid URL and a valid file name (necessary for prerendering).
  * @param {any} value
- * @param {Transport} transport
  */
-export function stringify_remote_arg(value, transport) {
+export function stringify_remote_arg(value) {
 	if (value === undefined) return '';
 
 	// If people hit file/url size limits, we can look into using something like compress_and_encode_text from svelte.dev beyond a certain size
-	const json = devalue.stringify(value, create_remote_arg_reducers(transport, true, new Map()));
+	const json = devalue.stringify(value, create_remote_arg_reducers(true));
 
 	return url_friendly_base64_encode(json);
 }
@@ -281,12 +261,11 @@ export function stringify_remote_arg(value, transport) {
 /**
  * Stringifies command arguments, including `File` objects.
  * @param {any} value
- * @param {Transport} transport
  */
-export async function stringify_command_arg(value, transport) {
+export async function stringify_command_arg(value) {
 	if (value === undefined) return '';
 
-	const reducers = create_remote_arg_reducers(transport, false, new Map());
+	const reducers = create_remote_arg_reducers(false);
 
 	/** @type {Set<Promise<any>>} */
 	const allowed_promises = new Set();
@@ -331,23 +310,24 @@ export async function stringify_command_arg(value, transport) {
  */
 function url_friendly_base64_encode(string) {
 	const bytes = text_encoder.encode(string);
+	// TODO replace with `bytes.toBase64({ alphabet: 'base64url', omitPadding: true })` when we require Node >= 25
 	return base64_encode(bytes).replaceAll('=', '').replaceAll('+', '-').replaceAll('/', '_');
 }
 
 /**
  * Parses the argument (if any) for a remote function
  * @param {string} string
- * @param {Transport} transport
  */
-export function parse_remote_arg(string, transport) {
+export function parse_remote_arg(string) {
 	if (!string) return undefined;
 
-	const json_string = new TextDecoder().decode(
+	const json_string = text_decoder.decode(
+		// TODO replace with `Uint8Array.fromBase64(string, { alphabet: 'base64url' })` when we require Node >= 25
 		// no need to add back `=` characters, atob can handle it
 		base64_decode(string.replaceAll('-', '+').replaceAll('_', '/'))
 	);
 
-	return devalue.parse(json_string, create_remote_arg_revivers(transport));
+	return devalue.parse(json_string, create_remote_arg_revivers());
 }
 
 /**

package/src/runtime/utils.js

@@ -1,6 +1,7 @@
 import { BROWSER } from 'esm-env';
 
 export const text_encoder = new TextEncoder();
+export const text_decoder = new TextDecoder();
 
 /**
  * Like node's path.relative, but without using node
@@ -28,6 +29,7 @@ export function get_relative_path(from, to) {
  * @returns {string}
  */
 export function base64_encode(bytes) {
+	// TODO replace with `bytes.toBase64()` when we require Node >= 25
 	// Using `Buffer` is faster than iterating
 	if (!BROWSER && globalThis.Buffer) {
 		return globalThis.Buffer.from(bytes).toString('base64');
@@ -47,6 +49,7 @@ export function base64_encode(bytes) {
  * @returns {Uint8Array}
  */
 export function base64_decode(encoded) {
+	// TODO replace with `Uint8Array.fromBase64(encoded)` when we require Node >= 25
 	// Using `Buffer` is faster than iterating
 	if (!BROWSER && globalThis.Buffer) {
 		const buffer = globalThis.Buffer.from(encoded, 'base64');

package/src/types/ambient-private.d.ts

@@ -13,8 +13,10 @@ declare module '__sveltekit/paths' {
 declare module '__sveltekit/server' {
 	import { SSRManifest } from '@sveltejs/kit';
 
+	export let fix_stack_trace: (error: Error) => string;
 	export let manifest: SSRManifest;
 	export function read_implementation(path: string): ReadableStream;
+	export function set_fix_stack_trace(fn: (error: Error) => string): void;
 	export function set_manifest(manifest: SSRManifest): void;
 	export function set_read_implementation(fn: (path: string) => ReadableStream): void;
 }
@@ -23,7 +25,7 @@ declare module '__sveltekit/env' {
 	// exported environment variables are defined in env.d.ts
 
 	/** Populate exported environment variables */
-	export function set_env(environment: Record<string, string>): void;
+	export function set_env(environment: Record<string, string | undefined>): void;
 
 	/** public env vars */
 	export const explicit_public_env: Record<string, any>;
@@ -43,3 +45,11 @@ declare module '__sveltekit/env/public/client' {
 declare module '__sveltekit/env/public/server' {
 	// exported environment variables are defined in env.d.ts
 }
+
+/** Internal version of $app/manifest */
+declare module '__sveltekit/manifest-data' {
+	export const immutable: Array<{ path: string }>;
+	export const assets: Array<{ path: string }>;
+	export const prerendered: Array<{ path: string }>;
+	export const routes: Array<{ id: string; page: boolean; endpoint: boolean }>;
+}