@thomasfosterau/effect-sveltekit 0.0.0

package/dist/server/Hooks.d.ts

@@ -0,0 +1,97 @@
+import { SvelteKitServices } from "../app-runtime.js";
+import { Effect } from "effect";
+import { Handle, HandleFetch, HandleServerError, ServerInit } from "@sveltejs/kit";
+
+//#region src/server/Hooks.d.ts
+declare namespace Hooks_d_exports {
+  export { handle, handleError, handleFetch, init };
+}
+/**
+ * Wraps an Effect-based function as a SvelteKit
+ * [`handle`](https://svelte.dev/docs/kit/hooks#Server-hooks-handle) hook, which
+ * runs on every request and controls how the response is produced.
+ *
+ * SvelteKit control flow (`redirect()`, `error()`) raised inside the effect is
+ * passed through to SvelteKit.
+ *
+ * @example
+ * ```ts
+ * // src/hooks.server.ts
+ * import { Hooks } from '@thomasfosterau/effect-sveltekit/server';
+ * import { Effect } from 'effect';
+ *
+ * export const handle = Hooks.handle(({ event, resolve }) =>
+ *   Effect.gen(function* () {
+ *     // custom logic before resolve
+ *     const response = yield* Effect.promise(() => resolve(event));
+ *     // custom logic after resolve
+ *     return response;
+ *   })
+ * );
+ * ```
+ */
+declare function handle(fn: (args: Parameters<Handle>[0]) => Effect.Effect<Response, unknown, SvelteKitServices>): Handle;
+/**
+ * Wraps an Effect-based function as a SvelteKit
+ * [`handleFetch`](https://svelte.dev/docs/kit/hooks#Server-hooks-handleFetch)
+ * hook, which intercepts `event.fetch` calls made on the server (in `load`,
+ * actions, endpoints, ...). The effect produces the `Response` to use.
+ *
+ * @example
+ * ```ts
+ * // src/hooks.server.ts
+ * import { Hooks } from '@thomasfosterau/effect-sveltekit/server';
+ * import { Effect } from 'effect';
+ *
+ * export const handleFetch = Hooks.handleFetch(({ request, fetch }) =>
+ *   Effect.gen(function* () {
+ *     // Redirect internal API calls to the upstream service.
+ *     const url = request.url.replace('https://api.internal', 'http://localhost:9999');
+ *     return yield* Effect.promise(() => fetch(new Request(url, request)));
+ *   })
+ * );
+ * ```
+ */
+declare function handleFetch(fn: (args: Parameters<HandleFetch>[0]) => Effect.Effect<Response, unknown, SvelteKitServices>): HandleFetch;
+/**
+ * Wraps an Effect-based function as the SvelteKit server
+ * [`handleError`](https://svelte.dev/docs/kit/hooks#Shared-hooks-handleError)
+ * hook, which runs when an unexpected error is thrown while responding to a
+ * request. The effect receives the error and request event and produces the
+ * shape exposed to the client (your `App.Error`, or nothing).
+ *
+ * @example
+ * ```ts
+ * // src/hooks.server.ts
+ * import { Hooks } from '@thomasfosterau/effect-sveltekit/server';
+ * import { Effect } from 'effect';
+ *
+ * export const handleError = Hooks.handleError(({ error, event }) =>
+ *   Effect.gen(function* () {
+ *     const id = crypto.randomUUID();
+ *     yield* Effect.logError(`${event.url.pathname} (${id})`, error);
+ *     return { message: 'Internal Error', id };
+ *   })
+ * );
+ * ```
+ */
+declare function handleError(fn: (args: Parameters<HandleServerError>[0]) => Effect.Effect<Awaited<ReturnType<HandleServerError>>, unknown, SvelteKitServices>): HandleServerError;
+/**
+ * Wraps an Effect as the SvelteKit server
+ * [`init`](https://svelte.dev/docs/kit/hooks#Shared-hooks-init) hook, which
+ * runs once before the server responds to its first request. There is no
+ * request event available, so the effect runs without per-request services.
+ *
+ * @example
+ * ```ts
+ * // src/hooks.server.ts
+ * import { Hooks } from '@thomasfosterau/effect-sveltekit/server';
+ * import { Effect } from 'effect';
+ *
+ * export const init = Hooks.init(Effect.logInfo('server starting up'));
+ * ```
+ */
+declare function init(effect: Effect.Effect<void, unknown>): ServerInit;
+//#endregion
+export { Hooks_d_exports };
+//# sourceMappingURL=Hooks.d.ts.map

package/dist/server/Hooks.js

