@sveltejs/kit 1.0.0-next.412 → 1.0.0-next.415

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.0.0-next.412",
+  "version": "1.0.0-next.415",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",

package/src/core/constants.js

@@ -1,3 +1,5 @@
 // in `vite dev` and `vite preview`, we use a fake asset path so that we can
 // serve local assets while verifying that requests are correctly prefixed
 export const SVELTE_KIT_ASSETS = '/_svelte_kit_assets';
+
+export const GENERATED_COMMENT = '// this file is generated — do not edit it\n';

package/src/core/env.js

@@ -0,0 +1,91 @@
+import { GENERATED_COMMENT } from './constants.js';
+
+/**
+ * @param {string} id
+ * @param {Record<string, string>} env
+ * @returns {string}
+ */
+export function create_module(id, env) {
+	/** @type {string[]} */
+	const declarations = [];
+
+	for (const key in env) {
+		if (!valid_identifier.test(key) || reserved.has(key)) {
+			continue;
+		}
+
+		const comment = `/** @type {import('${id}').${key}} */`;
+		const declaration = `export const ${key} = ${JSON.stringify(env[key])};`;
+
+		declarations.push(`${comment}\n${declaration}`);
+	}
+
+	return GENERATED_COMMENT + declarations.join('\n\n');
+}
+
+/**
+ * @param {string} id
+ * @param {Record<string, string>} env
+ * @returns {string}
+ */
+export function create_types(id, env) {
+	const declarations = Object.keys(env)
+		.filter((k) => valid_identifier.test(k))
+		.map((k) => `\texport const ${k}: string;`)
+		.join('\n');
+
+	return `declare module '${id}' {\n${declarations}\n}`;
+}
+
+export const reserved = new Set([
+	'do',
+	'if',
+	'in',
+	'for',
+	'let',
+	'new',
+	'try',
+	'var',
+	'case',
+	'else',
+	'enum',
+	'eval',
+	'null',
+	'this',
+	'true',
+	'void',
+	'with',
+	'await',
+	'break',
+	'catch',
+	'class',
+	'const',
+	'false',
+	'super',
+	'throw',
+	'while',
+	'yield',
+	'delete',
+	'export',
+	'import',
+	'public',
+	'return',
+	'static',
+	'switch',
+	'typeof',
+	'default',
+	'extends',
+	'finally',
+	'package',
+	'private',
+	'continue',
+	'debugger',
+	'function',
+	'arguments',
+	'interface',
+	'protected',
+	'implements',
+	'instanceof'
+]);
+
+export const valid_identifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;

package/src/core/sync/utils.js

@@ -42,56 +42,3 @@ export function trim(str) {
 	const pattern = new RegExp(`^${indentation}`, 'gm');
 	return str.replace(pattern, '').trim();
 }
-
-export const reserved = new Set([
-	'do',
-	'if',
-	'in',
-	'for',
-	'let',
-	'new',
-	'try',
-	'var',
-	'case',
-	'else',
-	'enum',
-	'eval',
-	'null',
-	'this',
-	'true',
-	'void',
-	'with',
-	'await',
-	'break',
-	'catch',
-	'class',
-	'const',
-	'false',
-	'super',
-	'throw',
-	'while',
-	'yield',
-	'delete',
-	'export',
-	'import',
-	'public',
-	'return',
-	'static',
-	'switch',
-	'typeof',
-	'default',
-	'extends',
-	'finally',
-	'package',
-	'private',
-	'continue',
-	'debugger',
-	'function',
-	'arguments',
-	'interface',
-	'protected',
-	'implements',
-	'instanceof'
-]);
-
-export const valid_identifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;

package/src/core/sync/write_ambient.js

@@ -1,9 +1,9 @@
 import path from 'path';
-import colors from 'kleur';
 import { get_env } from '../../vite/utils.js';
-import { write_if_changed, reserved, valid_identifier } from './utils.js';
+import { GENERATED_COMMENT } from '../constants.js';
+import { create_types } from '../env.js';
+import { write_if_changed } from './utils.js';
 
