@thomasfosterau/effect-sveltekit 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { Remote_d_exports } from "./Remote.js";
+import { SvelteKitServices, UniversalRuntime, makeUniversalRuntime } from "./app-runtime.js";
+import { load } from "./universal.js";
+import { Hooks_d_exports } from "./Hooks.js";
+import { sveltekitConfig, sveltekitConfigProvider } from "./config.js";
+export { Hooks_d_exports as Hooks, Remote_d_exports as Remote, type SvelteKitServices, type UniversalRuntime, load, makeUniversalRuntime, sveltekitConfig, sveltekitConfigProvider };

package/dist/index.js

@@ -0,0 +1,6 @@
+import { makeUniversalRuntime } from "./app-runtime.js";
+import { load } from "./universal.js";
+import { Remote_exports } from "./Remote.js";
+import { Hooks_exports } from "./Hooks.js";
+import { sveltekitConfig, sveltekitConfigProvider } from "./config.js";
+export { Hooks_exports as Hooks, Remote_exports as Remote, load, makeUniversalRuntime, sveltekitConfig, sveltekitConfigProvider };

package/dist/internal/app-state.d.ts

@@ -0,0 +1,39 @@
+import { Stream } from "effect";
+
+//#region src/internal/app-state.d.ts
+/**
+ * The fields of SvelteKit's `page` we snapshot. Mirrors the shape of
+ * `@sveltejs/kit`'s `Page`, but as a plain readonly record rather than the live
+ * mutating proxy.
+ */
+interface PageSnapshot<P extends ReadonlyPage = ReadonlyPage> {
+  readonly url: P["url"];
+  readonly params: P["params"];
+  readonly route: P["route"];
+  readonly status: P["status"];
+  readonly error: P["error"];
+  readonly data: P["data"];
+  readonly state: P["state"];
+  readonly form: P["form"];
+}
+/**
+ * The subset of `Page` fields the snapshot reads. Deliberately loose (the value
+ * types are `unknown` / broad) so SvelteKit's `Page` — whose `params` / `data`
+ * / `error` / `state` are app-specific — satisfies the constraint, while
+ * `PageSnapshot<P>` recovers the precise field types from `P`.
+ */
+interface ReadonlyPage {
+  readonly url: URL;
+  readonly params: Record<string, string | undefined>;
+  readonly route: {
+    readonly id: string | null;
+  };
+  readonly status: number;
+  readonly error: unknown;
+  readonly data: Record<string, unknown>;
+  readonly state: unknown;
+  readonly form: unknown;
+}
+//#endregion
+export { PageSnapshot };
+//# sourceMappingURL=app-state.d.ts.map

package/dist/internal/app-state.js

@@ -0,0 +1,52 @@
+import { Effect, Queue, Stream } from "effect";
+//#region src/internal/app-state.ts
+/**
+* Pure, `$app/*`-free core for the `$app/state` bridge in `../State.ts`.
+*
+* The public `page` can't be unit-tested directly because importing it
+* pulls in `$app/navigation` and `$app/state` (SvelteKit virtual modules that
+* only exist inside a build). The snapshotting and the "emit now, then after
+* each navigation" plumbing live here instead, parameterised over the
+* navigation registrar and a `readPage` thunk, so they can be driven with
+* stand-ins in tests while the public wrapper stays a thin pass-through.
+*
+* @internal
+*/
+/**
+* Builds a shallow snapshot of the `page` fields that matter. We copy the
+* fields rather than forwarding the live `$app/state` proxy so downstream Effect
+* consumers see a stable value (the proxy mutates in place on every
+* navigation, which would make a captured reference unreliable). Nested values
+* (`url`, `data`, ...) are *not* deep-cloned: they're replaced wholesale on each
+* navigation, so a shallow copy is enough to distinguish snapshots.
+*/
+function snapshotPage(page) {
+	return {
+		url: page.url,
+		params: page.params,
+		route: page.route,
+		status: page.status,
+		error: page.error,
+		data: page.data,
+		state: page.state,
+		form: page.form
+	};
+}
+/**
+* Emits a snapshot of `readPage()` immediately, then again every time
+* `registerAfterNavigate`'s callback fires (i.e. after each navigation). Backed
+* by an unbounded queue, exposed as a `Stream` — the same push bridge as the
+* navigation-event helpers.
+*/
+function pageSnapshotStream(registerAfterNavigate, readPage) {
+	const queue = Effect.runSync(Queue.unbounded());
+	Queue.offerUnsafe(queue, snapshotPage(readPage()));
+	registerAfterNavigate(() => {
+		Queue.offerUnsafe(queue, snapshotPage(readPage()));
+	});
+	return Stream.fromQueue(queue);
+}
+//#endregion
+export { pageSnapshotStream };
+
+//# sourceMappingURL=app-state.js.map

