svelte-effect-runtime 1.6.2 → 2.0.0-beta.1

package/.dist/remote/client/query.d.ts

@@ -0,0 +1,57 @@
+import type { RemoteFailure } from "../shared.js";
+import type { Effect } from "effect";
+type RemoteResourceEffect<Output> = Effect.Effect<Output, RemoteFailure<unknown>> & {
+    readonly current: Output | undefined;
+    readonly error: unknown;
+    readonly loading: boolean;
+    readonly ready: boolean;
+};
+type RemoteQueryEffect<Output> = RemoteResourceEffect<Output> & {
+    readonly refresh: () => Effect.Effect<void, unknown, never>;
+    readonly set: (value: Output) => void;
+    readonly withOverride: (update: (current: Output) => Output) => unknown;
+};
+type RemoteLiveQueryEffect<Output> = RemoteResourceEffect<Output> & AsyncIterable<Output> & {
+    readonly connected: boolean;
+    readonly done: boolean;
+    readonly reconnect: () => Effect.Effect<void, unknown, never>;
+};
+/**
+ * Creates a remote query adapter. The returned function takes input and
+ * returns an `Effect` that executes SvelteKit's native query function.
+ *
+ * @example
+ * ```ts
+ * const getUser = create_remote_query_adapter(nativeQuery, (value) => value);
+ * const user = yield* getUser({ id: 1 });
+ * ```
+ *
+ * @since 2.0.0
+ * @param native_factory - SvelteKit's native query function or a legacy
+ *   response factory used by tests.
+ * @param decode_payload - Function to decode the response payload.
+ * @param _base - Deprecated transport base retained for compatibility.
+ * @returns A function returning an Effect of the response.
+ * @internal
+ */
+export declare function create_remote_query_adapter<Input, Output>(native_factory: unknown, decode_payload: (value: unknown) => unknown, _base?: string): (input: Input) => RemoteQueryEffect<Output>;
+/**
+ * Creates a remote live query adapter. The returned function takes input and
+ * returns an `Effect` that awaits the first live value while preserving live
+ * stream state and reconnect controls.
+ *
+ * @example
+ * ```ts
+ * const getTime = create_remote_live_query_adapter(nativeLive, (value) => value);
+ * const time = yield* getTime();
+ * ```
+ *
+ * @since 2.0.0
+ * @param native_factory - SvelteKit's native live query function.
+ * @param decode_payload - Function to decode the initial response payload.
+ * @param _base - Deprecated transport base retained for compatibility.
+ * @returns A function returning an Effect-backed live query resource.
+ * @internal
+ */
+export declare function create_remote_live_query_adapter<Input, Output>(native_factory: unknown, decode_payload: (value: unknown) => unknown, _base?: string): (input: Input) => RemoteLiveQueryEffect<Output>;
+export {};

package/.dist/remote/client/responses.d.ts

@@ -0,0 +1,28 @@
+import type { RemoteFailure } from "../shared.js";
+/**
+ * Decodes a failed fetch response into the runtime failure model.
+ *
+ * @example
+ * ```ts
+ * const failure = await decode_response_failure(response);
+ * ```
+ *
+ * @since 2.0.0
+ * @param response - Failed fetch response returned by the remote endpoint.
+ * @returns Remote failure represented by the response.
+ */
+export declare function decode_response_failure(response: Response): Promise<RemoteFailure<unknown>>;
+/**
+ * Decodes either a raw value or `Response` returned by a native remote helper.
+ *
+ * @example
+ * ```ts
+ * const output = await decode_response_or_value(result, decode_payload);
+ * ```
+ *
+ * @since 2.0.0
+ * @param value - Native result value or fetch response.
+ * @param decode_payload - Function used to decode successful payloads.
+ * @returns Decoded successful output.
+ */
+export declare function decode_response_or_value<Output>(value: unknown, decode_payload: (value: unknown) => unknown): Promise<Output>;

package/.dist/remote/client/types.d.ts