@@ -0,0 +1,108 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { defaultServerRuntime } from "../internal/default-runtime.js";
+import "effect";
+//#region src/server/Hooks.ts
+var Hooks_exports = /* @__PURE__ */ __exportAll({
+	handle: () => handle,
+	handleError: () => handleError,
+	handleFetch: () => handleFetch,
+	init: () => init
+});
+/**
+* Wraps an Effect-based function as a SvelteKit
+* [`handle`](https://svelte.dev/docs/kit/hooks#Server-hooks-handle) hook, which
+* runs on every request and controls how the response is produced.
+*
+* SvelteKit control flow (`redirect()`, `error()`) raised inside the effect is
+* passed through to SvelteKit.
+*
+* @example
+* ```ts
+* // src/hooks.server.ts
+* import { Hooks } from '@thomasfosterau/effect-sveltekit/server';
+* import { Effect } from 'effect';
+*
+* export const handle = Hooks.handle(({ event, resolve }) =>
+*   Effect.gen(function* () {
+*     // custom logic before resolve
+*     const response = yield* Effect.promise(() => resolve(event));
+*     // custom logic after resolve
+*     return response;
+*   })
+* );
+* ```
+*/
+function handle(fn) {
+	return defaultServerRuntime().handle(fn);
+}
+/**
+* Wraps an Effect-based function as a SvelteKit
+* [`handleFetch`](https://svelte.dev/docs/kit/hooks#Server-hooks-handleFetch)
+* hook, which intercepts `event.fetch` calls made on the server (in `load`,
+* actions, endpoints, ...). The effect produces the `Response` to use.
+*
+* @example
+* ```ts
+* // src/hooks.server.ts
+* import { Hooks } from '@thomasfosterau/effect-sveltekit/server';
+* import { Effect } from 'effect';
+*
+* export const handleFetch = Hooks.handleFetch(({ request, fetch }) =>
+*   Effect.gen(function* () {
+*     // Redirect internal API calls to the upstream service.
+*     const url = request.url.replace('https://api.internal', 'http://localhost:9999');
+*     return yield* Effect.promise(() => fetch(new Request(url, request)));
+*   })
+* );
+* ```
+*/
+function handleFetch(fn) {
+	return defaultServerRuntime().handleFetch(fn);
+}
+/**
+* Wraps an Effect-based function as the SvelteKit server
+* [`handleError`](https://svelte.dev/docs/kit/hooks#Shared-hooks-handleError)
+* hook, which runs when an unexpected error is thrown while responding to a
+* request. The effect receives the error and request event and produces the
+* shape exposed to the client (your `App.Error`, or nothing).
+*
+* @example
+* ```ts
+* // src/hooks.server.ts
+* import { Hooks } from '@thomasfosterau/effect-sveltekit/server';
+* import { Effect } from 'effect';
+*
+* export const handleError = Hooks.handleError(({ error, event }) =>
+*   Effect.gen(function* () {
+*     const id = crypto.randomUUID();
+*     yield* Effect.logError(`${event.url.pathname} (${id})`, error);
+*     return { message: 'Internal Error', id };
+*   })
+* );
+* ```
+*/
+function handleError(fn) {
+	return defaultServerRuntime().handleError(fn);
+}
+/**
+* Wraps an Effect as the SvelteKit server
+* [`init`](https://svelte.dev/docs/kit/hooks#Shared-hooks-init) hook, which
+* runs once before the server responds to its first request. There is no
+* request event available, so the effect runs without per-request services.
+*
+* @example
+* ```ts
+* // src/hooks.server.ts
+* import { Hooks } from '@thomasfosterau/effect-sveltekit/server';
+* import { Effect } from 'effect';
+*
+* export const init = Hooks.init(Effect.logInfo('server starting up'));
+* ```
+*/
+function init(effect) {
+	return defaultServerRuntime().init(effect);
+}
+//#endregion
+export { Hooks_exports };
+
+//# sourceMappingURL=Hooks.js.map

package/dist/server/Hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Hooks.js","names":[],"sources":["../../src/server/Hooks.ts"],"sourcesContent":["/**\n * Effect wrappers for SvelteKit's server-side hooks (`src/hooks.server.ts`),\n * exposed as the `Hooks` namespace of `@thomasfosterau/effect-sveltekit/server`.\n *\n * Each helper turns an Effect (or a function returning one) into the\n * function-shaped export SvelteKit expects. Effects run on the SvelteKit server\n * runtime, so they have access to platform services (`HttpClient`, the\n * `RequestEvent`, ...). To additionally provide your application's services,\n * use the matching methods on an app-wide runtime from `makeServerRuntime`.\n *\n * @example\n * ```ts\n * // src/hooks.server.ts\n * import { Hooks } from '@thomasfosterau/effect-sveltekit/server';\n * import { Effect } from 'effect';\n *\n * export const handle = Hooks.handle(({ event, resolve }) =>\n *   Effect.gen(function* () {\n *     const response = yield* Effect.promise(() => resolve(event));\n *     yield* Effect.logInfo(`${event.url.pathname} -> ${response.status}`);\n *     return response;\n *   })\n * );\n * ```\n */\n\nimport type { Handle, HandleFetch, HandleServerError, ServerInit } from \"@sveltejs/kit\";\nimport { Effect } from \"effect\";\nimport type { SvelteKitServices } from \"../app-runtime.js\";\nimport { defaultServerRuntime } from \"../internal/default-runtime.js\";\n\n/**\n * Wraps an Effect-based function as a SvelteKit\n * [`handle`](https://svelte.dev/docs/kit/hooks#Server-hooks-handle) hook, which\n * runs on every request and controls how the response is produced.\n *\n * SvelteKit control flow (`redirect()`, `error()`) raised inside the effect is\n * passed through to SvelteKit.\n *\n * @example\n * ```ts\n * // src/hooks.server.ts\n * import { Hooks } from '@thomasfosterau/effect-sveltekit/server';\n * import { Effect } from 'effect';\n *\n * export const handle = Hooks.handle(({ event, resolve }) =>\n *   Effect.gen(function* () {\n *     // custom logic before resolve\n *     const response = yield* Effect.promise(() => resolve(event));\n *     // custom logic after resolve\n *     return response;\n *   })\n * );\n * ```\n */\nexport function handle(\n  fn: (args: Parameters<Handle>[0]) => Effect.Effect<Response, unknown, SvelteKitServices>,\n): Handle {\n  return defaultServerRuntime().handle(fn);\n}\n\n/**\n * Wraps an Effect-based function as a SvelteKit\n * [`handleFetch`](https://svelte.dev/docs/kit/hooks#Server-hooks-handleFetch)\n * hook, which intercepts `event.fetch` calls made on the server (in `load`,\n * actions, endpoints, ...). The effect produces the `Response` to use.\n *\n * @example\n * ```ts\n * // src/hooks.server.ts\n * import { Hooks } from '@thomasfosterau/effect-sveltekit/server';\n * import { Effect } from 'effect';\n *\n * export const handleFetch = Hooks.handleFetch(({ request, fetch }) =>\n *   Effect.gen(function* () {\n *     // Redirect internal API calls to the upstream service.\n *     const url = request.url.replace('https://api.internal', 'http://localhost:9999');\n *     return yield* Effect.promise(() => fetch(new Request(url, request)));\n *   })\n * );\n * ```\n */\nexport function handleFetch(\n  fn: (args: Parameters<HandleFetch>[0]) => Effect.Effect<Response, unknown, SvelteKitServices>,\n): HandleFetch {\n  return defaultServerRuntime().handleFetch(fn);\n}\n\n/**\n * Wraps an Effect-based function as the SvelteKit server\n * [`handleError`](https://svelte.dev/docs/kit/hooks#Shared-hooks-handleError)\n * hook, which runs when an unexpected error is thrown while responding to a\n * request. The effect receives the error and request event and produces the\n * shape exposed to the client (your `App.Error`, or nothing).\n *\n * @example\n * ```ts\n * // src/hooks.server.ts\n * import { Hooks } from '@thomasfosterau/effect-sveltekit/server';\n * import { Effect } from 'effect';\n *\n * export const handleError = Hooks.handleError(({ error, event }) =>\n *   Effect.gen(function* () {\n *     const id = crypto.randomUUID();\n *     yield* Effect.logError(`${event.url.pathname} (${id})`, error);\n *     return { message: 'Internal Error', id };\n *   })\n * );\n * ```\n */\nexport function handleError(\n  fn: (\n    args: Parameters<HandleServerError>[0],\n  ) => Effect.Effect<Awaited<ReturnType<HandleServerError>>, unknown, SvelteKitServices>,\n): HandleServerError {\n  return defaultServerRuntime().handleError(fn);\n}\n\n/**\n * Wraps an Effect as the SvelteKit server\n * [`init`](https://svelte.dev/docs/kit/hooks#Shared-hooks-init) hook, which\n * runs once before the server responds to its first request. There is no\n * request event available, so the effect runs without per-request services.\n *\n * @example\n * ```ts\n * // src/hooks.server.ts\n * import { Hooks } from '@thomasfosterau/effect-sveltekit/server';\n * import { Effect } from 'effect';\n *\n * export const init = Hooks.init(Effect.logInfo('server starting up'));\n * ```\n */\nexport function init(effect: Effect.Effect<void, unknown>): ServerInit {\n  return defaultServerRuntime().init(effect);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuDA,SAAgB,OACd,IACQ;CACR,OAAO,qBAAqB,EAAE,OAAO,EAAE;AACzC;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,YACd,IACa;CACb,OAAO,qBAAqB,EAAE,YAAY,EAAE;AAC9C;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,YACd,IAGmB;CACnB,OAAO,qBAAqB,EAAE,YAAY,EAAE;AAC9C;;;;;;;;;;;;;;;;AAiBA,SAAgB,KAAK,QAAkD;CACrE,OAAO,qBAAqB,EAAE,KAAK,MAAM;AAC3C"}

