@thomasfosterau/effect-sveltekit 0.0.0

package/dist/remote.server.js

@@ -0,0 +1,90 @@
+import { SvelteKitRuntime } from "./runtime.js";
+import "effect";
+import "effect/unstable/http/HttpClient";
+import * as AppServer from "$app/server";
+//#region src/remote.server.ts
+function runRemoteEffect(effect) {
+	const event = AppServer.getRequestEvent();
+	return SvelteKitRuntime.forRequest(event).runPromise(effect);
+}
+function unavailable(name) {
+	throw new Error(`${name} is not available in the installed SvelteKit version. Update @sveltejs/kit to use this API.`);
+}
+/**
+* Detects a Standard Schema validator via its `~standard` marker property.
+*
+* This cannot be a simple `typeof value === "function"` check on the handler
+* position: some Standard Schema implementations (such as Effect's
+* `Schema.toStandardSchemaV1`) return callable class values, which would be
+* mistaken for handler functions.
+*/
+const isStandardSchema = (value) => value !== null && (typeof value === "object" || typeof value === "function") && "~standard" in value;
+/** True when the argument is the no-validation handler overload. */
+const isBareHandler = (value) => typeof value === "function" && !isStandardSchema(value);
+function query(arg1, arg2) {
+	if (isBareHandler(arg1)) {
+		const handler = arg1;
+		return AppServer.query(() => runRemoteEffect(handler()));
+	}
+	if (!arg2) throw new Error("query requires a handler function when a schema is provided");
+	return AppServer.query(arg1, (arg) => runRemoteEffect(arg2(arg)));
+}
+function queryBatch(validate, fn) {
+	return AppServer.query.batch(validate, (args) => runRemoteEffect(fn(args)));
+}
+const appServerCompat = AppServer;
+const queryCompat = AppServer.query;
+function getQueryLive() {
+	const live = queryCompat.live;
+	if (typeof live !== "function") unavailable("query.live");
+	return live;
+}
+function getRequested() {
+	const requestedFn = appServerCompat.requested;
+	if (typeof requestedFn !== "function") unavailable("requested");
+	return requestedFn;
+}
+function queryLive(validate, fn) {
+	return getQueryLive()(validate, (arg) => runRemoteEffect(fn(arg)));
+}
+function form(arg1, arg2) {
+	if (isBareHandler(arg1)) {
+		const handler = arg1;
+		return AppServer.form(() => runRemoteEffect(handler()));
+	}
+	if (!arg2) throw new Error("form requires a handler function when a schema is provided");
+	return AppServer.form(arg1, (data, issue) => runRemoteEffect(arg2(data, issue)));
+}
+function command(arg1, arg2) {
+	if (isBareHandler(arg1)) {
+		const handler = arg1;
+		return AppServer.command(() => runRemoteEffect(handler()));
+	}
+	if (!arg2) throw new Error("command requires a handler function when a schema is provided");
+	return AppServer.command(arg1, (arg) => runRemoteEffect(arg2(arg)));
+}
+function prerender(arg1, arg2, arg3) {
+	if (isBareHandler(arg1)) {
+		const handler = arg1;
+		return AppServer.prerender(() => runRemoteEffect(handler()), arg2);
+	}
+	if (typeof arg2 !== "function") throw new Error("prerender requires a handler function when a schema is provided");
+	return AppServer.prerender(arg1, (arg) => runRemoteEffect(arg2(arg)), arg3);
+}
+function requested(...args) {
+	return getRequested()(...args);
+}
+const RemoteFunction = {
+	query: Object.assign(query, {
+		batch: queryBatch,
+		live: queryLive
+	}),
+	form,
+	command,
+	prerender,
+	requested
+};
+//#endregion
+export { RemoteFunction };
+
+//# sourceMappingURL=remote.server.js.map