@@ -0,0 +1,83 @@
+import type { RemoteForm, RemoteFormInput } from "@sveltejs/kit";
+import type { RemoteFailure } from "../shared.js";
+import type { Effect } from "effect";
+/**
+ * Represents a pending operation counter that remote command adapters
+ * use to track in-flight requests.
+ *
+ * @since 2.0.0
+ * @internal
+ */
+export interface Pending {
+    /** Current count of in-flight requests. */
+    value: number;
+}
+/**
+ * Native callable method shape used when reflecting SvelteKit remote helpers.
+ *
+ * @since 2.0.0
+ */
+export type NativeMethod = (...args: unknown[]) => unknown;
+/**
+ * Property bag shape used for native SvelteKit form objects.
+ *
+ * @since 2.0.0
+ */
+export type NativeFormRecord = Record<PropertyKey, unknown>;
+/**
+ * Represents the form submit handle passed into an Effect-aware enhanced
+ * remote form callback.
+ *
+ * @example
+ * ```ts
+ * form.enhance(({ submit }) =>
+ *   Effect.gen(function* () {
+ *     yield* submit().updates();
+ *   })
+ * );
+ * ```
+ *
+ * @since 2.0.0
+ */
+export type EffectRemoteFormSubmit = Effect.Effect<unknown, RemoteFailure<unknown>> & {
+    updates: (...updates: unknown[]) => Effect.Effect<unknown, RemoteFailure<unknown>>;
+};
+/**
+ * Represents the callback payload passed to an Effect-aware remote form
+ * enhancement callback.
+ *
+ * @example
+ * ```ts
+ * form.enhance(({ data, submit }) =>
+ *   Effect.gen(function* () {
+ *     console.log(data);
+ *     yield* submit();
+ *   })
+ * );
+ * ```
+ *
+ * @since 2.0.0
+ */
+export type EffectRemoteFormEnhanceOptions<Input extends RemoteFormInput | void> = Omit<Parameters<RemoteForm<Input, unknown>["enhance"]>[0] extends (options: infer Options) => unknown ? Options : never, "submit"> & {
+    submit: () => EffectRemoteFormSubmit;
+};
+/**
+ * Represents a SvelteKit remote form whose submission, validation, and
+ * enhancement hooks expose Effect-returning APIs.
+ *
+ * @example
+ * ```ts
+ * const form = create_remote_form_adapter(nativeForm, (value) => value);
+ *
+ * yield* form.preflight(schema).validate();
+ * ```
+ *
+ * @since 2.0.0
+ */
+export type EffectRemoteForm<Input extends RemoteFormInput | void, Output> = ((input: Input) => Effect.Effect<Output, RemoteFailure<unknown>>) & Omit<RemoteForm<Input, Output>, "enhance" | "for" | "preflight" | "submit" | "validate"> & {
+    enhance(callback?: (options: EffectRemoteFormEnhanceOptions<Input>) => void | Promise<void> | Effect.Effect<void, unknown, unknown>): ReturnType<RemoteForm<Input, Output>["enhance"]>;
+    for(id: Parameters<RemoteForm<Input, Output>["for"]>[0]): Omit<EffectRemoteForm<Input, Output>, "for">;
+    preflight(schema: unknown): EffectRemoteForm<Input, Output>;
+    submit(input: Input): Effect.Effect<Output, RemoteFailure<unknown>>;
+    validate(options?: Parameters<RemoteForm<Input, Output>["validate"]>[0]): Effect.Effect<void, RemoteFailure<unknown>>;
+};

package/.dist/remote/client/utils.d.ts

@@ -0,0 +1,11 @@
+export { copy_property_descriptors } from "../../internal/descriptors.js";
+import type { NativeMethod } from "./types.js";
+/**
+ * Checks whether a value has a callable method property.
+ *
+ * @since 2.0.0
+ * @param value - Value to inspect.
+ * @param key - Method key to look up.
+ * @returns Whether the value has a function at `key`.
+ */
+export declare function has_method<K extends PropertyKey>(value: unknown, key: K): value is Record<K, NativeMethod>;

package/.dist/remote/client.d.ts

@@ -0,0 +1,2 @@
+export { create_remote_command_adapter, create_remote_form_adapter, create_remote_live_query_adapter, create_remote_query_adapter, } from "./client/index.js";
+export type { EffectRemoteForm, EffectRemoteFormEnhanceOptions, EffectRemoteFormSubmit, Pending, } from "./client/index.js";

package/.dist/remote/client.js

@@ -0,0 +1,2 @@
+import { i as create_remote_command_adapter, n as create_remote_query_adapter, r as create_remote_form_adapter, t as create_remote_live_query_adapter } from "../chunks/client-BeOE81fW.js";
+export { create_remote_command_adapter, create_remote_form_adapter, create_remote_live_query_adapter, create_remote_query_adapter };

