@thomasfosterau/effect-sveltekit 0.1.1 → 0.2.1

package/dist/internal/enhance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enhance.js","names":[],"sources":["../../src/internal/enhance.ts"],"sourcesContent":["/**\n * The runtime-agnostic core of the `use:enhance` bridge, kept free of any\n * `$app/*` import so it can be unit-tested outside a SvelteKit app build.\n */\n\nimport type { SubmitFunction } from \"@sveltejs/kit\";\nimport { Context, Effect, ManagedRuntime } from \"effect\";\n\n/** The input SvelteKit passes to a `SubmitFunction` before the request is sent. */\nexport type SubmitInput = Parameters<SubmitFunction>[0];\n\n/** The result callback a `SubmitFunction` may return, run once the action responds. */\ntype ResultCallback = Extract<Awaited<ReturnType<SubmitFunction>>, (...args: never) => unknown>;\n\n/** The options passed to the result callback (`result`, `update`, ...). */\nexport type ResultOptions = Parameters<ResultCallback>[0];\n\n/** A runtime the handler effects can run against (a `Context` or `ManagedRuntime`). */\nexport type EnhanceRuntime<R> = Context.Context<R> | ManagedRuntime.ManagedRuntime<R, never>;\n\n/** Effect-based handlers for the two phases of an enhanced form submission. */\nexport interface EnhanceHandlers<R = never> {\n  /**\n   * Runs before the request is sent. Call `input.cancel()` to abort the\n   * submission (the result phase then never runs). Use for optimistic UI or\n   * validation.\n   */\n  readonly onSubmit?: (input: SubmitInput) => Effect.Effect<void, never, R>;\n  /**\n   * Runs once the action responds, with the `ActionResult` and SvelteKit's\n   * `update()` (which applies the default behaviour — updating `page.form`,\n   * resetting the form, invalidating). If omitted, SvelteKit's default\n   * behaviour applies automatically.\n   */\n  readonly onResult?: (options: ResultOptions) => Effect.Effect<void, never, R>;\n}\n\n/** Options for {@link makeSubmitFunction}. */\nexport interface EnhanceOptions<R = never> {\n  /**\n   * The runtime to run the handler effects against. Omit when the handlers\n   * require no services (`R = never`); they then run on the default runtime.\n   */\n  readonly runtime?: EnhanceRuntime<R>;\n}\n\n/** Run an `Effect<A, never, R>` on the given runtime (or the default when none). */\nconst runPromiseWith =\n  <R>(runtime: EnhanceRuntime<R> | undefined) =>\n  <A>(effect: Effect.Effect<A, never, R>): Promise<A> => {\n    if (runtime === undefined) return Effect.runPromise(effect as Effect.Effect<A, never, never>);\n    return Context.isContext(runtime)\n      ? Effect.runPromiseWith(runtime)(effect)\n      : runtime.runPromise(effect);\n  };\n\n/**\n * Build a SvelteKit `SubmitFunction` from Effect-based handlers. See\n * `Forms.enhance` for the public entry point and documentation.\n */\nexport const makeSubmitFunction = <R = never>(\n  handlers: EnhanceHandlers<R>,\n  options?: EnhanceOptions<R>,\n): SubmitFunction => {\n  const run = runPromiseWith(options?.runtime);\n  return async (input) => {\n    if (handlers.onSubmit) await run(handlers.onSubmit(input));\n    // Returning `undefined` lets SvelteKit apply its default result behaviour.\n    if (!handlers.onResult) return undefined;\n    const onResult = handlers.onResult;\n    return (resultOptions) => run(onResult(resultOptions));\n  };\n};\n"],"mappings":";;;AA+CA,MAAM,kBACA,aACA,WAAmD;CACrD,IAAI,YAAY,KAAA,GAAW,OAAO,OAAO,WAAW,MAAwC;CAC5F,OAAO,QAAQ,UAAU,OAAO,IAC5B,OAAO,eAAe,OAAO,EAAE,MAAM,IACrC,QAAQ,WAAW,MAAM;AAC/B;;;;;AAMF,MAAa,sBACX,UACA,YACmB;CACnB,MAAM,MAAM,eAAe,SAAS,OAAO;CAC3C,OAAO,OAAO,UAAU;EACtB,IAAI,SAAS,UAAU,MAAM,IAAI,SAAS,SAAS,KAAK,CAAC;EAEzD,IAAI,CAAC,SAAS,UAAU,OAAO,KAAA;EAC/B,MAAM,WAAW,SAAS;EAC1B,QAAQ,kBAAkB,IAAI,SAAS,aAAa,CAAC;CACvD;AACF"}

package/dist/internal/remote-run.d.ts

@@ -12,6 +12,17 @@ type FormErrorMapper = (error: unknown, ctx: {
   readonly issue: InvalidField<any>;
   readonly data: unknown;
 }) => never;
+/** Runs a remote handler's effect and settles it (value or thrown via translator). */
+type Runner = <A>(effect: Effect.Effect<A, unknown, any>) => Promise<A>;
+/** Like {@link Runner}, but with the form's `issue` / `data` for error interop. */
+type FormRunner = <A>(effect: Effect.Effect<A, unknown, any>, ctx: {
+  readonly issue: InvalidField<any>;
+  readonly data: unknown;
+}) => Promise<A>;
+interface RunHelpers {
+  readonly run: Runner;
+  readonly runForm: FormRunner;
+}
 //#endregion
-export { FormErrorMapper };
+export { FormErrorMapper, RunHelpers };
 //# sourceMappingURL=remote-run.d.ts.map

package/dist/internal/remote-run.js

@@ -1,10 +1,8 @@
-import { causeToThrowable } from "./error.js";
+import { SvelteKit } from "../kit.js";
 import { Cause, Exit } from "effect";
 //#region src/internal/remote-run.ts