package/dist/remote.server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote.server.js","names":[],"sources":["../src/remote.server.ts"],"sourcesContent":["import * as AppServer from \"$app/server\";\nimport type {\n  RemoteCommand,\n  RemoteForm,\n  RemoteFormInput,\n  RemotePrerenderFunction,\n  RemoteQueryFunction,\n  InvalidField,\n} from \"@sveltejs/kit\";\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport * as HttpClient from \"effect/unstable/http/HttpClient\";\nimport { Effect } from \"effect\";\nimport { SvelteKitRuntime, SvelteKitRequestEvent } from \"./runtime.js\";\n\ntype SvelteKitEffectEnv = HttpClient.HttpClient | SvelteKitRequestEvent;\n\nfunction runRemoteEffect<A, E, R extends SvelteKitEffectEnv>(\n  effect: Effect.Effect<A, E, R>,\n): Promise<A> {\n  const event = AppServer.getRequestEvent();\n  const runtime = SvelteKitRuntime.forRequest(event);\n  return runtime.runPromise(effect);\n}\n\nfunction unavailable(name: string): never {\n  throw new Error(\n    `${name} is not available in the installed SvelteKit version. Update @sveltejs/kit to use this API.`,\n  );\n}\n\ntype UnknownEffect = Effect.Effect<unknown, unknown, SvelteKitEffectEnv>;\ntype EffectHandler = (arg: unknown) => UnknownEffect;\ntype EffectFormHandler = (data: unknown, issue: unknown) => UnknownEffect;\ntype EffectVoidHandler = () => UnknownEffect;\n\n/**\n * Detects a Standard Schema validator via its `~standard` marker property.\n *\n * This cannot be a simple `typeof value === \"function\"` check on the handler\n * position: some Standard Schema implementations (such as Effect's\n * `Schema.toStandardSchemaV1`) return callable class values, which would be\n * mistaken for handler functions.\n */\nconst isStandardSchema = (value: unknown): value is StandardSchemaV1 =>\n  value !== null &&\n  (typeof value === \"object\" || typeof value === \"function\") &&\n  \"~standard\" in value;\n\n/** True when the argument is the no-validation handler overload. */\nconst isBareHandler = (value: unknown): value is EffectVoidHandler =>\n  typeof value === \"function\" && !isStandardSchema(value);\n\nexport function query<Output>(\n  fn: () => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n): RemoteQueryFunction<void, Output>;\nexport function query<Input, Output>(\n  validate: \"unchecked\",\n  fn: (arg: Input) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n): RemoteQueryFunction<Input, Output>;\nexport function query<Schema extends StandardSchemaV1, Output>(\n  schema: Schema,\n  fn: (\n    arg: StandardSchemaV1.InferOutput<Schema>,\n  ) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n): RemoteQueryFunction<StandardSchemaV1.InferInput<Schema>, Output>;\nexport function query(\n  arg1: unknown,\n  arg2?: (arg: unknown) => Effect.Effect<unknown, unknown, SvelteKitEffectEnv>,\n): any {\n  if (isBareHandler(arg1)) {\n    const handler = arg1;\n    return AppServer.query(() => runRemoteEffect(handler()));\n  }\n\n  if (!arg2) {\n    throw new Error(\"query requires a handler function when a schema is provided\");\n  }\n\n  return AppServer.query(arg1 as \"unchecked\", (arg: unknown) => runRemoteEffect(arg2(arg)));\n}\n\nexport function queryBatch<Input, Output>(\n  validate: \"unchecked\",\n  fn: (\n    args: Input[],\n  ) => Effect.Effect<(arg: Input, idx: number) => Output, unknown, SvelteKitEffectEnv>,\n): RemoteQueryFunction<Input, Output>;\nexport function queryBatch<Schema extends StandardSchemaV1, Output>(\n  schema: Schema,\n  fn: (\n    args: StandardSchemaV1.InferOutput<Schema>[],\n  ) => Effect.Effect<\n    (arg: StandardSchemaV1.InferOutput<Schema>, idx: number) => Output,\n    unknown,\n    SvelteKitEffectEnv\n  >,\n): RemoteQueryFunction<StandardSchemaV1.InferInput<Schema>, Output>;\nexport function queryBatch(\n  validate: unknown,\n  fn: (\n    args: unknown[],\n  ) => Effect.Effect<(arg: unknown, idx: number) => unknown, unknown, SvelteKitEffectEnv>,\n): any {\n  return AppServer.query.batch(validate as \"unchecked\", (args: unknown[]) =>\n    runRemoteEffect(fn(args)),\n  );\n}\n\ntype QueryLiveFactory = (\n  validate: unknown,\n  fn: (arg: unknown) => Promise<AsyncIterable<unknown>> | AsyncIterable<unknown>,\n) => unknown;\n\ntype QueryWithCompat = typeof AppServer.query & {\n  live?: QueryLiveFactory;\n};\n\ntype AppServerWithCompat = typeof AppServer & {\n  requested?: (...args: unknown[]) => unknown;\n};\n\nconst appServerCompat = AppServer as AppServerWithCompat;\nconst queryCompat = AppServer.query as QueryWithCompat;\n\nfunction getQueryLive(): QueryLiveFactory {\n  const live = queryCompat.live;\n\n  if (typeof live !== \"function\") {\n    unavailable(\"query.live\");\n  }\n\n  return live;\n}\n\nfunction getRequested(): (...args: unknown[]) => unknown {\n  const requestedFn = appServerCompat.requested;\n\n  if (typeof requestedFn !== \"function\") {\n    unavailable(\"requested\");\n  }\n\n  return requestedFn;\n}\n\nexport function queryLive<Input, Output>(\n  validate: \"unchecked\",\n  fn: (arg: Input) => Effect.Effect<AsyncIterable<Output>, unknown, SvelteKitEffectEnv>,\n): RemoteQueryFunction<Input, Output>;\nexport function queryLive<Schema extends StandardSchemaV1, Output>(\n  schema: Schema,\n  fn: (\n    arg: StandardSchemaV1.InferOutput<Schema>,\n  ) => Effect.Effect<AsyncIterable<Output>, unknown, SvelteKitEffectEnv>,\n): RemoteQueryFunction<StandardSchemaV1.InferInput<Schema>, Output>;\nexport function queryLive(\n  validate: unknown,\n  fn: (arg: unknown) => Effect.Effect<AsyncIterable<unknown>, unknown, SvelteKitEffectEnv>,\n): any {\n  const live = getQueryLive();\n  return live(validate, (arg) => runRemoteEffect(fn(arg)));\n}\n\nexport function form<Output>(\n  fn: () => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n): RemoteForm<void, Output>;\nexport function form<Input extends RemoteFormInput, Output>(\n  validate: \"unchecked\",\n  fn: (\n    data: Input,\n    issue: InvalidField<Input>,\n  ) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n): RemoteForm<Input, Output>;\nexport function form<Schema extends StandardSchemaV1<RemoteFormInput, Record<string, any>>, Output>(\n  validate: Schema,\n  fn: (\n    data: StandardSchemaV1.InferOutput<Schema>,\n    issue: InvalidField<StandardSchemaV1.InferInput<Schema>>,\n  ) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n): RemoteForm<StandardSchemaV1.InferInput<Schema>, Output>;\nexport function form(arg1: unknown, arg2?: unknown): any {\n  if (isBareHandler(arg1)) {\n    const handler = arg1;\n    return AppServer.form(() => runRemoteEffect(handler()));\n  }\n\n  if (!arg2) {\n    throw new Error(\"form requires a handler function when a schema is provided\");\n  }\n\n  return AppServer.form(arg1 as \"unchecked\", (data: unknown, issue: unknown) =>\n    runRemoteEffect((arg2 as EffectFormHandler)(data, issue)),\n  );\n}\n\nexport function command<Output>(\n  fn: () => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n): RemoteCommand<void, Output>;\nexport function command<Input, Output>(\n  validate: \"unchecked\",\n  fn: (arg: Input) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n): RemoteCommand<Input, Output>;\nexport function command<Schema extends StandardSchemaV1, Output>(\n  validate: Schema,\n  fn: (\n    arg: StandardSchemaV1.InferOutput<Schema>,\n  ) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n): RemoteCommand<StandardSchemaV1.InferInput<Schema>, Output>;\nexport function command(\n  arg1: unknown,\n  arg2?: (arg: unknown) => Effect.Effect<unknown, unknown, SvelteKitEffectEnv>,\n): any {\n  if (isBareHandler(arg1)) {\n    const handler = arg1;\n    return AppServer.command(() => runRemoteEffect(handler()));\n  }\n\n  if (!arg2) {\n    throw new Error(\"command requires a handler function when a schema is provided\");\n  }\n\n  return AppServer.command(arg1 as \"unchecked\", (arg: unknown) => runRemoteEffect(arg2(arg)));\n}\n\nexport function prerender<Output>(\n  fn: () => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n  options?: {\n    inputs?: () => Promise<void[]> | void[];\n    dynamic?: boolean;\n  },\n): RemotePrerenderFunction<void, Output>;\nexport function prerender<Input, Output>(\n  validate: \"unchecked\",\n  fn: (arg: Input) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n  options?: {\n    inputs?: () => Promise<Input[]> | Input[];\n    dynamic?: boolean;\n  },\n): RemotePrerenderFunction<Input, Output>;\nexport function prerender<Schema extends StandardSchemaV1, Output>(\n  schema: Schema,\n  fn: (\n    arg: StandardSchemaV1.InferOutput<Schema>,\n  ) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n  options?: {\n    inputs?: () =>\n      | Promise<StandardSchemaV1.InferInput<Schema>[]>\n      | StandardSchemaV1.InferInput<Schema>[];\n    dynamic?: boolean;\n  },\n): RemotePrerenderFunction<StandardSchemaV1.InferInput<Schema>, Output>;\nexport function prerender(\n  arg1: unknown,\n  arg2?:\n    | ((arg: unknown) => Effect.Effect<unknown, unknown, SvelteKitEffectEnv>)\n    | {\n        inputs?: () => Promise<unknown[]> | unknown[];\n        dynamic?: boolean;\n      },\n  arg3?: {\n    inputs?: () => Promise<unknown[]> | unknown[];\n    dynamic?: boolean;\n  },\n): any {\n  if (isBareHandler(arg1)) {\n    const handler = arg1;\n    return AppServer.prerender(\n      () => runRemoteEffect(handler()),\n      arg2 as { inputs?: () => Promise<void[]> | void[]; dynamic?: boolean } | undefined,\n    );\n  }\n\n  if (typeof arg2 !== \"function\") {\n    throw new Error(\"prerender requires a handler function when a schema is provided\");\n  }\n\n  return AppServer.prerender(\n    arg1 as \"unchecked\",\n    (arg: unknown) => runRemoteEffect((arg2 as EffectHandler)(arg)),\n    arg3,\n  );\n}\n\nexport function requested<Result = unknown>(...args: unknown[]): Result {\n  const requestedFn = getRequested();\n  return requestedFn(...args) as Result;\n}\n\ntype QueryNamespace = {\n  <Output>(\n    fn: () => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n  ): RemoteQueryFunction<void, Output>;\n  <Input, Output>(\n    validate: \"unchecked\",\n    fn: (arg: Input) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n  ): RemoteQueryFunction<Input, Output>;\n  <Schema extends StandardSchemaV1, Output>(\n    schema: Schema,\n    fn: (\n      arg: StandardSchemaV1.InferOutput<Schema>,\n    ) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n  ): RemoteQueryFunction<StandardSchemaV1.InferInput<Schema>, Output>;\n  batch: typeof queryBatch;\n  live: typeof queryLive;\n};\n\nconst queryWithHelpers = Object.assign(query, {\n  batch: queryBatch,\n  live: queryLive,\n}) as QueryNamespace;\n\nexport const RemoteFunction = {\n  query: queryWithHelpers,\n  form,\n  command,\n  prerender,\n  requested,\n};\n"],"mappings":";;;;;AAgBA,SAAS,gBACP,QACY;CACZ,MAAM,QAAQ,UAAU,gBAAgB;CAExC,OADgB,iBAAiB,WAAW,KAC/B,EAAE,WAAW,MAAM;AAClC;AAEA,SAAS,YAAY,MAAqB;CACxC,MAAM,IAAI,MACR,GAAG,KAAK,4FACV;AACF;;;;;;;;;AAeA,MAAM,oBAAoB,UACxB,UAAU,SACT,OAAO,UAAU,YAAY,OAAO,UAAU,eAC/C,eAAe;;AAGjB,MAAM,iBAAiB,UACrB,OAAO,UAAU,cAAc,CAAC,iBAAiB,KAAK;AAexD,SAAgB,MACd,MACA,MACK;CACL,IAAI,cAAc,IAAI,GAAG;EACvB,MAAM,UAAU;EAChB,OAAO,UAAU,YAAY,gBAAgB,QAAQ,CAAC,CAAC;CACzD;CAEA,IAAI,CAAC,MACH,MAAM,IAAI,MAAM,6DAA6D;CAG/E,OAAO,UAAU,MAAM,OAAsB,QAAiB,gBAAgB,KAAK,GAAG,CAAC,CAAC;AAC1F;AAkBA,SAAgB,WACd,UACA,IAGK;CACL,OAAO,UAAU,MAAM,MAAM,WAA0B,SACrD,gBAAgB,GAAG,IAAI,CAAC,CAC1B;AACF;AAeA,MAAM,kBAAkB;AACxB,MAAM,cAAc,UAAU;AAE9B,SAAS,eAAiC;CACxC,MAAM,OAAO,YAAY;CAEzB,IAAI,OAAO,SAAS,YAClB,YAAY,YAAY;CAG1B,OAAO;AACT;AAEA,SAAS,eAAgD;CACvD,MAAM,cAAc,gBAAgB;CAEpC,IAAI,OAAO,gBAAgB,YACzB,YAAY,WAAW;CAGzB,OAAO;AACT;AAYA,SAAgB,UACd,UACA,IACK;CAEL,OADa,aACH,EAAE,WAAW,QAAQ,gBAAgB,GAAG,GAAG,CAAC,CAAC;AACzD;AAmBA,SAAgB,KAAK,MAAe,MAAqB;CACvD,IAAI,cAAc,IAAI,GAAG;EACvB,MAAM,UAAU;EAChB,OAAO,UAAU,WAAW,gBAAgB,QAAQ,CAAC,CAAC;CACxD;CAEA,IAAI,CAAC,MACH,MAAM,IAAI,MAAM,4DAA4D;CAG9E,OAAO,UAAU,KAAK,OAAsB,MAAe,UACzD,gBAAiB,KAA2B,MAAM,KAAK,CAAC,CAC1D;AACF;AAeA,SAAgB,QACd,MACA,MACK;CACL,IAAI,cAAc,IAAI,GAAG;EACvB,MAAM,UAAU;EAChB,OAAO,UAAU,cAAc,gBAAgB,QAAQ,CAAC,CAAC;CAC3D;CAEA,IAAI,CAAC,MACH,MAAM,IAAI,MAAM,+DAA+D;CAGjF,OAAO,UAAU,QAAQ,OAAsB,QAAiB,gBAAgB,KAAK,GAAG,CAAC,CAAC;AAC5F;AA6BA,SAAgB,UACd,MACA,MAMA,MAIK;CACL,IAAI,cAAc,IAAI,GAAG;EACvB,MAAM,UAAU;EAChB,OAAO,UAAU,gBACT,gBAAgB,QAAQ,CAAC,GAC/B,IACF;CACF;CAEA,IAAI,OAAO,SAAS,YAClB,MAAM,IAAI,MAAM,iEAAiE;CAGnF,OAAO,UAAU,UACf,OACC,QAAiB,gBAAiB,KAAuB,GAAG,CAAC,GAC9D,IACF;AACF;AAEA,SAAgB,UAA4B,GAAG,MAAyB;CAEtE,OADoB,aACH,EAAE,GAAG,IAAI;AAC5B;AAyBA,MAAa,iBAAiB;CAC5B,OANuB,OAAO,OAAO,OAAO;EAC5C,OAAO;EACP,MAAM;CACR,CAGS;CACP;CACA;CACA;CACA;AACF"}

