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

package/src/exports/hooks/public.d.ts

@@ -0,0 +1,195 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { NavigationEvent } from '@sveltejs/kit';
+import { RequestEvent } from '$app/server';
+import { MaybePromise } from 'types';
+
+export * from './index.js';
+
+/**
+ * The [`handle`](https://svelte.dev/docs/kit/hooks#handle) hook runs every time the SvelteKit server receives a [request](https://svelte.dev/docs/kit/web-standards#Fetch-APIs-Request) and
+ * determines the [response](https://svelte.dev/docs/kit/web-standards#Fetch-APIs-Response).
+ * It receives an `event` object representing the request and a function called `resolve`, which renders the route and generates a `Response`.
+ * This allows you to modify response headers or bodies, or bypass SvelteKit entirely (for implementing routes programmatically, for example).
+ */
+export type Handle = (input: {
+	event: RequestEvent;
+	resolve: (event: RequestEvent, opts?: ResolveOptions) => Promise<Response>;
+}) => MaybePromise<Response>;
+
+type CaughtErrorMap = {
+	app: App.Error;
+	framework: { status: number; message: string };
+	unknown: unknown;
+};
+
+type ValidationCaughtError<Issue extends StandardSchemaV1.Issue> = {
+	kind: 'validation';
+	error: { status: number; message: string };
+	issues: Issue[];
+};
+
+/**
+ * The error passed to the [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hooks.
+ * Use the `kind` discriminant to distinguish errors from your app (thrown with the
+ * [`error`](https://svelte.dev/docs/kit/errors#App-errors) helper), errors generated by
+ * SvelteKit itself (such as 404s), validation errors, and unknown errors (thrown by your code,
+ * or code it calls).
+ */
+export type CaughtError<Issue extends StandardSchemaV1.Issue = StandardSchemaV1.Issue> =
+	| {
+			[Kind in keyof CaughtErrorMap]: {
+				/** Identifies the category and origin of the error */
+				kind: Kind;
+				/** The caught error. Its type depends on `kind` */
+				error: CaughtErrorMap[Kind];
+				/** Only present for validation errors */
+				issues?: undefined;
+			};
+	  }[keyof CaughtErrorMap]
+	| ValidationCaughtError<Issue>;
+
+/** The error passed to the client-side `handleError` hook. */
+export type ClientCaughtError = Exclude<CaughtError, { kind: 'validation' }>;
+
+/**
+ * The server-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs for every error thrown while responding to a request, except redirects.
+ *
+ * The `kind` property discriminates between _app_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#App-errors) helper),
+ * _framework_ errors (generated by SvelteKit itself, such as 404s), _validation_ errors (caused by invalid remote function arguments)
+ * and _unknown_ errors (thrown by your code, or code it calls).
+ *
+ * The hook returns an object matching `App.Error`, in which `status` and `message` are optional — return them only to
+ * override the defaults. Omitted properties are inherited from the caught error: the body passed to `error(...)` for app errors,
+ * the status and safe message for framework and validation errors, and `500`/`'Internal Error'` for unknown errors. Return nothing to
+ * keep the defaults entirely (if you augment `App.Error` with required properties, you must return those).
+ *
+ * Make sure that this function _never_ throws an error.
+ */
+export type HandleServerError<Issue extends StandardSchemaV1.Issue = StandardSchemaV1.Issue> = (
+	input: CaughtError<Issue> & { event: RequestEvent }
+) => MaybePromise<AppErrorWithOptionalDefaults | VoidIfNoRequiredAppErrorProperties>;
+
+/**
+ * The client-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs for every error thrown while navigating, except redirects.
+ * Errors that were already transformed by the server-side hook are not passed to it a second time.
+ *
+ * The `kind` property discriminates between _app_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#App-errors) helper),
+ * _framework_ errors (generated by SvelteKit itself, such as 404s) and _unknown_ errors (thrown by your code, or code it calls).
+ *
+ * The hook returns an object matching `App.Error`, in which `status` and `message` are optional — return them only to
+ * override the defaults. Omitted properties are inherited from the caught error: the body passed to `error(...)` for app errors,
+ * the status and safe message for framework errors, and `500`/`'Internal Error'` for unknown errors. Return nothing to
+ * keep the defaults entirely (if you augment `App.Error` with required properties, you must return those).
+ *
+ * Make sure that this function _never_ throws an error.
+ */
+export type HandleClientError = (
+	input: ClientCaughtError & { event: NavigationEvent }
+) => MaybePromise<AppErrorWithOptionalDefaults | VoidIfNoRequiredAppErrorProperties>;
+
+/**
+ * The [`handleFetch`](https://svelte.dev/docs/kit/hooks#handleFetch) hook allows you to modify (or replace) the result of an [`event.fetch`](https://svelte.dev/docs/kit/load#Making-fetch-requests) call that runs on the server (or during prerendering) inside an endpoint, `load`, `action`, `handle`, `handleError` or `reroute`.
+ */
+export type HandleFetch = (input: {
+	event: RequestEvent;
+	request: Request;
+	fetch: typeof fetch;
+}) => MaybePromise<Response>;
+
+/**
+ * The [`init`](https://svelte.dev/docs/kit/hooks#init) will be invoked before the server responds to its first request
+ * @since 2.10.0
+ */
+export type ServerInit = () => MaybePromise<void>;
+
+/**
+ * The [`init`](https://svelte.dev/docs/kit/hooks#init) will be invoked once the app starts in the browser
+ * @since 2.10.0
+ */
+export type ClientInit = () => MaybePromise<void>;
+
+/**
+ * The [`reroute`](https://svelte.dev/docs/kit/hooks#reroute) hook allows you to modify the URL before it is used to determine which route to render.
+ * @since 2.3.0
+ */
+export type Reroute = (event: { url: URL; fetch: typeof fetch }) => MaybePromise<void | string>;
+
+/**
+ * The [`transport`](https://svelte.dev/docs/kit/hooks#transport) hook allows you to transport custom types across the server/client boundary.
+ *
+ * Each transporter has a pair of `encode` and `decode` functions. On the server, `encode` determines whether a value is an instance of the custom type and, if so, returns a non-falsy encoding of the value which can be an object or an array (or `false` otherwise).
+ *
+ * In the browser, `decode` turns the encoding back into an instance of the custom type.
+ *
+ * ```ts
+ * import type { Transport } from '@sveltejs/kit/hooks';
+ *
+ * declare class MyCustomType {
+ * 	data: any
+ * }
+ *
+ * // hooks.js
+ * export const transport: Transport = {
+ * 	MyCustomType: {
+ * 		encode: (value) => value instanceof MyCustomType && [value.data],
+ * 		decode: ([data]) => new MyCustomType(data)
+ * 	}
+ * };
+ * ```
+ * @since 2.11.0
+ */
+export type Transport = Record<string, Transporter>;
+
+/**
+ * A member of the [`transport`](https://svelte.dev/docs/kit/hooks#transport) hook.
+ */
+export interface Transporter<
+	T = any,
+	U = any /* minus falsy values, but we can't properly express that */
+> {
+	encode: (value: T) => false | U;
+	decode: (data: U) => T;
+}
+
+export interface ResolveOptions {
+	/**
+	 * Applies custom transforms to HTML. If `done` is true, it's the final chunk. Chunks are not guaranteed to be well-formed HTML
+	 * (they could include an element's opening tag but not its closing tag, for example)
+	 * but they will always be split at sensible boundaries such as `%sveltekit.head%` or layout/page components.
+	 * @param input the html chunk and the info if this is the last chunk
+	 */
+	transformPageChunk?: (input: { html: string; done: boolean }) => MaybePromise<string | undefined>;
+	/**
+	 * Determines which headers should be included in serialized responses when a `load` function loads a resource with `fetch`.
+	 * By default, none will be included.
+	 * @param name header name
+	 * @param value header value
+	 */
+	filterSerializedResponseHeaders?: (name: string, value: string) => boolean;
+	/**
+	 * Determines which files should be preloaded. Files are preloaded via `<link>` tags added to the
+	 * `<head>` tag; if `output.linkHeaderPreload` is enabled, dynamically rendered pages use the
+	 * [`Link` response header](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Link) instead.
+	 * By default, `js` and `css` files will be preloaded.
+	 * @param input the type of the file and its path
+	 */
+	preload?: (input: { type: 'font' | 'css' | 'js' | 'asset'; path: string }) => boolean;
+}
+
+type AppErrorWithOptionalDefaults = Omit<App.Error, 'status' | 'message'> & {
+	status?: App.Error['status'];
+	message?: App.Error['message'];
+};
+
+/**
+ * `void` is only a valid `handleError` return when `App.Error` adds no required properties
+ * beyond `status` and `message` — both of which are optional in the return, since they default
+ * to those of the caught error. If `App.Error` is augmented with required properties, the hook
+ * must return them, so returning nothing becomes a type error.
+ */
+type VoidIfNoRequiredAppErrorProperties = {
+	status: number;
+	message: string;
+} extends App.Error
+	? void
+	: never;