-/** The default translator: SvelteKit control flow through, anything else a 500. */
-const defaultTranslate = (cause) => {
-	throw causeToThrowable(cause);
-};
+/** The default translator: Kit control-flow errors through, anything else a 500. */
+const defaultTranslate = SvelteKit.translate;
 /** Build the `run` / `runForm` helpers from an exit resolver and a translator. */
 const makeRunHelpers = (resolve, translate, formError) => {
 	const run = (effect) => {

package/dist/internal/remote-run.js.map

@@ -1 +1 @@
-{"version":3,"file":"remote-run.js","names":[],"sources":["../../src/internal/remote-run.ts"],"sourcesContent":["/**\n * Run/settle helpers for the remote-function wrappers, factored out so they can\n * be unit-tested without importing `$app/server` (a SvelteKit virtual module\n * unavailable outside an app build). The `$app/server`-dependent resolvers live\n * in `remote.server.ts`; this module only deals in `Exit`s.\n */\n\nimport type { InvalidField } from \"@sveltejs/kit\";\nimport { Cause, type Effect, Exit } from \"effect\";\nimport { causeToThrowable } from \"./error.js\";\nimport type { ErrorTranslator } from \"../request-runtime.js\";\n\n/** The default translator: SvelteKit control flow through, anything else a 500. */\nexport const defaultTranslate: ErrorTranslator = (cause) => {\n  throw causeToThrowable(cause);\n};\n\n/**\n * Maps a remote *form* handler's failure into SvelteKit's field issues, given\n * the form's parsed `data` and the `issue` helper. It may call `invalid()` so a\n * structured/nested validation error drives field-level invalidation instead of\n * a generic failure. Receives the squashed handler failure.\n */\nexport type FormErrorMapper = (\n  error: unknown,\n  ctx: { readonly issue: InvalidField<any>; readonly data: unknown },\n) => never;\n\n/** Runs a remote handler's effect and settles it (value or thrown via translator). */\nexport type Runner = <A>(effect: Effect.Effect<A, unknown, any>) => Promise<A>;\n\n/** Like {@link Runner}, but with the form's `issue` / `data` for error interop. */\nexport type FormRunner = <A>(\n  effect: Effect.Effect<A, unknown, any>,\n  ctx: { readonly issue: InvalidField<any>; readonly data: unknown },\n) => Promise<A>;\n\nexport interface RunHelpers {\n  readonly run: Runner;\n  readonly runForm: FormRunner;\n}\n\n/** How to obtain an `Exit` for the current request, plus optional teardown. */\nexport type ExitResolver = () => {\n  readonly runExit: <A>(effect: Effect.Effect<A, unknown, any>) => Promise<Exit.Exit<A, unknown>>;\n  readonly dispose?: () => void;\n};\n\n/** Build the `run` / `runForm` helpers from an exit resolver and a translator. */\nexport const makeRunHelpers = (\n  resolve: ExitResolver,\n  translate: ErrorTranslator,\n  formError?: FormErrorMapper,\n): RunHelpers => {\n  const run: Runner = (effect) => {\n    const { runExit, dispose } = resolve();\n    return runExit(effect).then((exit) => {\n      try {\n        return Exit.isSuccess(exit) ? exit.value : translate(exit.cause);\n      } finally {\n        dispose?.();\n      }\n    });\n  };\n  const runForm: FormRunner = (effect, ctx) => {\n    const { runExit, dispose } = resolve();\n    return runExit(effect).then((exit) => {\n      try {\n        if (Exit.isSuccess(exit)) return exit.value;\n        return formError ? formError(Cause.squash(exit.cause), ctx) : translate(exit.cause);\n      } finally {\n        dispose?.();\n      }\n    });\n  };\n  return { run, runForm };\n};\n"],"mappings":";;;;AAaA,MAAa,oBAAqC,UAAU;CAC1D,MAAM,iBAAiB,KAAK;AAC9B;;AAkCA,MAAa,kBACX,SACA,WACA,cACe;CACf,MAAM,OAAe,WAAW;EAC9B,MAAM,EAAE,SAAS,YAAY,QAAQ;EACrC,OAAO,QAAQ,MAAM,EAAE,MAAM,SAAS;GACpC,IAAI;IACF,OAAO,KAAK,UAAU,IAAI,IAAI,KAAK,QAAQ,UAAU,KAAK,KAAK;GACjE,UAAU;IACR,UAAU;GACZ;EACF,CAAC;CACH;CACA,MAAM,WAAuB,QAAQ,QAAQ;EAC3C,MAAM,EAAE,SAAS,YAAY,QAAQ;EACrC,OAAO,QAAQ,MAAM,EAAE,MAAM,SAAS;GACpC,IAAI;IACF,IAAI,KAAK,UAAU,IAAI,GAAG,OAAO,KAAK;IACtC,OAAO,YAAY,UAAU,MAAM,OAAO,KAAK,KAAK,GAAG,GAAG,IAAI,UAAU,KAAK,KAAK;GACpF,UAAU;IACR,UAAU;GACZ;EACF,CAAC;CACH;CACA,OAAO;EAAE;EAAK;CAAQ;AACxB"}
+{"version":3,"file":"remote-run.js","names":[],"sources":["../../src/internal/remote-run.ts"],"sourcesContent":["/**\n * Run/settle helpers for the remote-function wrappers, factored out so they can\n * be unit-tested without importing `$app/server` (a SvelteKit virtual module\n * unavailable outside an app build). The `$app/server`-dependent resolvers live\n * in `remote.server.ts`; this module only deals in `Exit`s.\n */\n\nimport type { InvalidField } from \"@sveltejs/kit\";\nimport { Cause, type Effect, Exit } from \"effect\";\nimport type { ErrorTranslator } from \"../request-runtime.js\";\nimport { SvelteKit } from \"../kit.js\";\n\n/** The default translator: Kit control-flow errors through, anything else a 500. */\nexport const defaultTranslate: ErrorTranslator = SvelteKit.translate;\n\n/**\n * Maps a remote *form* handler's failure into SvelteKit's field issues, given\n * the form's parsed `data` and the `issue` helper. It may call `invalid()` so a\n * structured/nested validation error drives field-level invalidation instead of\n * a generic failure. Receives the squashed handler failure.\n */\nexport type FormErrorMapper = (\n  error: unknown,\n  ctx: { readonly issue: InvalidField<any>; readonly data: unknown },\n) => never;\n\n/** Runs a remote handler's effect and settles it (value or thrown via translator). */\nexport type Runner = <A>(effect: Effect.Effect<A, unknown, any>) => Promise<A>;\n\n/** Like {@link Runner}, but with the form's `issue` / `data` for error interop. */\nexport type FormRunner = <A>(\n  effect: Effect.Effect<A, unknown, any>,\n  ctx: { readonly issue: InvalidField<any>; readonly data: unknown },\n) => Promise<A>;\n\nexport interface RunHelpers {\n  readonly run: Runner;\n  readonly runForm: FormRunner;\n}\n\n/** How to obtain an `Exit` for the current request, plus optional teardown. */\nexport type ExitResolver = () => {\n  readonly runExit: <A>(effect: Effect.Effect<A, unknown, any>) => Promise<Exit.Exit<A, unknown>>;\n  readonly dispose?: () => void;\n};\n\n/** Build the `run` / `runForm` helpers from an exit resolver and a translator. */\nexport const makeRunHelpers = (\n  resolve: ExitResolver,\n  translate: ErrorTranslator,\n  formError?: FormErrorMapper,\n): RunHelpers => {\n  const run: Runner = (effect) => {\n    const { runExit, dispose } = resolve();\n    return runExit(effect).then((exit) => {\n      try {\n        return Exit.isSuccess(exit) ? exit.value : translate(exit.cause);\n      } finally {\n        dispose?.();\n      }\n    });\n  };\n  const runForm: FormRunner = (effect, ctx) => {\n    const { runExit, dispose } = resolve();\n    return runExit(effect).then((exit) => {\n      try {\n        if (Exit.isSuccess(exit)) return exit.value;\n        return formError ? formError(Cause.squash(exit.cause), ctx) : translate(exit.cause);\n      } finally {\n        dispose?.();\n      }\n    });\n  };\n  return { run, runForm };\n};\n"],"mappings":";;;;AAaA,MAAa,mBAAoC,UAAU;;AAkC3D,MAAa,kBACX,SACA,WACA,cACe;CACf,MAAM,OAAe,WAAW;EAC9B,MAAM,EAAE,SAAS,YAAY,QAAQ;EACrC,OAAO,QAAQ,MAAM,EAAE,MAAM,SAAS;GACpC,IAAI;IACF,OAAO,KAAK,UAAU,IAAI,IAAI,KAAK,QAAQ,UAAU,KAAK,KAAK;GACjE,UAAU;IACR,UAAU;GACZ;EACF,CAAC;CACH;CACA,MAAM,WAAuB,QAAQ,QAAQ;EAC3C,MAAM,EAAE,SAAS,YAAY,QAAQ;EACrC,OAAO,QAAQ,MAAM,EAAE,MAAM,SAAS;GACpC,IAAI;IACF,IAAI,KAAK,UAAU,IAAI,GAAG,OAAO,KAAK;IACtC,OAAO,YAAY,UAAU,MAAM,OAAO,KAAK,KAAK,GAAG,GAAG,IAAI,UAAU,KAAK,KAAK;GACpF,UAAU;IACR,UAAU;GACZ;EACF,CAAC;CACH;CACA,OAAO;EAAE;EAAK;CAAQ;AACxB"}

package/dist/internal/sse.js

@@ -0,0 +1,37 @@
+//#region src/internal/sse.ts
+/**
+* Server-Sent Events framing helpers, factored out of the endpoint wrapper so
+* the wire format can be unit-tested in isolation.
+*
+* See the [SSE specification](https://html.spec.whatwg.org/multipage/server-sent-events.html).
+*/
+/** The response headers required for a `text/event-stream` body. */
+const SSE_HEADERS = {
+	"Content-Type": "text/event-stream",
+	"Cache-Control": "no-cache, no-transform",
+	Connection: "keep-alive"
+};
+/**
+* Encode a single SSE event as its wire representation, terminated by the
+* blank line that dispatches it.
+*
+* `data` is split on newlines into one `data:` line each (per the spec, a bare
+* newline in a value would otherwise be ambiguous). `event` / `id` are emitted
+* only when present.
+*/
+const encodeSseFrame = (frame) => {
+	let out = "";
+	if (frame.id !== void 0) out += `id: ${frame.id}\n`;
+	if (frame.event !== void 0) out += `event: ${frame.event}\n`;
+	for (const line of frame.data.split("\n")) out += `data: ${line}\n`;
+	out += "\n";
+	return out;
+};
+/** Encode the one-shot `retry:` field that sets the client reconnection delay. */
+const encodeRetry = (milliseconds) => `retry: ${milliseconds}\n\n`;
+/** A comment line used as a heartbeat/keepalive (ignored by the client). */
+const HEARTBEAT_FRAME = ": heartbeat\n\n";
+//#endregion
+export { HEARTBEAT_FRAME, SSE_HEADERS, encodeRetry, encodeSseFrame };
+
+//# sourceMappingURL=sse.js.map

package/dist/internal/sse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.js","names":[],"sources":["../../src/internal/sse.ts"],"sourcesContent":["/**\n * Server-Sent Events framing helpers, factored out of the endpoint wrapper so\n * the wire format can be unit-tested in isolation.\n *\n * See the [SSE specification](https://html.spec.whatwg.org/multipage/server-sent-events.html).\n */\n\n/** The response headers required for a `text/event-stream` body. */\nexport const SSE_HEADERS: Readonly<Record<string, string>> = {\n  \"Content-Type\": \"text/event-stream\",\n  \"Cache-Control\": \"no-cache, no-transform\",\n  Connection: \"keep-alive\",\n};\n\n/** The fields of a single SSE event. */\nexport interface SseFrame {\n  /** The event payload. Multi-line strings are split into multiple `data:` lines. */\n  readonly data: string;\n  /** Optional event name (`event:` field). */\n  readonly event?: string | undefined;\n  /** Optional event id (`id:` field), which the browser echoes on reconnect. */\n  readonly id?: string | undefined;\n}\n\n/**\n * Encode a single SSE event as its wire representation, terminated by the\n * blank line that dispatches it.\n *\n * `data` is split on newlines into one `data:` line each (per the spec, a bare\n * newline in a value would otherwise be ambiguous). `event` / `id` are emitted\n * only when present.\n */\nexport const encodeSseFrame = (frame: SseFrame): string => {\n  let out = \"\";\n  if (frame.id !== undefined) out += `id: ${frame.id}\\n`;\n  if (frame.event !== undefined) out += `event: ${frame.event}\\n`;\n  // Split into per-line `data:` fields so embedded newlines survive.\n  for (const line of frame.data.split(\"\\n\")) out += `data: ${line}\\n`;\n  out += \"\\n\";\n  return out;\n};\n\n/** Encode the one-shot `retry:` field that sets the client reconnection delay. */\nexport const encodeRetry = (milliseconds: number): string => `retry: ${milliseconds}\\n\\n`;\n\n/** A comment line used as a heartbeat/keepalive (ignored by the client). */\nexport const HEARTBEAT_FRAME = \": heartbeat\\n\\n\";\n"],"mappings":";;;;;;;;AAQA,MAAa,cAAgD;CAC3D,gBAAgB;CAChB,iBAAiB;CACjB,YAAY;AACd;;;;;;;;;AAoBA,MAAa,kBAAkB,UAA4B;CACzD,IAAI,MAAM;CACV,IAAI,MAAM,OAAO,KAAA,GAAW,OAAO,OAAO,MAAM,GAAG;CACnD,IAAI,MAAM,UAAU,KAAA,GAAW,OAAO,UAAU,MAAM,MAAM;CAE5D,KAAK,MAAM,QAAQ,MAAM,KAAK,MAAM,IAAI,GAAG,OAAO,SAAS,KAAK;CAChE,OAAO;CACP,OAAO;AACT;;AAGA,MAAa,eAAe,iBAAiC,UAAU,aAAa;;AAGpF,MAAa,kBAAkB"}

package/dist/kit.d.ts

@@ -0,0 +1,130 @@
+import { Cause, Effect } from "effect";
+
+//#region src/kit.d.ts
+/**
+ * An Effect-native redirect. Yield via {@link SvelteKit.redirect}; translated
+ * at the request boundary by {@link SvelteKit.translate}.
+ */
+declare class KitRedirect extends Error {
+  readonly status: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308;
+  readonly location: string | URL;
+  readonly _tag: "KitRedirect";
+  constructor(status: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308, location: string | URL);
+}
+/**
+ * An Effect-native HTTP error. Yield via {@link SvelteKit.error}; translated
+ * at the request boundary by {@link SvelteKit.translate}.
+ */
+declare class KitError extends Error {
+  readonly status: number;
+  readonly body?: string | Record<string, unknown> | undefined;
+  readonly _tag: "KitError";
+  constructor(status: number, body?: string | Record<string, unknown> | undefined);
+}
+/**
+ * An Effect-native form-action failure. Yield via {@link SvelteKit.fail};
+ * translated at the request boundary by {@link SvelteKit.translate}.
+ */
+declare class KitActionFailure<T extends Record<string, unknown> = Record<string, unknown>> extends Error {
+  readonly status: number;
+  readonly data: T;
+  readonly _tag: "KitActionFailure";
+  constructor(status: number, data: T);
+}
+/**
+ * A single domain-error case for {@link SvelteKit.makeTranslator}.
+ *
+ * Receives the squashed error value. Throw (e.g. `error()` / `redirect()`) to
+ * handle the case; return normally to pass through to the next case.
+ */
+type KitTranslatorCase = (error: unknown) => undefined | void;
+/**
+ * A boundary translator: turn a failed `Cause` into thrown SvelteKit control
+ * flow or an `ActionFailure` return value.
+ *
+ * The Kit base translator ({@link SvelteKit.translate}) handles
+ * {@link KitRedirect}, {@link KitError}, and {@link KitActionFailure}. Build a
+ * custom translator via {@link SvelteKit.makeTranslator}.
+ */
+type KitErrorTranslator = (cause: Cause.Cause<unknown>) => never;
+/**
+ * Effect-native SvelteKit control-flow helpers and the default boundary
+ * translator.
+ *
+ * **Error types**: {@link KitRedirect}, {@link KitError}, {@link KitActionFailure}
+ * are tagged Effect failures — use them with `Effect.catchTag`, `Match.tag`,
+ * and `instanceof` checks.
+ *
+ * **Default translator**: `SvelteKit.translate` is wired in as the default
+ * `translateError` for every server wrapper (`serverLoad`, `action`,
+ * `makeRuntimeAdapter`, `RemoteFunction.withRuntime`, etc.).
+ */
+declare const SvelteKit: {
+  /**
+   * Fail with a redirect. Equivalent to SvelteKit's `redirect()` but as an
+   * Effect failure instead of a thrown exception.
+   *
+   * @example
+   * ```ts
+   * yield* SvelteKit.redirect(303, "/login");
+   * ```
+   */
+  readonly redirect: (status: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308, location: string | URL) => Effect.Effect<never, KitRedirect>;
+  /**
+   * Fail with an HTTP error. Equivalent to SvelteKit's `error()` but as an
+   * Effect failure instead of a thrown exception.
+   *
+   * @example
+   * ```ts
+   * yield* SvelteKit.error(404, "Not found");
+   * yield* SvelteKit.error(403, { message: "Forbidden" });
+   * ```
+   */
+  readonly error: (status: number, body?: string | Record<string, unknown>) => Effect.Effect<never, KitError>;
+  /**
+   * Fail with a form-action failure. Equivalent to SvelteKit's `fail()` but as
+   * an Effect failure instead of a return value.
+   *
+   * @example
+   * ```ts
+   * yield* SvelteKit.fail(422, { email: "already taken" });
+   * ```
+   */
+  readonly fail: <T extends Record<string, unknown>>(status: number, data: T) => Effect.Effect<never, KitActionFailure<T>>;
+  /**
+   * The turnkey boundary translator. Converts {@link KitRedirect} →
+   * `redirect()`, {@link KitError} → `error()`, {@link KitActionFailure} →
+   * `fail()`, and anything else → `EffectCauseError` (500).
+   *
+   * This is the default `translateError` for every server wrapper. To extend it
+   * with your own domain errors, use {@link SvelteKit.makeTranslator}.
+   */
+  readonly translate: KitErrorTranslator;
+  /**
+   * Build a custom boundary translator by prepending domain-error cases before
+   * the Kit base cases.
+   *
+   * Each case function receives the squashed error value. Throw (e.g. call
+   * `error()` / `redirect()` from `@sveltejs/kit`) to handle the case; return
+   * normally to pass through to the next case or the Kit base translator.
+   *
+   * @example
+   * ```ts
+   * import { error } from "@sveltejs/kit";
+   *
+   * const translateError = SvelteKit.makeTranslator([
+   *   (e) => { if (e instanceof NotFound) error(404, "Not found"); },
+   *   (e) => { if (e instanceof Forbidden) error(403, "Forbidden"); },
+   * ]);
+   *
+   * const { serverLoad } = makeRuntimeAdapter(
+   *   RequestRuntime.fromLayer(AppLayer),
+   *   { translateError },
+   * );
+   * ```
+   */
+  readonly makeTranslator: (extraCases: ReadonlyArray<KitTranslatorCase>) => KitErrorTranslator;
+};
+//#endregion
+export { KitActionFailure, KitError, KitErrorTranslator, KitRedirect, KitTranslatorCase, SvelteKit };
+//# sourceMappingURL=kit.d.ts.map

package/dist/kit.js

@@ -0,0 +1,185 @@
+import { causeToThrowable } from "./internal/error.js";
+import { Cause, Effect } from "effect";
+import { error, fail, redirect } from "@sveltejs/kit";
+//#region src/kit.ts
+/**
+* Effect-native SvelteKit control-flow errors and a turnkey boundary translator.
+*
+* Every server consumer previously needed to hand-roll their own `translateError`
+* that mapped domain errors → `redirect()` / `error()` / `fail()`. This module
+* ships the catalogue those consumers all reinvented:
+*
+* - {@link KitRedirect}, {@link KitError}, {@link KitActionFailure} — tagged
+*   Effect failure types for each SvelteKit control-flow call.
+* - {@link SvelteKit.redirect}, {@link SvelteKit.error}, {@link SvelteKit.fail}
+*   — helpers that `yield*` a typed failure instead of throwing.
+* - {@link SvelteKit.translate} — the base `ErrorTranslator` that converts those
+*   failures to the appropriate SvelteKit call at the request boundary.
+* - {@link SvelteKit.makeTranslator} — compose `translate` with your own
+*   domain-error cases (consumer cases run first).
+*
+* @example
+* ```ts
+* import { SvelteKit, makeRuntimeAdapter, RequestRuntime } from "@thomasfosterau/effect-sveltekit/server";
+* import { Effect } from "effect";
+*
+* // Yield kit errors instead of throwing:
+* const load = serverLoad(() =>
+*   Effect.gen(function* () {
+*     const user = yield* getUser;
+*     if (!user) yield* SvelteKit.redirect(303, "/login");
+*     if (!user.active) yield* SvelteKit.error(403, "Account disabled");
+*     return { user };
+*   })
+* );
+*
+* // Compose with your own domain errors:
+* import { error } from "@sveltejs/kit";
+* const { serverLoad } = makeRuntimeAdapter(
+*   RequestRuntime.fromLayer(AppLayer),
+*   {
+*     translateError: SvelteKit.makeTranslator([
+*       (e) => { if (e instanceof NotFound) error(404, "Not found"); },
+*     ]),
+*   },
+* );
+* ```
+*/
+/**
+* An Effect-native redirect. Yield via {@link SvelteKit.redirect}; translated
+* at the request boundary by {@link SvelteKit.translate}.
+*/
+var KitRedirect = class extends Error {
+	status;
+	location;
+	_tag = "KitRedirect";
+	constructor(status, location) {
+		super(`Redirect to ${String(location)}`);
+		this.status = status;
+		this.location = location;
+		this.name = "KitRedirect";
+	}
+};
+/**
+* An Effect-native HTTP error. Yield via {@link SvelteKit.error}; translated
+* at the request boundary by {@link SvelteKit.translate}.
+*/
+var KitError = class extends Error {
+	status;
+	body;
+	_tag = "KitError";
+	constructor(status, body) {
+		super(`HTTP ${status}`);
+		this.status = status;
+		this.body = body;
+		this.name = "KitError";
+	}
+};
+/**
+* An Effect-native form-action failure. Yield via {@link SvelteKit.fail};
+* translated at the request boundary by {@link SvelteKit.translate}.
+*/
+var KitActionFailure = class extends Error {
+	status;
+	data;
+	_tag = "KitActionFailure";
+	constructor(status, data) {
+		super(`Action failure ${status}`);
+		this.status = status;
+		this.data = data;
+		this.name = "KitActionFailure";
+	}
+};
+const baseTranslate = (cause) => {
+	const squashed = Cause.squash(cause);
+	if (squashed instanceof KitRedirect) redirect(squashed.status, squashed.location);
+	if (squashed instanceof KitError) error(squashed.status, squashed.body);
+	if (squashed instanceof KitActionFailure) return fail(squashed.status, squashed.data);
+	throw causeToThrowable(cause);
+};
+/**
+* Effect-native SvelteKit control-flow helpers and the default boundary
+* translator.
+*
+* **Error types**: {@link KitRedirect}, {@link KitError}, {@link KitActionFailure}
+* are tagged Effect failures — use them with `Effect.catchTag`, `Match.tag`,
+* and `instanceof` checks.
+*
+* **Default translator**: `SvelteKit.translate` is wired in as the default
+* `translateError` for every server wrapper (`serverLoad`, `action`,
+* `makeRuntimeAdapter`, `RemoteFunction.withRuntime`, etc.).
+*/
+const SvelteKit = {
+	/**
+	* Fail with a redirect. Equivalent to SvelteKit's `redirect()` but as an
+	* Effect failure instead of a thrown exception.
+	*
+	* @example
+	* ```ts
+	* yield* SvelteKit.redirect(303, "/login");
+	* ```
+	*/
+	redirect: (status, location) => Effect.fail(new KitRedirect(status, location)),
+	/**
+	* Fail with an HTTP error. Equivalent to SvelteKit's `error()` but as an
+	* Effect failure instead of a thrown exception.
+	*
+	* @example
+	* ```ts
+	* yield* SvelteKit.error(404, "Not found");
+	* yield* SvelteKit.error(403, { message: "Forbidden" });
+	* ```
+	*/
+	error: (status, body) => Effect.fail(new KitError(status, body)),
+	/**
+	* Fail with a form-action failure. Equivalent to SvelteKit's `fail()` but as
+	* an Effect failure instead of a return value.
+	*
+	* @example
+	* ```ts
+	* yield* SvelteKit.fail(422, { email: "already taken" });
+	* ```
+	*/
+	fail: (status, data) => Effect.fail(new KitActionFailure(status, data)),
+	/**
+	* The turnkey boundary translator. Converts {@link KitRedirect} →
+	* `redirect()`, {@link KitError} → `error()`, {@link KitActionFailure} →
+	* `fail()`, and anything else → `EffectCauseError` (500).
+	*
+	* This is the default `translateError` for every server wrapper. To extend it
+	* with your own domain errors, use {@link SvelteKit.makeTranslator}.
+	*/
+	translate: baseTranslate,
+	/**
+	* Build a custom boundary translator by prepending domain-error cases before
+	* the Kit base cases.
+	*
+	* Each case function receives the squashed error value. Throw (e.g. call
+	* `error()` / `redirect()` from `@sveltejs/kit`) to handle the case; return
+	* normally to pass through to the next case or the Kit base translator.
+	*
+	* @example
+	* ```ts
+	* import { error } from "@sveltejs/kit";
+	*
+	* const translateError = SvelteKit.makeTranslator([
+	*   (e) => { if (e instanceof NotFound) error(404, "Not found"); },
+	*   (e) => { if (e instanceof Forbidden) error(403, "Forbidden"); },
+	* ]);
+	*
+	* const { serverLoad } = makeRuntimeAdapter(
+	*   RequestRuntime.fromLayer(AppLayer),
+	*   { translateError },
+	* );
+	* ```
+	*/
+	makeTranslator: (extraCases) => (cause) => {
+		const squashed = Cause.squash(cause);
+		for (const matcher of extraCases) matcher(squashed);
+		return baseTranslate(cause);
+	}
+};
+//#endregion
+export { KitActionFailure, KitError, KitRedirect, SvelteKit };
+
+//# sourceMappingURL=kit.js.map

package/dist/kit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kit.js","names":["kitFail"],"sources":["../src/kit.ts"],"sourcesContent":["/**\n * Effect-native SvelteKit control-flow errors and a turnkey boundary translator.\n *\n * Every server consumer previously needed to hand-roll their own `translateError`\n * that mapped domain errors → `redirect()` / `error()` / `fail()`. This module\n * ships the catalogue those consumers all reinvented:\n *\n * - {@link KitRedirect}, {@link KitError}, {@link KitActionFailure} — tagged\n *   Effect failure types for each SvelteKit control-flow call.\n * - {@link SvelteKit.redirect}, {@link SvelteKit.error}, {@link SvelteKit.fail}\n *   — helpers that `yield*` a typed failure instead of throwing.\n * - {@link SvelteKit.translate} — the base `ErrorTranslator` that converts those\n *   failures to the appropriate SvelteKit call at the request boundary.\n * - {@link SvelteKit.makeTranslator} — compose `translate` with your own\n *   domain-error cases (consumer cases run first).\n *\n * @example\n * ```ts\n * import { SvelteKit, makeRuntimeAdapter, RequestRuntime } from \"@thomasfosterau/effect-sveltekit/server\";\n * import { Effect } from \"effect\";\n *\n * // Yield kit errors instead of throwing:\n * const load = serverLoad(() =>\n *   Effect.gen(function* () {\n *     const user = yield* getUser;\n *     if (!user) yield* SvelteKit.redirect(303, \"/login\");\n *     if (!user.active) yield* SvelteKit.error(403, \"Account disabled\");\n *     return { user };\n *   })\n * );\n *\n * // Compose with your own domain errors:\n * import { error } from \"@sveltejs/kit\";\n * const { serverLoad } = makeRuntimeAdapter(\n *   RequestRuntime.fromLayer(AppLayer),\n *   {\n *     translateError: SvelteKit.makeTranslator([\n *       (e) => { if (e instanceof NotFound) error(404, \"Not found\"); },\n *     ]),\n *   },\n * );\n * ```\n */\n\nimport { error as kitError, fail as kitFail, redirect as kitRedirect } from \"@sveltejs/kit\";\nimport { Cause, Effect } from \"effect\";\nimport { causeToThrowable } from \"./internal/error.js\";\n\n// ─── Tagged error classes ────────────────────────────────────────────────────\n\n/**\n * An Effect-native redirect. Yield via {@link SvelteKit.redirect}; translated\n * at the request boundary by {@link SvelteKit.translate}.\n */\nexport class KitRedirect extends Error {\n  readonly _tag = \"KitRedirect\" as const;\n\n  constructor(\n    readonly status: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308,\n    readonly location: string | URL,\n  ) {\n    super(`Redirect to ${String(location)}`);\n    this.name = \"KitRedirect\";\n  }\n}\n\n/**\n * An Effect-native HTTP error. Yield via {@link SvelteKit.error}; translated\n * at the request boundary by {@link SvelteKit.translate}.\n */\nexport class KitError extends Error {\n  readonly _tag = \"KitError\" as const;\n\n  constructor(\n    readonly status: number,\n    readonly body?: string | Record<string, unknown>,\n  ) {\n    super(`HTTP ${status}`);\n    this.name = \"KitError\";\n  }\n}\n\n/**\n * An Effect-native form-action failure. Yield via {@link SvelteKit.fail};\n * translated at the request boundary by {@link SvelteKit.translate}.\n */\nexport class KitActionFailure<\n  T extends Record<string, unknown> = Record<string, unknown>,\n> extends Error {\n  readonly _tag = \"KitActionFailure\" as const;\n\n  constructor(\n    readonly status: number,\n    readonly data: T,\n  ) {\n    super(`Action failure ${status}`);\n    this.name = \"KitActionFailure\";\n  }\n}\n\n// ─── Translator types ────────────────────────────────────────────────────────\n\n/**\n * A single domain-error case for {@link SvelteKit.makeTranslator}.\n *\n * Receives the squashed error value. Throw (e.g. `error()` / `redirect()`) to\n * handle the case; return normally to pass through to the next case.\n */\nexport type KitTranslatorCase = (error: unknown) => undefined | void;\n\n/**\n * A boundary translator: turn a failed `Cause` into thrown SvelteKit control\n * flow or an `ActionFailure` return value.\n *\n * The Kit base translator ({@link SvelteKit.translate}) handles\n * {@link KitRedirect}, {@link KitError}, and {@link KitActionFailure}. Build a\n * custom translator via {@link SvelteKit.makeTranslator}.\n */\nexport type KitErrorTranslator = (cause: Cause.Cause<unknown>) => never;\n\n// ─── Base translator ─────────────────────────────────────────────────────────\n\nconst baseTranslate: KitErrorTranslator = (cause) => {\n  const squashed = Cause.squash(cause);\n\n  if (squashed instanceof KitRedirect) {\n    // redirect() is typed as () => never — throws internally.\n    kitRedirect(squashed.status, squashed.location as string);\n  }\n\n  if (squashed instanceof KitError) {\n    // error() is typed as () => never — throws internally.\n    kitError(squashed.status as Parameters<typeof kitError>[0], squashed.body as any);\n  }\n\n  if (squashed instanceof KitActionFailure) {\n    // fail() returns an ActionFailure (doesn't throw). SvelteKit detects it as\n    // the action's return value. Typed as never to satisfy ErrorTranslator while\n    // allowing makeRuntimeAdapter's `return translateError(cause)` to propagate\n    // the ActionFailure to SvelteKit correctly at runtime.\n    return kitFail(squashed.status, squashed.data) as never;\n  }\n\n  throw causeToThrowable(cause);\n};\n\n// ─── Public namespace ─────────────────────────────────────────────────────────\n\n/**\n * Effect-native SvelteKit control-flow helpers and the default boundary\n * translator.\n *\n * **Error types**: {@link KitRedirect}, {@link KitError}, {@link KitActionFailure}\n * are tagged Effect failures — use them with `Effect.catchTag`, `Match.tag`,\n * and `instanceof` checks.\n *\n * **Default translator**: `SvelteKit.translate` is wired in as the default\n * `translateError` for every server wrapper (`serverLoad`, `action`,\n * `makeRuntimeAdapter`, `RemoteFunction.withRuntime`, etc.).\n */\nexport const SvelteKit = {\n  /**\n   * Fail with a redirect. Equivalent to SvelteKit's `redirect()` but as an\n   * Effect failure instead of a thrown exception.\n   *\n   * @example\n   * ```ts\n   * yield* SvelteKit.redirect(303, \"/login\");\n   * ```\n   */\n  redirect: (\n    status: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308,\n    location: string | URL,\n  ): Effect.Effect<never, KitRedirect> => Effect.fail(new KitRedirect(status, location)),\n\n  /**\n   * Fail with an HTTP error. Equivalent to SvelteKit's `error()` but as an\n   * Effect failure instead of a thrown exception.\n   *\n   * @example\n   * ```ts\n   * yield* SvelteKit.error(404, \"Not found\");\n   * yield* SvelteKit.error(403, { message: \"Forbidden\" });\n   * ```\n   */\n  error: (\n    status: number,\n    body?: string | Record<string, unknown>,\n  ): Effect.Effect<never, KitError> => Effect.fail(new KitError(status, body)),\n\n  /**\n   * Fail with a form-action failure. Equivalent to SvelteKit's `fail()` but as\n   * an Effect failure instead of a return value.\n   *\n   * @example\n   * ```ts\n   * yield* SvelteKit.fail(422, { email: \"already taken\" });\n   * ```\n   */\n  fail: <T extends Record<string, unknown>>(\n    status: number,\n    data: T,\n  ): Effect.Effect<never, KitActionFailure<T>> => Effect.fail(new KitActionFailure(status, data)),\n\n  /**\n   * The turnkey boundary translator. Converts {@link KitRedirect} →\n   * `redirect()`, {@link KitError} → `error()`, {@link KitActionFailure} →\n   * `fail()`, and anything else → `EffectCauseError` (500).\n   *\n   * This is the default `translateError` for every server wrapper. To extend it\n   * with your own domain errors, use {@link SvelteKit.makeTranslator}.\n   */\n  translate: baseTranslate,\n\n  /**\n   * Build a custom boundary translator by prepending domain-error cases before\n   * the Kit base cases.\n   *\n   * Each case function receives the squashed error value. Throw (e.g. call\n   * `error()` / `redirect()` from `@sveltejs/kit`) to handle the case; return\n   * normally to pass through to the next case or the Kit base translator.\n   *\n   * @example\n   * ```ts\n   * import { error } from \"@sveltejs/kit\";\n   *\n   * const translateError = SvelteKit.makeTranslator([\n   *   (e) => { if (e instanceof NotFound) error(404, \"Not found\"); },\n   *   (e) => { if (e instanceof Forbidden) error(403, \"Forbidden\"); },\n   * ]);\n   *\n   * const { serverLoad } = makeRuntimeAdapter(\n   *   RequestRuntime.fromLayer(AppLayer),\n   *   { translateError },\n   * );\n   * ```\n   */\n  makeTranslator:\n    (extraCases: ReadonlyArray<KitTranslatorCase>): KitErrorTranslator =>\n    (cause) => {\n      const squashed = Cause.squash(cause);\n      for (const matcher of extraCases) {\n        matcher(squashed);\n      }\n      return baseTranslate(cause);\n    },\n} as const;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDA,IAAa,cAAb,cAAiC,MAAM;CAI1B;CACA;CAJX,OAAgB;CAEhB,YACE,QACA,UACA;EACA,MAAM,eAAe,OAAO,QAAQ,GAAG;EAH9B,KAAA,SAAA;EACA,KAAA,WAAA;EAGT,KAAK,OAAO;CACd;AACF;;;;;AAMA,IAAa,WAAb,cAA8B,MAAM;CAIvB;CACA;CAJX,OAAgB;CAEhB,YACE,QACA,MACA;EACA,MAAM,QAAQ,QAAQ;EAHb,KAAA,SAAA;EACA,KAAA,OAAA;EAGT,KAAK,OAAO;CACd;AACF;;;;;AAMA,IAAa,mBAAb,cAEU,MAAM;CAIH;CACA;CAJX,OAAgB;CAEhB,YACE,QACA,MACA;EACA,MAAM,kBAAkB,QAAQ;EAHvB,KAAA,SAAA;EACA,KAAA,OAAA;EAGT,KAAK,OAAO;CACd;AACF;AAwBA,MAAM,iBAAqC,UAAU;CACnD,MAAM,WAAW,MAAM,OAAO,KAAK;CAEnC,IAAI,oBAAoB,aAEtB,SAAY,SAAS,QAAQ,SAAS,QAAkB;CAG1D,IAAI,oBAAoB,UAEtB,MAAS,SAAS,QAA0C,SAAS,IAAW;CAGlF,IAAI,oBAAoB,kBAKtB,OAAOA,KAAQ,SAAS,QAAQ,SAAS,IAAI;CAG/C,MAAM,iBAAiB,KAAK;AAC9B;;;;;;;;;;;;;AAgBA,MAAa,YAAY;;;;;;;;;;CAUvB,WACE,QACA,aACsC,OAAO,KAAK,IAAI,YAAY,QAAQ,QAAQ,CAAC;;;;;;;;;;;CAYrF,QACE,QACA,SACmC,OAAO,KAAK,IAAI,SAAS,QAAQ,IAAI,CAAC;;;;;;;;;;CAW3E,OACE,QACA,SAC8C,OAAO,KAAK,IAAI,iBAAiB,QAAQ,IAAI,CAAC;;;;;;;;;CAU9F,WAAW;;;;;;;;;;;;;;;;;;;;;;;;CAyBX,iBACG,gBACA,UAAU;EACT,MAAM,WAAW,MAAM,OAAO,KAAK;EACnC,KAAK,MAAM,WAAW,YACpB,QAAQ,QAAQ;EAElB,OAAO,cAAc,KAAK;CAC5B;AACJ"}