package/dist/runtime.d.ts

@@ -0,0 +1,130 @@
+import { Context, Effect, Layer, ManagedRuntime } from "effect";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import { RequestEvent } from "@sveltejs/kit";
+
+//#region src/runtime.d.ts
+declare const SvelteKitRequestEvent_base: Context.ServiceClass<SvelteKitRequestEvent, "SvelteKitRequestEvent", RequestEvent<Record<string, string>, string | null>>;
+/**
+ * Service that provides access to the current SvelteKit RequestEvent.
+ * This allows Effect code to access request-specific data like cookies, headers, etc.
+ */
+declare class SvelteKitRequestEvent extends SvelteKitRequestEvent_base {}
+/**
+ * Custom runtime for SvelteKit server-side helpers.
+ *
+ * This runtime is designed for SvelteKit server-side execution and provides:
+ * - HttpClient for making HTTP requests
+ * - FetchHttpClient using the platform's fetch implementation
+ * - SvelteKitRequestEvent for accessing SvelteKit-specific request data
+ *
+ * @example
+ * ```ts
+ * import { SvelteKitRuntime } from '@thomasfosterau/effect-sveltekit/server';
+ * import { Effect } from 'effect';
+ * import * as HttpClient from 'effect/unstable/http/HttpClient';
+ *
+ * export const load = (event) => {
+ *   const runtime = SvelteKitRuntime.forRequest(event);
+ *   return runtime.runPromise(
+ *     Effect.gen(function* () {
+ *       // Access HttpClient from the runtime
+ *       const client = yield* HttpClient.HttpClient;
+ *       const response = yield* client.get("https://api.example.com/data");
+ *       return { data: response };
+ *     })
+ *   );
+ * };
+ * ```
+ */
+declare class SvelteKitRuntime {
+  /**
+   * Creates a layer with platform services for a specific request.
+   * This includes FetchHttpClient and access to the RequestEvent.
+   *
+   * @param event - The SvelteKit RequestEvent
+   * @returns A layer providing platform services
+   */
+  private static createRequestLayer;
+  /**
+   * Creates a runtime for a specific SvelteKit request.
+   * This runtime includes all platform services configured for the request.
+   *
+   * @param event - The SvelteKit RequestEvent
+   * @returns A managed runtime with platform services
+   */
+  static forRequest(event: RequestEvent): ManagedRuntime.ManagedRuntime<HttpClient.HttpClient | SvelteKitRequestEvent, never>;
+  /**
+   * Extends the request runtime with additional services.
+   *
+   * @param event - The SvelteKit RequestEvent
+   * @param layer - Additional layer to merge
+   * @returns A managed runtime with both platform and custom services
+   *
+   * @example
+   * ```ts
+   * import { SvelteKitRuntime } from '@thomasfosterau/effect-sveltekit/server';
+   * import { Layer, Context } from 'effect';
+   *
+   * class Database extends Context.Service<Database, {
+   *   query: (sql: string) => Effect.Effect<unknown>
+   * }>()("Database") {}
+   *
+   * const dbLayer = Layer.succeed(Database, {
+   *   query: (sql) => Effect.succeed([])
+   * });
+   *
+   * export const load = (event) => {
+   *   const runtime = SvelteKitRuntime.extend(event, dbLayer);
+   *   // Use runtime...
+   * };
+   * ```
+   */
+  static extend<R, E>(event: RequestEvent, layer: Layer.Layer<R, E>): ManagedRuntime.ManagedRuntime<R | HttpClient.HttpClient | SvelteKitRequestEvent, E>;
+  /**
+   * Creates a runtime that provides `HttpClient` backed by the given fetch
+   * implementation, without a `SvelteKitRequestEvent`.
+   *
+   * This is used for universal `load` functions running on the client, where
+   * there is no `RequestEvent` but the load event still exposes `fetch`.
+   *
+   * @param fetchFn - The fetch implementation to back HttpClient with
+   * @returns A managed runtime providing HttpClient
+   */
+  static forFetch(fetchFn: typeof globalThis.fetch): ManagedRuntime.ManagedRuntime<HttpClient.HttpClient, never>;
+  /**
+   * The base layer for SvelteKit without request-specific services.
+   * Use this for effects that don't need access to the request.
+   */
+  static readonly baseLayer: Layer.Layer<never, never, never>;
+  /**
+   * Creates a runtime from a custom layer.
+   *
+   * @param layer - The layer to use for the runtime
+   * @returns A managed runtime
+   */
+  static make<R, E>(layer: Layer.Layer<R, E>): ManagedRuntime.ManagedRuntime<R, E>;
+}
+/**
+ * Helper to run an effect with the SvelteKit runtime for a specific request.
+ * This automatically sets up and tears down the runtime.
+ *
+ * @param event - The SvelteKit RequestEvent
+ * @param effect - The effect to run
+ * @returns A promise with the result
+ *
+ * @example
+ * ```ts
+ * import { runWithSvelteKitRuntime } from '@thomasfosterau/effect-sveltekit/server';
+ * import { Effect } from 'effect';
+ *
+ * export const load = async (event) => {
+ *   return await runWithSvelteKitRuntime(event,
+ *     Effect.succeed({ message: "Hello!" })
+ *   );
+ * };
+ * ```
+ */
+declare function runWithSvelteKitRuntime<A, E>(event: RequestEvent, effect: Effect.Effect<A, E, HttpClient.HttpClient | SvelteKitRequestEvent>): Promise<A>;
+//#endregion
+export { SvelteKitRequestEvent, SvelteKitRuntime, runWithSvelteKitRuntime };
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.js