package/dist/internal/app-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-state.js","names":[],"sources":["../../src/internal/app-state.ts"],"sourcesContent":["/**\n * Pure, `$app/*`-free core for the `$app/state` bridge in `../State.ts`.\n *\n * The public `page` can't be unit-tested directly because importing it\n * pulls in `$app/navigation` and `$app/state` (SvelteKit virtual modules that\n * only exist inside a build). The snapshotting and the \"emit now, then after\n * each navigation\" plumbing live here instead, parameterised over the\n * navigation registrar and a `readPage` thunk, so they can be driven with\n * stand-ins in tests while the public wrapper stays a thin pass-through.\n *\n * @internal\n */\n\nimport { Effect, Queue, Stream } from \"effect\";\n\n/**\n * The fields of SvelteKit's `page` we snapshot. Mirrors the shape of\n * `@sveltejs/kit`'s `Page`, but as a plain readonly record rather than the live\n * mutating proxy.\n */\nexport interface PageSnapshot<P extends ReadonlyPage = ReadonlyPage> {\n  readonly url: P[\"url\"];\n  readonly params: P[\"params\"];\n  readonly route: P[\"route\"];\n  readonly status: P[\"status\"];\n  readonly error: P[\"error\"];\n  readonly data: P[\"data\"];\n  readonly state: P[\"state\"];\n  readonly form: P[\"form\"];\n}\n\n/**\n * The subset of `Page` fields the snapshot reads. Deliberately loose (the value\n * types are `unknown` / broad) so SvelteKit's `Page` — whose `params` / `data`\n * / `error` / `state` are app-specific — satisfies the constraint, while\n * `PageSnapshot<P>` recovers the precise field types from `P`.\n */\nexport interface ReadonlyPage {\n  readonly url: URL;\n  readonly params: Record<string, string | undefined>;\n  readonly route: { readonly id: string | null };\n  readonly status: number;\n  readonly error: unknown;\n  readonly data: Record<string, unknown>;\n  readonly state: unknown;\n  readonly form: unknown;\n}\n\n/**\n * Builds a shallow snapshot of the `page` fields that matter. We copy the\n * fields rather than forwarding the live `$app/state` proxy so downstream Effect\n * consumers see a stable value (the proxy mutates in place on every\n * navigation, which would make a captured reference unreliable). Nested values\n * (`url`, `data`, ...) are *not* deep-cloned: they're replaced wholesale on each\n * navigation, so a shallow copy is enough to distinguish snapshots.\n */\nexport function snapshotPage<P extends ReadonlyPage>(page: P): PageSnapshot<P> {\n  return {\n    url: page.url,\n    params: page.params,\n    route: page.route,\n    status: page.status,\n    error: page.error,\n    data: page.data,\n    state: page.state,\n    form: page.form,\n  };\n}\n\n/**\n * Emits a snapshot of `readPage()` immediately, then again every time\n * `registerAfterNavigate`'s callback fires (i.e. after each navigation). Backed\n * by an unbounded queue, exposed as a `Stream` — the same push bridge as the\n * navigation-event helpers.\n */\nexport function pageSnapshotStream<P extends ReadonlyPage>(\n  registerAfterNavigate: (callback: () => void) => void,\n  readPage: () => P,\n): Stream.Stream<PageSnapshot<P>> {\n  const queue = Effect.runSync(Queue.unbounded<PageSnapshot<P>>());\n  // Initial value: the current page, so consumers start from a known state.\n  Queue.offerUnsafe(queue, snapshotPage(readPage()));\n  // afterNavigate fires once on mount too, but emitting up front means a\n  // late-subscribing consumer still sees the current page without waiting for a\n  // navigation.\n  registerAfterNavigate(() => {\n    Queue.offerUnsafe(queue, snapshotPage(readPage()));\n  });\n  return Stream.fromQueue(queue);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAwDA,SAAgB,aAAqC,MAA0B;CAC7E,OAAO;EACL,KAAK,KAAK;EACV,QAAQ,KAAK;EACb,OAAO,KAAK;EACZ,QAAQ,KAAK;EACb,OAAO,KAAK;EACZ,MAAM,KAAK;EACX,OAAO,KAAK;EACZ,MAAM,KAAK;CACb;AACF;;;;;;;AAQA,SAAgB,mBACd,uBACA,UACgC;CAChC,MAAM,QAAQ,OAAO,QAAQ,MAAM,UAA2B,CAAC;CAE/D,MAAM,YAAY,OAAO,aAAa,SAAS,CAAC,CAAC;CAIjD,4BAA4B;EAC1B,MAAM,YAAY,OAAO,aAAa,SAAS,CAAC,CAAC;CACnD,CAAC;CACD,OAAO,OAAO,UAAU,KAAK;AAC/B"}

package/dist/internal/auto.d.ts

@@ -0,0 +1,70 @@
+import { ServerRuntime, UniversalRuntime } from "../app-runtime.js";
+import { Effect } from "effect";
+import { Action, Actions, Handle, HandleClientError, HandleFetch, HandleServerError, Load, RequestEvent, Reroute, ServerLoad } from "@sveltejs/kit";
+
+//#region src/internal/auto.d.ts
+type AnyEffect = Effect.Effect<unknown, unknown, never>;
+type AnyRuntime = ServerRuntime<any, any> | UniversalRuntime<any, any>;
+/**
+ * Module shape accepted for the plugin's `serverRuntime` / `clientRuntime`
+ * options: the runtime can be the default export or a named `runtime` export.
+ */
+interface RuntimeModule {
+  readonly runtime?: AnyRuntime;
+  readonly default?: AnyRuntime;
+}
+type LoadLikeInput = undefined | AnyEffect | ((event: any) => unknown);
+/**
+ * Wraps a value intended to be a SvelteKit universal `load` export.
+ * Used by the Vite plugin for `+page.ts` / `+layout.ts`.
+ */
+declare function wrapLoad<T extends LoadLikeInput>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : Load;
+/**
+ * Wraps a value intended to be a SvelteKit server `load` export.
+ * Used by the Vite plugin for `+page.server.ts` / `+layout.server.ts`.
+ */
+declare function wrapServerLoad<T extends LoadLikeInput>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : ServerLoad;
+/**
+ * Wraps a single SvelteKit action handler.
+ */
+declare function wrapAction<T extends LoadLikeInput>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : Action;
+/**
+ * Wraps a SvelteKit `actions` object, individually wrapping each entry.
+ */
+declare function wrapActions<T extends Record<string, LoadLikeInput> | undefined>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : Actions;
+/**
+ * Wraps a SvelteKit `handle` hook export.
+ */
+declare function wrapHandle<T extends undefined | AnyEffect | ((args: Parameters<Handle>[0]) => unknown)>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : Handle;
+/**
+ * Wraps a SvelteKit `handleFetch` hook export.
+ */
+declare function wrapHandleFetch<T extends undefined | AnyEffect | ((args: Parameters<HandleFetch>[0]) => unknown)>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : HandleFetch;
+type AnyHandleError = HandleServerError | HandleClientError;
+/**
+ * Wraps a SvelteKit `handleError` hook export.
+ */
+declare function wrapHandleError<T extends undefined | AnyEffect | ((args: Parameters<AnyHandleError>[0]) => unknown)>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : AnyHandleError;
+/**
+ * Wraps a SvelteKit HTTP endpoint export (`GET`, `POST`, etc.).
+ * Errors thrown by the underlying Effect propagate to SvelteKit's normal
+ * error-handling pipeline (i.e. they are not silently swallowed). Use the
+ * explicit `endpoint()` helper if you need the `exposeErrors` toggle.
+ */
+declare function wrapEndpoint<T extends undefined | AnyEffect | ((event: RequestEvent) => unknown)>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : (event: RequestEvent) => Response | Promise<Response>;
+type RerouteEvent = Parameters<Reroute>[0];
+/**
+ * Wraps a SvelteKit universal `reroute` hook export. The effect runs on the
+ * universal runtime with an `HttpClient` backed by the event's `fetch`, on both
+ * the server and the client.
+ */
+declare function wrapReroute<T extends undefined | AnyEffect | ((event: RerouteEvent) => unknown)>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : Reroute;
+/**
+ * Wraps a SvelteKit `init` hook export (server or client).
+ * `init` runs once at startup; there is no request event available, but the
+ * application runtime's services (if configured) are.
+ */
+declare function wrapInit<T extends undefined | AnyEffect | (() => unknown)>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : () => Promise<void>;
+//#endregion
+export { RuntimeModule, wrapAction, wrapActions, wrapEndpoint, wrapHandle, wrapHandleError, wrapHandleFetch, wrapInit, wrapLoad, wrapReroute, wrapServerLoad };
+//# sourceMappingURL=auto.d.ts.map

