@thomasfosterau/effect-sveltekit 0.1.1 → 0.2.1

package/dist/realtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtime.js","names":[],"sources":["../src/realtime.ts"],"sourcesContent":["/**\n * Client-side realtime bridges: consume a Server-Sent-Events endpoint or a\n * WebSocket as an Effect `Stream`. The counterpart to `Endpoint.fromStream`\n * (server) on the `@thomasfosterau/effect-sveltekit/client` `Realtime` namespace.\n *\n * These use the browser globals `EventSource` / `WebSocket`; both can be\n * overridden (e.g. a Node polyfill, or a fake in tests) via the `implementation`\n * option. The source is opened when the stream is run and closed when its scope\n * closes, so a `Stream.take` / component teardown tears down the connection.\n */\n\nimport { Cause, Data, Effect, Queue, Stream } from \"effect\";\n\n// ---------------------------------------------------------------------------\n// EventSource\n// ---------------------------------------------------------------------------\n\n/** A decoded Server-Sent Event. */\nexport interface SseMessage {\n  /** The event name (`\"message\"` for unnamed events). */\n  readonly event: string;\n  /** The event payload (the joined `data:` lines). */\n  readonly data: string;\n  /** The last event id seen, or `\"\"` if none. */\n  readonly lastEventId: string;\n}\n\n/** Raised when an `EventSource` connection fails fatally (its `readyState` is `CLOSED`). */\nexport class EventSourceError extends Data.TaggedError(\"EventSourceError\")<{\n  readonly url: string;\n}> {}\n\n/** The subset of the `EventSource` constructor this module relies on. */\nexport type EventSourceConstructor = new (\n  url: string,\n  eventSourceInitDict?: { withCredentials?: boolean },\n) => EventSource;\n\nexport interface FromEventSourceOptions {\n  /** Send credentials (cookies) with the request. Defaults to `false`. */\n  readonly withCredentials?: boolean;\n  /**\n   * Named events to listen for in addition to the default unnamed `message`\n   * event. An `Endpoint.fromStream({ event: \"tick\" })` server needs\n   * `events: [\"tick\"]` here.\n   */\n  readonly events?: ReadonlyArray<string>;\n  /** Buffer size for the backing queue. Defaults to 16. */\n  readonly bufferSize?: number;\n  /** Backpressure strategy when the buffer is full. Defaults to `\"sliding\"`. */\n  readonly strategy?: \"sliding\" | \"dropping\" | \"suspend\";\n  /** Override the `EventSource` constructor (Node polyfill, tests). */\n  readonly implementation?: EventSourceConstructor;\n}\n\n/**\n * Consume a Server-Sent-Events endpoint as a `Stream` of {@link SseMessage}.\n *\n * The browser's `EventSource` reconnects automatically after transient drops,\n * so the stream stays live across reconnects; it fails with\n * {@link EventSourceError} only when the connection closes fatally.\n *\n * @example\n * ```ts\n * import { Realtime } from \"@thomasfosterau/effect-sveltekit/client\";\n * import { Effect, Stream } from \"effect\";\n *\n * const program = Realtime.fromEventSource(\"/events\", { events: [\"tick\"] }).pipe(\n *   Stream.runForEach((msg) => Effect.log(`${msg.event}: ${msg.data}`)),\n * );\n * ```\n */\nexport const fromEventSource = (\n  url: string,\n  options?: FromEventSourceOptions,\n): Stream.Stream<SseMessage, EventSourceError> => {\n  const Impl = options?.implementation ?? (globalThis.EventSource as EventSourceConstructor);\n  return Stream.callback<SseMessage, EventSourceError>(\n    (queue) =>\n      Effect.sync(() => {\n        const source =\n          options?.withCredentials === undefined\n            ? new Impl(url)\n            : new Impl(url, { withCredentials: options.withCredentials });\n\n        const onMessage = (e: MessageEvent): void => {\n          Queue.offerUnsafe(queue, { event: e.type, data: e.data, lastEventId: e.lastEventId });\n        };\n\n        source.addEventListener(\"message\", onMessage);\n        for (const name of options?.events ?? []) source.addEventListener(name, onMessage);\n\n        source.addEventListener(\"error\", () => {\n          // EventSource reconnects on its own unless it has closed for good.\n          if (source.readyState === 2 /* CLOSED */) {\n            Queue.failCauseUnsafe(queue, Cause.fail(new EventSourceError({ url })));\n          }\n        });\n\n        return Effect.sync(() => source.close());\n      }),\n    { bufferSize: options?.bufferSize ?? 16, strategy: options?.strategy ?? \"sliding\" },\n  );\n};\n\n// ---------------------------------------------------------------------------\n// WebSocket\n// ---------------------------------------------------------------------------\n\n/** Raised when a `WebSocket` errors or closes uncleanly. */\nexport class WebSocketError extends Data.TaggedError(\"WebSocketError\")<{\n  readonly url: string;\n  readonly code?: number;\n  readonly reason?: string;\n}> {}\n\n/** The subset of the `WebSocket` constructor this module relies on. */\nexport type WebSocketConstructor = new (\n  url: string,\n  protocols?: string | ReadonlyArray<string>,\n) => WebSocket;\n\nexport interface FromWebSocketOptions {\n  /** Sub-protocols passed to the `WebSocket` constructor. */\n  readonly protocols?: string | ReadonlyArray<string>;\n  /** `arraybuffer` or `blob` for binary frames. Defaults to the platform default. */\n  readonly binaryType?: BinaryType;\n  /** Buffer size for the backing queue. Defaults to 16. */\n  readonly bufferSize?: number;\n  /** Backpressure strategy when the buffer is full. Defaults to `\"suspend\"`. */\n  readonly strategy?: \"sliding\" | \"dropping\" | \"suspend\";\n  /** Override the `WebSocket` constructor (Node polyfill, tests). */\n  readonly implementation?: WebSocketConstructor;\n}\n\n/**\n * Consume a `WebSocket` as a `Stream` of its message payloads\n * (`string | ArrayBuffer | Blob`, depending on `binaryType`).\n *\n * The stream ends when the socket closes cleanly and fails with\n * {@link WebSocketError} on an error or unclean close. The socket is closed when\n * the stream's scope closes.\n *\n * @example\n * ```ts\n * import { Realtime } from \"@thomasfosterau/effect-sveltekit/client\";\n * import { Effect, Stream } from \"effect\";\n *\n * const program = Realtime.fromWebSocket(\"wss://example.com/ws\").pipe(\n *   Stream.runForEach((data) => Effect.log(String(data))),\n * );\n * ```\n */\nexport const fromWebSocket = (\n  url: string,\n  options?: FromWebSocketOptions,\n): Stream.Stream<string | ArrayBuffer | Blob, WebSocketError> => {\n  const Impl = options?.implementation ?? (globalThis.WebSocket as WebSocketConstructor);\n  return Stream.callback<string | ArrayBuffer | Blob, WebSocketError>(\n    (queue) =>\n      Effect.sync(() => {\n        const socket = new Impl(url, options?.protocols);\n        if (options?.binaryType !== undefined) socket.binaryType = options.binaryType;\n\n        socket.addEventListener(\"message\", (e: MessageEvent) => {\n          Queue.offerUnsafe(queue, e.data);\n        });\n\n        socket.addEventListener(\"error\", () => {\n          Queue.failCauseUnsafe(queue, Cause.fail(new WebSocketError({ url })));\n        });\n\n        socket.addEventListener(\"close\", (e: CloseEvent) => {\n          if (e.wasClean) {\n            Queue.endUnsafe(queue);\n          } else {\n            Queue.failCauseUnsafe(\n              queue,\n              Cause.fail(new WebSocketError({ url, code: e.code, reason: e.reason })),\n            );\n          }\n        });\n\n        return Effect.sync(() => {\n          // Only close a socket that is still connecting/open.\n          if (socket.readyState === 0 || socket.readyState === 1) socket.close();\n        });\n      }),\n    { bufferSize: options?.bufferSize ?? 16, strategy: options?.strategy ?? \"suspend\" },\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA4BA,IAAa,mBAAb,cAAsC,KAAK,YAAY,kBAAkB,EAEtE,CAAC;;;;;;;;;;;;;;;;;;AA0CJ,MAAa,mBACX,KACA,YACgD;CAChD,MAAM,OAAO,SAAS,kBAAmB,WAAW;CACpD,OAAO,OAAO,UACX,UACC,OAAO,WAAW;EAChB,MAAM,SACJ,SAAS,oBAAoB,KAAA,IACzB,IAAI,KAAK,GAAG,IACZ,IAAI,KAAK,KAAK,EAAE,iBAAiB,QAAQ,gBAAgB,CAAC;EAEhE,MAAM,aAAa,MAA0B;GAC3C,MAAM,YAAY,OAAO;IAAE,OAAO,EAAE;IAAM,MAAM,EAAE;IAAM,aAAa,EAAE;GAAY,CAAC;EACtF;EAEA,OAAO,iBAAiB,WAAW,SAAS;EAC5C,KAAK,MAAM,QAAQ,SAAS,UAAU,CAAC,GAAG,OAAO,iBAAiB,MAAM,SAAS;EAEjF,OAAO,iBAAiB,eAAe;GAErC,IAAI,OAAO,eAAe,GACxB,MAAM,gBAAgB,OAAO,MAAM,KAAK,IAAI,iBAAiB,EAAE,IAAI,CAAC,CAAC,CAAC;EAE1E,CAAC;EAED,OAAO,OAAO,WAAW,OAAO,MAAM,CAAC;CACzC,CAAC,GACH;EAAE,YAAY,SAAS,cAAc;EAAI,UAAU,SAAS,YAAY;CAAU,CACpF;AACF;;AAOA,IAAa,iBAAb,cAAoC,KAAK,YAAY,gBAAgB,EAIlE,CAAC;;;;;;;;;;;;;;;;;;;AAuCJ,MAAa,iBACX,KACA,YAC+D;CAC/D,MAAM,OAAO,SAAS,kBAAmB,WAAW;CACpD,OAAO,OAAO,UACX,UACC,OAAO,WAAW;EAChB,MAAM,SAAS,IAAI,KAAK,KAAK,SAAS,SAAS;EAC/C,IAAI,SAAS,eAAe,KAAA,GAAW,OAAO,aAAa,QAAQ;EAEnE,OAAO,iBAAiB,YAAY,MAAoB;GACtD,MAAM,YAAY,OAAO,EAAE,IAAI;EACjC,CAAC;EAED,OAAO,iBAAiB,eAAe;GACrC,MAAM,gBAAgB,OAAO,MAAM,KAAK,IAAI,eAAe,EAAE,IAAI,CAAC,CAAC,CAAC;EACtE,CAAC;EAED,OAAO,iBAAiB,UAAU,MAAkB;GAClD,IAAI,EAAE,UACJ,MAAM,UAAU,KAAK;QAErB,MAAM,gBACJ,OACA,MAAM,KAAK,IAAI,eAAe;IAAE;IAAK,MAAM,EAAE;IAAM,QAAQ,EAAE;GAAO,CAAC,CAAC,CACxE;EAEJ,CAAC;EAED,OAAO,OAAO,WAAW;GAEvB,IAAI,OAAO,eAAe,KAAK,OAAO,eAAe,GAAG,OAAO,MAAM;EACvE,CAAC;CACH,CAAC,GACH;EAAE,YAAY,SAAS,cAAc;EAAI,UAAU,SAAS,YAAY;CAAU,CACpF;AACF"}