@@ -0,0 +1,143 @@
+import { Context, Layer, ManagedRuntime } from "effect";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import "effect/unstable/http/HttpClient";
+//#region src/runtime.ts
+/**
+* Service that provides access to the current SvelteKit RequestEvent.
+* This allows Effect code to access request-specific data like cookies, headers, etc.
+*/
+var SvelteKitRequestEvent = class extends Context.Service()("SvelteKitRequestEvent") {};
+/**
+* Custom runtime for SvelteKit server-side helpers.
+*
+* This runtime is designed for SvelteKit server-side execution and provides:
+* - HttpClient for making HTTP requests
+* - FetchHttpClient using the platform's fetch implementation
+* - SvelteKitRequestEvent for accessing SvelteKit-specific request data
+*
+* @example
+* ```ts
+* import { SvelteKitRuntime } from '@thomasfosterau/effect-sveltekit/server';
+* import { Effect } from 'effect';
+* import * as HttpClient from 'effect/unstable/http/HttpClient';
+*
+* export const load = (event) => {
+*   const runtime = SvelteKitRuntime.forRequest(event);
+*   return runtime.runPromise(
+*     Effect.gen(function* () {
+*       // Access HttpClient from the runtime
+*       const client = yield* HttpClient.HttpClient;
+*       const response = yield* client.get("https://api.example.com/data");
+*       return { data: response };
+*     })
+*   );
+* };
+* ```
+*/
+var SvelteKitRuntime = class {
+	/**
+	* Creates a layer with platform services for a specific request.
+	* This includes FetchHttpClient and access to the RequestEvent.
+	*
+	* @param event - The SvelteKit RequestEvent
+	* @returns A layer providing platform services
+	*/
+	static createRequestLayer(event) {
+		const httpClientLayer = FetchHttpClient.layer.pipe(Layer.provide(Layer.succeed(FetchHttpClient.Fetch, event.fetch)));
+		const requestEventLayer = Layer.succeed(SvelteKitRequestEvent, event);
+		return Layer.merge(httpClientLayer, requestEventLayer);
+	}
+	/**
+	* Creates a runtime for a specific SvelteKit request.
+	* This runtime includes all platform services configured for the request.
+	*
+	* @param event - The SvelteKit RequestEvent
+	* @returns A managed runtime with platform services
+	*/
+	static forRequest(event) {
+		return ManagedRuntime.make(this.createRequestLayer(event));
+	}
+	/**
+	* Extends the request runtime with additional services.
+	*
+	* @param event - The SvelteKit RequestEvent
+	* @param layer - Additional layer to merge
+	* @returns A managed runtime with both platform and custom services
+	*
+	* @example
+	* ```ts
+	* import { SvelteKitRuntime } from '@thomasfosterau/effect-sveltekit/server';
+	* import { Layer, Context } from 'effect';
+	*
+	* class Database extends Context.Service<Database, {
+	*   query: (sql: string) => Effect.Effect<unknown>
+	* }>()("Database") {}
+	*
+	* const dbLayer = Layer.succeed(Database, {
+	*   query: (sql) => Effect.succeed([])
+	* });
+	*
+	* export const load = (event) => {
+	*   const runtime = SvelteKitRuntime.extend(event, dbLayer);
+	*   // Use runtime...
+	* };
+	* ```
+	*/
+	static extend(event, layer) {
+		return ManagedRuntime.make(Layer.merge(this.createRequestLayer(event), layer));
+	}
+	/**
+	* Creates a runtime that provides `HttpClient` backed by the given fetch
+	* implementation, without a `SvelteKitRequestEvent`.
+	*
+	* This is used for universal `load` functions running on the client, where
+	* there is no `RequestEvent` but the load event still exposes `fetch`.
+	*
+	* @param fetchFn - The fetch implementation to back HttpClient with
+	* @returns A managed runtime providing HttpClient
+	*/
+	static forFetch(fetchFn) {
+		return ManagedRuntime.make(FetchHttpClient.layer.pipe(Layer.provide(Layer.succeed(FetchHttpClient.Fetch, fetchFn))));
+	}
+	/**
+	* The base layer for SvelteKit without request-specific services.
+	* Use this for effects that don't need access to the request.
+	*/
+	static baseLayer = Layer.empty;
+	/**
+	* Creates a runtime from a custom layer.
+	*
+	* @param layer - The layer to use for the runtime
+	* @returns A managed runtime
+	*/
+	static make(layer) {
+		return ManagedRuntime.make(layer);
+	}
+};
+/**
+* Helper to run an effect with the SvelteKit runtime for a specific request.
+* This automatically sets up and tears down the runtime.
+*
+* @param event - The SvelteKit RequestEvent
+* @param effect - The effect to run
+* @returns A promise with the result
+*
+* @example
+* ```ts
+* import { runWithSvelteKitRuntime } from '@thomasfosterau/effect-sveltekit/server';
+* import { Effect } from 'effect';
+*
+* export const load = async (event) => {
+*   return await runWithSvelteKitRuntime(event,
+*     Effect.succeed({ message: "Hello!" })
+*   );
+* };
+* ```
+*/
+function runWithSvelteKitRuntime(event, effect) {
+	return SvelteKitRuntime.forRequest(event).runPromise(effect);
+}
+//#endregion
+export { SvelteKitRequestEvent, SvelteKitRuntime, runWithSvelteKitRuntime };
+
+//# sourceMappingURL=runtime.js.map