package/dist/server.d.ts

@@ -0,0 +1,108 @@
+import { SvelteKitRequestEvent, SvelteKitRuntime, runWithSvelteKitRuntime } from "./runtime.js";
+import { RequestRuntime, ServerRuntime, SvelteKitServices, makeServerRuntime } from "./app-runtime.js";
+import { sveltekitConfig, sveltekitConfigProvider } from "./config.js";
+import { Hooks_d_exports } from "./server/Hooks.js";
+import { Endpoint_d_exports } from "./server/Endpoint.js";
+import { RemoteFunction } from "./remote.server.js";
+import { Effect } from "effect";
+import { Action, Actions, RequestEvent, ServerLoad } from "@sveltejs/kit";
+
+//#region src/server.d.ts
+/**
+ * Wraps an Effect-based function to work as a SvelteKit server load function.
+ * The effect has access to platform services (HttpClient, the RequestEvent, etc.)
+ * via the SvelteKit runtime.
+ *
+ * SvelteKit control flow (`redirect()`, `error()`) raised inside the effect is
+ * passed through to SvelteKit.
+ *
+ * To give effects access to your own application services, create an
+ * app-wide runtime with {@link makeServerRuntime} and use its `serverLoad`
+ * instead.
+ *
+ * @example
+ * ```ts
+ * import { serverLoad } from '@thomasfosterau/effect-sveltekit/server';
+ * import { Effect } from 'effect';
+ * import * as HttpClient from 'effect/unstable/http/HttpClient';
+ *
+ * export const load = serverLoad((event) =>
+ *   Effect.gen(function* () {
+ *     const client = yield* HttpClient.HttpClient;
+ *     const response = yield* client.get("https://api.example.com/data");
+ *     return { data: yield* response.json };
+ *   })
+ * );
+ * ```
+ */
+declare function serverLoad<Params extends Record<string, string> = any, ParentData extends Record<string, any> = any, OutputData extends Record<string, any> | void = any, RouteId extends string | null = any>(fn: (event: RequestEvent<Params, RouteId>) => Effect.Effect<OutputData, unknown, SvelteKitServices>): ServerLoad<Params, ParentData, OutputData, RouteId>;
+/**
+ * Wraps an Effect-based function to work as a SvelteKit action handler.
+ * The effect has access to platform services (HttpClient, the RequestEvent, etc.)
+ * via the SvelteKit runtime.
+ *
+ * @example
+ * ```ts
+ * import { action } from '@thomasfosterau/effect-sveltekit/server';
+ * import { Effect } from 'effect';
+ *
+ * export const actions = {
+ *   default: action((event) =>
+ *     Effect.gen(function* () {
+ *       const formData = yield* Effect.promise(() => event.request.formData());
+ *       // Process form data
+ *       return { success: true };
+ *     })
+ *   )
+ * };
+ * ```
+ */
+declare function action<Params extends Record<string, string> = any, OutputData extends Record<string, any> | void = any, RouteId extends string | null = any>(fn: (event: RequestEvent<Params, RouteId>) => Effect.Effect<OutputData, unknown, SvelteKitServices>): Action<Params, OutputData, RouteId>;
+/**
+ * Creates SvelteKit actions from an object of Effect-based action handlers.
+ * Each action will have access to platform services via the SvelteKit runtime.
+ *
+ * @example
+ * ```ts
+ * import { actions } from '@thomasfosterau/effect-sveltekit/server';
+ * import { Effect } from 'effect';
+ *
+ * export const actions = actions({
+ *   create: (event) => Effect.succeed({ created: true }),
+ *   delete: (event) => Effect.succeed({ deleted: true })
+ * });
+ * ```
+ */
+declare function actions<Params extends Record<string, string> = any, OutputData extends Record<string, any> | void = any, RouteId extends string | null = any>(actionsMap: Record<string, (event: RequestEvent<Params, RouteId>) => Effect.Effect<OutputData, unknown, SvelteKitServices>>): Actions<Params, OutputData, RouteId>;
+/**
+ * Wraps an Effect-based function to work as a SvelteKit API endpoint handler.
+ * The effect has access to platform services (HttpClient, the RequestEvent, etc.)
+ * via the SvelteKit runtime.
+ *
+ * SvelteKit control flow (`redirect()`, `error()`) raised inside the effect is
+ * passed through to SvelteKit. For any other failure, the error is logged
+ * server-side and a generic error message is returned to clients. For
+ * development/debugging, you can pass options to expose full error details.
+ *
+ * @example
+ * ```ts
+ * import { endpoint } from '@thomasfosterau/effect-sveltekit/server';
+ * import { Effect } from 'effect';
+ * import { json } from '@sveltejs/kit';
+ * import * as HttpClient from 'effect/unstable/http/HttpClient';
+ *
+ * export const GET = endpoint((event) =>
+ *   Effect.gen(function* () {
+ *     const client = yield* HttpClient.HttpClient;
+ *     const response = yield* client.get("https://api.example.com/data");
+ *     return json(yield* response.json);
+ *   })
+ * );
+ * ```
+ */
+declare function endpoint<Params extends Record<string, string> = any, RouteId extends string | null = any>(fn: (event: RequestEvent<Params, RouteId>) => Effect.Effect<Response, unknown, SvelteKitServices>, options?: {
+  exposeErrors?: boolean;
+}): (event: RequestEvent<Params, RouteId>) => Promise<Response>;
+//#endregion
+export { Endpoint_d_exports as Endpoint, Hooks_d_exports as Hooks, RemoteFunction, type RequestRuntime, type ServerRuntime, SvelteKitRequestEvent, SvelteKitRuntime, type SvelteKitServices, action, actions, endpoint, makeServerRuntime, runWithSvelteKitRuntime, serverLoad, sveltekitConfig, sveltekitConfigProvider };
+//# sourceMappingURL=server.d.ts.map