package/.dist/remote/server.d.ts

@@ -0,0 +1,66 @@
+import { Cause, Effect } from "effect";
+import type { FormIssue } from "./shared.js";
+/**
+ * Runs a user-supplied Effect program through a ManagedRuntime, maps its
+ * exit into the shape expected by SvelteKit, and returns the result or
+ * throws a SvelteKit-compatible error.
+ *
+ * @since 2.0.0
+ * @param effect - The Effect program to execute.
+ * @param runtime - The server-side ManagedRuntime.
+ * @param invalid - SvelteKit's `invalid` helper (bound per-request).
+ * @param error - SvelteKit's `error` helper.
+ * @returns A Promise that resolves with the effect's success value.
+ * @internal
+ */
+export declare function run_remote_effect<A>(effect: Effect.Effect<A, unknown, unknown>, runtime: {
+    runPromise: (e: Effect.Effect<unknown, unknown, unknown>) => Promise<unknown>;
+}, invalid: (status: number, body: unknown) => never, error: (status: number, body: unknown) => never): Promise<A>;
+/**
+ * Encodes an Effect Cause into a string that the client-side adapter can
+ * decode back into a typed `RemoteFailure`.
+ *
+ * @since 2.0.0
+ * @param cause - The Effect Cause from a failed execution.
+ * @returns A devalue-encoded string representing the serialised failure.
+ * @internal
+ */
+export declare function encode_remote_failure(cause: Cause.Cause<unknown>): string;
+/**
+ * Throws a SvelteKit `invalid` response from a {@link FormError}, calling
+ * through to the request-scoped `invalid` helper.
+ *
+ * @example
+ * ```ts
+ * throw_form_error(
+ *   [{ message: "Name is required", path: ["name"] }],
+ *   invalid,
+ * );
+ * ```
+ *
+ * @since 2.0.0
+ * @param issues - The list of form validation issues.
+ * @param invalid - SvelteKit's `invalid` helper bound to the current request.
+ * @internal
+ */
+export declare function throw_form_error(issues: readonly FormIssue[], invalid: (status: number, body: unknown) => never): never;
+/**
+ * Remaps low-level SvelteKit errors (e.g. "Cannot use ___ outside a route")
+ * into clear, actionable messages.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   return native_query(handler);
+ * } catch (err) {
+ *   throw normalize_remote_helper_error(err, "Query");
+ * }
+ * ```
+ *
+ * @since 2.0.0
+ * @param err - The error thrown by SvelteKit's native functions.
+ * @param helper_name - Name of the helper that triggered the error.
+ * @returns A more descriptive error.
+ * @internal
+ */
+export declare function normalize_remote_helper_error(err: unknown, helper_name: string): Error;

package/.dist/remote/server.js

