@sveltejs/kit 1.0.0-next.44 → 1.0.0-next.440

package/src/core/sync/write_types/test/layout-advanced/+layout.js

@@ -0,0 +1,5 @@
+export function load() {
+	return {
+		root: 'root'
+	};
+}

package/src/core/sync/write_types/test/layout-advanced/_expected/$types.d.ts

@@ -0,0 +1,32 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = {};
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type LayoutParams = RouteParams & {};
+type LayoutParentData = EnsureParentData<{}>;
+
+export type LayoutServerData = null;
+export type LayoutLoad<
+	OutputData extends (Partial<App.PageData> & Record<string, any>) | void =
+		| (Partial<App.PageData> & Record<string, any>)
+		| void
+> = Kit.Load<LayoutParams, LayoutServerData, LayoutParentData, OutputData>;
+export type LayoutLoadEvent = Parameters<LayoutLoad>[0];
+export type LayoutData = Omit<
+	LayoutParentData,
+	keyof Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../+layout.js').load>>
+	>
+> &
+	Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../+layout.js').load>>
+	>;

package/src/core/sync/write_types/test/layout-advanced/_expected/(main)/$types.d.ts

@@ -0,0 +1,42 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = {};
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type PageParentData = EnsureParentData<import('../$types.js').LayoutData>;
+type LayoutParams = RouteParams & {};
+type LayoutServerParentData = EnsureParentData<import('../$types.js').LayoutServerData>;
+type LayoutParentData = EnsureParentData<import('../$types.js').LayoutData>;
+
+export type PageServerData = null;
+export type PageLoad<
+	OutputData extends OutputDataShape<PageParentData> = OutputDataShape<PageParentData>
+> = Kit.Load<RouteParams, PageServerData, PageParentData, OutputData>;
+export type PageLoadEvent = Parameters<PageLoad>[0];
+export type PageData = Omit<
+	PageParentData,
+	keyof Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../../(main)/+page.js').load>>
+	>
+> &
+	Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../../(main)/+page.js').load>>
+	>;
+export type LayoutServerLoad<
+	OutputData extends (Partial<App.PageData> & Record<string, any>) | void =
+		| (Partial<App.PageData> & Record<string, any>)
+		| void
+> = Kit.ServerLoad<LayoutParams, LayoutServerParentData, OutputData>;
+export type LayoutServerLoadEvent = Parameters<LayoutServerLoad>[0];
+export type LayoutServerData = Kit.AwaitedProperties<
+	Awaited<ReturnType<typeof import('../../../../../../../../../(main)/+layout.server.js').load>>
+>;
+export type LayoutData = Omit<LayoutParentData, keyof LayoutServerData> & LayoutServerData;

package/src/core/sync/write_types/test/layout-advanced/_expected/(main)/sub/$types.d.ts

@@ -0,0 +1,32 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = {};
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type PageParentData = EnsureParentData<
+	Omit<import('../../$types.js').LayoutData, keyof import('../$types.js').LayoutData> &
+		import('../$types.js').LayoutData
+>;
+
+export type PageServerData = null;
+export type PageLoad<
+	OutputData extends OutputDataShape<PageParentData> = OutputDataShape<PageParentData>
+> = Kit.Load<RouteParams, PageServerData, PageParentData, OutputData>;
+export type PageLoadEvent = Parameters<PageLoad>[0];
+export type PageData = Omit<
+	PageParentData,
+	keyof Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../../../(main)/sub/+page.js').load>>
+	>
+> &
+	Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../../../(main)/sub/+page.js').load>>
+	>;

package/src/core/sync/write_types/test/simple-page-server-and-shared/+page.js

@@ -0,0 +1,5 @@
+export function load() {
+	return {
+		shared: 'shared'
+	};
+}

package/src/core/sync/write_types/test/simple-page-server-and-shared/+page.server.js

@@ -0,0 +1,5 @@
+export function load() {
+	return {
+		server: 'server'
+	};
+}

package/src/core/sync/write_types/test/simple-page-server-and-shared/_expected/$types.d.ts