package/dist/server.js

@@ -0,0 +1,131 @@
+import { SvelteKitRequestEvent, SvelteKitRuntime, runWithSvelteKitRuntime } from "./runtime.js";
+import { makeServerRuntime } from "./app-runtime.js";
+import { defaultServerRuntime } from "./internal/default-runtime.js";
+import { sveltekitConfig, sveltekitConfigProvider } from "./config.js";
+import { Hooks_exports } from "./server/Hooks.js";
+import { Endpoint_exports } from "./server/Endpoint.js";
+import { RemoteFunction } from "./remote.server.js";
+import { Cause, Exit } from "effect";
+import { isHttpError, isRedirect } from "@sveltejs/kit";
+//#region src/server.ts
+/**
+* Wraps an Effect-based function to work as a SvelteKit server load function.
+* The effect has access to platform services (HttpClient, the RequestEvent, etc.)
+* via the SvelteKit runtime.
+*
+* SvelteKit control flow (`redirect()`, `error()`) raised inside the effect is
+* passed through to SvelteKit.
+*
+* To give effects access to your own application services, create an
+* app-wide runtime with {@link makeServerRuntime} and use its `serverLoad`
+* instead.
+*
+* @example
+* ```ts
+* import { serverLoad } from '@thomasfosterau/effect-sveltekit/server';
+* import { Effect } from 'effect';
+* import * as HttpClient from 'effect/unstable/http/HttpClient';
+*
+* export const load = serverLoad((event) =>
+*   Effect.gen(function* () {
+*     const client = yield* HttpClient.HttpClient;
+*     const response = yield* client.get("https://api.example.com/data");
+*     return { data: yield* response.json };
+*   })
+* );
+* ```
+*/
+function serverLoad(fn) {
+	return defaultServerRuntime().serverLoad(fn);
+}
+/**
+* Wraps an Effect-based function to work as a SvelteKit action handler.
+* The effect has access to platform services (HttpClient, the RequestEvent, etc.)
+* via the SvelteKit runtime.
+*
+* @example
+* ```ts
+* import { action } from '@thomasfosterau/effect-sveltekit/server';
+* import { Effect } from 'effect';
+*
+* export const actions = {
+*   default: action((event) =>
+*     Effect.gen(function* () {
+*       const formData = yield* Effect.promise(() => event.request.formData());
+*       // Process form data
+*       return { success: true };
+*     })
+*   )
+* };
+* ```
+*/
+function action(fn) {
+	return defaultServerRuntime().action(fn);
+}
+/**
+* Creates SvelteKit actions from an object of Effect-based action handlers.
+* Each action will have access to platform services via the SvelteKit runtime.
+*
+* @example
+* ```ts
+* import { actions } from '@thomasfosterau/effect-sveltekit/server';
+* import { Effect } from 'effect';
+*
+* export const actions = actions({
+*   create: (event) => Effect.succeed({ created: true }),
+*   delete: (event) => Effect.succeed({ deleted: true })
+* });
+* ```
+*/
+function actions(actionsMap) {
+	return defaultServerRuntime().actions(actionsMap);
+}
+/**
+* Wraps an Effect-based function to work as a SvelteKit API endpoint handler.
+* The effect has access to platform services (HttpClient, the RequestEvent, etc.)
+* via the SvelteKit runtime.
+*
+* SvelteKit control flow (`redirect()`, `error()`) raised inside the effect is
+* passed through to SvelteKit. For any other failure, the error is logged
+* server-side and a generic error message is returned to clients. For
+* development/debugging, you can pass options to expose full error details.
+*
+* @example
+* ```ts
+* import { endpoint } from '@thomasfosterau/effect-sveltekit/server';
+* import { Effect } from 'effect';
+* import { json } from '@sveltejs/kit';
+* import * as HttpClient from 'effect/unstable/http/HttpClient';
+*
+* export const GET = endpoint((event) =>
+*   Effect.gen(function* () {
+*     const client = yield* HttpClient.HttpClient;
+*     const response = yield* client.get("https://api.example.com/data");
+*     return json(yield* response.json);
+*   })
+* );
+* ```
+*/
+function endpoint(fn, options) {
+	const { exposeErrors = false } = options ?? {};
+	return async (event) => {
+		const exit = await defaultServerRuntime().runPromiseExit(event, fn(event));
+		return Exit.match(exit, {
+			onFailure: (cause) => {
+				const squashed = Cause.squash(cause);
+				if (isRedirect(squashed) || isHttpError(squashed)) throw squashed;
+				console.error("Endpoint error:", Cause.pretty(cause));
+				const clientMessage = exposeErrors ? Cause.pretty(cause) : "Internal server error";
+				return new Response(JSON.stringify({ error: clientMessage }), {
+					status: 500,
+					headers: { "Content-Type": "application/json" }
+				});
+			},
+			onSuccess: (value) => value
+		});
+	};
+}
+//#endregion
+export { Endpoint_exports as Endpoint, Hooks_exports as Hooks, RemoteFunction, SvelteKitRequestEvent, SvelteKitRuntime, action, actions, endpoint, makeServerRuntime, runWithSvelteKitRuntime, serverLoad, sveltekitConfig, sveltekitConfigProvider };
+
+//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","names":["runtime"],"sources":["../src/server.ts"],"sourcesContent":["import type { Action, Actions, RequestEvent, ServerLoad } from \"@sveltejs/kit\";\nimport { Effect, Exit, Cause } from \"effect\";\nimport { isHttpError, isRedirect } from \"@sveltejs/kit\";\nimport type { SvelteKitServices } from \"./app-runtime.js\";\nimport { defaultServerRuntime as runtime } from \"./internal/default-runtime.js\";\n\nexport type { SvelteKitServices };\n\n/**\n * Wraps an Effect-based function to work as a SvelteKit server load function.\n * The effect has access to platform services (HttpClient, the RequestEvent, etc.)\n * via the SvelteKit runtime.\n *\n * SvelteKit control flow (`redirect()`, `error()`) raised inside the effect is\n * passed through to SvelteKit.\n *\n * To give effects access to your own application services, create an\n * app-wide runtime with {@link makeServerRuntime} and use its `serverLoad`\n * instead.\n *\n * @example\n * ```ts\n * import { serverLoad } from '@thomasfosterau/effect-sveltekit/server';\n * import { Effect } from 'effect';\n * import * as HttpClient from 'effect/unstable/http/HttpClient';\n *\n * export const load = serverLoad((event) =>\n *   Effect.gen(function* () {\n *     const client = yield* HttpClient.HttpClient;\n *     const response = yield* client.get(\"https://api.example.com/data\");\n *     return { data: yield* response.json };\n *   })\n * );\n * ```\n */\nexport function serverLoad<\n  Params extends Record<string, string> = any,\n  ParentData extends Record<string, any> = any,\n  OutputData extends Record<string, any> | void = any,\n  RouteId extends string | null = any,\n>(\n  fn: (\n    event: RequestEvent<Params, RouteId>,\n  ) => Effect.Effect<OutputData, unknown, SvelteKitServices>,\n): ServerLoad<Params, ParentData, OutputData, RouteId> {\n  return runtime().serverLoad(fn);\n}\n\n/**\n * Wraps an Effect-based function to work as a SvelteKit action handler.\n * The effect has access to platform services (HttpClient, the RequestEvent, etc.)\n * via the SvelteKit runtime.\n *\n * @example\n * ```ts\n * import { action } from '@thomasfosterau/effect-sveltekit/server';\n * import { Effect } from 'effect';\n *\n * export const actions = {\n *   default: action((event) =>\n *     Effect.gen(function* () {\n *       const formData = yield* Effect.promise(() => event.request.formData());\n *       // Process form data\n *       return { success: true };\n *     })\n *   )\n * };\n * ```\n */\nexport function action<\n  Params extends Record<string, string> = any,\n  OutputData extends Record<string, any> | void = any,\n  RouteId extends string | null = any,\n>(\n  fn: (\n    event: RequestEvent<Params, RouteId>,\n  ) => Effect.Effect<OutputData, unknown, SvelteKitServices>,\n): Action<Params, OutputData, RouteId> {\n  return runtime().action(fn);\n}\n\n/**\n * Creates SvelteKit actions from an object of Effect-based action handlers.\n * Each action will have access to platform services via the SvelteKit runtime.\n *\n * @example\n * ```ts\n * import { actions } from '@thomasfosterau/effect-sveltekit/server';\n * import { Effect } from 'effect';\n *\n * export const actions = actions({\n *   create: (event) => Effect.succeed({ created: true }),\n *   delete: (event) => Effect.succeed({ deleted: true })\n * });\n * ```\n */\nexport function actions<\n  Params extends Record<string, string> = any,\n  OutputData extends Record<string, any> | void = any,\n  RouteId extends string | null = any,\n>(\n  actionsMap: Record<\n    string,\n    (event: RequestEvent<Params, RouteId>) => Effect.Effect<OutputData, unknown, SvelteKitServices>\n  >,\n): Actions<Params, OutputData, RouteId> {\n  return runtime().actions(actionsMap);\n}\n\n/**\n * Wraps an Effect-based function to work as a SvelteKit API endpoint handler.\n * The effect has access to platform services (HttpClient, the RequestEvent, etc.)\n * via the SvelteKit runtime.\n *\n * SvelteKit control flow (`redirect()`, `error()`) raised inside the effect is\n * passed through to SvelteKit. For any other failure, the error is logged\n * server-side and a generic error message is returned to clients. For\n * development/debugging, you can pass options to expose full error details.\n *\n * @example\n * ```ts\n * import { endpoint } from '@thomasfosterau/effect-sveltekit/server';\n * import { Effect } from 'effect';\n * import { json } from '@sveltejs/kit';\n * import * as HttpClient from 'effect/unstable/http/HttpClient';\n *\n * export const GET = endpoint((event) =>\n *   Effect.gen(function* () {\n *     const client = yield* HttpClient.HttpClient;\n *     const response = yield* client.get(\"https://api.example.com/data\");\n *     return json(yield* response.json);\n *   })\n * );\n * ```\n */\nexport function endpoint<\n  Params extends Record<string, string> = any,\n  RouteId extends string | null = any,\n>(\n  fn: (event: RequestEvent<Params, RouteId>) => Effect.Effect<Response, unknown, SvelteKitServices>,\n  options?: { exposeErrors?: boolean },\n): (event: RequestEvent<Params, RouteId>) => Promise<Response> {\n  const { exposeErrors = false } = options ?? {};\n\n  return async (event) => {\n    const exit = await runtime().runPromiseExit(event as RequestEvent, fn(event));\n\n    return Exit.match(exit, {\n      onFailure: (cause) => {\n        // Let SvelteKit handle its own control flow objects.\n        const squashed = Cause.squash(cause);\n        if (isRedirect(squashed) || isHttpError(squashed)) {\n          throw squashed;\n        }\n\n        // Always log the full error server-side for debugging\n        console.error(\"Endpoint error:\", Cause.pretty(cause));\n\n        // Return generic error message to client unless explicitly enabled\n        const clientMessage = exposeErrors ? Cause.pretty(cause) : \"Internal server error\";\n\n        return new Response(JSON.stringify({ error: clientMessage }), {\n          status: 500,\n          headers: { \"Content-Type\": \"application/json\" },\n        });\n      },\n      onSuccess: (value) => value,\n    });\n  };\n}\n\n/**\n * Effect wrappers for the server-side hooks (`hooks.server.ts`): the `Hooks`\n * namespace exposes `handle`, `handleFetch`, `handleError`, and `init`.\n */\nexport * as Hooks from \"./server/Hooks.js\";\n\n/**\n * Create SvelteKit `+server.ts` endpoints backed by Effect: the `Endpoint`\n * namespace exposes `fromApi` (an `HttpApi`), `fromRouter` (an `HttpRouter`),\n * and `fromHttpEffect` (a single HTTP route effect).\n */\nexport * as Endpoint from \"./server/Endpoint.js\";\n\n/**\n * App-wide runtime: define your application's Effect services once and share\n * them across every request.\n */\nexport { makeServerRuntime, type ServerRuntime, type RequestRuntime } from \"./app-runtime.js\";\n\n/**\n * Export the SvelteKit runtime utilities for advanced use cases.\n */\nexport { SvelteKitRuntime, runWithSvelteKitRuntime, SvelteKitRequestEvent } from \"./runtime.js\";\nexport { RemoteFunction } from \"./remote.server.js\";\n\n/**\n * SvelteKit `$env` ⇄ Effect `Config` (see {@link sveltekitConfig}). The\n * Effect Schema ⇄ SvelteKit `transport` hook lives on the universal `Hooks`\n * namespace (`Hooks.transport`) in `@thomasfosterau/effect-sveltekit`.\n */\nexport { sveltekitConfig, sveltekitConfigProvider } from \"./config.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,WAMd,IAGqD;CACrD,OAAOA,qBAAQ,EAAE,WAAW,EAAE;AAChC;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,OAKd,IAGqC;CACrC,OAAOA,qBAAQ,EAAE,OAAO,EAAE;AAC5B;;;;;;;;;;;;;;;;AAiBA,SAAgB,QAKd,YAIsC;CACtC,OAAOA,qBAAQ,EAAE,QAAQ,UAAU;AACrC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,SAId,IACA,SAC6D;CAC7D,MAAM,EAAE,eAAe,UAAU,WAAW,CAAC;CAE7C,OAAO,OAAO,UAAU;EACtB,MAAM,OAAO,MAAMA,qBAAQ,EAAE,eAAe,OAAuB,GAAG,KAAK,CAAC;EAE5E,OAAO,KAAK,MAAM,MAAM;GACtB,YAAY,UAAU;IAEpB,MAAM,WAAW,MAAM,OAAO,KAAK;IACnC,IAAI,WAAW,QAAQ,KAAK,YAAY,QAAQ,GAC9C,MAAM;IAIR,QAAQ,MAAM,mBAAmB,MAAM,OAAO,KAAK,CAAC;IAGpD,MAAM,gBAAgB,eAAe,MAAM,OAAO,KAAK,IAAI;IAE3D,OAAO,IAAI,SAAS,KAAK,UAAU,EAAE,OAAO,cAAc,CAAC,GAAG;KAC5D,QAAQ;KACR,SAAS,EAAE,gBAAgB,mBAAmB;IAChD,CAAC;GACH;GACA,YAAY,UAAU;EACxB,CAAC;CACH;AACF"}