-const autogen_comment = '// this file is generated — do not edit it\n';
 const types_reference = '/// <reference types="@sveltejs/kit" />\n\n';
 
 /**
@@ -16,72 +16,12 @@ const types_reference = '/// <reference types="@sveltejs/kit" />\n\n';
 export function write_ambient(config, mode) {
 	const env = get_env(mode, config.env.publicPrefix);
 
-	// TODO when testing src, `$app` points at `src/runtime/app`... will
-	// probably need to fiddle with aliases
-	write_if_changed(
-		path.join(config.outDir, 'runtime/env/static/public.js'),
-		create_env_module('$env/static/public', env.public)
-	);
-
-	write_if_changed(
-		path.join(config.outDir, 'runtime/env/static/private.js'),
-		create_env_module('$env/static/private', env.private)
-	);
-
 	write_if_changed(
 		path.join(config.outDir, 'ambient.d.ts'),
-		autogen_comment +
+		GENERATED_COMMENT +
 			types_reference +
-			create_env_types('$env/static/public', env.public) +
+			create_types('$env/static/public', env.public) +
 			'\n\n' +
-			create_env_types('$env/static/private', env.private)
+			create_types('$env/static/private', env.private)
 	);
 }
-
-/**
- * @param {string} id
- * @param {Record<string, string>} env
- * @returns {string}
- */
-function create_env_module(id, env) {
-	/** @type {string[]} */
-	const declarations = [];
-
-	for (const key in env) {
-		const warning = !valid_identifier.test(key)
-			? 'not a valid identifier'
-			: reserved.has(key)
-			? 'a reserved word'
-			: null;
-
-		if (warning) {
-			console.error(
-				colors
-					.bold()
-					.yellow(`Omitting environment variable "${key}" from ${id} as it is ${warning}`)
-			);
-			continue;
-		}
-
-		const comment = `/** @type {import('${id}').${key}} */`;
-		const declaration = `export const ${key} = ${JSON.stringify(env[key])};`;
-
-		declarations.push(`${comment}\n${declaration}`);
-	}
-
-	return autogen_comment + declarations.join('\n\n');
-}
-
-/**
- * @param {string} id
- * @param {Record<string, string>} env
- * @returns {string}
- */
-function create_env_types(id, env) {
-	const declarations = Object.keys(env)
-		.filter((k) => valid_identifier.test(k))
-		.map((k) => `\texport const ${k}: string;`)
-		.join('\n');
-
-	return `declare module '${id}' {\n${declarations}\n}`;
-}

package/src/runtime/app/stores.js

@@ -32,7 +32,10 @@ export const getStores = () => {
 				subscribe: stores.navigating.subscribe
 			};
 		},
-		session: stores.session,
+		get session() {
+			removed_session();
+			return {};
+		},
 		updated: stores.updated
 	};
 };
@@ -54,29 +57,17 @@ export const navigating = {
 	}
 };
 
-/** @param {string} verb */
-const throw_error = (verb) => {
+function removed_session() {
+	// TODO remove for 1.0
 	throw new Error(
-		browser
-			? `Cannot ${verb} session store before subscribing`
-			: `Can only ${verb} session store in browser`
+		'stores.session is no longer available. See https://github.com/sveltejs/kit/discussions/5883'
 	);
-};
+}
 
-/** @type {typeof import('$app/stores').session} */
 export const session = {
-	subscribe(fn) {
-		const store = getStores().session;
-
-		if (browser) {
-			session.set = store.set;
-			session.update = store.update;
-		}
-
-		return store.subscribe(fn);
-	},
-	set: () => throw_error('set'),
-	update: () => throw_error('update')
+	subscribe: removed_session,
+	set: removed_session,
+	update: removed_session
 };
 
 /** @type {typeof import('$app/stores').updated} */
@@ -90,5 +81,11 @@ export const updated = {
 
 		return store.subscribe(fn);
 	},