@@ -0,0 +1,44 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = {};
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type PageServerParentData = EnsureParentData<LayoutServerData>;
+type PageParentData = EnsureParentData<LayoutData>;
+type LayoutParams = RouteParams & {};
+type LayoutParentData = EnsureParentData<{}>;
+
+export type PageServerLoad<
+	OutputData extends (Partial<App.PageData> & Record<string, any>) | void =
+		| (Partial<App.PageData> & Record<string, any>)
+		| void
+> = Kit.ServerLoad<RouteParams, PageServerParentData, OutputData>;
+export type PageServerLoadEvent = Parameters<PageServerLoad>[0];
+export type Errors = null;
+export type PageServerData = Kit.AwaitedProperties<
+	Awaited<ReturnType<typeof import('../../../../../../../../+page.server.js').load>>
+>;
+export type PageLoad<
+	OutputData extends OutputDataShape<PageParentData> = OutputDataShape<PageParentData>
+> = Kit.Load<RouteParams, PageServerData, PageParentData, OutputData>;
+export type PageLoadEvent = Parameters<PageLoad>[0];
+export type PageData = Omit<
+	PageParentData,
+	keyof Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../+page.js').load>>
+	>
+> &
+	Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../+page.js').load>>
+	>;
+export type Action = Kit.Action<RouteParams>;
+export type LayoutServerData = null;
+export type LayoutData = LayoutParentData;

package/src/core/sync/write_types/test/simple-page-server-only/+page.server.js

@@ -0,0 +1,5 @@
+export function load() {
+	return {
+		foo: 'bar'
+	};
+}

package/src/core/sync/write_types/test/simple-page-server-only/_expected/$types.d.ts

@@ -0,0 +1,30 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = {};
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type PageServerParentData = EnsureParentData<LayoutServerData>;
+type PageParentData = EnsureParentData<LayoutData>;
+type LayoutParams = RouteParams & {};
+type LayoutParentData = EnsureParentData<{}>;
+
+export type PageServerLoad<
+	OutputData extends OutputDataShape<PageServerParentData> = OutputDataShape<PageServerParentData>
+> = Kit.ServerLoad<RouteParams, PageServerParentData, OutputData>;
+export type PageServerLoadEvent = Parameters<PageServerLoad>[0];
+export type Errors = null;
+export type PageServerData = Kit.AwaitedProperties<
+	Awaited<ReturnType<typeof import('../../../../../../../../+page.server.js').load>>
+>;
+export type PageData = Omit<PageParentData, keyof PageServerData> & PageServerData;
+export type Action = Kit.Action<RouteParams>;
+export type LayoutServerData = null;
+export type LayoutData = LayoutParentData;

package/src/core/sync/write_types/test/simple-page-shared-only/+page.js

@@ -0,0 +1,5 @@
+export function load() {
+	return {
+		shared: 'shared'
+	};
+}

package/src/core/sync/write_types/test/simple-page-shared-only/_expected/$types.d.ts

@@ -0,0 +1,33 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = {};
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type PageParentData = EnsureParentData<LayoutData>;
+type LayoutParams = RouteParams & {};
+type LayoutParentData = EnsureParentData<{}>;
+
+export type PageServerData = null;
+export type PageLoad<
+	OutputData extends OutputDataShape<PageParentData> = OutputDataShape<PageParentData>
+> = Kit.Load<RouteParams, PageServerData, PageParentData, OutputData>;
+export type PageLoadEvent = Parameters<PageLoad>[0];
+export type PageData = Omit<
+	PageParentData,
+	keyof Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../+page.js').load>>
+	>
+> &
+	Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../+page.js').load>>
+	>;
+export type LayoutServerData = null;
+export type LayoutData = LayoutParentData;

package/src/core/sync/write_types/test/slugs/+layout.js

@@ -0,0 +1 @@
+export function load() {}

package/src/core/sync/write_types/test/slugs/+layout.svelte

@@ -0,0 +1 @@
+export function load() {}

package/src/core/sync/write_types/test/slugs/[...rest]/+page.js

@@ -0,0 +1,3 @@
+export function load() {
+	return { rest: 'rest' };
+}

package/src/core/sync/write_types/test/slugs/[slug]/+page.js

@@ -0,0 +1,3 @@
+export function load() {
+	return { slug: 'slug' };
+}

package/src/core/sync/write_types/test/slugs/_expected/$types.d.ts

@@ -0,0 +1,32 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = {};
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type LayoutParams = RouteParams & { rest?: string; slug?: string };
+type LayoutParentData = EnsureParentData<{}>;
+
+export type LayoutServerData = null;
+export type LayoutLoad<
+	OutputData extends (Partial<App.PageData> & Record<string, any>) | void =
+		| (Partial<App.PageData> & Record<string, any>)
+		| void
+> = Kit.Load<LayoutParams, LayoutServerData, LayoutParentData, OutputData>;
+export type LayoutLoadEvent = Parameters<LayoutLoad>[0];
+export type LayoutData = Omit<
+	LayoutParentData,
+	keyof Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../+layout.js').load>>
+	>
+> &
+	Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../+layout.js').load>>
+	>;