package/dist/internal/auto.js

@@ -0,0 +1,161 @@
+import { causeToThrowable } from "./error.js";
+import { makeServerRuntime, makeUniversalRuntime } from "../app-runtime.js";
+import { Effect, Exit } from "effect";
+//#region src/internal/auto.ts
+let defaultServerRuntime;
+let defaultUniversalRuntime;
+/** Extract the runtime from a runtime module, if any. */
+const runtimeOfModule = (mod) => mod?.runtime ?? mod?.default;
+/** Distinguish a ServerRuntime from a UniversalRuntime structurally. */
+const isServerRuntime = (runtime) => "serverLoad" in runtime;
+/** The server runtime for a module, falling back to the shared default. */
+const serverRuntimeOf = (mod) => {
+	const runtime = runtimeOfModule(mod);
+	if (runtime !== void 0 && isServerRuntime(runtime)) return runtime;
+	return defaultServerRuntime ??= makeServerRuntime();
+};
+/** The universal runtime for a module, falling back to the shared default. */
+const universalRuntimeOf = (mod) => {
+	const runtime = runtimeOfModule(mod);
+	if (runtime !== void 0 && !isServerRuntime(runtime)) return runtime;
+	return defaultUniversalRuntime ??= makeUniversalRuntime();
+};
+/** Run an effect without any request context (e.g. `init` hooks). */
+async function runBare(effect, runtime) {
+	const exit = runtime ? await runtime.runtime.runPromiseExit(effect) : await Effect.runPromiseExit(effect);
+	return Exit.match(exit, {
+		onFailure: (cause) => {
+			throw causeToThrowable(cause);
+		},
+		onSuccess: (value) => value
+	});
+}
+function isEffectValue(value) {
+	return Effect.isEffect(value);
+}
+/**
+* Wraps a value intended to be a SvelteKit universal `load` export.
+* Used by the Vite plugin for `+page.ts` / `+layout.ts`.
+*/
+function wrapLoad(value, runtimeMod) {
+	if (value === void 0) return void 0;
+	return (async (event) => {
+		const result = isEffectValue(value) ? value : value(event);
+		if (!isEffectValue(result)) return result;
+		return universalRuntimeOf(runtimeMod).load(() => result)(event);
+	});
+}
+/** Shared implementation for server-side, event-based wrappers. */
+function wrapServerEvent(value, runtimeMod) {
+	if (value === void 0) return void 0;
+	return async (event) => {
+		const result = isEffectValue(value) ? value : value(event);
+		if (!isEffectValue(result)) return result;
+		return serverRuntimeOf(runtimeMod).runPromise(event, result);
+	};
+}
+/**
+* Wraps a value intended to be a SvelteKit server `load` export.
+* Used by the Vite plugin for `+page.server.ts` / `+layout.server.ts`.
+*/
+function wrapServerLoad(value, runtimeMod) {
+	return wrapServerEvent(value, runtimeMod);
+}
+/**
+* Wraps a single SvelteKit action handler.
+*/
+function wrapAction(value, runtimeMod) {
+	return wrapServerEvent(value, runtimeMod);
+}
+/**
+* Wraps a SvelteKit `actions` object, individually wrapping each entry.
+*/
+function wrapActions(value, runtimeMod) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "object" || value === null) return value;
+	const wrapped = {};
+	for (const [key, fn] of Object.entries(value)) {
+		const wrappedAction = wrapAction(fn, runtimeMod);
+		if (wrappedAction !== void 0) wrapped[key] = wrappedAction;
+	}
+	return wrapped;
+}
+/**
+* Wraps a SvelteKit `handle` hook export.
+*/
+function wrapHandle(value, runtimeMod) {
+	if (value === void 0) return void 0;
+	const handle = (input) => {
+		const result = isEffectValue(value) ? value : value(input);
+		if (!isEffectValue(result)) return result;
+		return serverRuntimeOf(runtimeMod).handle(() => result)(input);
+	};
+	return handle;
+}
+/**
+* Wraps a SvelteKit `handleFetch` hook export.
+*/
+function wrapHandleFetch(value, runtimeMod) {
+	if (value === void 0) return void 0;
+	const handleFetch = async (args) => {
+		const result = isEffectValue(value) ? value : value(args);
+		if (!isEffectValue(result)) return result;
+		return serverRuntimeOf(runtimeMod).runPromise(args.event, result);
+	};
+	return handleFetch;
+}
+/**
+* Wraps a SvelteKit `handleError` hook export.
+*/
+function wrapHandleError(value, runtimeMod) {
+	if (value === void 0) return void 0;
+	return (async (args) => {
+		const result = isEffectValue(value) ? value : value(args);
+		if (!isEffectValue(result)) return result;
+		const event = args.event;
+		if (event !== void 0 && "request" in event) return serverRuntimeOf(runtimeMod).runPromise(event, result);
+		return runBare(result, runtimeOfModule(runtimeMod));
+	});
+}
+/**
+* Wraps a SvelteKit HTTP endpoint export (`GET`, `POST`, etc.).
+* Errors thrown by the underlying Effect propagate to SvelteKit's normal
+* error-handling pipeline (i.e. they are not silently swallowed). Use the
+* explicit `endpoint()` helper if you need the `exposeErrors` toggle.
+*/
+function wrapEndpoint(value, runtimeMod) {
+	return wrapServerEvent(value, runtimeMod);
+}
+/**
+* Wraps a SvelteKit universal `reroute` hook export. The effect runs on the
+* universal runtime with an `HttpClient` backed by the event's `fetch`, on both
+* the server and the client.
+*/
+function wrapReroute(value, runtimeMod) {
+	if (value === void 0) return void 0;
+	return ((event) => {
+		const result = isEffectValue(value) ? value : value(event);
+		if (!isEffectValue(result)) return result;
+		return universalRuntimeOf(runtimeMod).runPromise(event.fetch, result);
+	});
+}
+/**
+* Wraps a SvelteKit `init` hook export (server or client).
+* `init` runs once at startup; there is no request event available, but the
+* application runtime's services (if configured) are.
+*/
+function wrapInit(value, runtimeMod) {
+	if (value === void 0) return void 0;
+	return (async () => {
+		const result = isEffectValue(value) ? value : value();
+		if (!isEffectValue(result)) {
+			await result;
+			return;
+		}
+		await runBare(result, runtimeOfModule(runtimeMod));
+	});
+}
+//#endregion
+export { wrapAction, wrapActions, wrapEndpoint, wrapHandle, wrapHandleError, wrapHandleFetch, wrapInit, wrapLoad, wrapReroute, wrapServerLoad };
+
+//# sourceMappingURL=auto.js.map