package/dist/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","names":[],"sources":["../src/runtime.ts"],"sourcesContent":["import { Layer, ManagedRuntime, Context, Effect } from \"effect\";\nimport * as HttpClient from \"effect/unstable/http/HttpClient\";\nimport * as FetchHttpClient from \"effect/unstable/http/FetchHttpClient\";\nimport type { RequestEvent } from \"@sveltejs/kit\";\n\n/**\n * Service that provides access to the current SvelteKit RequestEvent.\n * This allows Effect code to access request-specific data like cookies, headers, etc.\n */\nexport class SvelteKitRequestEvent extends Context.Service<SvelteKitRequestEvent, RequestEvent>()(\n  \"SvelteKitRequestEvent\",\n) {}\n\n/**\n * Custom runtime for SvelteKit server-side helpers.\n *\n * This runtime is designed for SvelteKit server-side execution and provides:\n * - HttpClient for making HTTP requests\n * - FetchHttpClient using the platform's fetch implementation\n * - SvelteKitRequestEvent for accessing SvelteKit-specific request data\n *\n * @example\n * ```ts\n * import { SvelteKitRuntime } from '@thomasfosterau/effect-sveltekit/server';\n * import { Effect } from 'effect';\n * import * as HttpClient from 'effect/unstable/http/HttpClient';\n *\n * export const load = (event) => {\n *   const runtime = SvelteKitRuntime.forRequest(event);\n *   return runtime.runPromise(\n *     Effect.gen(function* () {\n *       // Access HttpClient from the runtime\n *       const client = yield* HttpClient.HttpClient;\n *       const response = yield* client.get(\"https://api.example.com/data\");\n *       return { data: response };\n *     })\n *   );\n * };\n * ```\n */\nexport class SvelteKitRuntime {\n  /**\n   * Creates a layer with platform services for a specific request.\n   * This includes FetchHttpClient and access to the RequestEvent.\n   *\n   * @param event - The SvelteKit RequestEvent\n   * @returns A layer providing platform services\n   */\n  private static createRequestLayer(\n    event: RequestEvent,\n  ): Layer.Layer<HttpClient.HttpClient | SvelteKitRequestEvent> {\n    // Provide HttpClient using SvelteKit's fetch\n    const httpClientLayer = FetchHttpClient.layer.pipe(\n      Layer.provide(Layer.succeed(FetchHttpClient.Fetch, event.fetch)),\n    );\n\n    // Provide access to the RequestEvent\n    const requestEventLayer = Layer.succeed(SvelteKitRequestEvent, event);\n\n    return Layer.merge(httpClientLayer, requestEventLayer);\n  }\n\n  /**\n   * Creates a runtime for a specific SvelteKit request.\n   * This runtime includes all platform services configured for the request.\n   *\n   * @param event - The SvelteKit RequestEvent\n   * @returns A managed runtime with platform services\n   */\n  static forRequest(\n    event: RequestEvent,\n  ): ManagedRuntime.ManagedRuntime<HttpClient.HttpClient | SvelteKitRequestEvent, never> {\n    return ManagedRuntime.make(this.createRequestLayer(event));\n  }\n\n  /**\n   * Extends the request runtime with additional services.\n   *\n   * @param event - The SvelteKit RequestEvent\n   * @param layer - Additional layer to merge\n   * @returns A managed runtime with both platform and custom services\n   *\n   * @example\n   * ```ts\n   * import { SvelteKitRuntime } from '@thomasfosterau/effect-sveltekit/server';\n   * import { Layer, Context } from 'effect';\n   *\n   * class Database extends Context.Service<Database, {\n   *   query: (sql: string) => Effect.Effect<unknown>\n   * }>()(\"Database\") {}\n   *\n   * const dbLayer = Layer.succeed(Database, {\n   *   query: (sql) => Effect.succeed([])\n   * });\n   *\n   * export const load = (event) => {\n   *   const runtime = SvelteKitRuntime.extend(event, dbLayer);\n   *   // Use runtime...\n   * };\n   * ```\n   */\n  static extend<R, E>(\n    event: RequestEvent,\n    layer: Layer.Layer<R, E>,\n  ): ManagedRuntime.ManagedRuntime<R | HttpClient.HttpClient | SvelteKitRequestEvent, E> {\n    return ManagedRuntime.make(Layer.merge(this.createRequestLayer(event), layer));\n  }\n\n  /**\n   * Creates a runtime that provides `HttpClient` backed by the given fetch\n   * implementation, without a `SvelteKitRequestEvent`.\n   *\n   * This is used for universal `load` functions running on the client, where\n   * there is no `RequestEvent` but the load event still exposes `fetch`.\n   *\n   * @param fetchFn - The fetch implementation to back HttpClient with\n   * @returns A managed runtime providing HttpClient\n   */\n  static forFetch(\n    fetchFn: typeof globalThis.fetch,\n  ): ManagedRuntime.ManagedRuntime<HttpClient.HttpClient, never> {\n    return ManagedRuntime.make(\n      FetchHttpClient.layer.pipe(Layer.provide(Layer.succeed(FetchHttpClient.Fetch, fetchFn))),\n    );\n  }\n\n  /**\n   * The base layer for SvelteKit without request-specific services.\n   * Use this for effects that don't need access to the request.\n   */\n  static readonly baseLayer = Layer.empty;\n\n  /**\n   * Creates a runtime from a custom layer.\n   *\n   * @param layer - The layer to use for the runtime\n   * @returns A managed runtime\n   */\n  static make<R, E>(layer: Layer.Layer<R, E>): ManagedRuntime.ManagedRuntime<R, E> {\n    return ManagedRuntime.make(layer);\n  }\n}\n\n/**\n * Helper to run an effect with the SvelteKit runtime for a specific request.\n * This automatically sets up and tears down the runtime.\n *\n * @param event - The SvelteKit RequestEvent\n * @param effect - The effect to run\n * @returns A promise with the result\n *\n * @example\n * ```ts\n * import { runWithSvelteKitRuntime } from '@thomasfosterau/effect-sveltekit/server';\n * import { Effect } from 'effect';\n *\n * export const load = async (event) => {\n *   return await runWithSvelteKitRuntime(event,\n *     Effect.succeed({ message: \"Hello!\" })\n *   );\n * };\n * ```\n */\nexport function runWithSvelteKitRuntime<A, E>(\n  event: RequestEvent,\n  effect: Effect.Effect<A, E, HttpClient.HttpClient | SvelteKitRequestEvent>,\n): Promise<A> {\n  const runtime = SvelteKitRuntime.forRequest(event);\n  return runtime.runPromise(effect);\n}\n"],"mappings":";;;;;;;;AASA,IAAa,wBAAb,cAA2C,QAAQ,QAA6C,EAC9F,uBACF,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BH,IAAa,mBAAb,MAA8B;;;;;;;;CAQ5B,OAAe,mBACb,OAC4D;EAE5D,MAAM,kBAAkB,gBAAgB,MAAM,KAC5C,MAAM,QAAQ,MAAM,QAAQ,gBAAgB,OAAO,MAAM,KAAK,CAAC,CACjE;EAGA,MAAM,oBAAoB,MAAM,QAAQ,uBAAuB,KAAK;EAEpE,OAAO,MAAM,MAAM,iBAAiB,iBAAiB;CACvD;;;;;;;;CASA,OAAO,WACL,OACqF;EACrF,OAAO,eAAe,KAAK,KAAK,mBAAmB,KAAK,CAAC;CAC3D;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BA,OAAO,OACL,OACA,OACqF;EACrF,OAAO,eAAe,KAAK,MAAM,MAAM,KAAK,mBAAmB,KAAK,GAAG,KAAK,CAAC;CAC/E;;;;;;;;;;;CAYA,OAAO,SACL,SAC6D;EAC7D,OAAO,eAAe,KACpB,gBAAgB,MAAM,KAAK,MAAM,QAAQ,MAAM,QAAQ,gBAAgB,OAAO,OAAO,CAAC,CAAC,CACzF;CACF;;;;;CAMA,OAAgB,YAAY,MAAM;;;;;;;CAQlC,OAAO,KAAW,OAA+D;EAC/E,OAAO,eAAe,KAAK,KAAK;CAClC;AACF;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,wBACd,OACA,QACY;CAEZ,OADgB,iBAAiB,WAAW,KAC/B,EAAE,WAAW,MAAM;AAClC"}

package/dist/server/Endpoint.d.ts