@@ -0,0 +1,104 @@
+import { create_serialized_remote_failure_envelope } from "./shared.js";
+import { Cause, Effect, Exit } from "effect";
+import { stringify } from "devalue";
+//#region src/remote/server.ts
+/**
+* Runs a user-supplied Effect program through a ManagedRuntime, maps its
+* exit into the shape expected by SvelteKit, and returns the result or
+* throws a SvelteKit-compatible error.
+*
+* @since 2.0.0
+* @param effect - The Effect program to execute.
+* @param runtime - The server-side ManagedRuntime.
+* @param invalid - SvelteKit's `invalid` helper (bound per-request).
+* @param error - SvelteKit's `error` helper.
+* @returns A Promise that resolves with the effect's success value.
+* @internal
+*/
+async function run_remote_effect(effect, runtime, invalid, error) {
+	const exit = await runtime.runPromise(Effect.exit(effect));
+	if (Exit.isSuccess(exit)) return exit.value;
+	handle_failure(exit.cause, invalid, error);
+}
+/**
+* Inspects the Effect Cause for failures and either throws a form
+* validation error (via SvelteKit's `invalid`) or encodes the error
+* and throws it via SvelteKit's `error`.
+*/
+function handle_failure(cause, invalid, error) {
+	const reasons = cause.reasons;
+	for (const reason of reasons) if (Cause.isFailReason(reason)) {
+		const failure = reason.error;
+		if (typeof failure === "object" && failure !== null && failure._tag === "FormError") invalid(400, { issues: failure.issues ?? [] });
+	}
+	error(500, create_serialized_remote_failure_envelope(encode_remote_failure(cause)));
+}
+/**
+* Encodes an Effect Cause into a string that the client-side adapter can
+* decode back into a typed `RemoteFailure`.
+*
+* @since 2.0.0
+* @param cause - The Effect Cause from a failed execution.
+* @returns A devalue-encoded string representing the serialised failure.
+* @internal
+*/
+function encode_remote_failure(cause) {
+	const reasons = cause.reasons;
+	for (const reason of reasons) if (Cause.isFailReason(reason)) {
+		const failure = reason.error;
+		if (typeof failure === "object" && failure !== null) try {
+			return stringify(failure);
+		} catch {
+			continue;
+		}
+	}
+	return stringify({ message: "Unknown error" });
+}
+/**
+* Throws a SvelteKit `invalid` response from a {@link FormError}, calling
+* through to the request-scoped `invalid` helper.
+*
+* @example
+* ```ts
+* throw_form_error(
+*   [{ message: "Name is required", path: ["name"] }],
+*   invalid,
+* );
+* ```
+*
+* @since 2.0.0
+* @param issues - The list of form validation issues.
+* @param invalid - SvelteKit's `invalid` helper bound to the current request.
+* @internal
+*/
+function throw_form_error(issues, invalid) {
+	invalid(400, { issues });
+}
+/**
+* Remaps low-level SvelteKit errors (e.g. "Cannot use ___ outside a route")
+* into clear, actionable messages.
+*
+* @example
+* ```ts
+* try {
+*   return native_query(handler);
+* } catch (err) {
+*   throw normalize_remote_helper_error(err, "Query");
+* }
+* ```
+*
+* @since 2.0.0
+* @param err - The error thrown by SvelteKit's native functions.
+* @param helper_name - Name of the helper that triggered the error.
+* @returns A more descriptive error.
+* @internal
+*/
+function normalize_remote_helper_error(err, helper_name) {
+	const message = err instanceof Error ? err.message : String(err);
+	if (message.includes("Cannot use") || message.includes("outside a route")) return /* @__PURE__ */ new Error(`${helper_name} was called outside a .remote.ts file. Ensure the file is named \`*.remote.ts\` and is located in a route directory.`);
+	return err instanceof Error ? err : new Error(message);
+}
+//#endregion
+export { encode_remote_failure, normalize_remote_helper_error, run_remote_effect, throw_form_error };
+
+//# sourceMappingURL=server.js.map