package/dist/internal/auto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto.js","names":[],"sources":["../../src/internal/auto.ts"],"sourcesContent":["/**\n * Runtime auto-wrappers used by the SvelteKit Vite plugin.\n *\n * The plugin replaces user-declared SvelteKit exports (`load`, `actions`,\n * `handle`, HTTP method handlers, etc.) with calls into the helpers in this\n * module. At runtime each helper detects whether the underlying value is an\n * Effect, a function returning an Effect, or a plain SvelteKit-compatible\n * function/value, and routes accordingly.\n *\n * When the plugin is configured with a `serverRuntime` / `clientRuntime`\n * module, that module's app-wide runtime (created with `makeServerRuntime` /\n * `makeUniversalRuntime`) is passed as the second argument to these helpers,\n * so plain-Effect exports get access to the application's services.\n *\n * This module is internal — the public Vite plugin generates references to it.\n */\n\nimport type {\n  Action,\n  Actions,\n  Handle,\n  HandleClientError,\n  HandleFetch,\n  HandleServerError,\n  Load,\n  RequestEvent,\n  Reroute,\n  ServerLoad,\n} from \"@sveltejs/kit\";\nimport { Effect, Exit } from \"effect\";\nimport {\n  makeServerRuntime,\n  makeUniversalRuntime,\n  type ServerRuntime,\n  type UniversalRuntime,\n} from \"../app-runtime.js\";\nimport { causeToThrowable } from \"./error.js\";\n\ntype AnyEffect = Effect.Effect<unknown, unknown, never>;\n\ntype AnyRuntime = ServerRuntime<any, any> | UniversalRuntime<any, any>;\n\n/**\n * Module shape accepted for the plugin's `serverRuntime` / `clientRuntime`\n * options: the runtime can be the default export or a named `runtime` export.\n */\nexport interface RuntimeModule {\n  readonly runtime?: AnyRuntime;\n  readonly default?: AnyRuntime;\n}\n\n// Default runtimes (no application layer), created lazily and shared across\n// all requests in the process.\nlet defaultServerRuntime: ServerRuntime<any, any> | undefined;\nlet defaultUniversalRuntime: UniversalRuntime<any, any> | undefined;\n\n/** Extract the runtime from a runtime module, if any. */\nconst runtimeOfModule = (mod?: RuntimeModule): AnyRuntime | undefined =>\n  mod?.runtime ?? mod?.default;\n\n/** Distinguish a ServerRuntime from a UniversalRuntime structurally. */\nconst isServerRuntime = (runtime: AnyRuntime): runtime is ServerRuntime<any, any> =>\n  \"serverLoad\" in runtime;\n\n/** The server runtime for a module, falling back to the shared default. */\nconst serverRuntimeOf = (mod?: RuntimeModule): ServerRuntime<any, any> => {\n  const runtime = runtimeOfModule(mod);\n  if (runtime !== undefined && isServerRuntime(runtime)) return runtime;\n  return (defaultServerRuntime ??= makeServerRuntime<any, any>());\n};\n\n/** The universal runtime for a module, falling back to the shared default. */\nconst universalRuntimeOf = (mod?: RuntimeModule): UniversalRuntime<any, any> => {\n  const runtime = runtimeOfModule(mod);\n  if (runtime !== undefined && !isServerRuntime(runtime)) return runtime;\n  return (defaultUniversalRuntime ??= makeUniversalRuntime<any, any>());\n};\n\n/** Run an effect without any request context (e.g. `init` hooks). */\nasync function runBare(effect: AnyEffect, runtime?: AnyRuntime): Promise<unknown> {\n  const exit = runtime\n    ? ((await runtime.runtime.runPromiseExit(effect)) as Exit.Exit<unknown, unknown>)\n    : await Effect.runPromiseExit(effect);\n\n  return Exit.match(exit, {\n    onFailure: (cause) => {\n      throw causeToThrowable(cause);\n    },\n    onSuccess: (value) => value,\n  });\n}\n\nfunction isEffectValue(value: unknown): value is AnyEffect {\n  return Effect.isEffect(value as never);\n}\n\ntype LoadLikeInput = undefined | AnyEffect | ((event: any) => unknown);\n\n/**\n * Wraps a value intended to be a SvelteKit universal `load` export.\n * Used by the Vite plugin for `+page.ts` / `+layout.ts`.\n */\nexport function wrapLoad<T extends LoadLikeInput>(\n  value: T,\n  runtimeMod?: RuntimeModule,\n): T extends undefined ? undefined : Load {\n  if (value === undefined) return undefined as never;\n\n  return (async (event: Parameters<Load>[0]) => {\n    const result = isEffectValue(value) ? value : (value as (event: unknown) => unknown)(event);\n    if (!isEffectValue(result)) return result;\n\n    // Reuse the universal runtime's load wrapper so client/server detection\n    // and per-request services stay in one place.\n    return universalRuntimeOf(runtimeMod).load(\n      () => result as Effect.Effect<Record<string, unknown>, unknown, never>,\n    )(event);\n  }) as never;\n}\n\n/** Shared implementation for server-side, event-based wrappers. */\nfunction wrapServerEvent<T extends LoadLikeInput>(\n  value: T,\n  runtimeMod?: RuntimeModule,\n): undefined | ((event: RequestEvent) => Promise<unknown>) {\n  if (value === undefined) return undefined;\n\n  return async (event: RequestEvent) => {\n    const result = isEffectValue(value)\n      ? value\n      : (value as (event: RequestEvent) => unknown)(event);\n    if (!isEffectValue(result)) return result;\n\n    return serverRuntimeOf(runtimeMod).runPromise(event, result);\n  };\n}\n\n/**\n * Wraps a value intended to be a SvelteKit server `load` export.\n * Used by the Vite plugin for `+page.server.ts` / `+layout.server.ts`.\n */\nexport function wrapServerLoad<T extends LoadLikeInput>(\n  value: T,\n  runtimeMod?: RuntimeModule,\n): T extends undefined ? undefined : ServerLoad {\n  return wrapServerEvent(value, runtimeMod) as never;\n}\n\n/**\n * Wraps a single SvelteKit action handler.\n */\nexport function wrapAction<T extends LoadLikeInput>(\n  value: T,\n  runtimeMod?: RuntimeModule,\n): T extends undefined ? undefined : Action {\n  return wrapServerEvent(value, runtimeMod) as never;\n}\n\n/**\n * Wraps a SvelteKit `actions` object, individually wrapping each entry.\n */\nexport function wrapActions<T extends Record<string, LoadLikeInput> | undefined>(\n  value: T,\n  runtimeMod?: RuntimeModule,\n): T extends undefined ? undefined : Actions {\n  if (value === undefined) return undefined as never;\n  if (typeof value !== \"object\" || value === null) return value as never;\n\n  const wrapped: Actions = {};\n  for (const [key, fn] of Object.entries(value)) {\n    const wrappedAction = wrapAction(fn as LoadLikeInput, runtimeMod);\n    if (wrappedAction !== undefined) {\n      wrapped[key] = wrappedAction;\n    }\n  }\n  return wrapped as never;\n}\n\n/**\n * Wraps a SvelteKit `handle` hook export.\n */\nexport function wrapHandle<\n  T extends undefined | AnyEffect | ((args: Parameters<Handle>[0]) => unknown),\n>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : Handle {\n  if (value === undefined) return undefined as never;\n\n  const handle: Handle = (input) => {\n    const result = isEffectValue(value)\n      ? value\n      : (value as (args: Parameters<Handle>[0]) => unknown)(input);\n    if (!isEffectValue(result)) return result as Response | Promise<Response>;\n\n    // Route through `handle` so the per-request runtime is installed on\n    // `event.locals` for the rest of the request, like the explicit wrapper.\n    return serverRuntimeOf(runtimeMod).handle(\n      () => result as Effect.Effect<Response, unknown, never>,\n    )(input) as Promise<Response>;\n  };\n  return handle as never;\n}\n\n/**\n * Wraps a SvelteKit `handleFetch` hook export.\n */\nexport function wrapHandleFetch<\n  T extends undefined | AnyEffect | ((args: Parameters<HandleFetch>[0]) => unknown),\n>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : HandleFetch {\n  if (value === undefined) return undefined as never;\n\n  const handleFetch: HandleFetch = async (args) => {\n    const result = isEffectValue(value)\n      ? value\n      : (value as (args: Parameters<HandleFetch>[0]) => unknown)(args);\n    if (!isEffectValue(result)) return result as Response | Promise<Response>;\n\n    return serverRuntimeOf(runtimeMod).runPromise(args.event, result) as Promise<Response>;\n  };\n  return handleFetch as never;\n}\n\ntype AnyHandleError = HandleServerError | HandleClientError;\n\n/**\n * Wraps a SvelteKit `handleError` hook export.\n */\nexport function wrapHandleError<\n  T extends undefined | AnyEffect | ((args: Parameters<AnyHandleError>[0]) => unknown),\n>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : AnyHandleError {\n  if (value === undefined) return undefined as never;\n\n  return (async (args: Parameters<AnyHandleError>[0]) => {\n    const result = isEffectValue(value)\n      ? value\n      : (value as (args: Parameters<AnyHandleError>[0]) => unknown)(args);\n    if (!isEffectValue(result)) return result as ReturnType<AnyHandleError>;\n\n    // Server errors carry a RequestEvent; client errors carry a NavigationEvent.\n    const event = (args as { event?: RequestEvent }).event;\n    const isServerEvent = event !== undefined && \"request\" in event;\n\n    if (isServerEvent) {\n      return serverRuntimeOf(runtimeMod).runPromise(event, result) as ReturnType<AnyHandleError>;\n    }\n\n    // Client-side: run on the bare app runtime (no request services).\n    return runBare(result, runtimeOfModule(runtimeMod)) as ReturnType<AnyHandleError>;\n  }) as never;\n}\n\n/**\n * Wraps a SvelteKit HTTP endpoint export (`GET`, `POST`, etc.).\n * Errors thrown by the underlying Effect propagate to SvelteKit's normal\n * error-handling pipeline (i.e. they are not silently swallowed). Use the\n * explicit `endpoint()` helper if you need the `exposeErrors` toggle.\n */\nexport function wrapEndpoint<T extends undefined | AnyEffect | ((event: RequestEvent) => unknown)>(\n  value: T,\n  runtimeMod?: RuntimeModule,\n): T extends undefined ? undefined : (event: RequestEvent) => Response | Promise<Response> {\n  return wrapServerEvent(value as LoadLikeInput, runtimeMod) as never;\n}\n\ntype RerouteEvent = Parameters<Reroute>[0];\n\n/**\n * Wraps a SvelteKit universal `reroute` hook export. The effect runs on the\n * universal runtime with an `HttpClient` backed by the event's `fetch`, on both\n * the server and the client.\n */\nexport function wrapReroute<T extends undefined | AnyEffect | ((event: RerouteEvent) => unknown)>(\n  value: T,\n  runtimeMod?: RuntimeModule,\n): T extends undefined ? undefined : Reroute {\n  if (value === undefined) return undefined as never;\n\n  return ((event: RerouteEvent) => {\n    const result = isEffectValue(value)\n      ? value\n      : (value as (event: RerouteEvent) => unknown)(event);\n    if (!isEffectValue(result)) return result as ReturnType<Reroute>;\n\n    return universalRuntimeOf(runtimeMod).runPromise(event.fetch, result) as ReturnType<Reroute>;\n  }) as never;\n}\n\n/**\n * Wraps a SvelteKit `init` hook export (server or client).\n * `init` runs once at startup; there is no request event available, but the\n * application runtime's services (if configured) are.\n */\nexport function wrapInit<T extends undefined | AnyEffect | (() => unknown)>(\n  value: T,\n  runtimeMod?: RuntimeModule,\n): T extends undefined ? undefined : () => Promise<void> {\n  if (value === undefined) return undefined as never;\n\n  return (async () => {\n    const result = isEffectValue(value) ? value : (value as () => unknown)();\n    if (!isEffectValue(result)) {\n      await result;\n      return;\n    }\n    await runBare(result, runtimeOfModule(runtimeMod));\n  }) as never;\n}\n"],"mappings":"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"}