@@ -0,0 +1,101 @@
+import { Effect, Layer, Scope } from "effect";
+import { RequestHandler } from "@sveltejs/kit";
+import * as HttpRouter from "effect/unstable/http/HttpRouter";
+import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
+import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
+import * as HttpApi from "effect/unstable/httpapi/HttpApi";
+import * as HttpApiGroup from "effect/unstable/httpapi/HttpApiGroup";
+
+//#region src/server/Endpoint.d.ts
+declare namespace Endpoint_d_exports {
+  export { EndpointHandler, EndpointOptions, fromApi, fromHttpEffect, fromRouter };
+}
+/**
+ * A SvelteKit endpoint handler — the built-in
+ * [`RequestHandler`](https://svelte.dev/docs/kit/@sveltejs-kit#RequestHandler) —
+ * backed by an Effect HTTP construct. Assign it to a `+server.ts` export
+ * (`fallback`, `GET`, ...). `dispose()` closes the scope of the layer behind it.
+ */
+type EndpointHandler = RequestHandler & {
+  /** Close the scope of the layer backing the endpoint (runs its finalizers). */readonly dispose: () => Promise<void>;
+};
+/** Shared options for every `Endpoint.from*` helper. */
+interface EndpointOptions {
+  /**
+   * A leading path segment to strip from each request before it reaches the
+   * Effect handler — the SvelteKit mount point. For an endpoint mounted at
+   * `src/routes/api/[...path]/+server.ts` whose routes are defined relative to
+   * the API root, pass `prefix: "/api"` so `/api/users` is dispatched as
+   * `/users`. The match respects path boundaries (`/api` does not strip
+   * `/apiary`). Defaults to no stripping.
+   */
+  readonly prefix?: string;
+}
+/**
+ * Create a SvelteKit endpoint that serves an Effect
+ * [`HttpApi`](https://effect.website).
+ *
+ * `layer` implements the API's groups (built with `HttpApiBuilder.group`), with
+ * any application services already provided. The platform services an `HttpApi`
+ * requires (`HttpPlatform`, `FileSystem`, `Path`, `Etag`) are supplied for you.
+ *
+ * @example
+ * ```ts
+ * // src/routes/api/[...path]/+server.ts
+ * import { Endpoint } from "@thomasfosterau/effect-sveltekit/server";
+ * import { api } from "$lib/server/api";
+ * import { ApiLive } from "$lib/server/handlers";
+ *
+ * export const fallback = Endpoint.fromApi(api, ApiLive, { prefix: "/api" });
+ * ```
+ */
+declare const fromApi: <Id extends string, Groups extends HttpApiGroup.Any, E>(api: HttpApi.HttpApi<Id, Groups>, layer: Layer.Layer<HttpApiGroup.ToService<Id, Groups>, E>, options?: EndpointOptions & {
+  /** Serve the OpenAPI spec for the API at this path (e.g. `"/openapi.json"`). */readonly openapiPath?: `/${string}`; /** Add Effect's request logger middleware. Defaults to `false` (quiet). */
+  readonly logger?: boolean;
+}) => EndpointHandler;
+/**
+ * Create a SvelteKit endpoint that serves an Effect `HttpRouter` (provided by
+ * `layer`). The router's routes must be self-contained (any services they need
+ * are provided within `layer`).
+ *
+ * @example
+ * ```ts
+ * // src/routes/api/[...path]/+server.ts
+ * import { Endpoint } from "@thomasfosterau/effect-sveltekit/server";
+ * import { Effect } from "effect";
+ * import { HttpRouter, HttpServerResponse } from "effect/unstable/http";
+ *
+ * const RouterLive = HttpRouter.use((router) =>
+ *   router.add("GET", "/hello", Effect.succeed(HttpServerResponse.text("hi"))),
+ * );
+ *
+ * export const fallback = Endpoint.fromRouter(RouterLive, { prefix: "/api" });
+ * ```
+ */
+declare const fromRouter: <A, E, R extends HttpRouter.HttpRouter | HttpRouter.Request<"Requires", any> | HttpRouter.Request<"GlobalRequires", any> | HttpRouter.Request<"Error", any> | HttpRouter.Request<"GlobalError", any>>(layer: Layer.Layer<A, E, R>, options?: EndpointOptions & {
+  /** Add Effect's request logger middleware. Defaults to `false` (quiet). */readonly logger?: boolean;
+}) => EndpointHandler;
+/**
+ * Create a SvelteKit endpoint from a single Effect HTTP route — an effect
+ * producing an `HttpServerResponse` for the current `HttpServerRequest`. Pass
+ * `options.layer` to provide the route's services; the layer is built once and
+ * shared.
+ *
+ * @example
+ * ```ts
+ * // src/routes/health/+server.ts
+ * import { Endpoint } from "@thomasfosterau/effect-sveltekit/server";
+ * import { Effect } from "effect";
+ * import { HttpServerResponse } from "effect/unstable/http";
+ *
+ * export const GET = Endpoint.fromHttpEffect(
+ *   Effect.succeed(HttpServerResponse.text("ok")),
+ * );
+ * ```
+ */
+declare const fromHttpEffect: <E, R = never, ProvidedE = never>(effect: Effect.Effect<HttpServerResponse.HttpServerResponse, E, R | HttpServerRequest.HttpServerRequest | Scope.Scope>, options?: EndpointOptions & {
+  /** A layer providing the route's services (`R`), built once and shared. */readonly layer?: Layer.Layer<R, ProvidedE>;
+}) => EndpointHandler;
+//#endregion
+export { Endpoint_d_exports };
+//# sourceMappingURL=Endpoint.d.ts.map

package/dist/server/Endpoint.js

@@ -0,0 +1,109 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { Layer } from "effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Etag from "effect/unstable/http/Etag";
+import * as HttpEffect from "effect/unstable/http/HttpEffect";
+import * as HttpPlatform from "effect/unstable/http/HttpPlatform";
+import * as HttpRouter from "effect/unstable/http/HttpRouter";
+import * as HttpApiBuilder from "effect/unstable/httpapi/HttpApiBuilder";
+//#region src/server/Endpoint.ts
+var Endpoint_exports = /* @__PURE__ */ __exportAll({
+	fromApi: () => fromApi,
+	fromHttpEffect: () => fromHttpEffect,
+	fromRouter: () => fromRouter
+});
+const noopDispose = () => Promise.resolve();
+/** Remove `prefix` from the request's path (respecting `/` boundaries). */
+const stripPrefix = (request, prefix) => {
+	const normalized = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+	if (normalized === "") return request;
+	const url = new URL(request.url);
+	const path = url.pathname;
+	if (path === normalized) url.pathname = "/";
+	else if (path.startsWith(`${normalized}/`)) url.pathname = path.slice(normalized.length);
+	else return request;
+	return new Request(url, request);
+};
+/** Wrap a Web handler (and its dispose) as a SvelteKit endpoint handler. */
+const make = (webHandler, dispose, prefix) => {
+	const handler = (event) => webHandler(prefix === void 0 ? event.request : stripPrefix(event.request, prefix));
+	return Object.assign(handler, { dispose });
+};
+/** The platform services an `HttpApi` needs, with a no-op file system. */
+const apiPlatform = Layer.mergeAll(Path.layer, Etag.layerWeak, HttpPlatform.layer).pipe(Layer.provideMerge(FileSystem.layerNoop({})));
+/**
+* Create a SvelteKit endpoint that serves an Effect
+* [`HttpApi`](https://effect.website).
+*
+* `layer` implements the API's groups (built with `HttpApiBuilder.group`), with
+* any application services already provided. The platform services an `HttpApi`
+* requires (`HttpPlatform`, `FileSystem`, `Path`, `Etag`) are supplied for you.
+*
+* @example
+* ```ts
+* // src/routes/api/[...path]/+server.ts
+* import { Endpoint } from "@thomasfosterau/effect-sveltekit/server";
+* import { api } from "$lib/server/api";
+* import { ApiLive } from "$lib/server/handlers";
+*
+* export const fallback = Endpoint.fromApi(api, ApiLive, { prefix: "/api" });
+* ```
+*/
+const fromApi = (api, layer, options) => {
+	const appLayer = HttpApiBuilder.layer(api, options?.openapiPath ? { openapiPath: options.openapiPath } : void 0).pipe(Layer.provide(layer), Layer.provide(apiPlatform));
+	const { handler, dispose } = HttpRouter.toWebHandler(appLayer, { disableLogger: options?.logger !== true });
+	return make(handler, dispose, options?.prefix);
+};
+/**
+* Create a SvelteKit endpoint that serves an Effect `HttpRouter` (provided by
+* `layer`). The router's routes must be self-contained (any services they need
+* are provided within `layer`).
+*
+* @example
+* ```ts
+* // src/routes/api/[...path]/+server.ts
+* import { Endpoint } from "@thomasfosterau/effect-sveltekit/server";
+* import { Effect } from "effect";
+* import { HttpRouter, HttpServerResponse } from "effect/unstable/http";
+*
+* const RouterLive = HttpRouter.use((router) =>
+*   router.add("GET", "/hello", Effect.succeed(HttpServerResponse.text("hi"))),
+* );
+*
+* export const fallback = Endpoint.fromRouter(RouterLive, { prefix: "/api" });
+* ```
+*/
+const fromRouter = (layer, options) => {
+	const { handler, dispose } = HttpRouter.toWebHandler(layer, { disableLogger: options?.logger !== true });
+	return make(handler, dispose, options?.prefix);
+};
+/**
+* Create a SvelteKit endpoint from a single Effect HTTP route — an effect
+* producing an `HttpServerResponse` for the current `HttpServerRequest`. Pass
+* `options.layer` to provide the route's services; the layer is built once and
+* shared.
+*
+* @example
+* ```ts
+* // src/routes/health/+server.ts
+* import { Endpoint } from "@thomasfosterau/effect-sveltekit/server";
+* import { Effect } from "effect";
+* import { HttpServerResponse } from "effect/unstable/http";
+*
+* export const GET = Endpoint.fromHttpEffect(
+*   Effect.succeed(HttpServerResponse.text("ok")),
+* );
+* ```
+*/
+const fromHttpEffect = (effect, options) => {
+	if (options?.layer) {
+		const { handler, dispose } = HttpEffect.toWebHandlerLayer(effect, options.layer);
+		return make(handler, dispose, options.prefix);
+	}
+	return make(HttpEffect.toWebHandler(effect), noopDispose, options?.prefix);
+};
+//#endregion
+export { Endpoint_exports };
+
+//# sourceMappingURL=Endpoint.js.map