package/dist/request-parse.d.ts

@@ -0,0 +1,89 @@
+import { SvelteKitRequestEvent } from "./runtime.js";
+import { Effect, Schema } from "effect";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/request-parse.d.ts
+/** A single issue reported by a Standard Schema validator. */
+interface ParseIssue {
+  readonly message: string;
+  readonly path?: ReadonlyArray<PropertyKey | {
+    readonly key: PropertyKey;
+  }>;
+}
+declare const ParseError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "ParseError";
+} & Readonly<A>;
+/**
+ * Raised when a schema validator rejects the request data.
+ *
+ * Carry the raw `issues` array from the Standard Schema validator so callers
+ * can pattern-match on specific field failures.
+ *
+ * @example
+ * ```ts
+ * import { ParseError } from '@thomasfosterau/effect-sveltekit/server';
+ * import { Effect } from 'effect';
+ *
+ * const result = yield* decodeJson(MySchema).pipe(
+ *   Effect.catchTag("ParseError", (e) => Effect.succeed({ fallback: true })),
+ * );
+ * ```
+ */
+declare class ParseError extends ParseError_base<{
+  readonly issues: ReadonlyArray<ParseIssue>;
+}> {}
+/**
+ * Decode the route `params` object against `schema`.
+ *
+ * `params` is a plain `Record<string, string>` from the matched URL segments;
+ * the schema is free to coerce values (e.g. `Schema.NumberFromString`).
+ *
+ * @example
+ * ```ts
+ * const Params = Schema.Struct({ id: Schema.String });
+ * const { id } = yield* decodeParams(Params);
+ * ```
+ */
+declare const decodeParams: <O>(schema: Schema.Schema<O> | StandardSchemaV1<unknown, O>) => Effect.Effect<O, ParseError, SvelteKitRequestEvent>;
+/**
+ * Decode the URL search / query parameters against `schema`.
+ *
+ * The raw value passed to the validator is a plain object built from
+ * `event.url.searchParams` (multiple values for the same key become an array).
+ *
+ * @example
+ * ```ts
+ * const Query = Schema.Struct({ page: Schema.NumberFromString });
+ * const { page } = yield* decodeSearchParams(Query);
+ * ```
+ */
+declare const decodeSearchParams: <O>(schema: Schema.Schema<O> | StandardSchemaV1<unknown, O>) => Effect.Effect<O, ParseError, SvelteKitRequestEvent>;
+/**
+ * Parse the request body as JSON and decode it against `schema`.
+ *
+ * Fails with `ParseError` if the body is not valid JSON or if the schema
+ * rejects the parsed value.
+ *
+ * @example
+ * ```ts
+ * const Body = Schema.Struct({ name: Schema.String });
+ * const { name } = yield* decodeJson(Body);
+ * ```
+ */
+declare const decodeJson: <O>(schema: Schema.Schema<O> | StandardSchemaV1<unknown, O>) => Effect.Effect<O, ParseError, SvelteKitRequestEvent>;
+/**
+ * Parse the request body as `FormData` and decode it against `schema`.
+ *
+ * The raw value passed to the validator is a plain object; fields with
+ * multiple values (same name) become arrays.
+ *
+ * @example
+ * ```ts
+ * const Form = Schema.Struct({ email: Schema.String });
+ * const { email } = yield* decodeFormData(Form);
+ * ```
+ */
+declare const decodeFormData: <O>(schema: Schema.Schema<O> | StandardSchemaV1<unknown, O>) => Effect.Effect<O, ParseError, SvelteKitRequestEvent>;
+//#endregion
+export { ParseError, ParseIssue, decodeFormData, decodeJson, decodeParams, decodeSearchParams };
+//# sourceMappingURL=request-parse.d.ts.map

package/dist/request-parse.js

@@ -0,0 +1,121 @@
+import { SvelteKitRequestEvent } from "./runtime.js";
+import { toStandardValidator } from "./internal/remote-validators.js";
+import { Data, Effect } from "effect";
+//#region src/request-parse.ts
+/**
+* Raised when a schema validator rejects the request data.
+*
+* Carry the raw `issues` array from the Standard Schema validator so callers
+* can pattern-match on specific field failures.
+*
+* @example
+* ```ts
+* import { ParseError } from '@thomasfosterau/effect-sveltekit/server';
+* import { Effect } from 'effect';
+*
+* const result = yield* decodeJson(MySchema).pipe(
+*   Effect.catchTag("ParseError", (e) => Effect.succeed({ fallback: true })),
+* );
+* ```
+*/
+var ParseError = class extends Data.TaggedError("ParseError") {};
+/** Validate `value` against `schema` and return the typed output or fail. */
+const validate = (schema, value) => Effect.callback((resume) => {
+	const resultOrPromise = schema["~standard"].validate(value);
+	const settle = (result) => {
+		if ("issues" in result && result.issues !== void 0) resume(Effect.fail(new ParseError({ issues: result.issues })));
+		else resume(Effect.succeed(result.value));
+	};
+	if (resultOrPromise instanceof Promise) resultOrPromise.then(settle, (err) => {
+		resume(Effect.fail(new ParseError({ issues: [{ message: String(err) }] })));
+	});
+	else settle(resultOrPromise);
+});
+/** Normalise an Effect Schema or Standard Schema V1 to Standard Schema V1. */
+const normalise = (schema) => toStandardValidator(schema);
+/**
+* Decode the route `params` object against `schema`.
+*
+* `params` is a plain `Record<string, string>` from the matched URL segments;
+* the schema is free to coerce values (e.g. `Schema.NumberFromString`).
+*
+* @example
+* ```ts
+* const Params = Schema.Struct({ id: Schema.String });
+* const { id } = yield* decodeParams(Params);
+* ```
+*/
+const decodeParams = (schema) => Effect.gen(function* () {
+	const event = yield* SvelteKitRequestEvent;
+	return yield* validate(normalise(schema), event.params);
+});
+/**
+* Decode the URL search / query parameters against `schema`.
+*
+* The raw value passed to the validator is a plain object built from
+* `event.url.searchParams` (multiple values for the same key become an array).
+*
+* @example
+* ```ts
+* const Query = Schema.Struct({ page: Schema.NumberFromString });
+* const { page } = yield* decodeSearchParams(Query);
+* ```
+*/
+const decodeSearchParams = (schema) => Effect.gen(function* () {
+	const event = yield* SvelteKitRequestEvent;
+	const raw = {};
+	for (const key of event.url.searchParams.keys()) {
+		const values = event.url.searchParams.getAll(key);
+		raw[key] = values.length === 1 ? values[0] : values;
+	}
+	return yield* validate(normalise(schema), raw);
+});
+/**
+* Parse the request body as JSON and decode it against `schema`.
+*
+* Fails with `ParseError` if the body is not valid JSON or if the schema
+* rejects the parsed value.
+*
+* @example
+* ```ts
+* const Body = Schema.Struct({ name: Schema.String });
+* const { name } = yield* decodeJson(Body);
+* ```
+*/
+const decodeJson = (schema) => Effect.gen(function* () {
+	const event = yield* SvelteKitRequestEvent;
+	const json = yield* Effect.tryPromise({
+		try: () => event.request.json(),
+		catch: (err) => new ParseError({ issues: [{ message: `Invalid JSON: ${String(err)}` }] })
+	});
+	return yield* validate(normalise(schema), json);
+});
+/**
+* Parse the request body as `FormData` and decode it against `schema`.
+*
+* The raw value passed to the validator is a plain object; fields with
+* multiple values (same name) become arrays.
+*
+* @example
+* ```ts
+* const Form = Schema.Struct({ email: Schema.String });
+* const { email } = yield* decodeFormData(Form);
+* ```
+*/
+const decodeFormData = (schema) => Effect.gen(function* () {
+	const event = yield* SvelteKitRequestEvent;
+	const formData = yield* Effect.tryPromise({
+		try: () => event.request.formData(),
+		catch: (err) => new ParseError({ issues: [{ message: `Failed to read form data: ${String(err)}` }] })
+	});
+	const raw = {};
+	for (const key of formData.keys()) {
+		const values = formData.getAll(key).map(String);
+		raw[key] = values.length === 1 ? values[0] : values;
+	}
+	return yield* validate(normalise(schema), raw);
+});
+//#endregion
+export { ParseError, decodeFormData, decodeJson, decodeParams, decodeSearchParams };
+
+//# sourceMappingURL=request-parse.js.map