package/.dist/remote/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","names":[],"sources":["../../../modules/svelte-effect-runtime/src/remote/server.ts"],"sourcesContent":["import { create_serialized_remote_failure_envelope } from \"$/remote/shared.ts\";\nimport { Cause, Effect, Exit } from \"effect\";\nimport { stringify } from \"devalue\";\nimport type { FormIssue } from \"$/remote/shared.ts\";\n\n/**\n * Runs a user-supplied Effect program through a ManagedRuntime, maps its\n * exit into the shape expected by SvelteKit, and returns the result or\n * throws a SvelteKit-compatible error.\n *\n * @since 2.0.0\n * @param effect - The Effect program to execute.\n * @param runtime - The server-side ManagedRuntime.\n * @param invalid - SvelteKit's `invalid` helper (bound per-request).\n * @param error - SvelteKit's `error` helper.\n * @returns A Promise that resolves with the effect's success value.\n * @internal\n */\nexport async function run_remote_effect<A>(\n  effect: Effect.Effect<A, unknown, unknown>,\n  runtime: {\n    runPromise: (\n      e: Effect.Effect<unknown, unknown, unknown>,\n    ) => Promise<unknown>;\n  },\n  invalid: (status: number, body: unknown) => never,\n  error: (status: number, body: unknown) => never,\n): Promise<A> {\n  const exit: Exit.Exit<A, unknown> = await runtime.runPromise(\n    Effect.exit(effect) as Effect.Effect<unknown, unknown, unknown>,\n  ) as Exit.Exit<A, unknown>;\n\n  if (Exit.isSuccess(exit)) {\n    return exit.value;\n  }\n\n  handle_failure(exit.cause, invalid, error);\n}\n\n/**\n * Inspects the Effect Cause for failures and either throws a form\n * validation error (via SvelteKit's `invalid`) or encodes the error\n * and throws it via SvelteKit's `error`.\n */\nfunction handle_failure(\n  cause: Cause.Cause<unknown>,\n  invalid: (status: number, body: unknown) => never,\n  error: (status: number, body: unknown) => never,\n): never {\n  const reasons =\n    (cause as unknown as { reasons: Array<{ _tag: string; error?: unknown }> })\n      .reasons;\n\n  for (const reason of reasons) {\n    if (Cause.isFailReason(reason as never)) {\n      const failure = reason.error;\n      if (\n        typeof failure === \"object\" &&\n        failure !== null &&\n        (failure as Record<string, unknown>)._tag === \"FormError\"\n      ) {\n        const issues = (failure as { issues?: readonly FormIssue[] }).issues ??\n          [];\n        invalid(400, { issues });\n      }\n    }\n  }\n\n  const encoded = encode_remote_failure(cause);\n  const envelope = create_serialized_remote_failure_envelope(encoded);\n\n  error(500, envelope);\n}\n\n/**\n * Encodes an Effect Cause into a string that the client-side adapter can\n * decode back into a typed `RemoteFailure`.\n *\n * @since 2.0.0\n * @param cause - The Effect Cause from a failed execution.\n * @returns A devalue-encoded string representing the serialised failure.\n * @internal\n */\nexport function encode_remote_failure(cause: Cause.Cause<unknown>): string {\n  const reasons =\n    (cause as unknown as { reasons: Array<{ _tag: string; error?: unknown }> })\n      .reasons;\n\n  for (const reason of reasons) {\n    if (Cause.isFailReason(reason as never)) {\n      const failure = reason.error;\n      if (typeof failure === \"object\" && failure !== null) {\n        try {\n          return stringify(failure);\n        } catch {\n          continue;\n        }\n      }\n    }\n  }\n\n  return stringify({ message: \"Unknown error\" });\n}\n\n/**\n * Throws a SvelteKit `invalid` response from a {@link FormError}, calling\n * through to the request-scoped `invalid` helper.\n *\n * @example\n * ```ts\n * throw_form_error(\n *   [{ message: \"Name is required\", path: [\"name\"] }],\n *   invalid,\n * );\n * ```\n *\n * @since 2.0.0\n * @param issues - The list of form validation issues.\n * @param invalid - SvelteKit's `invalid` helper bound to the current request.\n * @internal\n */\nexport function throw_form_error(\n  issues: readonly FormIssue[],\n  invalid: (status: number, body: unknown) => never,\n): never {\n  invalid(400, { issues });\n}\n\n/**\n * Remaps low-level SvelteKit errors (e.g. \"Cannot use ___ outside a route\")\n * into clear, actionable messages.\n *\n * @example\n * ```ts\n * try {\n *   return native_query(handler);\n * } catch (err) {\n *   throw normalize_remote_helper_error(err, \"Query\");\n * }\n * ```\n *\n * @since 2.0.0\n * @param err - The error thrown by SvelteKit's native functions.\n * @param helper_name - Name of the helper that triggered the error.\n * @returns A more descriptive error.\n * @internal\n */\nexport function normalize_remote_helper_error(\n  err: unknown,\n  helper_name: string,\n): Error {\n  const message = err instanceof Error ? err.message : String(err);\n\n  if (message.includes(\"Cannot use\") || message.includes(\"outside a route\")) {\n    return new Error(\n      `${helper_name} was called outside a .remote.ts file. ` +\n        `Ensure the file is named \\`*.remote.ts\\` and is located in a route directory.`,\n    );\n  }\n\n  return err instanceof Error ? err : new Error(message);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAkBA,eAAsB,kBACpB,QACA,SAKA,SACA,OACY;CACZ,MAAM,OAA8B,MAAM,QAAQ,WAChD,OAAO,KAAK,OAAO,CACpB;AAED,KAAI,KAAK,UAAU,KAAK,CACtB,QAAO,KAAK;AAGd,gBAAe,KAAK,OAAO,SAAS,MAAM;;;;;;;AAQ5C,SAAS,eACP,OACA,SACA,OACO;CACP,MAAM,UACH,MACE;AAEL,MAAK,MAAM,UAAU,QACnB,KAAI,MAAM,aAAa,OAAgB,EAAE;EACvC,MAAM,UAAU,OAAO;AACvB,MACE,OAAO,YAAY,YACnB,YAAY,QACX,QAAoC,SAAS,YAI9C,SAAQ,KAAK,EAAE,QAFC,QAA8C,UAC5D,EAAE,EACmB,CAAC;;AAQ9B,OAAM,KAFW,0CADD,sBAAsB,MAAM,CACuB,CAE/C;;;;;;;;;;;AAYtB,SAAgB,sBAAsB,OAAqC;CACzE,MAAM,UACH,MACE;AAEL,MAAK,MAAM,UAAU,QACnB,KAAI,MAAM,aAAa,OAAgB,EAAE;EACvC,MAAM,UAAU,OAAO;AACvB,MAAI,OAAO,YAAY,YAAY,YAAY,KAC7C,KAAI;AACF,UAAO,UAAU,QAAQ;UACnB;AACN;;;AAMR,QAAO,UAAU,EAAE,SAAS,iBAAiB,CAAC;;;;;;;;;;;;;;;;;;;AAoBhD,SAAgB,iBACd,QACA,SACO;AACP,SAAQ,KAAK,EAAE,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;AAsB1B,SAAgB,8BACd,KACA,aACO;CACP,MAAM,UAAU,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI;AAEhE,KAAI,QAAQ,SAAS,aAAa,IAAI,QAAQ,SAAS,kBAAkB,CACvE,wBAAO,IAAI,MACT,GAAG,YAAY,sHAEhB;AAGH,QAAO,eAAe,QAAQ,MAAM,IAAI,MAAM,QAAQ"}