package/dist/realtime.d.ts

@@ -0,0 +1,105 @@
+import { Cause, Stream } from "effect";
+
+//#region src/realtime.d.ts
+declare namespace realtime_d_exports {
+  export { EventSourceConstructor, EventSourceError, FromEventSourceOptions, FromWebSocketOptions, SseMessage, WebSocketConstructor, WebSocketError, fromEventSource, fromWebSocket };
+}
+/** A decoded Server-Sent Event. */
+interface SseMessage {
+  /** The event name (`"message"` for unnamed events). */
+  readonly event: string;
+  /** The event payload (the joined `data:` lines). */
+  readonly data: string;
+  /** The last event id seen, or `""` if none. */
+  readonly lastEventId: string;
+}
+declare const EventSourceError_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] }>) => Cause.YieldableError & {
+  readonly _tag: "EventSourceError";
+} & Readonly<A>;
+/** Raised when an `EventSource` connection fails fatally (its `readyState` is `CLOSED`). */
+declare class EventSourceError extends EventSourceError_base<{
+  readonly url: string;
+}> {}
+/** The subset of the `EventSource` constructor this module relies on. */
+type EventSourceConstructor = new (url: string, eventSourceInitDict?: {
+  withCredentials?: boolean;
+}) => EventSource;
+interface FromEventSourceOptions {
+  /** Send credentials (cookies) with the request. Defaults to `false`. */
+  readonly withCredentials?: boolean;
+  /**
+   * Named events to listen for in addition to the default unnamed `message`
+   * event. An `Endpoint.fromStream({ event: "tick" })` server needs
+   * `events: ["tick"]` here.
+   */
+  readonly events?: ReadonlyArray<string>;
+  /** Buffer size for the backing queue. Defaults to 16. */
+  readonly bufferSize?: number;
+  /** Backpressure strategy when the buffer is full. Defaults to `"sliding"`. */
+  readonly strategy?: "sliding" | "dropping" | "suspend";
+  /** Override the `EventSource` constructor (Node polyfill, tests). */
+  readonly implementation?: EventSourceConstructor;
+}
+/**
+ * Consume a Server-Sent-Events endpoint as a `Stream` of {@link SseMessage}.
+ *
+ * The browser's `EventSource` reconnects automatically after transient drops,
+ * so the stream stays live across reconnects; it fails with
+ * {@link EventSourceError} only when the connection closes fatally.
+ *
+ * @example
+ * ```ts
+ * import { Realtime } from "@thomasfosterau/effect-sveltekit/client";
+ * import { Effect, Stream } from "effect";
+ *
+ * const program = Realtime.fromEventSource("/events", { events: ["tick"] }).pipe(
+ *   Stream.runForEach((msg) => Effect.log(`${msg.event}: ${msg.data}`)),
+ * );
+ * ```
+ */
+declare const fromEventSource: (url: string, options?: FromEventSourceOptions) => Stream.Stream<SseMessage, EventSourceError>;
+declare const WebSocketError_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] }>) => Cause.YieldableError & {
+  readonly _tag: "WebSocketError";
+} & Readonly<A>;
+/** Raised when a `WebSocket` errors or closes uncleanly. */
+declare class WebSocketError extends WebSocketError_base<{
+  readonly url: string;
+  readonly code?: number;
+  readonly reason?: string;
+}> {}
+/** The subset of the `WebSocket` constructor this module relies on. */
+type WebSocketConstructor = new (url: string, protocols?: string | ReadonlyArray<string>) => WebSocket;
+interface FromWebSocketOptions {
+  /** Sub-protocols passed to the `WebSocket` constructor. */
+  readonly protocols?: string | ReadonlyArray<string>;
+  /** `arraybuffer` or `blob` for binary frames. Defaults to the platform default. */
+  readonly binaryType?: BinaryType;
+  /** Buffer size for the backing queue. Defaults to 16. */
+  readonly bufferSize?: number;
+  /** Backpressure strategy when the buffer is full. Defaults to `"suspend"`. */
+  readonly strategy?: "sliding" | "dropping" | "suspend";
+  /** Override the `WebSocket` constructor (Node polyfill, tests). */
+  readonly implementation?: WebSocketConstructor;
+}
+/**
+ * Consume a `WebSocket` as a `Stream` of its message payloads
+ * (`string | ArrayBuffer | Blob`, depending on `binaryType`).
+ *
+ * The stream ends when the socket closes cleanly and fails with
+ * {@link WebSocketError} on an error or unclean close. The socket is closed when
+ * the stream's scope closes.
+ *
+ * @example
+ * ```ts
+ * import { Realtime } from "@thomasfosterau/effect-sveltekit/client";
+ * import { Effect, Stream } from "effect";
+ *
+ * const program = Realtime.fromWebSocket("wss://example.com/ws").pipe(
+ *   Stream.runForEach((data) => Effect.log(String(data))),
+ * );
+ * ```
+ */
+declare const fromWebSocket: (url: string, options?: FromWebSocketOptions) => Stream.Stream<string | ArrayBuffer | Blob, WebSocketError>;
+//#endregion
+export { realtime_d_exports };
+//# sourceMappingURL=realtime.d.ts.map