package/dist/request-parse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-parse.js","names":[],"sources":["../src/request-parse.ts"],"sourcesContent":["/**\n * Schema-driven request parsing utilities for SvelteKit server handlers.\n *\n * Each helper reads a part of the current request (route params, search params,\n * JSON body, or form data), validates it against a schema (Effect `Schema` or\n * any Standard Schema V1 validator), and returns the typed output as an\n * `Effect`. A validation failure surfaces as {@link ParseError}.\n *\n * All four utilities require `SvelteKitRequestEvent` in the environment so they\n * compose naturally inside `serverLoad` / `action` / `endpoint` handlers.\n *\n * @example\n * ```ts\n * import { serverLoad } from '@thomasfosterau/effect-sveltekit/server';\n * import { decodeParams, decodeSearchParams } from '@thomasfosterau/effect-sveltekit/server';\n * import { Schema } from 'effect';\n *\n * const Params = Schema.Struct({ id: Schema.String });\n * const Query  = Schema.Struct({ page: Schema.NumberFromString });\n *\n * export const load = serverLoad(() =>\n *   Effect.gen(function* () {\n *     const { id }   = yield* decodeParams(Params);\n *     const { page } = yield* decodeSearchParams(Query);\n *     return { id, page };\n *   }),\n * );\n * ```\n */\n\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport { Data, Effect, Schema } from \"effect\";\nimport { SvelteKitRequestEvent } from \"./runtime.js\";\nimport { toStandardValidator } from \"./internal/remote-validators.js\";\n\n// ---------------------------------------------------------------------------\n// ParseError\n// ---------------------------------------------------------------------------\n\n/** A single issue reported by a Standard Schema validator. */\nexport interface ParseIssue {\n  readonly message: string;\n  readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }>;\n}\n\n/**\n * Raised when a schema validator rejects the request data.\n *\n * Carry the raw `issues` array from the Standard Schema validator so callers\n * can pattern-match on specific field failures.\n *\n * @example\n * ```ts\n * import { ParseError } from '@thomasfosterau/effect-sveltekit/server';\n * import { Effect } from 'effect';\n *\n * const result = yield* decodeJson(MySchema).pipe(\n *   Effect.catchTag(\"ParseError\", (e) => Effect.succeed({ fallback: true })),\n * );\n * ```\n */\nexport class ParseError extends Data.TaggedError(\"ParseError\")<{\n  readonly issues: ReadonlyArray<ParseIssue>;\n}> {}\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\n/** Validate `value` against `schema` and return the typed output or fail. */\nconst validate = <O>(\n  schema: StandardSchemaV1<unknown, O>,\n  value: unknown,\n): Effect.Effect<O, ParseError> =>\n  Effect.callback<O, ParseError>((resume) => {\n    const resultOrPromise = schema[\"~standard\"].validate(value);\n    const settle = (result: StandardSchemaV1.Result<O>) => {\n      if (\"issues\" in result && result.issues !== undefined) {\n        resume(Effect.fail(new ParseError({ issues: result.issues as ReadonlyArray<ParseIssue> })));\n      } else {\n        resume(Effect.succeed((result as StandardSchemaV1.SuccessResult<O>).value));\n      }\n    };\n    if (resultOrPromise instanceof Promise) {\n      resultOrPromise.then(settle, (err: unknown) => {\n        resume(Effect.fail(new ParseError({ issues: [{ message: String(err) }] })));\n      });\n    } else {\n      settle(resultOrPromise);\n    }\n  });\n\n/** Normalise an Effect Schema or Standard Schema V1 to Standard Schema V1. */\nconst normalise = <O>(schema: unknown): StandardSchemaV1<unknown, O> =>\n  toStandardValidator(schema) as StandardSchemaV1<unknown, O>;\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\n/**\n * Decode the route `params` object against `schema`.\n *\n * `params` is a plain `Record<string, string>` from the matched URL segments;\n * the schema is free to coerce values (e.g. `Schema.NumberFromString`).\n *\n * @example\n * ```ts\n * const Params = Schema.Struct({ id: Schema.String });\n * const { id } = yield* decodeParams(Params);\n * ```\n */\nexport const decodeParams = <O>(\n  schema: Schema.Schema<O> | StandardSchemaV1<unknown, O>,\n): Effect.Effect<O, ParseError, SvelteKitRequestEvent> =>\n  Effect.gen(function* () {\n    const event = yield* SvelteKitRequestEvent;\n    return yield* validate(normalise<O>(schema), event.params);\n  });\n\n/**\n * Decode the URL search / query parameters against `schema`.\n *\n * The raw value passed to the validator is a plain object built from\n * `event.url.searchParams` (multiple values for the same key become an array).\n *\n * @example\n * ```ts\n * const Query = Schema.Struct({ page: Schema.NumberFromString });\n * const { page } = yield* decodeSearchParams(Query);\n * ```\n */\nexport const decodeSearchParams = <O>(\n  schema: Schema.Schema<O> | StandardSchemaV1<unknown, O>,\n): Effect.Effect<O, ParseError, SvelteKitRequestEvent> =>\n  Effect.gen(function* () {\n    const event = yield* SvelteKitRequestEvent;\n    const raw: Record<string, string | string[]> = {};\n    for (const key of event.url.searchParams.keys()) {\n      const values = event.url.searchParams.getAll(key);\n      raw[key] = values.length === 1 ? values[0]! : values;\n    }\n    return yield* validate(normalise<O>(schema), raw);\n  });\n\n/**\n * Parse the request body as JSON and decode it against `schema`.\n *\n * Fails with `ParseError` if the body is not valid JSON or if the schema\n * rejects the parsed value.\n *\n * @example\n * ```ts\n * const Body = Schema.Struct({ name: Schema.String });\n * const { name } = yield* decodeJson(Body);\n * ```\n */\nexport const decodeJson = <O>(\n  schema: Schema.Schema<O> | StandardSchemaV1<unknown, O>,\n): Effect.Effect<O, ParseError, SvelteKitRequestEvent> =>\n  Effect.gen(function* () {\n    const event = yield* SvelteKitRequestEvent;\n    const json = yield* Effect.tryPromise({\n      try: () => event.request.json() as Promise<unknown>,\n      catch: (err) => new ParseError({ issues: [{ message: `Invalid JSON: ${String(err)}` }] }),\n    });\n    return yield* validate(normalise<O>(schema), json);\n  });\n\n/**\n * Parse the request body as `FormData` and decode it against `schema`.\n *\n * The raw value passed to the validator is a plain object; fields with\n * multiple values (same name) become arrays.\n *\n * @example\n * ```ts\n * const Form = Schema.Struct({ email: Schema.String });\n * const { email } = yield* decodeFormData(Form);\n * ```\n */\nexport const decodeFormData = <O>(\n  schema: Schema.Schema<O> | StandardSchemaV1<unknown, O>,\n): Effect.Effect<O, ParseError, SvelteKitRequestEvent> =>\n  Effect.gen(function* () {\n    const event = yield* SvelteKitRequestEvent;\n    const formData = yield* Effect.tryPromise({\n      try: () => event.request.formData(),\n      catch: (err) =>\n        new ParseError({ issues: [{ message: `Failed to read form data: ${String(err)}` }] }),\n    });\n    const raw: Record<string, string | string[]> = {};\n    for (const key of formData.keys()) {\n      const values = formData.getAll(key).map(String);\n      raw[key] = values.length === 1 ? values[0]! : values;\n    }\n    return yield* validate(normalise<O>(schema), raw);\n  });\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA6DA,IAAa,aAAb,cAAgC,KAAK,YAAY,YAAY,EAE1D,CAAC;;AAOJ,MAAM,YACJ,QACA,UAEA,OAAO,UAAyB,WAAW;CACzC,MAAM,kBAAkB,OAAO,aAAa,SAAS,KAAK;CAC1D,MAAM,UAAU,WAAuC;EACrD,IAAI,YAAY,UAAU,OAAO,WAAW,KAAA,GAC1C,OAAO,OAAO,KAAK,IAAI,WAAW,EAAE,QAAQ,OAAO,OAAoC,CAAC,CAAC,CAAC;OAE1F,OAAO,OAAO,QAAS,OAA6C,KAAK,CAAC;CAE9E;CACA,IAAI,2BAA2B,SAC7B,gBAAgB,KAAK,SAAS,QAAiB;EAC7C,OAAO,OAAO,KAAK,IAAI,WAAW,EAAE,QAAQ,CAAC,EAAE,SAAS,OAAO,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAC5E,CAAC;MAED,OAAO,eAAe;AAE1B,CAAC;;AAGH,MAAM,aAAgB,WACpB,oBAAoB,MAAM;;;;;;;;;;;;;AAkB5B,MAAa,gBACX,WAEA,OAAO,IAAI,aAAa;CACtB,MAAM,QAAQ,OAAO;CACrB,OAAO,OAAO,SAAS,UAAa,MAAM,GAAG,MAAM,MAAM;AAC3D,CAAC;;;;;;;;;;;;;AAcH,MAAa,sBACX,WAEA,OAAO,IAAI,aAAa;CACtB,MAAM,QAAQ,OAAO;CACrB,MAAM,MAAyC,CAAC;CAChD,KAAK,MAAM,OAAO,MAAM,IAAI,aAAa,KAAK,GAAG;EAC/C,MAAM,SAAS,MAAM,IAAI,aAAa,OAAO,GAAG;EAChD,IAAI,OAAO,OAAO,WAAW,IAAI,OAAO,KAAM;CAChD;CACA,OAAO,OAAO,SAAS,UAAa,MAAM,GAAG,GAAG;AAClD,CAAC;;;;;;;;;;;;;AAcH,MAAa,cACX,WAEA,OAAO,IAAI,aAAa;CACtB,MAAM,QAAQ,OAAO;CACrB,MAAM,OAAO,OAAO,OAAO,WAAW;EACpC,WAAW,MAAM,QAAQ,KAAK;EAC9B,QAAQ,QAAQ,IAAI,WAAW,EAAE,QAAQ,CAAC,EAAE,SAAS,iBAAiB,OAAO,GAAG,IAAI,CAAC,EAAE,CAAC;CAC1F,CAAC;CACD,OAAO,OAAO,SAAS,UAAa,MAAM,GAAG,IAAI;AACnD,CAAC;;;;;;;;;;;;;AAcH,MAAa,kBACX,WAEA,OAAO,IAAI,aAAa;CACtB,MAAM,QAAQ,OAAO;CACrB,MAAM,WAAW,OAAO,OAAO,WAAW;EACxC,WAAW,MAAM,QAAQ,SAAS;EAClC,QAAQ,QACN,IAAI,WAAW,EAAE,QAAQ,CAAC,EAAE,SAAS,6BAA6B,OAAO,GAAG,IAAI,CAAC,EAAE,CAAC;CACxF,CAAC;CACD,MAAM,MAAyC,CAAC;CAChD,KAAK,MAAM,OAAO,SAAS,KAAK,GAAG;EACjC,MAAM,SAAS,SAAS,OAAO,GAAG,EAAE,IAAI,MAAM;EAC9C,IAAI,OAAO,OAAO,WAAW,IAAI,OAAO,KAAM;CAChD;CACA,OAAO,OAAO,SAAS,UAAa,MAAM,GAAG,GAAG;AAClD,CAAC"}

package/dist/request-runtime.js