package/src/core/sync/write_types/test/slugs/_expected/[...rest]/$types.d.ts

@@ -0,0 +1,29 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = { rest: string };
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type PageParentData = EnsureParentData<import('../$types.js').LayoutData>;
+
+export type PageServerData = null;
+export type PageLoad<
+	OutputData extends OutputDataShape<PageParentData> = OutputDataShape<PageParentData>
+> = Kit.Load<RouteParams, PageServerData, PageParentData, OutputData>;
+export type PageLoadEvent = Parameters<PageLoad>[0];
+export type PageData = Omit<
+	PageParentData,
+	keyof Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../../[...rest]/+page.js').load>>
+	>
+> &
+	Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../../[...rest]/+page.js').load>>
+	>;

package/src/core/sync/write_types/test/slugs/_expected/[slug]/$types.d.ts

@@ -0,0 +1,29 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = { slug: string };
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type PageParentData = EnsureParentData<import('../$types.js').LayoutData>;
+
+export type PageServerData = null;
+export type PageLoad<
+	OutputData extends OutputDataShape<PageParentData> = OutputDataShape<PageParentData>
+> = Kit.Load<RouteParams, PageServerData, PageParentData, OutputData>;
+export type PageLoadEvent = Parameters<PageLoad>[0];
+export type PageData = Omit<
+	PageParentData,
+	keyof Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../../[slug]/+page.js').load>>
+	>
+> &
+	Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../../[slug]/+page.js').load>>
+	>;

package/src/core/sync/write_types/test/slugs-layout-not-all-pages-have-load/+layout.js

@@ -0,0 +1 @@
+export function load() {}

package/src/core/sync/write_types/test/slugs-layout-not-all-pages-have-load/+layout.svelte

@@ -0,0 +1 @@
+export function load() {}

package/src/core/sync/write_types/test/slugs-layout-not-all-pages-have-load/_expected/$types.d.ts

@@ -0,0 +1,30 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = {};
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type LayoutParams = RouteParams & { rest?: string; slug?: string };
+type LayoutParentData = EnsureParentData<{}>;
+
+export type LayoutServerData = null;
+export type LayoutLoad<
+	OutputData extends OutputDataShape<LayoutParentData> = OutputDataShape<LayoutParentData>
+> = Kit.Load<LayoutParams, LayoutServerData, LayoutParentData, OutputData>;
+export type LayoutLoadEvent = Parameters<LayoutLoad>[0];
+export type LayoutData = Omit<
+	LayoutParentData,
+	keyof Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../+layout.js').load>>
+	>
+> &
+	Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../+layout.js').load>>
+	>;

package/src/core/sync/write_types/test/slugs-layout-not-all-pages-have-load/_expected/nested/$types.d.ts

@@ -0,0 +1,32 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = {};
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type LayoutParams = RouteParams & { rest?: string };
+type LayoutParentData = EnsureParentData<import('../$types.js').LayoutData>;
+
+export type LayoutServerData = null;
+export type LayoutLoad<
+	OutputData extends (Partial<App.PageData> & Record<string, any>) | void =
+		| (Partial<App.PageData> & Record<string, any>)
+		| void
+> = Kit.Load<LayoutParams, LayoutServerData, LayoutParentData, OutputData>;
+export type LayoutLoadEvent = Parameters<LayoutLoad>[0];
+export type LayoutData = Omit<
+	LayoutParentData,
+	keyof Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../../nested/+layout.js').load>>
+	>
+> &
+	Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../../nested/+layout.js').load>>
+	>;

package/src/core/sync/write_types/test/slugs-layout-not-all-pages-have-load/_expected/nested/[...rest]/$types.d.ts

@@ -0,0 +1,36 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = { rest: string };
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type PageParentData = EnsureParentData<
+	Omit<import('../../$types.js').LayoutData, keyof import('../$types.js').LayoutData> &
+		import('../$types.js').LayoutData
+>;
+
+export type PageServerData = null;
+export type PageLoad<
+	OutputData extends OutputDataShape<PageParentData> = OutputDataShape<PageParentData>
+> = Kit.Load<RouteParams, PageServerData, PageParentData, OutputData>;
+export type PageLoadEvent = Parameters<PageLoad>[0];
+export type PageData = Omit<
+	PageParentData,
+	keyof Kit.AwaitedProperties<
+		Awaited<
+			ReturnType<typeof import('../../../../../../../../../../nested/[...rest]/+page.js').load>
+		>
+	>
+> &
+	Kit.AwaitedProperties<
+		Awaited<
+			ReturnType<typeof import('../../../../../../../../../../nested/[...rest]/+page.js').load>
+		>
+	>;