package/.dist/remote/shared.d.ts

@@ -0,0 +1,202 @@
+/**
+ * Shared types, markers, and constructors used by both the client-side remote
+ * adapters and the server-side handler runtime. These types define the error
+ * protocol that flows across the network boundary.
+ *
+ * @since 2.0.0
+ */
+/**
+ * Well-known marker injected into every serialised remote-failure envelope
+ * so the client can reliably distinguish runtime errors from domain values.
+ *
+ * @since 2.0.0
+ * @internal
+ */
+export declare const EFFECT_REMOTE_ERROR_MARKER = "__svelte_effect_remote__";
+/**
+ * Well-known symbol used to attach a payload decoder to a remote function
+ * so the client's transport layer can decode domain error types.
+ *
+ * @since 2.0.0
+ * @internal
+ */
+export declare const REMOTE_ERROR_DECODER: unique symbol;
+/** Form validation helpers and types. */
+/**
+ * A single field-level or form-level validation issue reported by a
+ * {@link Form} handler.
+ *
+ * @since 2.0.0
+ */
+export interface FormIssue {
+    /** Human-readable validation message. */
+    message: string;
+    /** Path to the offending field as an array of string-or-number keys. */
+    path: (string | number)[];
+}
+/**
+ * Error subtype thrown by {@link Form} handlers to signal validation
+ * failures. The `issues` array is forwarded to SvelteKit's `invalid()`
+ * helper on the server and surfaced as `FormError` on the client.
+ *
+ * @since 2.0.0
+ */
+export interface FormError<SchemaType = unknown> {
+    readonly _tag: "FormError";
+    readonly issues: readonly FormIssue[];
+    /** Phantom type slot for the schema this error was derived from. */
+    readonly _schema?: SchemaType;
+}
+/**
+ * Creates a {@link FormError} holding the given issues.
+ *
+ * @since 2.0.0
+ * @param issues - The validation issues to attach.
+ * @returns A FormError with the `_tag` set and no schema reference.
+ */
+export declare function create_form_error(issues: readonly FormIssue[]): FormError;
+/**
+ * Type guard that narrows an unknown value to a {@link FormError}.
+ *
+ * @since 2.0.0
+ * @param value - The value to check.
+ * @returns `true` when the value is a FormError.
+ */
+export declare function is_form_error(value: unknown): value is FormError;
+/** Remote error types shared by client and server helpers. */
+/**
+ * Union of all wire-level error shapes that a remote function can
+ * surface on its error channel.
+ *
+ * @example
+ * ```ts
+ * const result = yield* myQuery();
+ * // error channel is RemoteFailure<DomainError>
+ * ```
+ *
+ * @since 2.0.0
+ */
+export type RemoteFailure<ErrorType> = ErrorType | RemoteValidationError | RemoteHttpError | RemoteTransportError;
+/**
+ * Validation errors that originate from a server-side {@link Form}
+ * handler calling `invalid()` (SvelteKit's `fail`).
+ *
+ * @since 2.0.0
+ */
+export interface RemoteValidationError {
+    readonly _tag: "RemoteValidationError";
+    readonly issues?: readonly FormIssue[];
+    readonly body?: unknown;
+    readonly status: number;
+}
+/**
+ * HTTP-level errors with a status code and optional response body. Raised
+ * when the server explicitly calls SvelteKit's `error(status, body)`.
+ *
+ * @since 2.0.0
+ */
+export interface RemoteHttpError {
+    readonly _tag: "RemoteHttpError";
+    readonly status: number;
+    readonly body?: unknown;
+    readonly cause?: unknown;
+}
+/**
+ * Transport-level errors raised by the client adapter when the network
+ * request fails or the response cannot be decoded.
+ *
+ * @since 2.0.0
+ */
+export interface RemoteTransportError {
+    readonly _tag: "RemoteTransportError";
+    readonly cause?: unknown;
+    readonly body?: unknown;
+}
+/**
+ * Wire format for an encoded remote failure. The server wraps domain
+ * errors in this envelope before serialising them with devalue.
+ *
+ * @since 2.0.0
+ * @internal
+ */
+export interface SerializedRemoteFailureEnvelope {
+    readonly __svelte_effect_remote__: true;
+    readonly encoded: string;
+}
+/** Constructors for structured remote error values. */
+/**
+ * Creates a {@link RemoteValidationError} from a list of form issues.
+ *
+ * @since 2.0.0
+ * @param issues - The validation issues reported by the server handler.
+ * @param body - Optional response body returned alongside the error.
+ * @param status - HTTP status code (defaults to 400).
+ * @returns A remote-validation error shape.
+ * @internal
+ */
+export declare function create_remote_validation_error(issues: readonly FormIssue[], body?: unknown, status?: number): RemoteValidationError;
+/**
+ * Creates a {@link RemoteHttpError} for a given HTTP status.
+ *
+ * @since 2.0.0
+ * @param status - The HTTP status code.
+ * @param body - Optional response body.
+ * @param cause - Optional underlying cause.
+ * @returns A remote HTTP error shape.
+ * @internal
+ */
+export declare function create_remote_http_error(status: number, body?: unknown, cause?: unknown): RemoteHttpError;
+/**
+ * Creates a {@link RemoteTransportError} for network or decode failures.
+ *
+ * @since 2.0.0
+ * @param cause - The underlying error that caused the transport failure.
+ * @param body - Optional response body if one was received.
+ * @returns A remote transport error shape.
+ * @internal
+ */
+export declare function create_remote_transport_error(cause: unknown, body?: unknown): RemoteTransportError;
+/**
+ * Wraps a devalue-encoded error string inside a
+ * {@link SerializedRemoteFailureEnvelope}.
+ *
+ * @since 2.0.0
+ * @param encoded - The devalue-encoded error value.
+ * @returns The wire-format envelope.
+ * @internal
+ */
+export declare function create_serialized_remote_failure_envelope(encoded: string): SerializedRemoteFailureEnvelope;
+/** Type guards for structured remote error values. */
+/**
+ * Checks whether a value is a {@link SerializedRemoteFailureEnvelope}.
+ *
+ * @since 2.0.0
+ * @param value - The value to check.
+ * @returns `true` when the value is a serialised failure envelope.
+ * @internal
+ */
+export declare function is_serialized_remote_failure_envelope(value: unknown): value is SerializedRemoteFailureEnvelope;
+/**
+ * Checks whether a value is a {@link RemoteValidationError}.
+ *
+ * @since 2.0.0
+ * @param value - The value to check.
+ * @returns `true` when the value is a remote validation error.
+ */
+export declare function is_remote_validation_error(value: unknown): value is RemoteValidationError;
+/**
+ * Checks whether a value is a {@link RemoteHttpError}.
+ *
+ * @since 2.0.0
+ * @param value - The value to check.
+ * @returns `true` when the value is a remote HTTP error.
+ */
+export declare function is_remote_http_error(value: unknown): value is RemoteHttpError;
+/**
+ * Checks whether a value is a {@link RemoteTransportError}.
+ *
+ * @since 2.0.0
+ * @param value - The value to check.
+ * @returns `true` when the value is a remote transport error.
+ */
+export declare function is_remote_transport_error(value: unknown): value is RemoteTransportError;