package/dist/realtime.js

@@ -0,0 +1,111 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { Cause, Data, Effect, Queue, Stream } from "effect";
+//#region src/realtime.ts
+/**
+* Client-side realtime bridges: consume a Server-Sent-Events endpoint or a
+* WebSocket as an Effect `Stream`. The counterpart to `Endpoint.fromStream`
+* (server) on the `@thomasfosterau/effect-sveltekit/client` `Realtime` namespace.
+*
+* These use the browser globals `EventSource` / `WebSocket`; both can be
+* overridden (e.g. a Node polyfill, or a fake in tests) via the `implementation`
+* option. The source is opened when the stream is run and closed when its scope
+* closes, so a `Stream.take` / component teardown tears down the connection.
+*/
+var realtime_exports = /* @__PURE__ */ __exportAll({
+	EventSourceError: () => EventSourceError,
+	WebSocketError: () => WebSocketError,
+	fromEventSource: () => fromEventSource,
+	fromWebSocket: () => fromWebSocket
+});
+/** Raised when an `EventSource` connection fails fatally (its `readyState` is `CLOSED`). */
+var EventSourceError = class extends Data.TaggedError("EventSourceError") {};
+/**
+* Consume a Server-Sent-Events endpoint as a `Stream` of {@link SseMessage}.
+*
+* The browser's `EventSource` reconnects automatically after transient drops,
+* so the stream stays live across reconnects; it fails with
+* {@link EventSourceError} only when the connection closes fatally.
+*
+* @example
+* ```ts
+* import { Realtime } from "@thomasfosterau/effect-sveltekit/client";
+* import { Effect, Stream } from "effect";
+*
+* const program = Realtime.fromEventSource("/events", { events: ["tick"] }).pipe(
+*   Stream.runForEach((msg) => Effect.log(`${msg.event}: ${msg.data}`)),
+* );
+* ```
+*/
+const fromEventSource = (url, options) => {
+	const Impl = options?.implementation ?? globalThis.EventSource;
+	return Stream.callback((queue) => Effect.sync(() => {
+		const source = options?.withCredentials === void 0 ? new Impl(url) : new Impl(url, { withCredentials: options.withCredentials });
+		const onMessage = (e) => {
+			Queue.offerUnsafe(queue, {
+				event: e.type,
+				data: e.data,
+				lastEventId: e.lastEventId
+			});
+		};
+		source.addEventListener("message", onMessage);
+		for (const name of options?.events ?? []) source.addEventListener(name, onMessage);
+		source.addEventListener("error", () => {
+			if (source.readyState === 2) Queue.failCauseUnsafe(queue, Cause.fail(new EventSourceError({ url })));
+		});
+		return Effect.sync(() => source.close());
+	}), {
+		bufferSize: options?.bufferSize ?? 16,
+		strategy: options?.strategy ?? "sliding"
+	});
+};
+/** Raised when a `WebSocket` errors or closes uncleanly. */
+var WebSocketError = class extends Data.TaggedError("WebSocketError") {};
+/**
+* Consume a `WebSocket` as a `Stream` of its message payloads
+* (`string | ArrayBuffer | Blob`, depending on `binaryType`).
+*
+* The stream ends when the socket closes cleanly and fails with
+* {@link WebSocketError} on an error or unclean close. The socket is closed when
+* the stream's scope closes.
+*
+* @example
+* ```ts
+* import { Realtime } from "@thomasfosterau/effect-sveltekit/client";
+* import { Effect, Stream } from "effect";
+*
+* const program = Realtime.fromWebSocket("wss://example.com/ws").pipe(
+*   Stream.runForEach((data) => Effect.log(String(data))),
+* );
+* ```
+*/
+const fromWebSocket = (url, options) => {
+	const Impl = options?.implementation ?? globalThis.WebSocket;
+	return Stream.callback((queue) => Effect.sync(() => {
+		const socket = new Impl(url, options?.protocols);
+		if (options?.binaryType !== void 0) socket.binaryType = options.binaryType;
+		socket.addEventListener("message", (e) => {
+			Queue.offerUnsafe(queue, e.data);
+		});
+		socket.addEventListener("error", () => {
+			Queue.failCauseUnsafe(queue, Cause.fail(new WebSocketError({ url })));
+		});
+		socket.addEventListener("close", (e) => {
+			if (e.wasClean) Queue.endUnsafe(queue);
+			else Queue.failCauseUnsafe(queue, Cause.fail(new WebSocketError({
+				url,
+				code: e.code,
+				reason: e.reason
+			})));
+		});
+		return Effect.sync(() => {
+			if (socket.readyState === 0 || socket.readyState === 1) socket.close();
+		});
+	}), {
+		bufferSize: options?.bufferSize ?? 16,
+		strategy: options?.strategy ?? "suspend"
+	});
+};
+//#endregion
+export { realtime_exports };
+
+//# sourceMappingURL=realtime.js.map