package/dist/internal/default-runtime.js

@@ -0,0 +1,21 @@
+import { makeServerRuntime, makeUniversalRuntime } from "../app-runtime.js";
+//#region src/internal/default-runtime.ts
+/**
+* Lazily-created default runtimes (no application layer) backing the package's
+* standalone helpers — the `serverLoad` / `action` / `load` wrappers and the
+* `Hooks` namespaces.
+*
+* They live in their own module so the entry points (`server.ts`,
+* `universal.ts`) and the `Hooks` modules they re-export can all share a single
+* instance without importing one another (which would be circular).
+*/
+let serverRuntime;
+/** The shared default server runtime, created on first use. */
+const defaultServerRuntime = () => serverRuntime ??= makeServerRuntime();
+let universalRuntime;
+/** The shared default universal runtime, created on first use. */
+const defaultUniversalRuntime = () => universalRuntime ??= makeUniversalRuntime();
+//#endregion
+export { defaultServerRuntime, defaultUniversalRuntime };
+
+//# sourceMappingURL=default-runtime.js.map

package/dist/internal/default-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-runtime.js","names":[],"sources":["../../src/internal/default-runtime.ts"],"sourcesContent":["/**\n * Lazily-created default runtimes (no application layer) backing the package's\n * standalone helpers — the `serverLoad` / `action` / `load` wrappers and the\n * `Hooks` namespaces.\n *\n * They live in their own module so the entry points (`server.ts`,\n * `universal.ts`) and the `Hooks` modules they re-export can all share a single\n * instance without importing one another (which would be circular).\n */\n\nimport {\n  makeServerRuntime,\n  makeUniversalRuntime,\n  type ServerRuntime,\n  type UniversalRuntime,\n} from \"../app-runtime.js\";\n\nlet serverRuntime: ServerRuntime | undefined;\n/** The shared default server runtime, created on first use. */\nexport const defaultServerRuntime = (): ServerRuntime => (serverRuntime ??= makeServerRuntime());\n\nlet universalRuntime: UniversalRuntime | undefined;\n/** The shared default universal runtime, created on first use. */\nexport const defaultUniversalRuntime = (): UniversalRuntime =>\n  (universalRuntime ??= makeUniversalRuntime());\n"],"mappings":";;;;;;;;;;;AAiBA,IAAI;;AAEJ,MAAa,6BAA6C,kBAAkB,kBAAkB;AAE9F,IAAI;;AAEJ,MAAa,gCACV,qBAAqB,qBAAqB"}