package/dist/transport.d.ts

@@ -0,0 +1,23 @@
+import { Schema } from "effect";
+import { Transport, Transporter } from "@sveltejs/kit";
+
+//#region src/transport.d.ts
+/**
+ * Builds a SvelteKit {@link Transporter} from an Effect {@link Schema.Codec}.
+ *
+ * The decoded `Type` is detected with `Schema.is`; matching values are encoded
+ * with `Schema.encodeSync` and wrapped in a single-element tuple. The wrapper
+ * guarantees the encoding is truthy — SvelteKit treats a falsy `encode` result
+ * (e.g. an encoded `0`, `""`, `false`, or `null`) as "not this type" — and is
+ * unwrapped again by `decode` on the client.
+ */
+declare const transporter: <T, E>(schema: Schema.Codec<T, E>) => Transporter<T, readonly [E]>;
+/**
+ * Assembles a SvelteKit `transport` object from a record of Effect schemas,
+ * applying {@link transporter} to each. The keys are arbitrary labels (they
+ * only need to be stable between server and client).
+ */
+declare const transport: (schemas: Record<string, Schema.Codec<any, any>>) => Transport;
+//#endregion
+export { transport, transporter };
+//# sourceMappingURL=transport.d.ts.map

package/dist/transport.js

@@ -0,0 +1,34 @@
+import { Schema } from "effect";
+//#region src/transport.ts
+/**
+* Builds a SvelteKit {@link Transporter} from an Effect {@link Schema.Codec}.
+*
+* The decoded `Type` is detected with `Schema.is`; matching values are encoded
+* with `Schema.encodeSync` and wrapped in a single-element tuple. The wrapper
+* guarantees the encoding is truthy — SvelteKit treats a falsy `encode` result
+* (e.g. an encoded `0`, `""`, `false`, or `null`) as "not this type" — and is
+* unwrapped again by `decode` on the client.
+*/
+const transporter = (schema) => {
+	const guard = Schema.is(schema);
+	const encode = Schema.encodeSync(schema);
+	const decode = Schema.decodeSync(schema);
+	return {
+		encode: (value) => guard(value) ? [encode(value)] : false,
+		decode: ([data]) => decode(data)
+	};
+};
+/**
+* Assembles a SvelteKit `transport` object from a record of Effect schemas,
+* applying {@link transporter} to each. The keys are arbitrary labels (they
+* only need to be stable between server and client).
+*/
+const transport = (schemas) => {
+	const result = {};
+	for (const [name, schema] of Object.entries(schemas)) result[name] = transporter(schema);
+	return result;
+};
+//#endregion
+export { transport, transporter };
+
+//# sourceMappingURL=transport.js.map