package/src/core/sync/write_types/test/slugs-layout-not-all-pages-have-load/_expected/nested/[slug]/$types.d.ts

@@ -0,0 +1,17 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = { slug: string };
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type PageParentData = EnsureParentData<import('../../$types.js').LayoutData>;
+
+export type PageServerData = null;
+export type PageData = PageParentData;

package/src/core/sync/write_types/test/slugs-layout-not-all-pages-have-load/nested/+layout.js

@@ -0,0 +1 @@
+export function load() {}

package/src/core/sync/write_types/test/slugs-layout-not-all-pages-have-load/nested/+layout.svelte

@@ -0,0 +1 @@
+export function load() {}

package/src/core/sync/write_types/test/slugs-layout-not-all-pages-have-load/nested/[...rest]/+page.js

@@ -0,0 +1,3 @@
+export function load() {
+	return { rest: 'rest' };
+}

package/src/core/utils.js

@@ -0,0 +1,70 @@
+import path from 'path';
+import colors from 'kleur';
+import { fileURLToPath } from 'url';
+import { posixify } from '../utils/filesystem.js';
+
+/**
+ * Resolved path of the `runtime` directory
+ *
+ * TODO Windows issue:
+ * Vite or sth else somehow sets the driver letter inconsistently to lower or upper case depending on the run environment.
+ * In playwright debug mode run through VS Code this a root-to-lowercase conversion is needed in order for the tests to run.
+ * If we do this conversion in other cases it has the opposite effect though and fails.
+ */
+export const runtime_directory = posixify(fileURLToPath(new URL('../runtime', import.meta.url)));
+
+/** Prefix for the `runtime` directory, for use with import declarations */
+export const runtime_prefix = posixify_path(runtime_directory);
+
+/**
+ * This allows us to import SvelteKit internals that aren't exposed via `pkg.exports` in a
+ * way that works whether `@sveltejs/kit` is installed inside the project's `node_modules`
+ * or in a workspace root
+ */
+export const runtime_base = runtime_directory.startsWith(process.cwd())
+	? `/${path.relative('.', runtime_directory)}`
+	: `/@fs${
+			// Windows/Linux separation - Windows starts with a drive letter, we need a / in front there
+			runtime_directory.startsWith('/') ? '' : '/'
+	  }${runtime_directory}`;
+
+/** @param {string} str */
+function posixify_path(str) {
+	const parsed = path.parse(str);
+	return `/${parsed.dir.slice(parsed.root.length).split(path.sep).join('/')}/${parsed.base}`;
+}
+
+function noop() {}
+
+/** @param {{ verbose: boolean }} opts */
+export function logger({ verbose }) {
+	/** @type {import('types').Logger} */
+	const log = (msg) => console.log(msg.replace(/^/gm, '  '));
+
+	/** @param {string} msg */
+	const err = (msg) => console.error(msg.replace(/^/gm, '  '));
+
+	log.success = (msg) => log(colors.green(`✔ ${msg}`));
+	log.error = (msg) => err(colors.bold().red(msg));
+	log.warn = (msg) => log(colors.bold().yellow(msg));
+
+	log.minor = verbose ? (msg) => log(colors.grey(msg)) : noop;
+	log.info = verbose ? log : noop;
+
+	return log;
+}
+
+/** @param {import('types').ManifestData} manifest_data */
+export function get_mime_lookup(manifest_data) {
+	/** @type {Record<string, string>} */
+	const mime = {};
+
+	manifest_data.assets.forEach((asset) => {
+		if (asset.type) {
+			const ext = path.extname(asset.file);
+			mime[ext] = asset.type;
+		}
+	});
+
+	return mime;
+}

package/src/hooks.js

@@ -0,0 +1,26 @@
+/**
+ * @param {...import('types').Handle} handlers
+ * @returns {import('types').Handle}
+ */
+export function sequence(...handlers) {
+	const length = handlers.length;
+	if (!length) return ({ event, resolve }) => resolve(event);
+
+	return ({ event, resolve }) => {
+		return apply_handle(0, event);
+
+		/**
+		 * @param {number} i
+		 * @param {import('types').RequestEvent} event
+		 * @returns {import('types').MaybePromise<Response>}
+		 */
+		function apply_handle(i, event) {
+			const handle = handlers[i];
+
+			return handle({
+				event,
+				resolve: i < length - 1 ? (event) => apply_handle(i + 1, event) : resolve
+			});
+		}
+	};
+}