package/dist/internal/error.js

@@ -0,0 +1,31 @@
+import { Cause } from "effect";
+import { isHttpError, isRedirect } from "@sveltejs/kit";
+//#region src/internal/error.ts
+/**
+* Custom error type that preserves the original Effect Cause.
+*/
+var EffectCauseError = class extends Error {
+	constructor(message, cause) {
+		super(message);
+		this.name = "EffectCauseError";
+		this.cause = cause;
+	}
+};
+/**
+* Converts a failed Effect Cause into the value to `throw`.
+*
+* SvelteKit uses thrown `redirect()` and `error()` objects for control flow.
+* When one of those is raised inside an Effect (either thrown, surfacing as a
+* defect, or used as a typed failure) the original object is rethrown so
+* SvelteKit can handle it as intended. Anything else is wrapped in an
+* `EffectCauseError` that preserves the full Cause for debugging.
+*/
+const causeToThrowable = (cause) => {
+	const squashed = Cause.squash(cause);
+	if (isRedirect(squashed) || isHttpError(squashed)) return squashed;
+	return new EffectCauseError(Cause.pretty(cause), cause);
+};
+//#endregion
+export { causeToThrowable };
+
+//# sourceMappingURL=error.js.map

package/dist/internal/error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.js","names":[],"sources":["../../src/internal/error.ts"],"sourcesContent":["import { isHttpError, isRedirect } from \"@sveltejs/kit\";\nimport { Cause } from \"effect\";\n\n/**\n * Custom error type that preserves the original Effect Cause.\n */\nexport class EffectCauseError extends Error {\n  declare cause: Cause.Cause<unknown>;\n\n  constructor(message: string, cause: Cause.Cause<unknown>) {\n    super(message);\n    this.name = \"EffectCauseError\";\n    this.cause = cause;\n  }\n}\n\n/**\n * Converts a failed Effect Cause into the value to `throw`.\n *\n * SvelteKit uses thrown `redirect()` and `error()` objects for control flow.\n * When one of those is raised inside an Effect (either thrown, surfacing as a\n * defect, or used as a typed failure) the original object is rethrown so\n * SvelteKit can handle it as intended. Anything else is wrapped in an\n * `EffectCauseError` that preserves the full Cause for debugging.\n */\nexport const causeToThrowable = (cause: Cause.Cause<unknown>): unknown => {\n  const squashed = Cause.squash(cause);\n  if (isRedirect(squashed) || isHttpError(squashed)) {\n    return squashed;\n  }\n  return new EffectCauseError(Cause.pretty(cause), cause);\n};\n"],"mappings":";;;;;;AAMA,IAAa,mBAAb,cAAsC,MAAM;CAG1C,YAAY,SAAiB,OAA6B;EACxD,MAAM,OAAO;EACb,KAAK,OAAO;EACZ,KAAK,QAAQ;CACf;AACF;;;;;;;;;;AAWA,MAAa,oBAAoB,UAAyC;CACxE,MAAM,WAAW,MAAM,OAAO,KAAK;CACnC,IAAI,WAAW,QAAQ,KAAK,YAAY,QAAQ,GAC9C,OAAO;CAET,OAAO,IAAI,iBAAiB,MAAM,OAAO,KAAK,GAAG,KAAK;AACxD"}

package/dist/internal/navigation-events.js

@@ -0,0 +1,41 @@
+import { Effect, Queue, Stream } from "effect";
+//#region src/internal/navigation-events.ts
+/**
+* Pure, `$app/navigation`-free core for the navigation-event bridge in
+* `../Navigation.ts`.
+*
+* The public helpers can't be unit-tested directly because importing them pulls
+* in `$app/navigation` (a SvelteKit virtual module that only exists inside a
+* build). The queue → stream plumbing and the run-per-navigation + cleanup
+* forwarding live here instead, parameterised over the callback registrar, so
+* they can be driven with a stand-in registrar in tests while the public
+* wrappers stay a thin pass-through of SvelteKit's real functions.
+*
+* @internal
+*/
+/**
+* Registers `register`'s callback against a fresh unbounded queue and exposes
+* that queue as a `Stream`. The callback is wired synchronously (so the public
+* wrappers register during component init, where `$app/navigation` requires);
+* each value offered through it is later yielded by the stream.
+*/
+function registeredStream(register) {
+	const queue = Effect.runSync(Queue.unbounded());
+	register((value) => {
+		Queue.offerUnsafe(queue, value);
+	});
+	return Stream.fromQueue(queue);
+}
+/**
+* Registers `register`'s callback so that each navigation runs `fn` via
+* `runEffect`, forwarding any cleanup function the resolved Effect produces back
+* to the registrar (SvelteKit awaits it before completing the navigation and
+* runs the returned cleanup once the DOM has updated).
+*/
+function onNavigateWith(register, fn, runEffect) {
+	register((navigation) => runEffect(fn(navigation)));
+}
+//#endregion
+export { onNavigateWith, registeredStream };
+
+//# sourceMappingURL=navigation-events.js.map