package/dist/transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.js","names":[],"sources":["../src/transport.ts"],"sourcesContent":["/**\n * Effect Schema ⇄ SvelteKit `transport` hook.\n *\n * SvelteKit's universal [`transport`](https://svelte.dev/docs/kit/hooks#Universal-hooks-transport)\n * hook moves custom (non-POJO) values across the server/client boundary — for\n * data returned from `load` functions and from remote functions. Each entry is\n * a {@link Transporter}: a sync `encode` (server) / `decode` (client) pair,\n * where `encode` returns `false` for values it does not handle.\n *\n * An Effect {@link Schema.Codec} is exactly such a pair. {@link transporter}\n * turns a schema into a `Transporter`, and {@link transport} assembles a whole\n * `transport` object from a record of schemas — so `Option`, `DateTime`,\n * branded types, `Schema.Class` instances, tagged errors, etc. round-trip with\n * no hand-written serialization.\n *\n * ```ts\n * // src/hooks.ts\n * import { Hooks } from \"@thomasfosterau/effect-sveltekit\";\n * import { Schema } from \"effect\";\n *\n * export const transport = Hooks.transport({\n *   Option: Schema.Option(Schema.Number),\n *   Date: Schema.Date,\n * });\n * ```\n */\n\nimport type { Transport, Transporter } from \"@sveltejs/kit\";\nimport { Schema } from \"effect\";\n\n/**\n * Builds a SvelteKit {@link Transporter} from an Effect {@link Schema.Codec}.\n *\n * The decoded `Type` is detected with `Schema.is`; matching values are encoded\n * with `Schema.encodeSync` and wrapped in a single-element tuple. The wrapper\n * guarantees the encoding is truthy — SvelteKit treats a falsy `encode` result\n * (e.g. an encoded `0`, `\"\"`, `false`, or `null`) as \"not this type\" — and is\n * unwrapped again by `decode` on the client.\n */\nexport const transporter = <T, E>(schema: Schema.Codec<T, E>): Transporter<T, readonly [E]> => {\n  const guard = Schema.is(schema);\n  const encode = Schema.encodeSync(schema);\n  const decode = Schema.decodeSync(schema);\n  return {\n    encode: (value) => (guard(value) ? ([encode(value)] as const) : false),\n    decode: ([data]) => decode(data),\n  };\n};\n\n/**\n * Assembles a SvelteKit `transport` object from a record of Effect schemas,\n * applying {@link transporter} to each. The keys are arbitrary labels (they\n * only need to be stable between server and client).\n */\nexport const transport = (schemas: Record<string, Schema.Codec<any, any>>): Transport => {\n  const result: Transport = {};\n  for (const [name, schema] of Object.entries(schemas)) {\n    result[name] = transporter(schema);\n  }\n  return result;\n};\n"],"mappings":";;;;;;;;;;;AAuCA,MAAa,eAAqB,WAA6D;CAC7F,MAAM,QAAQ,OAAO,GAAG,MAAM;CAC9B,MAAM,SAAS,OAAO,WAAW,MAAM;CACvC,MAAM,SAAS,OAAO,WAAW,MAAM;CACvC,OAAO;EACL,SAAS,UAAW,MAAM,KAAK,IAAK,CAAC,OAAO,KAAK,CAAC,IAAc;EAChE,SAAS,CAAC,UAAU,OAAO,IAAI;CACjC;AACF;;;;;;AAOA,MAAa,aAAa,YAA+D;CACvF,MAAM,SAAoB,CAAC;CAC3B,KAAK,MAAM,CAAC,MAAM,WAAW,OAAO,QAAQ,OAAO,GACjD,OAAO,QAAQ,YAAY,MAAM;CAEnC,OAAO;AACT"}