@@ -1,4 +1,4 @@
-import { causeToThrowable } from "./internal/error.js";
+import { SvelteKit } from "./kit.js";
 import { Cause, Effect, Exit, ManagedRuntime } from "effect";
 import { isHttpError, isRedirect } from "@sveltejs/kit";
 //#region src/request-runtime.ts
@@ -140,9 +140,7 @@ const RequestRuntime = {
 * ```
 */
 const makeRuntimeAdapter = (provider, opts) => {
-	const translateError = opts?.translateError ?? ((cause) => {
-		throw causeToThrowable(cause);
-	});
+	const translateError = opts?.translateError ?? SvelteKit.translate;
 	const runSettle = async (event, effect) => {
 		const exit = await provider.run(event).runPromiseExit(effect);
 		try {
@@ -152,9 +150,9 @@ const makeRuntimeAdapter = (provider, opts) => {
 			provider.disposeAfterResponse?.(event);
 		}
 	};
-	const action = (fn) => (event) => runSettle(event, fn(event));
+	const action = (fn) => (event) => runSettle(event, fn(event).pipe(Effect.withSpan(`action ${event.route.id ?? "(unknown)"}`, { kind: "server" })));
 	return {
-		serverLoad: (fn) => (event) => runSettle(event, fn(event)),
+		serverLoad: (fn) => (event) => runSettle(event, fn(event).pipe(Effect.withSpan(`serverLoad ${event.route.id ?? "(unknown)"}`, { kind: "server" }))),
 		action,
 		actions: (map) => {
 			const wrapped = {};
@@ -162,18 +160,21 @@ const makeRuntimeAdapter = (provider, opts) => {
 			return wrapped;
 		},
 		endpoint: (fn, options) => async (event) => {
-			const exit = await provider.run(event).runPromiseExit(fn(event));
+			const effect = fn(event).pipe(Effect.withSpan(`${event.request.method} ${event.route.id ?? "(unknown)"}`, { kind: "server" }));
+			const exit = await provider.run(event).runPromiseExit(effect);
 			try {
 				if (Exit.isSuccess(exit)) return exit.value;
-				if (opts?.translateError) return opts.translateError(exit.cause);
-				const squashed = Cause.squash(exit.cause);
-				if (isRedirect(squashed) || isHttpError(squashed)) throw squashed;
-				console.error("Endpoint error:", Cause.pretty(exit.cause));
-				const message = options?.exposeErrors ? Cause.pretty(exit.cause) : "Internal server error";
-				return new Response(JSON.stringify({ error: message }), {
-					status: 500,
-					headers: { "Content-Type": "application/json" }
-				});
+				try {
+					return translateError(exit.cause);
+				} catch (err) {
+					if (isRedirect(err) || isHttpError(err)) throw err;
+					console.error("Endpoint error:", Cause.pretty(exit.cause));
+					const message = options?.exposeErrors ? Cause.pretty(exit.cause) : "Internal server error";
+					return new Response(JSON.stringify({ error: message }), {
+						status: 500,
+						headers: { "Content-Type": "application/json" }
+					});
+				}
 			} finally {
 				provider.disposeAfterResponse?.(event);
 			}

package/dist/request-runtime.js.map

@@ -1 +1 @@
-{"version":3,"file":"request-runtime.js","names":[],"sources":["../src/request-runtime.ts"],"sourcesContent":["/**\n * A general, Effect-idiomatic way to provide the per-request execution context\n * for SvelteKit server wrappers.\n *\n * Where {@link makeServerRuntime} bakes in \"the package owns a runtime, built\n * once per process,\" this module factors out the single decision *how to obtain\n * the execution context for this request* behind one open abstraction — a\n * {@link RequestRuntimeProvider}. Existing models (a build-once\n * `ManagedRuntime`, a layer built once), a consumer-owned runtime resolved from\n * `event.locals`, and a package-built per-request runtime are all just\n * {@link RequestRuntime} constructors of the same provider, not separate code\n * paths.\n *\n * {@link makeRuntimeAdapter} binds the `serverLoad` / `action` / `actions` /\n * `endpoint` wrappers to a provider (and an optional boundary error\n * translator), so the handler effect's requirement channel `R` is the\n * *provider's* services — your own application catalogue — rather than the fixed\n * {@link SvelteKitServices}.\n *\n * @example\n * ```ts\n * // The consumer owns a per-request ManagedRuntime on event.locals.runtime\n * // (rebuilt mid-request); the package adopts it, resolved at call time.\n * import { makeRuntimeAdapter, RequestRuntime } from \"@thomasfosterau/effect-sveltekit/server\";\n *\n * const { serverLoad, action, actions, endpoint } = makeRuntimeAdapter(\n *   RequestRuntime.fromLocals((event) => event.locals.runtime),\n *   { translateError: toSvelteKit },\n * );\n *\n * export const load = serverLoad((event) =>\n *   Effect.gen(function* () {\n *     const db = yield* Database; // app service from locals.runtime\n *     return { items: yield* db.list() };\n *   }),\n * );\n * ```\n */\n\nimport {\n  isHttpError,\n  isRedirect,\n  type Action,\n  type Actions,\n  type RequestEvent,\n  type RequestHandler,\n  type ServerLoad,\n} from \"@sveltejs/kit\";\nimport { Cause, Context, Effect, Exit, type Fiber, Layer, ManagedRuntime } from \"effect\";\nimport type { SvelteRouteParams } from \"./internal/route-params.js\";\nimport { causeToThrowable } from \"./internal/error.js\";\n\n/**\n * The runners a {@link RequestRuntimeProvider} resolves for a single request:\n * a way to run an `Effect<A, unknown, R>` that requires the provider's services\n * `R`. The error channel is `unknown` because a boundary translator (see\n * {@link makeRuntimeAdapter}) decides how failures surface.\n */\nexport interface RequestRuntimeRunners<in R> {\n  /** Run the request's effect, keeping its `Exit` (never rejects). */\n  readonly runPromiseExit: <A>(\n    effect: Effect.Effect<A, unknown, R>,\n  ) => Promise<Exit.Exit<A, unknown>>;\n  /** Fork the request's effect, returning the running fiber. */\n  readonly runFork: <A>(effect: Effect.Effect<A, unknown, R>) => Fiber.Fiber<A, unknown>;\n}\n\n/**\n * How to execute a request's effects. Resolved per request, at call time, so a\n * runtime the consumer rebuilds mid-request is honoured automatically.\n *\n * Implementations own the scope/lifecycle of whatever they build. `R` is the\n * set of services the handler effect may require; `E` is the layer construction\n * error type (informational — failures surface through the translator).\n */\nexport interface RequestRuntimeProvider<R, E = never> {\n  /** Resolve the runners for a request. Consulted per call, never cached. */\n  readonly run: (event: RequestEvent) => RequestRuntimeRunners<R>;\n  /**\n   * Optional teardown to run after the response is produced. Called by\n   * {@link makeRuntimeAdapter} once the handler has settled — e.g. to route a\n   * per-request resource's disposal through `ctx.waitUntil` on Workers.\n   */\n  readonly disposeAfterResponse?: (event: RequestEvent) => void;\n  /** Phantom marker so `E` participates in inference. */\n  readonly _E?: (_: never) => E;\n}\n\n/** Runners backed by an existing `ManagedRuntime`. */\nconst runnersFromManagedRuntime = <R>(\n  rt: ManagedRuntime.ManagedRuntime<R, unknown>,\n): RequestRuntimeRunners<R> => ({\n  runPromiseExit: (effect) => rt.runPromiseExit(effect) as Promise<Exit.Exit<never, unknown>>,\n  runFork: (effect) => rt.runFork(effect) as Fiber.Fiber<never, unknown>,\n});\n\n/** Runners backed by a built service `Context` (run on the default scheduler). */\nconst runnersFromContext = <R>(context: Context.Context<R>): RequestRuntimeRunners<R> => ({\n  runPromiseExit: (effect) => Effect.runPromiseExitWith(context)(effect),\n  runFork: (effect) => Effect.runForkWith(context)(effect),\n});\n\n/** Runners for a target that is either a `ManagedRuntime` or a `Context`. */\nconst runnersFor = <R>(\n  target: ManagedRuntime.ManagedRuntime<R, unknown> | Context.Context<R>,\n): RequestRuntimeRunners<R> =>\n  ManagedRuntime.isManagedRuntime(target)\n    ? runnersFromManagedRuntime(target as ManagedRuntime.ManagedRuntime<R, unknown>)\n    : runnersFromContext(target as Context.Context<R>);\n\n/** Options for {@link RequestRuntime.fromLayerPerRequest}. */\nexport interface FromLayerPerRequestOptions {\n  /**\n   * Defer teardown of the per-request runtime to after the response is\n   * produced, instead of awaiting `dispose()` inline. On Workers, route it\n   * through `ctx.waitUntil` so disposal does not fight response streaming or\n   * socket pinning:\n   *\n   * ```ts\n   * { afterResponse: (event, dispose) => event.platform!.ctx.waitUntil(dispose()) }\n   * ```\n   */\n  readonly afterResponse?: (event: RequestEvent, dispose: () => Promise<void>) => void;\n}\n\n/**\n * Constructors for {@link RequestRuntimeProvider}. Each expresses one way to\n * obtain a request's execution context; the wrappers don't care which.\n */\nexport const RequestRuntime = {\n  /**\n   * Adopt a `ManagedRuntime` the consumer already built (the build-once model,\n   * expressed as a provider).\n   */\n  fromManagedRuntime: <R, E>(\n    rt: ManagedRuntime.ManagedRuntime<R, E>,\n  ): RequestRuntimeProvider<R, E> => {\n    const runners = runnersFromManagedRuntime(rt as ManagedRuntime.ManagedRuntime<R, unknown>);\n    return { run: () => runners };\n  },\n\n  /**\n   * Let the package build a single `ManagedRuntime` from a layer, lazily on\n   * first use and shared across requests (the existing build-once-per-process\n   * model).\n   */\n  fromLayer: <R, E>(layer: Layer.Layer<R, E>): RequestRuntimeProvider<R, E> => {\n    let runners: RequestRuntimeRunners<R> | undefined;\n    return {\n      run: () =>\n        (runners ??= runnersFromManagedRuntime(\n          ManagedRuntime.make(layer) as ManagedRuntime.ManagedRuntime<R, unknown>,\n        )),\n    };\n  },\n\n  /**\n   * Adopt a runtime the consumer stashed on the request (e.g. on\n   * `event.locals`). Resolved at call time, so a runtime rebuilt mid-request is\n   * honoured automatically. The getter may return a `ManagedRuntime` or a\n   * built service `Context`.\n   */\n  fromLocals: <R>(\n    get: (event: RequestEvent) => ManagedRuntime.ManagedRuntime<R, unknown> | Context.Context<R>,\n  ): RequestRuntimeProvider<R> => ({\n    run: (event) => runnersFor(get(event)),\n  }),\n\n  /**\n   * Let the package build *and dispose* a `ManagedRuntime` per request from a\n   * layer factory. Each handler invocation builds its own runtime from\n   * `layer(event)` and disposes it once the effect settles — so a per-request\n   * resource (a DB pool) dies with the request. Use `opts.afterResponse` to\n   * defer disposal to after the response (Workers `ctx.waitUntil`).\n   *\n   * For sharing one runtime across every load/action of a request, prefer\n   * {@link RequestRuntime.fromLocals} with a runtime the consumer builds in\n   * `hooks.server.ts`.\n   */\n  fromLayerPerRequest: <R, E>(\n    layer: (event: RequestEvent) => Layer.Layer<R, E>,\n    opts?: FromLayerPerRequestOptions,\n  ): RequestRuntimeProvider<R, E> => ({\n    run: (event) => {\n      const dispose = (rt: ManagedRuntime.ManagedRuntime<R, E>) => () => rt.dispose();\n      const teardown = (rt: ManagedRuntime.ManagedRuntime<R, E>): Promise<void> => {\n        if (opts?.afterResponse) {\n          opts.afterResponse(event, dispose(rt));\n          return Promise.resolve();\n        }\n        return rt.dispose();\n      };\n      return {\n        runPromiseExit: async (effect) => {\n          const rt = ManagedRuntime.make(layer(event));\n          try {\n            return (await rt.runPromiseExit(effect)) as Exit.Exit<never, unknown>;\n          } finally {\n            await teardown(rt);\n          }\n        },\n        runFork: (effect) => {\n          const rt = ManagedRuntime.make(layer(event));\n          const fiber = rt.runFork(effect) as Fiber.Fiber<never, unknown>;\n          fiber.addObserver(() => void teardown(rt));\n          return fiber;\n        },\n      };\n    },\n  }),\n};\n\n/** A boundary translator: turn a failed `Cause` into a thrown value. */\nexport type ErrorTranslator = (cause: Cause.Cause<unknown>) => never;\n\n/** Options shared by {@link makeRuntimeAdapter}. */\nexport interface RuntimeAdapterOptions {\n  /**\n   * Translate a failed `Cause` into SvelteKit control flow at the boundary.\n   * Called for `serverLoad` / `action` / `actions` failures; it may throw\n   * `redirect()` / `error()` (and, for remote forms, call `invalid()`).\n   * Defaults to the package's passthrough: SvelteKit's own `redirect()` /\n   * `error()` are rethrown, anything else becomes an `EffectCauseError` (a 500).\n   */\n  readonly translateError?: ErrorTranslator;\n}\n\n/** Options for the adapter's `endpoint` wrapper. */\nexport interface AdapterEndpointOptions {\n  /**\n   * Include full error details (`Cause.pretty`) in the default 500 JSON body.\n   * Ignored when a `translateError` is configured. Defaults to `false`.\n   */\n  readonly exposeErrors?: boolean;\n}\n\n/** The wrappers produced by {@link makeRuntimeAdapter}, bound to a provider. */\nexport interface RuntimeAdapter<R> {\n  readonly serverLoad: <\n    Params extends SvelteRouteParams = SvelteRouteParams,\n    ParentData extends Record<string, any> = any,\n    OutputData extends Record<string, any> | void = any,\n    RouteId extends string | null = any,\n  >(\n    fn: (event: RequestEvent<Params, RouteId>) => Effect.Effect<OutputData, unknown, R>,\n  ) => ServerLoad<Params, ParentData, OutputData, RouteId>;\n  readonly action: <\n    Params extends SvelteRouteParams = SvelteRouteParams,\n    OutputData extends Record<string, any> | void = any,\n    RouteId extends string | null = any,\n  >(\n    fn: (event: RequestEvent<Params, RouteId>) => Effect.Effect<OutputData, unknown, R>,\n  ) => Action<Params, OutputData, RouteId>;\n  readonly actions: <\n    Params extends SvelteRouteParams = SvelteRouteParams,\n    OutputData extends Record<string, any> | void = any,\n    RouteId extends string | null = any,\n  >(\n    map: Record<\n      string,\n      (event: RequestEvent<Params, RouteId>) => Effect.Effect<OutputData, unknown, R>\n    >,\n  ) => Actions<Params, OutputData, RouteId>;\n  readonly endpoint: <\n    Params extends SvelteRouteParams = SvelteRouteParams,\n    RouteId extends string | null = any,\n  >(\n    fn: (event: RequestEvent<Params, RouteId>) => Effect.Effect<Response, unknown, R>,\n    options?: AdapterEndpointOptions,\n  ) => RequestHandler<Params, RouteId>;\n}\n\n/**\n * Bind the SvelteKit server wrappers to a {@link RequestRuntimeProvider} (and an\n * optional boundary error translator).\n *\n * Unlike the standalone `serverLoad` / `action` / `endpoint`, the handler\n * effect's required services `R` come from the provider — your own application\n * catalogue — not the fixed {@link SvelteKitServices}. The package does not\n * merge `HttpClient` / `SvelteKitRequestEvent` onto this path; add them to your\n * own layer if you want them.\n *\n * @example\n * ```ts\n * // Package owns the runtime per request on Workers, disposed via waitUntil.\n * const { serverLoad } = makeRuntimeAdapter(\n *   RequestRuntime.fromLayerPerRequest((event) => AppLayer(event.platform!.env), {\n *     afterResponse: (event, dispose) => event.platform!.ctx.waitUntil(dispose()),\n *   }),\n * );\n * ```\n */\nexport const makeRuntimeAdapter = <R>(\n  provider: RequestRuntimeProvider<R, any>,\n  opts?: RuntimeAdapterOptions,\n): RuntimeAdapter<R> => {\n  const translateError: ErrorTranslator =\n    opts?.translateError ??\n    ((cause) => {\n      throw causeToThrowable(cause);\n    });\n\n  const runSettle = async <A>(\n    event: RequestEvent,\n    effect: Effect.Effect<A, unknown, R>,\n  ): Promise<A> => {\n    const exit = await provider.run(event).runPromiseExit(effect);\n    try {\n      if (Exit.isSuccess(exit)) return exit.value;\n      return translateError(exit.cause);\n    } finally {\n      provider.disposeAfterResponse?.(event);\n    }\n  };\n\n  const action: RuntimeAdapter<R>[\"action\"] = (fn) => (event) => runSettle(event, fn(event));\n\n  return {\n    serverLoad: (fn) => (event) => runSettle(event, fn(event)),\n    action,\n    actions: (map) => {\n      const wrapped: Record<string, Action<any, any, any>> = {};\n      for (const [key, fn] of Object.entries(map)) wrapped[key] = action(fn);\n      return wrapped as never;\n    },\n    endpoint: (fn, options) => async (event) => {\n      const exit = await provider.run(event as RequestEvent).runPromiseExit(fn(event));\n      try {\n        if (Exit.isSuccess(exit)) return exit.value;\n        // A configured translator owns the whole failure path (control flow,\n        // structured error bodies, ...).\n        if (opts?.translateError) return opts.translateError(exit.cause);\n        // Default: pass SvelteKit control flow through, otherwise a 500.\n        const squashed = Cause.squash(exit.cause);\n        if (isRedirect(squashed) || isHttpError(squashed)) throw squashed;\n        console.error(\"Endpoint error:\", Cause.pretty(exit.cause));\n        const message = options?.exposeErrors ? Cause.pretty(exit.cause) : \"Internal server error\";\n        return new Response(JSON.stringify({ error: message }), {\n          status: 500,\n          headers: { \"Content-Type\": \"application/json\" },\n        });\n      } finally {\n        provider.disposeAfterResponse?.(event as RequestEvent);\n      }\n    },\n  };\n};\n"],"mappings":"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"}
+{"version":3,"file":"request-runtime.js","names":[],"sources":["../src/request-runtime.ts"],"sourcesContent":["/**\n * A general, Effect-idiomatic way to provide the per-request execution context\n * for SvelteKit server wrappers.\n *\n * Where {@link makeServerRuntime} bakes in \"the package owns a runtime, built\n * once per process,\" this module factors out the single decision *how to obtain\n * the execution context for this request* behind one open abstraction — a\n * {@link RequestRuntimeProvider}. Existing models (a build-once\n * `ManagedRuntime`, a layer built once), a consumer-owned runtime resolved from\n * `event.locals`, and a package-built per-request runtime are all just\n * {@link RequestRuntime} constructors of the same provider, not separate code\n * paths.\n *\n * {@link makeRuntimeAdapter} binds the `serverLoad` / `action` / `actions` /\n * `endpoint` wrappers to a provider (and an optional boundary error\n * translator), so the handler effect's requirement channel `R` is the\n * *provider's* services — your own application catalogue — rather than the fixed\n * {@link SvelteKitServices}.\n *\n * @example\n * ```ts\n * // The consumer owns a per-request ManagedRuntime on event.locals.runtime\n * // (rebuilt mid-request); the package adopts it, resolved at call time.\n * import { makeRuntimeAdapter, RequestRuntime } from \"@thomasfosterau/effect-sveltekit/server\";\n *\n * const { serverLoad, action, actions, endpoint } = makeRuntimeAdapter(\n *   RequestRuntime.fromLocals((event) => event.locals.runtime),\n *   { translateError: toSvelteKit },\n * );\n *\n * export const load = serverLoad((event) =>\n *   Effect.gen(function* () {\n *     const db = yield* Database; // app service from locals.runtime\n *     return { items: yield* db.list() };\n *   }),\n * );\n * ```\n */\n\nimport {\n  isHttpError,\n  isRedirect,\n  type Action,\n  type Actions,\n  type RequestEvent,\n  type RequestHandler,\n  type ServerLoad,\n} from \"@sveltejs/kit\";\nimport { Cause, Context, Effect, Exit, type Fiber, Layer, ManagedRuntime } from \"effect\";\nimport type { SvelteRouteParams } from \"./internal/route-params.js\";\nimport { SvelteKit } from \"./kit.js\";\n\n/**\n * The runners a {@link RequestRuntimeProvider} resolves for a single request:\n * a way to run an `Effect<A, unknown, R>` that requires the provider's services\n * `R`. The error channel is `unknown` because a boundary translator (see\n * {@link makeRuntimeAdapter}) decides how failures surface.\n */\nexport interface RequestRuntimeRunners<in R> {\n  /** Run the request's effect, keeping its `Exit` (never rejects). */\n  readonly runPromiseExit: <A>(\n    effect: Effect.Effect<A, unknown, R>,\n  ) => Promise<Exit.Exit<A, unknown>>;\n  /** Fork the request's effect, returning the running fiber. */\n  readonly runFork: <A>(effect: Effect.Effect<A, unknown, R>) => Fiber.Fiber<A, unknown>;\n}\n\n/**\n * How to execute a request's effects. Resolved per request, at call time, so a\n * runtime the consumer rebuilds mid-request is honoured automatically.\n *\n * Implementations own the scope/lifecycle of whatever they build. `R` is the\n * set of services the handler effect may require; `E` is the layer construction\n * error type (informational — failures surface through the translator).\n */\nexport interface RequestRuntimeProvider<R, E = never> {\n  /** Resolve the runners for a request. Consulted per call, never cached. */\n  readonly run: (event: RequestEvent) => RequestRuntimeRunners<R>;\n  /**\n   * Optional teardown to run after the response is produced. Called by\n   * {@link makeRuntimeAdapter} once the handler has settled — e.g. to route a\n   * per-request resource's disposal through `ctx.waitUntil` on Workers.\n   */\n  readonly disposeAfterResponse?: (event: RequestEvent) => void;\n  /** Phantom marker so `E` participates in inference. */\n  readonly _E?: (_: never) => E;\n}\n\n/** Runners backed by an existing `ManagedRuntime`. */\nconst runnersFromManagedRuntime = <R>(\n  rt: ManagedRuntime.ManagedRuntime<R, unknown>,\n): RequestRuntimeRunners<R> => ({\n  runPromiseExit: (effect) => rt.runPromiseExit(effect) as Promise<Exit.Exit<never, unknown>>,\n  runFork: (effect) => rt.runFork(effect) as Fiber.Fiber<never, unknown>,\n});\n\n/** Runners backed by a built service `Context` (run on the default scheduler). */\nconst runnersFromContext = <R>(context: Context.Context<R>): RequestRuntimeRunners<R> => ({\n  runPromiseExit: (effect) => Effect.runPromiseExitWith(context)(effect),\n  runFork: (effect) => Effect.runForkWith(context)(effect),\n});\n\n/** Runners for a target that is either a `ManagedRuntime` or a `Context`. */\nconst runnersFor = <R>(\n  target: ManagedRuntime.ManagedRuntime<R, unknown> | Context.Context<R>,\n): RequestRuntimeRunners<R> =>\n  ManagedRuntime.isManagedRuntime(target)\n    ? runnersFromManagedRuntime(target as ManagedRuntime.ManagedRuntime<R, unknown>)\n    : runnersFromContext(target as Context.Context<R>);\n\n/** Options for {@link RequestRuntime.fromLayerPerRequest}. */\nexport interface FromLayerPerRequestOptions {\n  /**\n   * Defer teardown of the per-request runtime to after the response is\n   * produced, instead of awaiting `dispose()` inline. On Workers, route it\n   * through `ctx.waitUntil` so disposal does not fight response streaming or\n   * socket pinning:\n   *\n   * ```ts\n   * { afterResponse: (event, dispose) => event.platform!.ctx.waitUntil(dispose()) }\n   * ```\n   */\n  readonly afterResponse?: (event: RequestEvent, dispose: () => Promise<void>) => void;\n}\n\n/**\n * Constructors for {@link RequestRuntimeProvider}. Each expresses one way to\n * obtain a request's execution context; the wrappers don't care which.\n */\nexport const RequestRuntime = {\n  /**\n   * Adopt a `ManagedRuntime` the consumer already built (the build-once model,\n   * expressed as a provider).\n   */\n  fromManagedRuntime: <R, E>(\n    rt: ManagedRuntime.ManagedRuntime<R, E>,\n  ): RequestRuntimeProvider<R, E> => {\n    const runners = runnersFromManagedRuntime(rt as ManagedRuntime.ManagedRuntime<R, unknown>);\n    return { run: () => runners };\n  },\n\n  /**\n   * Let the package build a single `ManagedRuntime` from a layer, lazily on\n   * first use and shared across requests (the existing build-once-per-process\n   * model).\n   */\n  fromLayer: <R, E>(layer: Layer.Layer<R, E>): RequestRuntimeProvider<R, E> => {\n    let runners: RequestRuntimeRunners<R> | undefined;\n    return {\n      run: () =>\n        (runners ??= runnersFromManagedRuntime(\n          ManagedRuntime.make(layer) as ManagedRuntime.ManagedRuntime<R, unknown>,\n        )),\n    };\n  },\n\n  /**\n   * Adopt a runtime the consumer stashed on the request (e.g. on\n   * `event.locals`). Resolved at call time, so a runtime rebuilt mid-request is\n   * honoured automatically. The getter may return a `ManagedRuntime` or a\n   * built service `Context`.\n   */\n  fromLocals: <R>(\n    get: (event: RequestEvent) => ManagedRuntime.ManagedRuntime<R, unknown> | Context.Context<R>,\n  ): RequestRuntimeProvider<R> => ({\n    run: (event) => runnersFor(get(event)),\n  }),\n\n  /**\n   * Let the package build *and dispose* a `ManagedRuntime` per request from a\n   * layer factory. Each handler invocation builds its own runtime from\n   * `layer(event)` and disposes it once the effect settles — so a per-request\n   * resource (a DB pool) dies with the request. Use `opts.afterResponse` to\n   * defer disposal to after the response (Workers `ctx.waitUntil`).\n   *\n   * For sharing one runtime across every load/action of a request, prefer\n   * {@link RequestRuntime.fromLocals} with a runtime the consumer builds in\n   * `hooks.server.ts`.\n   */\n  fromLayerPerRequest: <R, E>(\n    layer: (event: RequestEvent) => Layer.Layer<R, E>,\n    opts?: FromLayerPerRequestOptions,\n  ): RequestRuntimeProvider<R, E> => ({\n    run: (event) => {\n      const dispose = (rt: ManagedRuntime.ManagedRuntime<R, E>) => () => rt.dispose();\n      const teardown = (rt: ManagedRuntime.ManagedRuntime<R, E>): Promise<void> => {\n        if (opts?.afterResponse) {\n          opts.afterResponse(event, dispose(rt));\n          return Promise.resolve();\n        }\n        return rt.dispose();\n      };\n      return {\n        runPromiseExit: async (effect) => {\n          const rt = ManagedRuntime.make(layer(event));\n          try {\n            return (await rt.runPromiseExit(effect)) as Exit.Exit<never, unknown>;\n          } finally {\n            await teardown(rt);\n          }\n        },\n        runFork: (effect) => {\n          const rt = ManagedRuntime.make(layer(event));\n          const fiber = rt.runFork(effect) as Fiber.Fiber<never, unknown>;\n          fiber.addObserver(() => void teardown(rt));\n          return fiber;\n        },\n      };\n    },\n  }),\n};\n\n/** A boundary translator: turn a failed `Cause` into a thrown value. */\nexport type ErrorTranslator = (cause: Cause.Cause<unknown>) => never;\n\n/** Options shared by {@link makeRuntimeAdapter}. */\nexport interface RuntimeAdapterOptions {\n  /**\n   * Translate a failed `Cause` into SvelteKit control flow at the boundary.\n   * Called for `serverLoad` / `action` / `actions` failures; it may throw\n   * `redirect()` / `error()` (and, for remote forms, call `invalid()`).\n   * Defaults to the package's passthrough: SvelteKit's own `redirect()` /\n   * `error()` are rethrown, anything else becomes an `EffectCauseError` (a 500).\n   */\n  readonly translateError?: ErrorTranslator;\n}\n\n/** Options for the adapter's `endpoint` wrapper. */\nexport interface AdapterEndpointOptions {\n  /**\n   * Include full error details (`Cause.pretty`) in the default 500 JSON body.\n   * Ignored when a `translateError` is configured. Defaults to `false`.\n   */\n  readonly exposeErrors?: boolean;\n}\n\n/** The wrappers produced by {@link makeRuntimeAdapter}, bound to a provider. */\nexport interface RuntimeAdapter<R> {\n  readonly serverLoad: <\n    Params extends SvelteRouteParams = SvelteRouteParams,\n    ParentData extends Record<string, any> = any,\n    OutputData extends Record<string, any> | void = any,\n    RouteId extends string | null = any,\n  >(\n    fn: (event: RequestEvent<Params, RouteId>) => Effect.Effect<OutputData, unknown, R>,\n  ) => ServerLoad<Params, ParentData, OutputData, RouteId>;\n  readonly action: <\n    Params extends SvelteRouteParams = SvelteRouteParams,\n    OutputData extends Record<string, any> | void = any,\n    RouteId extends string | null = any,\n  >(\n    fn: (event: RequestEvent<Params, RouteId>) => Effect.Effect<OutputData, unknown, R>,\n  ) => Action<Params, OutputData, RouteId>;\n  readonly actions: <\n    Params extends SvelteRouteParams = SvelteRouteParams,\n    OutputData extends Record<string, any> | void = any,\n    RouteId extends string | null = any,\n  >(\n    map: Record<\n      string,\n      (event: RequestEvent<Params, RouteId>) => Effect.Effect<OutputData, unknown, R>\n    >,\n  ) => Actions<Params, OutputData, RouteId>;\n  readonly endpoint: <\n    Params extends SvelteRouteParams = SvelteRouteParams,\n    RouteId extends string | null = any,\n  >(\n    fn: (event: RequestEvent<Params, RouteId>) => Effect.Effect<Response, unknown, R>,\n    options?: AdapterEndpointOptions,\n  ) => RequestHandler<Params, RouteId>;\n}\n\n/**\n * Bind the SvelteKit server wrappers to a {@link RequestRuntimeProvider} (and an\n * optional boundary error translator).\n *\n * Unlike the standalone `serverLoad` / `action` / `endpoint`, the handler\n * effect's required services `R` come from the provider — your own application\n * catalogue — not the fixed {@link SvelteKitServices}. The package does not\n * merge `HttpClient` / `SvelteKitRequestEvent` onto this path; add them to your\n * own layer if you want them.\n *\n * @example\n * ```ts\n * // Package owns the runtime per request on Workers, disposed via waitUntil.\n * const { serverLoad } = makeRuntimeAdapter(\n *   RequestRuntime.fromLayerPerRequest((event) => AppLayer(event.platform!.env), {\n *     afterResponse: (event, dispose) => event.platform!.ctx.waitUntil(dispose()),\n *   }),\n * );\n * ```\n */\nexport const makeRuntimeAdapter = <R>(\n  provider: RequestRuntimeProvider<R, any>,\n  opts?: RuntimeAdapterOptions,\n): RuntimeAdapter<R> => {\n  const translateError: ErrorTranslator = opts?.translateError ?? SvelteKit.translate;\n\n  const runSettle = async <A>(\n    event: RequestEvent,\n    effect: Effect.Effect<A, unknown, R>,\n  ): Promise<A> => {\n    const exit = await provider.run(event).runPromiseExit(effect);\n    try {\n      if (Exit.isSuccess(exit)) return exit.value;\n      return translateError(exit.cause);\n    } finally {\n      provider.disposeAfterResponse?.(event);\n    }\n  };\n\n  const action: RuntimeAdapter<R>[\"action\"] = (fn) => (event) =>\n    runSettle(\n      event,\n      fn(event).pipe(\n        Effect.withSpan(`action ${event.route.id ?? \"(unknown)\"}`, { kind: \"server\" }),\n      ),\n    );\n\n  return {\n    serverLoad: (fn) => (event) =>\n      runSettle(\n        event,\n        fn(event).pipe(\n          Effect.withSpan(`serverLoad ${event.route.id ?? \"(unknown)\"}`, { kind: \"server\" }),\n        ),\n      ),\n    action,\n    actions: (map) => {\n      const wrapped: Record<string, Action<any, any, any>> = {};\n      for (const [key, fn] of Object.entries(map)) wrapped[key] = action(fn);\n      return wrapped as never;\n    },\n    endpoint: (fn, options) => async (event) => {\n      const effect = fn(event).pipe(\n        Effect.withSpan(\n          `${(event as RequestEvent).request.method} ${(event as RequestEvent).route.id ?? \"(unknown)\"}`,\n          { kind: \"server\" },\n        ),\n      );\n      const exit = await provider.run(event as RequestEvent).runPromiseExit(effect);\n      try {\n        if (Exit.isSuccess(exit)) return exit.value;\n        // Run the translator (default: SvelteKit.translate). SvelteKit\n        // control-flow objects (redirect, error, KitRedirect, KitError) are\n        // thrown so SvelteKit can handle them. Anything unrecognised is wrapped\n        // in an EffectCauseError and caught below to produce a 500 Response.\n        try {\n          return translateError(exit.cause);\n        } catch (err) {\n          if (isRedirect(err) || isHttpError(err)) throw err;\n          console.error(\"Endpoint error:\", Cause.pretty(exit.cause));\n          const message = options?.exposeErrors\n            ? Cause.pretty(exit.cause)\n            : \"Internal server error\";\n          return new Response(JSON.stringify({ error: message }), {\n            status: 500,\n            headers: { \"Content-Type\": \"application/json\" },\n          });\n        }\n      } finally {\n        provider.disposeAfterResponse?.(event as RequestEvent);\n      }\n    },\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyFA,MAAM,6BACJ,QAC8B;CAC9B,iBAAiB,WAAW,GAAG,eAAe,MAAM;CACpD,UAAU,WAAW,GAAG,QAAQ,MAAM;AACxC;;AAGA,MAAM,sBAAyB,aAA2D;CACxF,iBAAiB,WAAW,OAAO,mBAAmB,OAAO,EAAE,MAAM;CACrE,UAAU,WAAW,OAAO,YAAY,OAAO,EAAE,MAAM;AACzD;;AAGA,MAAM,cACJ,WAEA,eAAe,iBAAiB,MAAM,IAClC,0BAA0B,MAAmD,IAC7E,mBAAmB,MAA4B;;;;;AAqBrD,MAAa,iBAAiB;;;;;CAK5B,qBACE,OACiC;EACjC,MAAM,UAAU,0BAA0B,EAA+C;EACzF,OAAO,EAAE,WAAW,QAAQ;CAC9B;;;;;;CAOA,YAAkB,UAA2D;EAC3E,IAAI;EACJ,OAAO,EACL,WACG,YAAY,0BACX,eAAe,KAAK,KAAK,CAC3B,EACJ;CACF;;;;;;;CAQA,aACE,SAC+B,EAC/B,MAAM,UAAU,WAAW,IAAI,KAAK,CAAC,EACvC;;;;;;;;;;;;CAaA,sBACE,OACA,UACkC,EAClC,MAAM,UAAU;EACd,MAAM,WAAW,aAAkD,GAAG,QAAQ;EAC9E,MAAM,YAAY,OAA2D;GAC3E,IAAI,MAAM,eAAe;IACvB,KAAK,cAAc,OAAO,QAAQ,EAAE,CAAC;IACrC,OAAO,QAAQ,QAAQ;GACzB;GACA,OAAO,GAAG,QAAQ;EACpB;EACA,OAAO;GACL,gBAAgB,OAAO,WAAW;IAChC,MAAM,KAAK,eAAe,KAAK,MAAM,KAAK,CAAC;IAC3C,IAAI;KACF,OAAQ,MAAM,GAAG,eAAe,MAAM;IACxC,UAAU;KACR,MAAM,SAAS,EAAE;IACnB;GACF;GACA,UAAU,WAAW;IACnB,MAAM,KAAK,eAAe,KAAK,MAAM,KAAK,CAAC;IAC3C,MAAM,QAAQ,GAAG,QAAQ,MAAM;IAC/B,MAAM,kBAAkB,KAAK,SAAS,EAAE,CAAC;IACzC,OAAO;GACT;EACF;CACF,EACF;AACF;;;;;;;;;;;;;;;;;;;;;AAkFA,MAAa,sBACX,UACA,SACsB;CACtB,MAAM,iBAAkC,MAAM,kBAAkB,UAAU;CAE1E,MAAM,YAAY,OAChB,OACA,WACe;EACf,MAAM,OAAO,MAAM,SAAS,IAAI,KAAK,EAAE,eAAe,MAAM;EAC5D,IAAI;GACF,IAAI,KAAK,UAAU,IAAI,GAAG,OAAO,KAAK;GACtC,OAAO,eAAe,KAAK,KAAK;EAClC,UAAU;GACR,SAAS,uBAAuB,KAAK;EACvC;CACF;CAEA,MAAM,UAAuC,QAAQ,UACnD,UACE,OACA,GAAG,KAAK,EAAE,KACR,OAAO,SAAS,UAAU,MAAM,MAAM,MAAM,eAAe,EAAE,MAAM,SAAS,CAAC,CAC/E,CACF;CAEF,OAAO;EACL,aAAa,QAAQ,UACnB,UACE,OACA,GAAG,KAAK,EAAE,KACR,OAAO,SAAS,cAAc,MAAM,MAAM,MAAM,eAAe,EAAE,MAAM,SAAS,CAAC,CACnF,CACF;EACF;EACA,UAAU,QAAQ;GAChB,MAAM,UAAiD,CAAC;GACxD,KAAK,MAAM,CAAC,KAAK,OAAO,OAAO,QAAQ,GAAG,GAAG,QAAQ,OAAO,OAAO,EAAE;GACrE,OAAO;EACT;EACA,WAAW,IAAI,YAAY,OAAO,UAAU;GAC1C,MAAM,SAAS,GAAG,KAAK,EAAE,KACvB,OAAO,SACL,GAAI,MAAuB,QAAQ,OAAO,GAAI,MAAuB,MAAM,MAAM,eACjF,EAAE,MAAM,SAAS,CACnB,CACF;GACA,MAAM,OAAO,MAAM,SAAS,IAAI,KAAqB,EAAE,eAAe,MAAM;GAC5E,IAAI;IACF,IAAI,KAAK,UAAU,IAAI,GAAG,OAAO,KAAK;IAKtC,IAAI;KACF,OAAO,eAAe,KAAK,KAAK;IAClC,SAAS,KAAK;KACZ,IAAI,WAAW,GAAG,KAAK,YAAY,GAAG,GAAG,MAAM;KAC/C,QAAQ,MAAM,mBAAmB,MAAM,OAAO,KAAK,KAAK,CAAC;KACzD,MAAM,UAAU,SAAS,eACrB,MAAM,OAAO,KAAK,KAAK,IACvB;KACJ,OAAO,IAAI,SAAS,KAAK,UAAU,EAAE,OAAO,QAAQ,CAAC,GAAG;MACtD,QAAQ;MACR,SAAS,EAAE,gBAAgB,mBAAmB;KAChD,CAAC;IACH;GACF,UAAU;IACR,SAAS,uBAAuB,KAAqB;GACvD;EACF;CACF;AACF"}

package/dist/request-services.d.ts

@@ -0,0 +1,120 @@
+import { SvelteKitRequestEvent } from "./runtime.js";
+import { Context, Effect, Layer } from "effect";
+import { Cookies, RequestEvent } from "@sveltejs/kit";
+
+//#region src/request-services.d.ts
+/**
+ * The Effect-native interface exposed by {@link SvelteKitCookies}. Each method
+ * mirrors the corresponding `Cookies` method from `@sveltejs/kit` but returns
+ * an `Effect` rather than a raw value or `void`.
+ */
+interface SvelteKitCookiesInterface {
+  /** Get a cookie by name. Returns `undefined` when the cookie is absent. */
+  readonly get: (...args: Parameters<Cookies["get"]>) => Effect.Effect<ReturnType<Cookies["get"]>>;
+  /** Get all cookies as `{ name, value }` pairs. */
+  readonly getAll: (...args: Parameters<Cookies["getAll"]>) => Effect.Effect<ReturnType<Cookies["getAll"]>>;
+  /** Set a cookie (adds a `set-cookie` response header). */
+  readonly set: (...args: Parameters<Cookies["set"]>) => Effect.Effect<void>;
+  /** Delete a cookie by setting it to an empty value with a past expiry. */
+  readonly delete: (...args: Parameters<Cookies["delete"]>) => Effect.Effect<void>;
+  /** Serialize a cookie into a `Set-Cookie` string without adding it to the response. */
+  readonly serialize: (...args: Parameters<Cookies["serialize"]>) => Effect.Effect<ReturnType<Cookies["serialize"]>>;
+}
+declare const SvelteKitCookies_base: Context.ServiceClass<SvelteKitCookies, "@thomasfosterau/effect-sveltekit/SvelteKitCookies", SvelteKitCookiesInterface>;
+/**
+ * An Effect service wrapping the `RequestEvent.cookies` API.
+ *
+ * Available automatically in every server handler effect (it is part of
+ * {@link SvelteKitServices}). Use `yield* SvelteKitCookies` to obtain the
+ * service; call its methods (each returns an `Effect`) to read or write
+ * cookies.
+ *
+ * @example
+ * ```ts
+ * const session = yield* (yield* SvelteKitCookies).get("session");
+ * ```
+ */
+declare class SvelteKitCookies extends SvelteKitCookies_base {
+  /**
+   * Layer that builds the `SvelteKitCookies` service from the current
+   * {@link SvelteKitRequestEvent}. Included in the per-request context
+   * automatically; expose as a standalone layer for custom setups.
+   */
+  static readonly layer: Layer.Layer<SvelteKitCookies, never, SvelteKitRequestEvent>;
+}
+/**
+ * The Effect-native interface exposed by {@link SvelteKitResponseHeaders}.
+ */
+interface SvelteKitResponseHeadersInterface {
+  /**
+   * Set one or more response headers. Equivalent to `event.setHeaders(headers)`.
+   *
+   * Note: You cannot set `set-cookie` headers here — use
+   * {@link SvelteKitCookies} instead.
+   */
+  readonly set: (headers: Record<string, string>) => Effect.Effect<void>;
+}
+declare const SvelteKitResponseHeaders_base: Context.ServiceClass<SvelteKitResponseHeaders, "@thomasfosterau/effect-sveltekit/SvelteKitResponseHeaders", SvelteKitResponseHeadersInterface>;
+/**
+ * An Effect service wrapping the `RequestEvent.setHeaders` API.
+ *
+ * Available automatically in every server handler effect. Use
+ * `yield* SvelteKitResponseHeaders` to obtain the service, then call
+ * `headers.set(...)`.
+ *
+ * @example
+ * ```ts
+ * const headers = yield* SvelteKitResponseHeaders;
+ * yield* headers.set({ "cache-control": "max-age=60, s-maxage=300" });
+ * ```
+ */
+declare class SvelteKitResponseHeaders extends SvelteKitResponseHeaders_base {
+  /**
+   * Layer that builds the `SvelteKitResponseHeaders` service from the current
+   * {@link SvelteKitRequestEvent}.
+   */
+  static readonly layer: Layer.Layer<SvelteKitResponseHeaders, never, SvelteKitRequestEvent>;
+}
+declare const SvelteKitLocals_base: Context.ServiceClass<SvelteKitLocals, "@thomasfosterau/effect-sveltekit/SvelteKitLocals", App.Locals>;
+/**
+ * An Effect service that exposes the mutable `App.Locals` object for the
+ * current request.
+ *
+ * `yield* SvelteKitLocals` returns the live `event.locals` reference — the
+ * same object mutations in `hooks.server.ts` (e.g. setting `event.locals.user`
+ * in a `handle` hook) write to. Mutations made to it inside handler effects
+ * propagate back to subsequent hook middleware.
+ *
+ * Available automatically in every server handler effect.
+ *
+ * @example
+ * ```ts
+ * // Read a typed local (requires App.Locals augmentation in your app):
+ * const { user } = yield* SvelteKitLocals;
+ *
+ * // Write a local (useful in handle hooks run via makeServerRuntime.handle):
+ * const locals = yield* SvelteKitLocals;
+ * locals.user = yield* Auth.currentUser;
+ * ```
+ */
+declare class SvelteKitLocals extends SvelteKitLocals_base {
+  /**
+   * Layer that exposes `event.locals` (the mutable `App.Locals` reference)
+   * from the current {@link SvelteKitRequestEvent}.
+   */
+  static readonly layer: Layer.Layer<SvelteKitLocals, never, SvelteKitRequestEvent>;
+}
+/**
+ * A convenience layer that provides all three request services
+ * ({@link SvelteKitCookies}, {@link SvelteKitResponseHeaders},
+ * {@link SvelteKitLocals}) from the current {@link SvelteKitRequestEvent}.
+ *
+ * This layer is merged into the per-request context automatically by
+ * {@link makeServerRuntime}, the standalone wrappers, and
+ * {@link makeRuntimeAdapter}. Expose it here for use in custom setups that
+ * already have `SvelteKitRequestEvent` in scope.
+ */
+declare const requestServicesLayer: Layer.Layer<SvelteKitCookies | SvelteKitResponseHeaders | SvelteKitLocals, never, SvelteKitRequestEvent>;
+//#endregion
+export { SvelteKitCookies, SvelteKitCookiesInterface, SvelteKitLocals, SvelteKitResponseHeaders, SvelteKitResponseHeadersInterface, requestServicesLayer };
+//# sourceMappingURL=request-services.d.ts.map

package/dist/request-services.js

@@ -0,0 +1,120 @@
+import { SvelteKitRequestEvent } from "./runtime.js";
+import { Context, Effect, Layer } from "effect";
+//#region src/request-services.ts
+/**
+* An Effect service wrapping the `RequestEvent.cookies` API.
+*
+* Available automatically in every server handler effect (it is part of
+* {@link SvelteKitServices}). Use `yield* SvelteKitCookies` to obtain the
+* service; call its methods (each returns an `Effect`) to read or write
+* cookies.
+*
+* @example
+* ```ts
+* const session = yield* (yield* SvelteKitCookies).get("session");
+* ```
+*/
+var SvelteKitCookies = class SvelteKitCookies extends Context.Service()("@thomasfosterau/effect-sveltekit/SvelteKitCookies") {
+	/**
+	* Layer that builds the `SvelteKitCookies` service from the current
+	* {@link SvelteKitRequestEvent}. Included in the per-request context
+	* automatically; expose as a standalone layer for custom setups.
+	*/
+	static layer = Layer.effect(SvelteKitCookies, Effect.gen(function* () {
+		const { cookies } = yield* SvelteKitRequestEvent;
+		return {
+			get: (...args) => Effect.sync(() => cookies.get(...args)),
+			getAll: (...args) => Effect.sync(() => cookies.getAll(...args)),
+			set: (...args) => Effect.sync(() => cookies.set(...args)),
+			delete: (...args) => Effect.sync(() => cookies.delete(...args)),
+			serialize: (...args) => Effect.sync(() => cookies.serialize(...args))
+		};
+	}));
+};
+/**
+* An Effect service wrapping the `RequestEvent.setHeaders` API.
+*
+* Available automatically in every server handler effect. Use
+* `yield* SvelteKitResponseHeaders` to obtain the service, then call
+* `headers.set(...)`.
+*
+* @example
+* ```ts
+* const headers = yield* SvelteKitResponseHeaders;
+* yield* headers.set({ "cache-control": "max-age=60, s-maxage=300" });
+* ```
+*/
+var SvelteKitResponseHeaders = class SvelteKitResponseHeaders extends Context.Service()("@thomasfosterau/effect-sveltekit/SvelteKitResponseHeaders") {
+	/**
+	* Layer that builds the `SvelteKitResponseHeaders` service from the current
+	* {@link SvelteKitRequestEvent}.
+	*/
+	static layer = Layer.effect(SvelteKitResponseHeaders, Effect.gen(function* () {
+		const event = yield* SvelteKitRequestEvent;
+		return { set: (headers) => Effect.sync(() => event.setHeaders(headers)) };
+	}));
+};
+/**
+* An Effect service that exposes the mutable `App.Locals` object for the
+* current request.
+*
+* `yield* SvelteKitLocals` returns the live `event.locals` reference — the
+* same object mutations in `hooks.server.ts` (e.g. setting `event.locals.user`
+* in a `handle` hook) write to. Mutations made to it inside handler effects
+* propagate back to subsequent hook middleware.
+*
+* Available automatically in every server handler effect.
+*
+* @example
+* ```ts
+* // Read a typed local (requires App.Locals augmentation in your app):
+* const { user } = yield* SvelteKitLocals;
+*
+* // Write a local (useful in handle hooks run via makeServerRuntime.handle):
+* const locals = yield* SvelteKitLocals;
+* locals.user = yield* Auth.currentUser;
+* ```
+*/
+var SvelteKitLocals = class SvelteKitLocals extends Context.Service()("@thomasfosterau/effect-sveltekit/SvelteKitLocals") {
+	/**
+	* Layer that exposes `event.locals` (the mutable `App.Locals` reference)
+	* from the current {@link SvelteKitRequestEvent}.
+	*/
+	static layer = Layer.effect(SvelteKitLocals, Effect.gen(function* () {
+		return (yield* SvelteKitRequestEvent).locals;
+	}));
+};
+/**
+* A convenience layer that provides all three request services
+* ({@link SvelteKitCookies}, {@link SvelteKitResponseHeaders},
+* {@link SvelteKitLocals}) from the current {@link SvelteKitRequestEvent}.
+*
+* This layer is merged into the per-request context automatically by
+* {@link makeServerRuntime}, the standalone wrappers, and
+* {@link makeRuntimeAdapter}. Expose it here for use in custom setups that
+* already have `SvelteKitRequestEvent` in scope.
+*/
+const requestServicesLayer = Layer.mergeAll(SvelteKitCookies.layer, SvelteKitResponseHeaders.layer, SvelteKitLocals.layer);
+/**
+* Build all three request services directly from a {@link RequestEvent},
+* without going through {@link SvelteKitRequestEvent}. Used internally by
+* `requestLayer` in `app-runtime.ts` to avoid an extra indirection.
+*/
+const requestServicesFrom = (event) => {
+	const { cookies } = event;
+	return {
+		cookies: {
+			get: (...args) => Effect.sync(() => cookies.get(...args)),
+			getAll: (...args) => Effect.sync(() => cookies.getAll(...args)),
+			set: (...args) => Effect.sync(() => cookies.set(...args)),
+			delete: (...args) => Effect.sync(() => cookies.delete(...args)),
+			serialize: (...args) => Effect.sync(() => cookies.serialize(...args))
+		},
+		responseHeaders: { set: (headers) => Effect.sync(() => event.setHeaders(headers)) },
+		locals: event.locals
+	};
+};
+//#endregion
+export { SvelteKitCookies, SvelteKitLocals, SvelteKitResponseHeaders, requestServicesFrom, requestServicesLayer };
+
+//# sourceMappingURL=request-services.js.map