package/dist/internal/navigation-events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation-events.js","names":[],"sources":["../../src/internal/navigation-events.ts"],"sourcesContent":["/**\n * Pure, `$app/navigation`-free core for the navigation-event bridge in\n * `../Navigation.ts`.\n *\n * The public helpers can't be unit-tested directly because importing them pulls\n * in `$app/navigation` (a SvelteKit virtual module that only exists inside a\n * build). The queue → stream plumbing and the run-per-navigation + cleanup\n * forwarding live here instead, parameterised over the callback registrar, so\n * they can be driven with a stand-in registrar in tests while the public\n * wrappers stay a thin pass-through of SvelteKit's real functions.\n *\n * @internal\n */\n\nimport { Effect, Queue, Stream } from \"effect\";\n\n/**\n * Registers `register`'s callback against a fresh unbounded queue and exposes\n * that queue as a `Stream`. The callback is wired synchronously (so the public\n * wrappers register during component init, where `$app/navigation` requires);\n * each value offered through it is later yielded by the stream.\n */\nexport function registeredStream<A>(\n  register: (callback: (value: A) => void) => void,\n): Stream.Stream<A> {\n  const queue = Effect.runSync(Queue.unbounded<A>());\n  register((value) => {\n    Queue.offerUnsafe(queue, value);\n  });\n  return Stream.fromQueue(queue);\n}\n\n/**\n * Registers `register`'s callback so that each navigation runs `fn` via\n * `runEffect`, forwarding any cleanup function the resolved Effect produces back\n * to the registrar (SvelteKit awaits it before completing the navigation and\n * runs the returned cleanup once the DOM has updated).\n */\nexport function onNavigateWith<A>(\n  register: (callback: (value: A) => Promise<(() => void) | void> | (() => void) | void) => void,\n  fn: (navigation: A) => Effect.Effect<(() => void) | void>,\n  runEffect: <X>(effect: Effect.Effect<X>) => Promise<X>,\n): void {\n  register((navigation) => runEffect(fn(navigation)));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,iBACd,UACkB;CAClB,MAAM,QAAQ,OAAO,QAAQ,MAAM,UAAa,CAAC;CACjD,UAAU,UAAU;EAClB,MAAM,YAAY,OAAO,KAAK;CAChC,CAAC;CACD,OAAO,OAAO,UAAU,KAAK;AAC/B;;;;;;;AAQA,SAAgB,eACd,UACA,IACA,WACM;CACN,UAAU,eAAe,UAAU,GAAG,UAAU,CAAC,CAAC;AACpD"}

package/dist/remote-reactive.d.ts

@@ -0,0 +1,38 @@
+import { RemoteResource } from "@sveltejs/kit";
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+
+//#region src/remote-reactive.d.ts
+/**
+ * Bridges a SvelteKit remote resource (`query(...)`, `query.live(...)`,
+ * `prerender(...)`) into Effect's native
+ * {@link AsyncResult.AsyncResult} — the same result type the Svelte hooks in
+ * `@thomasfosterau/effect-svelte` expose — so remote-function data folds into
+ * the same templates and combinators (`AsyncResult.match`, `isSuccess`, ...).
+ *
+ * A `RemoteResource<T>` is already reactive (`current` / `loading` / `error` /
+ * `ready`); reading them inside the returned `current` getter tracks them, so
+ * the result updates as the resource does. The `loading` flag is surfaced as
+ * `AsyncResult`'s `waiting` (stale-while-revalidate): a refresh keeps the
+ * previous `Success` on screen.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { useRemoteQuery } from '@thomasfosterau/effect-sveltekit/client';
+ *   import { AsyncResult } from '@thomasfosterau/effect-svelte';
+ *   import { getTodos } from './todos.remote';
+ *
+ *   const todos = useRemoteQuery(getTodos());
+ * </script>
+ *
+ * {#if AsyncResult.isSuccess(todos.current)}
+ *   <ul>{#each todos.current.value as todo}<li>{todo.text}</li>{/each}</ul>
+ * {/if}
+ * ```
+ */
+declare function useRemoteQuery<T>(query: RemoteResource<T>): {
+  readonly current: AsyncResult.AsyncResult<T, unknown>;
+};
+//#endregion
+export { useRemoteQuery };
+//# sourceMappingURL=remote-reactive.d.ts.map

package/dist/remote-reactive.js

@@ -0,0 +1,44 @@
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+//#region src/remote-reactive.ts
+/**
+* Bridges a SvelteKit remote resource (`query(...)`, `query.live(...)`,
+* `prerender(...)`) into Effect's native
+* {@link AsyncResult.AsyncResult} — the same result type the Svelte hooks in
+* `@thomasfosterau/effect-svelte` expose — so remote-function data folds into
+* the same templates and combinators (`AsyncResult.match`, `isSuccess`, ...).
+*
+* A `RemoteResource<T>` is already reactive (`current` / `loading` / `error` /
+* `ready`); reading them inside the returned `current` getter tracks them, so
+* the result updates as the resource does. The `loading` flag is surfaced as
+* `AsyncResult`'s `waiting` (stale-while-revalidate): a refresh keeps the
+* previous `Success` on screen.
+*
+* @example
+* ```svelte
+* <script lang="ts">
+*   import { useRemoteQuery } from '@thomasfosterau/effect-sveltekit/client';
+*   import { AsyncResult } from '@thomasfosterau/effect-svelte';
+*   import { getTodos } from './todos.remote';
+*
+*   const todos = useRemoteQuery(getTodos());
+* <\/script>
+*
+* {#if AsyncResult.isSuccess(todos.current)}
+*   <ul>{#each todos.current.value as todo}<li>{todo.text}</li>{/each}</ul>
+* {/if}
+* ```
+*/
+function useRemoteQuery(query) {
+	return { get current() {
+		const loading = query.loading;
+		const error = query.error;
+		const ready = query.ready;
+		if (error !== void 0 && error !== null) return AsyncResult.fail(error, { waiting: loading });
+		if (ready) return AsyncResult.success(query.current, { waiting: loading });
+		return AsyncResult.initial(loading);
+	} };
+}
+//#endregion
+export { useRemoteQuery };
+
+//# sourceMappingURL=remote-reactive.js.map