package/dist/server/Endpoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Endpoint.js","names":[],"sources":["../../src/server/Endpoint.ts"],"sourcesContent":["/**\n * Create SvelteKit server endpoints (`+server.ts`) backed by Effect — the\n * `Endpoint` namespace of `@thomasfosterau/effect-sveltekit/server`.\n *\n * A SvelteKit endpoint is a `RequestHandler` (`(event) => Response`). Effect can\n * turn an [`HttpApi`](https://effect.website), an `HttpRouter`, or a single\n * route effect into a Web `fetch` handler; these helpers wrap one as a SvelteKit\n * endpoint handler so a route can be served by Effect. Mount it on a catch-all\n * route (`[...path]`) and assign it to `fallback` so every method and sub-path\n * reaches it:\n *\n * @example\n * ```ts\n * // src/routes/api/[...path]/+server.ts\n * import { Endpoint } from \"@thomasfosterau/effect-sveltekit/server\";\n * import { api } from \"$lib/server/api\";\n * import { ApiLive } from \"$lib/server/handlers\"; // HttpApiBuilder.group(...) + your services\n *\n * // `prefix` strips the SvelteKit mount path so the API's own paths\n * // (e.g. \"/users\") match.\n * export const fallback = Endpoint.fromApi(api, ApiLive, { prefix: \"/api\" });\n * ```\n *\n * The layer backing an endpoint is built once, lazily, on the first request and\n * shared across subsequent requests (like `makeServerRuntime`). The returned\n * handler carries a `dispose()` that closes the layer's scope — call it on\n * shutdown if the endpoint holds resources.\n *\n * The Effect handlers receive an Effect-native `HttpServerRequest` (built from\n * `event.request`), not the SvelteKit `RequestEvent`.\n */\n\nimport type { RequestHandler } from \"@sveltejs/kit\";\nimport { Layer } from \"effect\";\nimport type { Effect, Scope } from \"effect\";\nimport * as FileSystem from \"effect/FileSystem\";\nimport * as Path from \"effect/Path\";\nimport * as Etag from \"effect/unstable/http/Etag\";\nimport * as HttpEffect from \"effect/unstable/http/HttpEffect\";\nimport * as HttpPlatform from \"effect/unstable/http/HttpPlatform\";\nimport * as HttpRouter from \"effect/unstable/http/HttpRouter\";\nimport type * as HttpServerRequest from \"effect/unstable/http/HttpServerRequest\";\nimport type * as HttpServerResponse from \"effect/unstable/http/HttpServerResponse\";\nimport type * as HttpApi from \"effect/unstable/httpapi/HttpApi\";\nimport * as HttpApiBuilder from \"effect/unstable/httpapi/HttpApiBuilder\";\nimport type * as HttpApiGroup from \"effect/unstable/httpapi/HttpApiGroup\";\n\n/** A Web `fetch`-style handler, as produced by Effect's `toWebHandler` family. */\ntype WebHandler = (request: Request) => Promise<Response>;\n\n/**\n * A SvelteKit endpoint handler — the built-in\n * [`RequestHandler`](https://svelte.dev/docs/kit/@sveltejs-kit#RequestHandler) —\n * backed by an Effect HTTP construct. Assign it to a `+server.ts` export\n * (`fallback`, `GET`, ...). `dispose()` closes the scope of the layer behind it.\n */\nexport type EndpointHandler = RequestHandler & {\n  /** Close the scope of the layer backing the endpoint (runs its finalizers). */\n  readonly dispose: () => Promise<void>;\n};\n\n/** Shared options for every `Endpoint.from*` helper. */\nexport interface EndpointOptions {\n  /**\n   * A leading path segment to strip from each request before it reaches the\n   * Effect handler — the SvelteKit mount point. For an endpoint mounted at\n   * `src/routes/api/[...path]/+server.ts` whose routes are defined relative to\n   * the API root, pass `prefix: \"/api\"` so `/api/users` is dispatched as\n   * `/users`. The match respects path boundaries (`/api` does not strip\n   * `/apiary`). Defaults to no stripping.\n   */\n  readonly prefix?: string;\n}\n\nconst noopDispose = (): Promise<void> => Promise.resolve();\n\n/** Remove `prefix` from the request's path (respecting `/` boundaries). */\nconst stripPrefix = (request: Request, prefix: string): Request => {\n  const normalized = prefix.endsWith(\"/\") ? prefix.slice(0, -1) : prefix;\n  if (normalized === \"\") return request;\n\n  const url = new URL(request.url);\n  const path = url.pathname;\n  if (path === normalized) {\n    url.pathname = \"/\";\n  } else if (path.startsWith(`${normalized}/`)) {\n    url.pathname = path.slice(normalized.length);\n  } else {\n    return request;\n  }\n  return new Request(url, request);\n};\n\n/** Wrap a Web handler (and its dispose) as a SvelteKit endpoint handler. */\nconst make = (\n  webHandler: WebHandler,\n  dispose: () => Promise<void>,\n  prefix: string | undefined,\n): EndpointHandler => {\n  const handler: RequestHandler = (event) =>\n    webHandler(prefix === undefined ? event.request : stripPrefix(event.request, prefix));\n  return Object.assign(handler, { dispose });\n};\n\n/** The platform services an `HttpApi` needs, with a no-op file system. */\nconst apiPlatform = Layer.mergeAll(Path.layer, Etag.layerWeak, HttpPlatform.layer).pipe(\n  Layer.provideMerge(FileSystem.layerNoop({})),\n);\n\n/**\n * Create a SvelteKit endpoint that serves an Effect\n * [`HttpApi`](https://effect.website).\n *\n * `layer` implements the API's groups (built with `HttpApiBuilder.group`), with\n * any application services already provided. The platform services an `HttpApi`\n * requires (`HttpPlatform`, `FileSystem`, `Path`, `Etag`) are supplied for you.\n *\n * @example\n * ```ts\n * // src/routes/api/[...path]/+server.ts\n * import { Endpoint } from \"@thomasfosterau/effect-sveltekit/server\";\n * import { api } from \"$lib/server/api\";\n * import { ApiLive } from \"$lib/server/handlers\";\n *\n * export const fallback = Endpoint.fromApi(api, ApiLive, { prefix: \"/api\" });\n * ```\n */\nexport const fromApi = <Id extends string, Groups extends HttpApiGroup.Any, E>(\n  api: HttpApi.HttpApi<Id, Groups>,\n  layer: Layer.Layer<HttpApiGroup.ToService<Id, Groups>, E>,\n  options?: EndpointOptions & {\n    /** Serve the OpenAPI spec for the API at this path (e.g. `\"/openapi.json\"`). */\n    readonly openapiPath?: `/${string}`;\n    /** Add Effect's request logger middleware. Defaults to `false` (quiet). */\n    readonly logger?: boolean;\n  },\n): EndpointHandler => {\n  const appLayer = HttpApiBuilder.layer(\n    api,\n    options?.openapiPath ? { openapiPath: options.openapiPath } : undefined,\n  ).pipe(Layer.provide(layer), Layer.provide(apiPlatform));\n\n  const { handler, dispose } = HttpRouter.toWebHandler(\n    appLayer as Layer.Layer<never, E, HttpRouter.HttpRouter>,\n    { disableLogger: options?.logger !== true },\n  );\n  return make(handler, dispose, options?.prefix);\n};\n\n/**\n * Create a SvelteKit endpoint that serves an Effect `HttpRouter` (provided by\n * `layer`). The router's routes must be self-contained (any services they need\n * are provided within `layer`).\n *\n * @example\n * ```ts\n * // src/routes/api/[...path]/+server.ts\n * import { Endpoint } from \"@thomasfosterau/effect-sveltekit/server\";\n * import { Effect } from \"effect\";\n * import { HttpRouter, HttpServerResponse } from \"effect/unstable/http\";\n *\n * const RouterLive = HttpRouter.use((router) =>\n *   router.add(\"GET\", \"/hello\", Effect.succeed(HttpServerResponse.text(\"hi\"))),\n * );\n *\n * export const fallback = Endpoint.fromRouter(RouterLive, { prefix: \"/api\" });\n * ```\n */\nexport const fromRouter = <\n  A,\n  E,\n  R extends\n    | HttpRouter.HttpRouter\n    | HttpRouter.Request<\"Requires\", any>\n    | HttpRouter.Request<\"GlobalRequires\", any>\n    | HttpRouter.Request<\"Error\", any>\n    | HttpRouter.Request<\"GlobalError\", any>,\n>(\n  layer: Layer.Layer<A, E, R>,\n  options?: EndpointOptions & {\n    /** Add Effect's request logger middleware. Defaults to `false` (quiet). */\n    readonly logger?: boolean;\n  },\n): EndpointHandler => {\n  const { handler, dispose } = HttpRouter.toWebHandler(layer, {\n    disableLogger: options?.logger !== true,\n  });\n  return make(handler as WebHandler, dispose, options?.prefix);\n};\n\n/**\n * Create a SvelteKit endpoint from a single Effect HTTP route — an effect\n * producing an `HttpServerResponse` for the current `HttpServerRequest`. Pass\n * `options.layer` to provide the route's services; the layer is built once and\n * shared.\n *\n * @example\n * ```ts\n * // src/routes/health/+server.ts\n * import { Endpoint } from \"@thomasfosterau/effect-sveltekit/server\";\n * import { Effect } from \"effect\";\n * import { HttpServerResponse } from \"effect/unstable/http\";\n *\n * export const GET = Endpoint.fromHttpEffect(\n *   Effect.succeed(HttpServerResponse.text(\"ok\")),\n * );\n * ```\n */\nexport const fromHttpEffect = <E, R = never, ProvidedE = never>(\n  effect: Effect.Effect<\n    HttpServerResponse.HttpServerResponse,\n    E,\n    R | HttpServerRequest.HttpServerRequest | Scope.Scope\n  >,\n  options?: EndpointOptions & {\n    /** A layer providing the route's services (`R`), built once and shared. */\n    readonly layer?: Layer.Layer<R, ProvidedE>;\n  },\n): EndpointHandler => {\n  if (options?.layer) {\n    const { handler, dispose } = HttpEffect.toWebHandlerLayer(effect, options.layer);\n    return make(handler as WebHandler, dispose, options.prefix);\n  }\n  const handler = HttpEffect.toWebHandler(\n    effect as Effect.Effect<\n      HttpServerResponse.HttpServerResponse,\n      E,\n      HttpServerRequest.HttpServerRequest | Scope.Scope\n    >,\n  );\n  return make(handler, noopDispose, options?.prefix);\n};\n"],"mappings":";;;;;;;;;;;;;;;AA0EA,MAAM,oBAAmC,QAAQ,QAAQ;;AAGzD,MAAM,eAAe,SAAkB,WAA4B;CACjE,MAAM,aAAa,OAAO,SAAS,GAAG,IAAI,OAAO,MAAM,GAAG,EAAE,IAAI;CAChE,IAAI,eAAe,IAAI,OAAO;CAE9B,MAAM,MAAM,IAAI,IAAI,QAAQ,GAAG;CAC/B,MAAM,OAAO,IAAI;CACjB,IAAI,SAAS,YACX,IAAI,WAAW;MACV,IAAI,KAAK,WAAW,GAAG,WAAW,EAAE,GACzC,IAAI,WAAW,KAAK,MAAM,WAAW,MAAM;MAE3C,OAAO;CAET,OAAO,IAAI,QAAQ,KAAK,OAAO;AACjC;;AAGA,MAAM,QACJ,YACA,SACA,WACoB;CACpB,MAAM,WAA2B,UAC/B,WAAW,WAAW,KAAA,IAAY,MAAM,UAAU,YAAY,MAAM,SAAS,MAAM,CAAC;CACtF,OAAO,OAAO,OAAO,SAAS,EAAE,QAAQ,CAAC;AAC3C;;AAGA,MAAM,cAAc,MAAM,SAAS,KAAK,OAAO,KAAK,WAAW,aAAa,KAAK,EAAE,KACjF,MAAM,aAAa,WAAW,UAAU,CAAC,CAAC,CAAC,CAC7C;;;;;;;;;;;;;;;;;;;AAoBA,MAAa,WACX,KACA,OACA,YAMoB;CACpB,MAAM,WAAW,eAAe,MAC9B,KACA,SAAS,cAAc,EAAE,aAAa,QAAQ,YAAY,IAAI,KAAA,CAChE,EAAE,KAAK,MAAM,QAAQ,KAAK,GAAG,MAAM,QAAQ,WAAW,CAAC;CAEvD,MAAM,EAAE,SAAS,YAAY,WAAW,aACtC,UACA,EAAE,eAAe,SAAS,WAAW,KAAK,CAC5C;CACA,OAAO,KAAK,SAAS,SAAS,SAAS,MAAM;AAC/C;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,cAUX,OACA,YAIoB;CACpB,MAAM,EAAE,SAAS,YAAY,WAAW,aAAa,OAAO,EAC1D,eAAe,SAAS,WAAW,KACrC,CAAC;CACD,OAAO,KAAK,SAAuB,SAAS,SAAS,MAAM;AAC7D;;;;;;;;;;;;;;;;;;;AAoBA,MAAa,kBACX,QAKA,YAIoB;CACpB,IAAI,SAAS,OAAO;EAClB,MAAM,EAAE,SAAS,YAAY,WAAW,kBAAkB,QAAQ,QAAQ,KAAK;EAC/E,OAAO,KAAK,SAAuB,SAAS,QAAQ,MAAM;CAC5D;CAQA,OAAO,KAPS,WAAW,aACzB,MAMgB,GAAG,aAAa,SAAS,MAAM;AACnD"}