package/dist/universal.d.ts

@@ -0,0 +1,35 @@
+import { UniversalRuntime, makeUniversalRuntime } from "./app-runtime.js";
+import { Effect } from "effect";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import { Load } from "@sveltejs/kit";
+
+//#region src/universal.d.ts
+/**
+ * Wraps an Effect-based function to work as a SvelteKit universal load function.
+ *
+ * The effect has access to `HttpClient` on both the server and the client:
+ * it is backed by the load event's `fetch`, so relative URLs and SvelteKit's
+ * fetch behaviours (deduplication, cookies forwarding) work as expected.
+ *
+ * To give effects access to your own application services, create an
+ * app-wide runtime with `makeUniversalRuntime` and use its `load` instead.
+ *
+ * @example
+ * ```ts
+ * import { load as effectLoad } from '@thomasfosterau/effect-sveltekit';
+ * import * as HttpClient from 'effect/unstable/http/HttpClient';
+ * import { Effect } from 'effect';
+ *
+ * export const load = effectLoad((event) =>
+ *   Effect.gen(function* () {
+ *     const client = yield* HttpClient.HttpClient;
+ *     const response = yield* client.get(`/api/items/${event.params.id}`);
+ *     return { item: yield* response.json };
+ *   })
+ * );
+ * ```
+ */
+declare function load<Params extends Record<string, string> = any, InputData extends Record<string, unknown> | null = any, ParentData extends Record<string, unknown> = any, OutputData extends Record<string, unknown> | void = any, RouteId extends string | null = any>(fn: (event: Parameters<Load<Params, InputData, ParentData, OutputData, RouteId>>[0]) => Effect.Effect<OutputData, unknown, HttpClient.HttpClient>): Load<Params, InputData, ParentData, OutputData, RouteId>;
+//#endregion
+export { load };
+//# sourceMappingURL=universal.d.ts.map