package/dist/remote-reactive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-reactive.js","names":[],"sources":["../src/remote-reactive.ts"],"sourcesContent":["import type { RemoteResource } from \"@sveltejs/kit\";\nimport * as AsyncResult from \"effect/unstable/reactivity/AsyncResult\";\n\n/**\n * Bridges a SvelteKit remote resource (`query(...)`, `query.live(...)`,\n * `prerender(...)`) into Effect's native\n * {@link AsyncResult.AsyncResult} — the same result type the Svelte hooks in\n * `@thomasfosterau/effect-svelte` expose — so remote-function data folds into\n * the same templates and combinators (`AsyncResult.match`, `isSuccess`, ...).\n *\n * A `RemoteResource<T>` is already reactive (`current` / `loading` / `error` /\n * `ready`); reading them inside the returned `current` getter tracks them, so\n * the result updates as the resource does. The `loading` flag is surfaced as\n * `AsyncResult`'s `waiting` (stale-while-revalidate): a refresh keeps the\n * previous `Success` on screen.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { useRemoteQuery } from '@thomasfosterau/effect-sveltekit/client';\n *   import { AsyncResult } from '@thomasfosterau/effect-svelte';\n *   import { getTodos } from './todos.remote';\n *\n *   const todos = useRemoteQuery(getTodos());\n * </script>\n *\n * {#if AsyncResult.isSuccess(todos.current)}\n *   <ul>{#each todos.current.value as todo}<li>{todo.text}</li>{/each}</ul>\n * {/if}\n * ```\n */\nexport function useRemoteQuery<T>(query: RemoteResource<T>): {\n  readonly current: AsyncResult.AsyncResult<T, unknown>;\n} {\n  return {\n    get current() {\n      // Read every reactive field so the consumer's effect tracks the resource.\n      const loading = query.loading;\n      const error = query.error;\n      const ready = query.ready;\n\n      if (error !== undefined && error !== null) {\n        return AsyncResult.fail<unknown, T>(error, { waiting: loading });\n      }\n      if (ready) {\n        return AsyncResult.success<T, unknown>(query.current as T, { waiting: loading });\n      }\n      return AsyncResult.initial<T, unknown>(loading);\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,eAAkB,OAEhC;CACA,OAAO,EACL,IAAI,UAAU;EAEZ,MAAM,UAAU,MAAM;EACtB,MAAM,QAAQ,MAAM;EACpB,MAAM,QAAQ,MAAM;EAEpB,IAAI,UAAU,KAAA,KAAa,UAAU,MACnC,OAAO,YAAY,KAAiB,OAAO,EAAE,SAAS,QAAQ,CAAC;EAEjE,IAAI,OACF,OAAO,YAAY,QAAoB,MAAM,SAAc,EAAE,SAAS,QAAQ,CAAC;EAEjF,OAAO,YAAY,QAAoB,OAAO;CAChD,EACF;AACF"}

package/dist/remote.server.d.ts

@@ -0,0 +1,48 @@
+import { SvelteKitRequestEvent } from "./runtime.js";
+import { Effect } from "effect";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import { InvalidField, RemoteCommand, RemoteForm, RemoteFormInput, RemotePrerenderFunction, RemoteQueryFunction } from "@sveltejs/kit";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/remote.server.d.ts
+type SvelteKitEffectEnv = HttpClient.HttpClient | SvelteKitRequestEvent;
+declare function queryBatch<Input, Output>(validate: "unchecked", fn: (args: Input[]) => Effect.Effect<(arg: Input, idx: number) => Output, unknown, SvelteKitEffectEnv>): RemoteQueryFunction<Input, Output>;
+declare function queryBatch<Schema extends StandardSchemaV1, Output>(schema: Schema, fn: (args: StandardSchemaV1.InferOutput<Schema>[]) => Effect.Effect<(arg: StandardSchemaV1.InferOutput<Schema>, idx: number) => Output, unknown, SvelteKitEffectEnv>): RemoteQueryFunction<StandardSchemaV1.InferInput<Schema>, Output>;
+declare function queryLive<Input, Output>(validate: "unchecked", fn: (arg: Input) => Effect.Effect<AsyncIterable<Output>, unknown, SvelteKitEffectEnv>): RemoteQueryFunction<Input, Output>;
+declare function queryLive<Schema extends StandardSchemaV1, Output>(schema: Schema, fn: (arg: StandardSchemaV1.InferOutput<Schema>) => Effect.Effect<AsyncIterable<Output>, unknown, SvelteKitEffectEnv>): RemoteQueryFunction<StandardSchemaV1.InferInput<Schema>, Output>;
+declare function form<Output>(fn: () => Effect.Effect<Output, unknown, SvelteKitEffectEnv>): RemoteForm<void, Output>;
+declare function form<Input extends RemoteFormInput, Output>(validate: "unchecked", fn: (data: Input, issue: InvalidField<Input>) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>): RemoteForm<Input, Output>;
+declare function form<Schema extends StandardSchemaV1<RemoteFormInput, Record<string, any>>, Output>(validate: Schema, fn: (data: StandardSchemaV1.InferOutput<Schema>, issue: InvalidField<StandardSchemaV1.InferInput<Schema>>) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>): RemoteForm<StandardSchemaV1.InferInput<Schema>, Output>;
+declare function command<Output>(fn: () => Effect.Effect<Output, unknown, SvelteKitEffectEnv>): RemoteCommand<void, Output>;
+declare function command<Input, Output>(validate: "unchecked", fn: (arg: Input) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>): RemoteCommand<Input, Output>;
+declare function command<Schema extends StandardSchemaV1, Output>(validate: Schema, fn: (arg: StandardSchemaV1.InferOutput<Schema>) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>): RemoteCommand<StandardSchemaV1.InferInput<Schema>, Output>;
+declare function prerender<Output>(fn: () => Effect.Effect<Output, unknown, SvelteKitEffectEnv>, options?: {
+  inputs?: () => Promise<void[]> | void[];
+  dynamic?: boolean;
+}): RemotePrerenderFunction<void, Output>;
+declare function prerender<Input, Output>(validate: "unchecked", fn: (arg: Input) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>, options?: {
+  inputs?: () => Promise<Input[]> | Input[];
+  dynamic?: boolean;
+}): RemotePrerenderFunction<Input, Output>;
+declare function prerender<Schema extends StandardSchemaV1, Output>(schema: Schema, fn: (arg: StandardSchemaV1.InferOutput<Schema>) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>, options?: {
+  inputs?: () => Promise<StandardSchemaV1.InferInput<Schema>[]> | StandardSchemaV1.InferInput<Schema>[];
+  dynamic?: boolean;
+}): RemotePrerenderFunction<StandardSchemaV1.InferInput<Schema>, Output>;
+declare function requested<Result = unknown>(...args: unknown[]): Result;
+type QueryNamespace = {
+  <Output>(fn: () => Effect.Effect<Output, unknown, SvelteKitEffectEnv>): RemoteQueryFunction<void, Output>;
+  <Input, Output>(validate: "unchecked", fn: (arg: Input) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>): RemoteQueryFunction<Input, Output>;
+  <Schema extends StandardSchemaV1, Output>(schema: Schema, fn: (arg: StandardSchemaV1.InferOutput<Schema>) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>): RemoteQueryFunction<StandardSchemaV1.InferInput<Schema>, Output>;
+  batch: typeof queryBatch;
+  live: typeof queryLive;
+};
+declare const RemoteFunction: {
+  query: QueryNamespace;
+  form: typeof form;
+  command: typeof command;
+  prerender: typeof prerender;
+  requested: typeof requested;
+};
+//#endregion
+export { RemoteFunction };
+//# sourceMappingURL=remote.server.d.ts.map