-	check: () => throw_error('check')
+	check: () => {
+		throw new Error(
+			browser
+				? `Cannot check updated store before subscribing`
+				: `Can only check updated store in browser`
+		);
+	}
 };

package/src/runtime/client/client.js

@@ -50,13 +50,12 @@ function update_scroll_positions(index) {
 /**
  * @param {{
  *   target: Element;
- *   session: App.Session;
  *   base: string;
  *   trailing_slash: import('types').TrailingSlash;
  * }} opts
  * @returns {import('./types').Client}
  */
-export function create_client({ target, session, base, trailing_slash }) {
+export function create_client({ target, base, trailing_slash }) {
 	/** @type {Array<((href: string) => boolean)>} */
 	const invalidated = [];
 
@@ -64,7 +63,6 @@ export function create_client({ target, session, base, trailing_slash }) {
 		url: notifiable_store({}),
 		page: notifiable_store({}),
 		navigating: writable(/** @type {import('types').Navigation | null} */ (null)),
-		session: writable(session),
 		updated: create_updated_store()
 	};
 
@@ -102,23 +100,6 @@ export function create_client({ target, session, base, trailing_slash }) {
 	/** @type {import('svelte').SvelteComponent} */
 	let root;
 
-	/** @type {App.Session} */
-	let $session;
-
-	let ready = false;
-	stores.session.subscribe(async (value) => {
-		$session = value;
-
-		if (!ready) return;
-		session_id += 1;
-
-		const current_load_uses_session = current.branch.some((node) => node?.uses.session);
-		if (!current_load_uses_session) return;
-
-		update(new URL(location.href), []);
-	});
-	ready = true;
-
 	let router_enabled = true;
 
 	// keeping track of the history index in order to prevent popstate navigation events if needed
@@ -475,7 +456,6 @@ export function create_client({ target, session, base, trailing_slash }) {
 		const uses = {
 			params: new Set(),
 			url: false,
-			session: false,
 			dependencies: new Set(),
 			parent: false
 		};
@@ -511,7 +491,6 @@ export function create_client({ target, session, base, trailing_slash }) {
 			});
 		}
 
-		const session = $session;
 		const load_url = new LoadURL(url);
 
 		if (node.shared?.load) {
@@ -524,10 +503,6 @@ export function create_client({ target, session, base, trailing_slash }) {
 					uses.url = true;
 					return load_url;
 				},
-				get session() {
-					uses.session = true;
-					return session;
-				},
 				async fetch(resource, init) {
 					let requested;
 
@@ -581,6 +556,12 @@ export function create_client({ target, session, base, trailing_slash }) {
 						'@migration task: Replace `props` with `data` stuff https://github.com/sveltejs/kit/discussions/5774#discussioncomment-3292693'
 					);
 				},
+				get session() {
+					// TODO remove this for 1.0
+					throw new Error(
+						'session is no longer available. See https://github.com/sveltejs/kit/discussions/5883'
+					);
+				},
 				get stuff() {
 					throw new Error(
 						'@migration task: Remove stuff https://github.com/sveltejs/kit/discussions/5774#discussioncomment-3292693'
@@ -620,8 +601,7 @@ export function create_client({ target, session, base, trailing_slash }) {
 
 		const changed = current.url && {
 			url: id !== current.url.pathname + current.url.search,
-			params: Object.keys(params).filter((key) => current.params[key] !== params[key]),
-			session: session_id !== current.session_id
+			params: Object.keys(params).filter((key) => current.params[key] !== params[key])
 		};
 
 		// preload modules to avoid waterfall, but handle rejections
@@ -643,7 +623,6 @@ export function create_client({ target, session, base, trailing_slash }) {
 					!previous ||
 					(changed.url && previous.uses.url) ||
 					changed.params.some((param) => previous.uses.params.has(param)) ||
-					(changed.session && previous.uses.session) ||
 					Array.from(previous.uses.dependencies).some((dep) => invalidated.some((fn) => fn(dep))) ||
 					(previous.uses.parent && nodes_changed_since_last_render.includes(true));
 				nodes_changed_since_last_render.push(changed_since_last_render);
@@ -753,7 +732,6 @@ export function create_client({ target, session, base, trailing_slash }) {
 									uses: {
 										params: new Set(),
 										url: false,
-										session: false,
 										dependencies: new Set(),
 										parent: false
 									}
@@ -825,7 +803,6 @@ export function create_client({ target, session, base, trailing_slash }) {
 			uses: {
 				params: new Set(),
 				url: false,
-				session: false,
 				dependencies: new Set(),
 				parent: false
 			}

package/src/runtime/client/start.js

@@ -11,7 +11,6 @@ export { set_public_env } from '../env-public.js';
  *     base: string;
  *   },
  *   target: Element;
- *   session: any;
  *   route: boolean;
  *   spa: boolean;
  *   trailing_slash: import('types').TrailingSlash;
@@ -24,10 +23,9 @@ export { set_public_env } from '../env-public.js';
  *   };
  * }} opts
  */
-export async function start({ paths, target, session, route, spa, trailing_slash, hydrate }) {
+export async function start({ paths, target, route, spa, trailing_slash, hydrate }) {
 	const client = create_client({
 		target,
-		session,
 		base: paths.base,
 		trailing_slash
 	});

package/src/runtime/client/types.d.ts

@@ -69,7 +69,6 @@ export type BranchNode = {
 	uses: {
 		params: Set<string>;
 		url: boolean; // TODO make more granular?
-		session: boolean;
 		dependencies: Set<string>;
 		parent: boolean;
 	};

package/src/runtime/server/index.js

@@ -222,7 +222,6 @@ export async function respond(request, options, state) {
 						event,
 						options,
 						state,
-						$session: await options.hooks.getSession(event),
 						page_config: { router: true, hydrate: true },
 						status: 200,
 						error: null,
@@ -250,7 +249,8 @@ export async function respond(request, options, state) {
 								try {
 									if (error) return;
 
-									const node = n ? await options.manifest._.nodes[n]() : undefined;
+									// == because it could be undefined (in dev) or null (in build, because of JSON.stringify)
+									const node = n == undefined ? n : await options.manifest._.nodes[n]();
 									return {
 										// TODO return `uses`, so we can reuse server data effectively
 										data: await load_server_data({
@@ -260,7 +260,11 @@ export async function respond(request, options, state) {
 												/** @type {import('types').JSONObject} */
 												const data = {};
 												for (let j = 0; j < i; j += 1) {
-													Object.assign(data, await promises[j]);
+													const parent = await promises[j];
+													if (!parent || parent instanceof HttpError || 'error' in parent) {
+														return data;
+													}
+													Object.assign(data, parent.data);
 												}
 												return data;
 											}
@@ -360,12 +364,10 @@ export async function respond(request, options, state) {
 				// if this request came direct from the user, rather than
 				// via a `fetch` in a `load`, render a 404 page
 				if (!state.initiator) {
-					const $session = await options.hooks.getSession(event);
 					return await respond_with_error({
 						event,
 						options,
 						state,
-						$session,
 						status: 404,
 						error: new Error(`Not found: ${event.url.pathname}`),
 						resolve_opts
@@ -413,12 +415,10 @@ export async function respond(request, options, state) {
 
 		// TODO is this necessary? should we just return a plain 500 at this point?
 		try {
-			const $session = await options.hooks.getSession(event);
 			return await respond_with_error({
 				event,
 				options,
 				state,
-				$session,
 				status: 500,
 				error,
 				resolve_opts

package/src/runtime/server/page/index.js

@@ -43,8 +43,6 @@ export async function render_page(event, route, options, state, resolve_opts) {
 		}
 	}
 
-	const $session = await options.hooks.getSession(event);
-
 	const { fetcher, fetched, cookies } = create_fetch({ event, options, state, route });
 
 	try {
@@ -112,7 +110,6 @@ export async function render_page(event, route, options, state, resolve_opts) {
 				event,
 				options,
 				state,
-				$session,
 				resolve_opts
 			});
 		}
@@ -180,11 +177,9 @@ export async function render_page(event, route, options, state, resolve_opts) {
 			return Promise.resolve().then(async () => {
 				try {
 					return await load_data({
-						$session,
 						event,
 						fetcher,
 						node,
-						options,
 						parent: async () => {
 							const data = {};
 							for (let j = 0; j < i; j += 1) {
@@ -240,7 +235,6 @@ export async function render_page(event, route, options, state, resolve_opts) {
 								event,
 								options,
 								state,
-								$session,
 								resolve_opts,
 								page_config: { router: true, hydrate: true },
 								status,
@@ -294,7 +288,6 @@ export async function render_page(event, route, options, state, resolve_opts) {
 			event,
 			options,
 			state,
-			$session,
 			resolve_opts,
 			page_config: get_page_config(leaf_node, options),
 			status,
@@ -313,7 +306,6 @@ export async function render_page(event, route, options, state, resolve_opts) {
 			event,
 			options,
 			state,
-			$session,
 			status: 500,
 			error: /** @type {Error} */ (error),
 			resolve_opts

package/src/runtime/server/page/load_data.js

@@ -33,26 +33,15 @@ export async function load_server_data({ event, node, parent }) {
 /**
  * Calls the user's `load` function.
  * @param {{
- *   $session: Record<string, any>;
  *   event: import('types').RequestEvent;
  *   fetcher: typeof fetch;
  *   node: import('types').SSRNode | undefined;
- *   options: import('types').SSROptions;
  *   parent: () => Promise<Record<string, any>>;
  *   server_data_promise: Promise<import('types').JSONObject | null>;
  *   state: import('types').SSRState;
  * }} opts
  */
-export async function load_data({
-	$session,
-	event,
-	fetcher,
-	node,
-	options,
-	parent,
-	server_data_promise,
-	state
-}) {
+export async function load_data({ event, fetcher, node, parent, server_data_promise, state }) {
 	const server_data = await server_data_promise;
 
 	if (!node?.shared?.load) {
@@ -65,12 +54,10 @@ export async function load_data({
 		data: server_data,
 		routeId: event.routeId,
 		get session() {
-			if (node.shared.prerender ?? options.prerender.default) {
-				throw Error(
-					'Attempted to access session from a prerendered page. Session would never be populated.'
-				);
-			}
-			return $session;
+			// TODO remove for 1.0
+			throw new Error(
+				'session is no longer available. See https://github.com/sveltejs/kit/discussions/5883'
+			);
 		},
 		fetch: fetcher,
 		setHeaders: event.setHeaders,

package/src/runtime/server/page/render.js

@@ -1,7 +1,6 @@
 import devalue from 'devalue';
 import { readable, writable } from 'svelte/store';
 import * as cookie from 'cookie';
-import { coalesce_to_error } from '../../../utils/error.js';
 import { hash } from '../../hash.js';
 import { render_json_payload_script } from '../../../utils/escape.js';
 import { s } from '../../../utils/misc.js';
@@ -25,7 +24,6 @@ const updated = {
  *   cookies: import('set-cookie-parser').Cookie[];
  *   options: import('types').SSROptions;
  *   state: import('types').SSRState;
- *   $session: any;
  *   page_config: { hydrate: boolean, router: boolean };
  *   status: number;
  *   error: HttpError | Error | null;
@@ -40,7 +38,6 @@ export async function render_response({
 	cookies,
 	options,
 	state,
-	$session,
 	page_config,
 	status,
 	error = null,
@@ -79,14 +76,11 @@ export async function render_response({
 	}
 
 	if (resolve_opts.ssr) {
-		const session = writable($session);
-
 		/** @type {Record<string, any>} */
 		const props = {
 			stores: {
 				page: writable(null),
 				navigating: writable(null),
-				session,
 				updated
 			},
 			/** @type {import('types').Page} */
@@ -165,9 +159,6 @@ export async function render_response({
 		start({
 			target: document.querySelector('[data-sveltekit-hydrate="${target}"]').parentNode,
 			paths: ${s(options.paths)},
-			session: ${try_serialize($session, (error) => {
-				throw new Error(`Failed to serialize session data: ${error.message}`);
-			})},
 			route: ${!!page_config.router},
 			spa: ${!resolve_opts.ssr},
 			trailing_slash: ${s(options.trailing_slash)},
@@ -348,16 +339,3 @@ export async function render_response({
 		headers
 	});
 }
-
-/**
- * @param {any} data
- * @param {(error: Error) => void} [fail]
- */
-function try_serialize(data, fail) {
-	try {
-		return devalue(data);
-	} catch (err) {
-		if (fail) fail(coalesce_to_error(err));
-		return null;
-	}
-}

package/src/runtime/server/page/respond_with_error.js

@@ -15,21 +15,12 @@ import { create_fetch } from './fetch.js';
  *   event: import('types').RequestEvent;
  *   options: SSROptions;
  *   state: SSRState;
- *   $session: any;
  *   status: number;
  *   error: Error;
  *   resolve_opts: import('types').RequiredResolveOptions;
  * }} opts
  */
-export async function respond_with_error({
-	event,
-	options,
-	state,
-	$session,
-	status,
-	error,
-	resolve_opts
-}) {
+export async function respond_with_error({ event, options, state, status, error, resolve_opts }) {
 	const { fetcher, fetched, cookies } = create_fetch({
 		event,
 		options,
@@ -52,11 +43,9 @@ export async function respond_with_error({
 			const server_data = await server_data_promise;
 
 			const data = await load_data({
-				$session,
 				event,
 				fetcher,
 				node: default_layout,
-				options,
 				parent: async () => ({}),
 				server_data_promise,
 				state
@@ -79,7 +68,6 @@ export async function respond_with_error({
 		return await render_response({
 			options,
 			state,
-			$session,
 			page_config: {
 				hydrate: options.hydrate,
 				router: options.router

package/src/vite/build/build_server.js

@@ -110,7 +110,6 @@ export class Server {
 		if (!this.options.hooks) {
 			const module = await import(${s(hooks)});
 			this.options.hooks = {
-				getSession: module.getSession || (() => ({})),
 				handle: module.handle || (({ event, resolve }) => resolve(event)),
 				handleError: module.handleError || (({ error }) => console.error(error.stack)),
 				externalFetch: module.externalFetch || fetch

package/src/vite/dev/index.js

@@ -343,7 +343,6 @@ export async function dev(vite, vite_config, svelte_config, illegal_imports) {
 
 				/** @type {import('types').Hooks} */
 				const hooks = {
-					getSession: user_hooks.getSession || (() => ({})),
 					handle,
 					handleError:
 						user_hooks.handleError ||

package/src/vite/index.js

@@ -14,8 +14,9 @@ import { generate_manifest } from '../core/generate_manifest/index.js';
 import { runtime_directory, logger } from '../core/utils.js';
 import { find_deps, get_default_config as get_default_build_config } from './build/utils.js';
 import { preview } from './preview/index.js';
-import { get_aliases, resolve_entry, prevent_illegal_rollup_imports } from './utils.js';
+import { get_aliases, resolve_entry, prevent_illegal_rollup_imports, get_env } from './utils.js';
 import { fileURLToPath } from 'node:url';
+import { create_module } from '../core/env.js';
 
 const cwd = process.cwd();
 
@@ -107,6 +108,9 @@ function kit() {
 	/** @type {string | undefined} */
 	let deferred_warning;
 
+	/** @type {{ public: Record<string, string>; private: Record<string, string> }} */
+	let env;
+
 	/**
 	 * @type {{
 	 *   build_dir: string;
@@ -191,13 +195,13 @@ function kit() {
 		 * @see https://vitejs.dev/guide/api-plugin.html#config
 		 */
 		async config(config, config_env) {
-			// The config is created in build_server for SSR mode and passed inline
-			if (config.build?.ssr) {
-				return;
-			}
-
 			vite_config_env = config_env;
 			svelte_config = await load_config();
+			env = get_env(vite_config_env.mode, svelte_config.kit.env.publicPrefix);
+
+			// The config is created in build_server for SSR mode and passed inline
+			if (config.build?.ssr) return;
+
 			is_build = config_env.command === 'build';
 
 			paths = {
@@ -269,6 +273,20 @@ function kit() {
 			return result;
 		},
 
+		async resolveId(id) {
+			// treat $env/static/[public|private] as virtual
+			if (id.startsWith('$env/static/')) return `\0${id}`;
+		},
+
+		async load(id) {
+			switch (id) {
+				case '\0$env/static/private':
+					return create_module('$env/static/private', env.private);
+				case '\0$env/static/public':
+					return create_module('$env/static/public', env.public);
+			}
+		},
+
 		/**
 		 * Stores the final config.
 		 */
@@ -432,9 +450,10 @@ function kit() {
 				await adapt(svelte_config, build_data, prerendered, { log });
 			} else {
 				console.log(colors.bold().yellow('\nNo adapter specified'));
-				// prettier-ignore
+
+				const link = colors.bold().cyan('https://kit.svelte.dev/docs/adapters');
 				console.log(
-					`See ${colors.bold().cyan('https://kit.svelte.dev/docs/adapters')} to learn how to configure your app to run on the platform of your choosing`
+					`See ${link} to learn how to configure your app to run on the platform of your choosing`
 				);
 			}
 

package/src/vite/utils.js

@@ -105,6 +105,8 @@ export function get_aliases(config) {
 	const alias = [
 		{ find: '__GENERATED__', replacement: path.posix.join(config.outDir, 'generated') },
 		{ find: '$app', replacement: `${runtime_directory}/app` },
+		{ find: '$env/dynamic/public', replacement: `${runtime_directory}/env/dynamic/public.js` },
+		{ find: '$env/dynamic/private', replacement: `${runtime_directory}/env/dynamic/private.js` },
 		// For now, we handle `$lib` specially here rather than make it a default value for
 		// `config.kit.alias` since it has special meaning for packaging, etc.
 		{ find: '$lib', replacement: config.files.lib }
@@ -128,21 +130,6 @@ export function get_aliases(config) {
 		}
 	}
 
-	alias.push(
-		{
-			find: '$env/static/public',
-			replacement: path.posix.join(config.outDir, 'runtime/env/static/public.js')
-		},
-		{
-			find: '$env/static/private',
-			replacement: path.posix.join(config.outDir, 'runtime/env/static/private.js')
-		},
-		{
-			find: '$env',
-			replacement: `${runtime_directory}/env`
-		}
-	);
-
 	return alias;
 }
 

package/types/ambient.d.ts

@@ -12,12 +12,10 @@
  * 	interface PrivateEnv {}
  *
  * 	interface PublicEnv {}
- *
- * 	interface Session {}
  * }
  * ```
  *
- * By populating these interfaces, you will gain type safety when using `env`, `event.locals`, `event.platform`, `session` and `stuff`.
+ * By populating these interfaces, you will gain type safety when using `env`, `event.locals` and `event.platform`.
  *
  * Note that since it's an ambient declaration file, you have to be careful when using `import` statements. Once you add an `import`
  * at the top level, the declaration file is no longer considered ambient and you lose access to these typings in other files.
@@ -45,7 +43,7 @@
  */
 declare namespace App {
 	/**
-	 * The interface that defines `event.locals`, which can be accessed in [hooks](https://kit.svelte.dev/docs/hooks) (`handle`, `handleError` and `getSession`) and [endpoints](https://kit.svelte.dev/docs/routing#endpoints).
+	 * The interface that defines `event.locals`, which can be accessed in [hooks](https://kit.svelte.dev/docs/hooks) (`handle`, and `handleError`), server-only `load` functions, and `+server.js` files.
 	 */
 	export interface Locals {}
 
@@ -63,11 +61,6 @@ declare namespace App {
 	 * The interface that defines the dynamic environment variables exported from `$env/dynamic/public`.
 	 */
 	export interface PublicEnv extends Record<string, string> {}
-
-	/**
-	 * The interface that defines `session`, both as an argument to [`load`](https://kit.svelte.dev/docs/load) functions and the value of the [session store](https://kit.svelte.dev/docs/modules#$app-stores).
-	 */
-	export interface Session {}
 }
 
 /**
@@ -220,15 +213,15 @@ declare module '$app/paths' {
 
 /**
  * ```ts
- * import { getStores, navigating, page, session, updated } from '$app/stores';
+ * import { getStores, navigating, page, updated } from '$app/stores';
  * ```
  *
- * Stores are _contextual_ — they are added to the [context](https://svelte.dev/tutorial/context-api) of your root component. This means that `session` and `page` are unique to each request on the server, rather than shared between multiple requests handled by the same server simultaneously, which is what makes it safe to include user-specific data in `session`.
+ * Stores are _contextual_ — they are added to the [context](https://svelte.dev/tutorial/context-api) of your root component. This means that `page` is unique to each request on the server, rather than shared between multiple requests handled by the same server simultaneously.
  *
  * Because of that, you must subscribe to the stores during component initialization (which happens automatically if you reference the store value, e.g. as `$page`, in a component) before you can use them.
  */
 declare module '$app/stores' {
-	import { Readable, Writable } from 'svelte/store';
+	import { Readable } from 'svelte/store';
 	import { Navigation, Page } from '@sveltejs/kit';
 
 	/**
@@ -238,7 +231,6 @@ declare module '$app/stores' {
 	export function getStores(): {
 		navigating: typeof navigating;
 		page: typeof page;
-		session: typeof session;
 		updated: typeof updated;
 	};
 
@@ -252,11 +244,6 @@ declare module '$app/stores' {
 	 * When navigating finishes, its value reverts to `null`.
 	 */
 	export const navigating: Readable<Navigation | null>;
-	/**
-	 * A writable store whose initial value is whatever was returned from [`getSession`](https://kit.svelte.dev/docs/hooks#getsession).
-	 * It can be written to, but this will not cause changes to persist on the server — this is something you must implement yourself.
-	 */
-	export const session: Writable<App.Session>;
 	/**
 	 *  A readable store whose initial value is `false`. If [`version.pollInterval`](https://kit.svelte.dev/docs/configuration#version) is a non-zero value, SvelteKit will poll for new versions of the app and update the store value to `true` when it detects one. `updated.check()` will force an immediate check, regardless of polling.
 	 */

package/types/index.d.ts

@@ -177,10 +177,6 @@ export interface ExternalFetch {
 	(req: Request): Promise<Response>;
 }
 
-export interface GetSession {
-	(event: RequestEvent): MaybePromise<App.Session>;
-}
-
 export interface Handle {
 	(input: {
 		event: RequestEvent;
@@ -214,7 +210,6 @@ export interface LoadEvent<
 	params: Params;
 	data: Data;
 	routeId: string | null;
-	session: App.Session;
 	setHeaders: (headers: ResponseHeaders) => void;
 	url: URL;
 	parent: () => Promise<ParentData>;

package/types/internal.d.ts

@@ -5,7 +5,6 @@ import {
 	Config,
 	ExternalFetch,
 	ServerLoad,
-	GetSession,
 	Handle,
 	HandleError,
 	KitConfig,
@@ -92,7 +91,6 @@ export type GetParams = (match: RegExpExecArray) => Record<string, string>;
 
 export interface Hooks {
 	externalFetch: ExternalFetch;
-	getSession: GetSession;
 	handle: Handle;
 	handleError: HandleError;
 }