package/dist/universal.js

@@ -0,0 +1,36 @@
+import "./app-runtime.js";
+import { defaultUniversalRuntime } from "./internal/default-runtime.js";
+import "effect";
+//#region src/universal.ts
+/**
+* Wraps an Effect-based function to work as a SvelteKit universal load function.
+*
+* The effect has access to `HttpClient` on both the server and the client:
+* it is backed by the load event's `fetch`, so relative URLs and SvelteKit's
+* fetch behaviours (deduplication, cookies forwarding) work as expected.
+*
+* To give effects access to your own application services, create an
+* app-wide runtime with `makeUniversalRuntime` and use its `load` instead.
+*
+* @example
+* ```ts
+* import { load as effectLoad } from '@thomasfosterau/effect-sveltekit';
+* import * as HttpClient from 'effect/unstable/http/HttpClient';
+* import { Effect } from 'effect';
+*
+* export const load = effectLoad((event) =>
+*   Effect.gen(function* () {
+*     const client = yield* HttpClient.HttpClient;
+*     const response = yield* client.get(`/api/items/${event.params.id}`);
+*     return { item: yield* response.json };
+*   })
+* );
+* ```
+*/
+function load(fn) {
+	return defaultUniversalRuntime().load(fn);
+}
+//#endregion
+export { load };
+
+//# sourceMappingURL=universal.js.map

package/dist/universal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"universal.js","names":["runtime"],"sources":["../src/universal.ts"],"sourcesContent":["import type { Load } from \"@sveltejs/kit\";\nimport { Effect } from \"effect\";\nimport type * as HttpClient from \"effect/unstable/http/HttpClient\";\nimport { defaultUniversalRuntime as runtime } from \"./internal/default-runtime.js\";\n\n/**\n * Wraps an Effect-based function to work as a SvelteKit universal load function.\n *\n * The effect has access to `HttpClient` on both the server and the client:\n * it is backed by the load event's `fetch`, so relative URLs and SvelteKit's\n * fetch behaviours (deduplication, cookies forwarding) work as expected.\n *\n * To give effects access to your own application services, create an\n * app-wide runtime with `makeUniversalRuntime` and use its `load` instead.\n *\n * @example\n * ```ts\n * import { load as effectLoad } from '@thomasfosterau/effect-sveltekit';\n * import * as HttpClient from 'effect/unstable/http/HttpClient';\n * import { Effect } from 'effect';\n *\n * export const load = effectLoad((event) =>\n *   Effect.gen(function* () {\n *     const client = yield* HttpClient.HttpClient;\n *     const response = yield* client.get(`/api/items/${event.params.id}`);\n *     return { item: yield* response.json };\n *   })\n * );\n * ```\n */\nexport function load<\n  Params extends Record<string, string> = any,\n  InputData extends Record<string, unknown> | null = any,\n  ParentData extends Record<string, unknown> = any,\n  OutputData extends Record<string, unknown> | void = any,\n  RouteId extends string | null = any,\n>(\n  fn: (\n    event: Parameters<Load<Params, InputData, ParentData, OutputData, RouteId>>[0],\n  ) => Effect.Effect<OutputData, unknown, HttpClient.HttpClient>,\n): Load<Params, InputData, ParentData, OutputData, RouteId> {\n  return runtime().load(fn);\n}\n\n/**\n * App-wide runtime: define your application's (universal) Effect services\n * once and share them across every `load` invocation.\n */\nexport { makeUniversalRuntime, type UniversalRuntime } from \"./app-runtime.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,SAAgB,KAOd,IAG0D;CAC1D,OAAOA,wBAAQ,EAAE,KAAK,EAAE;AAC1B"}