package/src/exports/hooks/sequence.js

@@ -1,8 +1,9 @@
-/** @import { Handle, RequestEvent, ResolveOptions } from '@sveltejs/kit' */
-/** @import { MaybePromise } from 'types' */
+/** @import { RequestEvent } from '$app/server' */
+/** @import { Handle, ResolveOptions } from '@sveltejs/kit/hooks' */
 import {
 	merge_tracing,
 	get_request_store,
+	record_span,
 	with_request_store
 } from '@sveltejs/kit/internal/server';
 
@@ -17,7 +18,7 @@ import {
  * /// file: src/hooks.server.js
  * import { sequence } from '@sveltejs/kit/hooks';
  *
- * /// type: import('@sveltejs/kit').Handle
+ * /// type: import('@sveltejs/kit/hooks').Handle
  * async function first({ event, resolve }) {
  * 	console.log('first pre-processing');
  * 	const result = await resolve(event, {
@@ -36,7 +37,7 @@ import {
  * 	return result;
  * }
  *
- * /// type: import('@sveltejs/kit').Handle
+ * /// type: import('@sveltejs/kit/hooks').Handle
  * async function second({ event, resolve }) {
  * 	console.log('second pre-processing');
  * 	const result = await resolve(event, {
@@ -74,6 +75,8 @@ import {
  * first post-processing
  * ```
  *
+ * Calling `resolve` invokes the next handler in the sequence (or SvelteKit itself, if it is the last one). To pass data between handlers, use `event.locals`.
+ *
  * @param {...Handle} handlers The chain of `handle` functions
  * @returns {Handle}
  */
@@ -89,12 +92,12 @@ export function sequence(...handlers) {
 		 * @param {number} i
 		 * @param {RequestEvent} event
 		 * @param {ResolveOptions | undefined} parent_options
-		 * @returns {MaybePromise<Response>}
+		 * @returns {Promise<Response>}
 		 */
 		function apply_handle(i, event, parent_options) {
 			const handle = handlers[i];
 
-			return state.tracing.record_span({
+			return record_span({
 				name: `sveltekit.handle.sequenced.${handle.name ? handle.name : i}`,
 				attributes: {},
 				fn: async (current) => {

package/src/exports/index.js

@@ -1,6 +1,5 @@
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
-
-import { HttpError, Redirect, ActionFailure, ValidationError } from './internal/index.js';
+import { HttpError, Redirect, ActionFailure, ValidationError } from './internal/shared.js';
 import { BROWSER, DEV } from 'esm-env';
 import {
 	add_data_suffix,
@@ -9,8 +8,10 @@ import {
 	has_resolution_suffix,
 	strip_data_suffix,
 	strip_resolution_suffix
-} from '../runtime/pathname.js';
-import { text_encoder } from '../runtime/utils.js';
+} from '../pathname.js';
+import { validate_redirect_location } from './url.js';
+
+const text_encoder = new TextEncoder();
 
 export { VERSION } from '../version.js';
 
@@ -23,13 +24,13 @@ export { VERSION } from '../version.js';
 /**
  * Throws an error with a HTTP status code and an optional message.
  * When called during request handling, this will cause SvelteKit to
- * return an error response without invoking `handleError`.
+ * return an error response; the error will be passed to `handleError` as an _expected_ error.
  * Make sure you're not catching the thrown error, which would prevent SvelteKit from handling it.
  * @param {number} status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). Must be in the range 400-599.
- * @param {App.Error} body An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
+ * @param {string} [message] The error message.
  * @overload
- * @param {number} status
- * @param {App.Error} body
+ * @param {{ status: number; message: string } extends App.Error ? number : never} status
+ * @param {{ status: number; message: string } extends App.Error ? string : never} [message]
  * @return {never}
  * @throws {import('./public.js').HttpError} This error instructs SvelteKit to initiate HTTP error handling.
  * @throws {Error} If the provided status is invalid (not between 400 and 599).
@@ -37,13 +38,15 @@ export { VERSION } from '../version.js';
 /**
  * Throws an error with a HTTP status code and an optional message.
  * When called during request handling, this will cause SvelteKit to
- * return an error response without invoking `handleError`.
+ * return an error response; the error will be passed to `handleError` as an _expected_ error.
  * Make sure you're not catching the thrown error, which would prevent SvelteKit from handling it.
  * @param {number} status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). Must be in the range 400-599.
- * @param {{ message: string } extends App.Error ? App.Error | string | undefined : never} [body] An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
+ * @param {string} message The error message.
+ * @param {keyof Omit<App.Error, 'status' | 'message'> extends never ? never : Omit<App.Error, 'status' | 'message'>} properties Additional properties of the App.Error type.
  * @overload
  * @param {number} status
- * @param {{ message: string } extends App.Error ? App.Error | string | undefined : never} [body]
+ * @param {string} message
+ * @param {keyof Omit<App.Error, 'status' | 'message'> extends never ? never : Omit<App.Error, 'status' | 'message'>} properties
  * @return {never}
  * @throws {import('./public.js').HttpError} This error instructs SvelteKit to initiate HTTP error handling.
  * @throws {Error} If the provided status is invalid (not between 400 and 599).
@@ -51,20 +54,46 @@ export { VERSION } from '../version.js';
 /**
  * Throws an error with a HTTP status code and an optional message.
  * When called during request handling, this will cause SvelteKit to
- * return an error response without invoking `handleError`.
+ * return an error response; the error will be passed to `handleError` as an _expected_ error.
  * Make sure you're not catching the thrown error, which would prevent SvelteKit from handling it.
+ * @deprecated Passing an `App.Error` body as the second argument is deprecated — pass the `message` as the second argument, and any additional properties as the third
  * @param {number} status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). Must be in the range 400-599.
- * @param {{ message: string } extends App.Error ? App.Error | string | undefined : never} body An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
+ * @param {Omit<App.Error, 'status'> & { status?: App.Error['status'] }} body An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
+ * @overload
+ * @param {number} status
+ * @param {Omit<App.Error, 'status'> & { status?: App.Error['status'] }} properties
+ * @return {never}
+ * @throws {import('./public.js').HttpError} This error instructs SvelteKit to initiate HTTP error handling.
+ * @throws {Error} If the provided status is invalid (not between 400 and 599).
+ */
+/**
+ * Throws an error with a HTTP status code and an optional message.
+ * When called during request handling, this will cause SvelteKit to
+ * return an error response; the error will be passed to `handleError` as an _expected_ error.
+ * Make sure you're not catching the thrown error, which would prevent SvelteKit from handling it.
+ * @param {any} status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). Must be in the range 400-599.
+ * @param {any} [message] A string, or (deprecated) a partial App.Error object
+ * @param {any} [properties] Additional properties of the App.Error type when passing a string message.
  * @return {never}
  * @throws {import('./public.js').HttpError} This error instructs SvelteKit to initiate HTTP error handling.
  * @throws {Error} If the provided status is invalid (not between 400 and 599).
  */
-export function error(status, body) {
+export function error(status, message, properties) {
 	if ((!BROWSER || DEV) && (isNaN(status) || status < 400 || status > 599)) {
 		throw new Error(`HTTP error status codes must be between 400 and 599 — ${status} is invalid`);
 	}
 
-	throw new HttpError(status, body);
+	if (message !== undefined && typeof message !== 'string') {
+		if (DEV) {
+			console.warn(
+				'Passing an `App.Error` body as the second argument is deprecated — pass the `message` as the second argument, and any additional properties as the third'
+			);
+		}
+
+		({ message, ...properties } = message);
+	}
+
+	throw new HttpError({ ...properties, status, message: message ?? `Error: ${status}` });
 }
 
 /**
@@ -92,19 +121,23 @@ export function isHttpError(e, status) {
  *
  * @param {300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308 | ({} & number)} status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#redirection_messages). Must be in the range 300-308.
  * @param {string | URL} location The location to redirect to.
+ * @param {{ external?: boolean | string[] }} [options] To redirect to an external URL, you must pass `{ external: true }` to allow any external URL except `javascript:` URLs, or `{ external: [...] }` with an allowlist of permitted origins.
  * @throws {import('./public.js').Redirect} This error instructs SvelteKit to redirect to the specified location.
- * @throws {Error} If the provided status is invalid or the location cannot be used as a header value.
+ * @throws {Error} If the provided status is invalid, the location cannot be used as a header value, or the location is an external URL without permission.
  * @return {never}
  */
-export function redirect(status, location) {
+export function redirect(status, location, options) {
 	if ((!BROWSER || DEV) && (isNaN(status) || status < 300 || status > 308)) {
 		throw new Error('Invalid status code');
 	}
 
+	const href = location.toString();
+	validate_redirect_location(href, options);
+
 	throw new Redirect(
 		// @ts-ignore
 		status,
-		location.toString()
+		href
 	);
 }
 
@@ -212,7 +245,7 @@ export function isActionFailure(e) {
  * ```ts
  * import { invalid } from '@sveltejs/kit';
  * import { form } from '$app/server';
- * import { tryLogin } from '$lib/server/auth';
+ * import { tryLogin } from '#lib/server/auth';
  * import * as v from 'valibot';
  *
  * export const login = form(
@@ -237,16 +270,6 @@ export function invalid(...issues) {
 	);
 }
 
-/**
- * Checks whether this is an validation error thrown by {@link invalid}.
- * @param {unknown} e The object to check.
- * @return {e is import('./public.js').ActionFailure}
- * @since 2.47.3
- */
-export function isValidationError(e) {
-	return e instanceof ValidationError;
-}
-
 /**
  * Strips possible SvelteKit-internal suffixes and trailing slashes from the URL pathname.
  * Returns the normalized URL as well as a method for adding the potential suffix back

package/src/exports/internal/client.js

@@ -0,0 +1,5 @@
+export function get_origin() {
+	return window.location.origin;
+}
+
+export * from './shared.js';

package/src/exports/internal/env.js

@@ -1,10 +1,10 @@
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
-/** @import { EnvVarConfig } from '@sveltejs/kit' */
+/** @import { EnvVarConfig } from '@sveltejs/kit/env' */
 
 import { stackless } from '../../utils/error.js';
 
 const MISSING = {
-	message: `Value is missing. If it is optional, add a Standard Schema validator declaring it as such.`
+	message: `Value is missing. If it is optional, add a validator declaring it as such.`
 };
 
 const BAD_VALIDATOR = {
@@ -16,7 +16,7 @@ const ASYNC_VALIDATOR = {
 };
 
 /**
- * @param {Record<string, EnvVarConfig<any>>} variables
+ * @param {Record<string, EnvVarConfig<any> | undefined>} variables
  * @param {string | undefined} value
  * @param {string} name
  * @param {Record<string, StandardSchemaV1.Issue[]>} issues
@@ -24,10 +24,13 @@ const ASYNC_VALIDATOR = {
  */
 export function validate(variables, value, name, issues) {
 	const config = variables[name] ?? {};
-	const validator = config.schema;
+	// `defineEnvVars` normalizes function validators to standard schemas
+	const validator = /** @type {StandardSchemaV1<string | undefined, any> | undefined} */ (
+		config.schema
+	);
 
 	if (!validator) {
-		if (!value) issues[name] = [MISSING];
+		if (value === undefined) issues[name] = [MISSING];
 		return value;
 	}
 

package/src/exports/internal/index.js

@@ -1,90 +1 @@
-/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
-
-export class HttpError {
-	/**
-	 * @param {number} status
-	 * @param {{message: string} extends App.Error ? (App.Error | string | undefined) : App.Error} body
-	 */
-	constructor(status, body) {
-		this.status = status;
-		if (typeof body === 'string') {
-			this.body = { message: body };
-		} else if (body) {
-			this.body = body;
-		} else {
-			this.body = { message: `Error: ${status}` };
-		}
-	}
-
-	toString() {
-		return JSON.stringify(this.body);
-	}
-}
-
-export class Redirect {
-	/**
-	 * @param {300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308} status
-	 * @param {string} location
-	 */
-	constructor(status, location) {
-		try {
-			new Headers({ location });
-		} catch {
-			throw new Error(
-				`Invalid redirect location ${JSON.stringify(location)}: ` +
-					'this string contains characters that cannot be used in HTTP headers'
-			);
-		}
-
-		this.status = status;
-		this.location = location;
-	}
-}
-
-/**
- * An error that was thrown from within the SvelteKit runtime that is not fatal and doesn't result in a 500, such as a 404.
- * `SvelteKitError` goes through `handleError`.
- * @extends Error
- */
-export class SvelteKitError extends Error {
-	/**
-	 * @param {number} status
-	 * @param {string} text
-	 * @param {string} message
-	 */
-	constructor(status, text, message) {
-		super(message);
-		this.status = status;
-		this.text = text;
-	}
-}
-
-/**
- * @template [T=undefined]
- */
-export class ActionFailure {
-	/**
-	 * @param {number} status
-	 * @param {T} data
-	 */
-	constructor(status, data) {
-		this.status = status;
-		this.data = data;
-	}
-}
-
-/**
- * Error thrown when form validation fails imperatively
- */
-export class ValidationError extends Error {
-	/**
-	 * @param {StandardSchemaV1.Issue[]} issues
-	 */
-	constructor(issues) {
-		super('Validation failed');
-		this.name = 'ValidationError';
-		this.issues = issues;
-	}
-}
-
-export { init_remote_functions } from './remote-functions.js';
+export * from '#internal';

package/src/exports/internal/{event.js → server/event.js}

@@ -1,8 +1,7 @@
-/** @import { RequestEvent } from '@sveltejs/kit' */
+/** @import { RequestEvent } from '$app/server' */
 /** @import { RequestStore } from 'types' */
 /** @import { AsyncLocalStorage } from 'node:async_hooks' */
-
-import { IN_WEBCONTAINER } from '../../runtime/server/constants.js';
+import { IN_WEBCONTAINER } from '../../../constants.js';
 
 /** @type {RequestStore | null} */
 let sync_store = null;

package/src/exports/internal/server/index.js

@@ -0,0 +1,37 @@
+/** @import { Span } from '@opentelemetry/api' */
+import { try_get_request_store } from './event.js';
+
+export function get_origin() {
+	// `request.url` rather than `event.url`, which throws inside queries
+	const request = try_get_request_store()?.event.request;
+	return request && new URL(request.url).origin;
+}
+
+/**
+ * @template {{ tracing: { enabled: boolean, root: Span, current: Span } }} T
+ * @param {T} event_like
+ * @param {Span} current
+ * @returns {T}
+ */
+export function merge_tracing(event_like, current) {
+	return {
+		...event_like,
+		tracing: {
+			...event_like.tracing,
+			current
+		}
+	};
+}
+
+export {
+	with_request_store,
+	getRequestEvent,
+	get_request_store,
+	try_get_request_store
+} from './event.js';
+
+export { init_remote_functions } from './remote-functions.js';
+
+export { init_tracing, otel, record_span } from './telemetry.js';
+
+export * from '../shared.js';