svelte-effect-runtime 1.3.2 → 1.4.1

package/dist/v3/client.d.ts

@@ -1,13 +1,37 @@
 import { Effect, Exit, Layer, ManagedRuntime } from "effect";
 import { type RemoteFailure } from "../internal/remote-shared.js";
+/**
+ * Minimal runtime abstraction the client adapters rely on. Implemented by the
+ * Effect `ManagedRuntime` returned from {@link ClientRuntime.make}, but
+ * callers may substitute their own object conforming to this shape.
+ *
+ * @see https://ser.barekey.dev/content/reference/client-runtime
+ */
 export interface EffectRuntime<R = unknown> {
+    /**
+     * Execute an Effect and receive a cancellation token. The optional `onExit`
+     * callback fires with the final `Exit` value once the fiber completes.
+     */
     runCallback<A, E, R2>(effect: Effect.Effect<A, E, R2>, options?: {
         onExit?: (exit: Exit.Exit<A, E>) => void;
     }): () => void;
+    /**
+     * Execute an Effect and return a Promise that resolves with the success
+     * value or rejects with the propagated failure.
+     */
     runPromise<A, E, R2>(effect: Effect.Effect<A, E, R2>): Promise<A>;
+    /**
+     * Tear down the runtime and release any resources held by its root scope.
+     */
     dispose(): Promise<void>;
 }
 export type { FormError, FormIssue, RemoteDomainError, RemoteFailure, RemoteHttpError, RemoteTransportError, RemoteValidationError, } from "../internal/remote-shared.js";
+/**
+ * Alias for {@link EffectRuntime} exposed as a stable service name used by
+ * generated code and documentation.
+ *
+ * @see https://ser.barekey.dev/content/reference/client-runtime
+ */
 export interface ClientRuntimeService extends EffectRuntime<unknown> {
 }
 type RuntimeSeedLayer<R> = Layer.Layer<R, never, R>;

package/dist/v3/mod.d.ts

@@ -1,3 +1,27 @@
+/**
+ * v3 public entrypoint for `svelte-effect-runtime`.
+ *
+ * Exposes the stable client runtime, lifecycle helpers, and shared remote
+ * error / result types. Import from `svelte-effect-runtime/v3` to pin against
+ * the v3 runtime explicitly; the package default entry (`mod.ts`) re-exports
+ * everything here.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   ClientRuntime,
+ *   run_component_effect,
+ * } from "svelte-effect-runtime/v3";
+ * import { Effect } from "effect";
+ *
+ * const runtime = ClientRuntime.make();
+ * run_component_effect(runtime, Effect.log("hi from v3"));
+ * ```
+ *
+ * @see https://ser.barekey.dev/
+ *
+ * @module
+ */
 export type { EffectPreprocessOptions } from "./preprocess.js";
 export type { ClientRuntimeService, EffectRuntime, FormError, FormIssue, RemoteDomainError, RemoteFailure, RemoteHttpError, RemoteTransportError, RemoteValidationError, } from "./client.js";
 export { ClientRuntime, get_effect_runtime_or_throw, run_component_effect, run_inline_effect, to_effect, to_native, } from "./client.js";

package/dist/v3/server.d.ts

@@ -4,21 +4,43 @@ import { Effect, Layer, ManagedRuntime, Schema } from "effect";
 import type { Context } from "effect";
 import { type FormError } from "../internal/remote-shared.js";
 type EffectSchema = Schema.Schema.Any;
+/**
+ * Single entry in a {@link Transport} table. Describes how to encode a value
+ * of type `T` to a wire payload and decode it back.
+ *
+ * @see https://ser.barekey.dev/content/reference/transport
+ */
 export interface Transporter<T = unknown, U = {
     value: unknown;
 }> {
+    /** Restore the original value from the wire payload. */
     decode: (data: U) => T;
+    /**
+     * Encode the value to a wire payload, or return `false` when this transporter
+     * does not apply to the supplied value.
+     */
     encode: (value: T) => false | U;
 }
+/**
+ * Named collection of {@link Transporter}s, passed to devalue so custom types
+ * survive the client/server round-trip.
+ *
+ * @see https://ser.barekey.dev/content/reference/transport
+ */
 export type Transport = Record<string, Transporter>;
+/** Alias for SvelteKit's native remote-form input shape. */
 export type RemoteFormInput = SvelteKitRemoteFormInput;
+/** SvelteKit's native `query` function signature, re-exported for typing. */
 export type RemoteQueryFunction<Input, Output> = (arg: OptionalArgument<Input>) => Promise<Output>;
+/** SvelteKit's native `command` shape, re-exported for typing. */
 export type RemoteCommand<Input, Output> = ((arg: OptionalArgument<Input>) => Promise<Output> & {
     updates(...updates: Array<unknown>): Promise<Output>;
 }) & {
     readonly pending: number;
 };
+/** SvelteKit's native `prerender` function signature, re-exported for typing. */
 export type RemotePrerenderFunction<Input, Output> = (arg: OptionalArgument<Input>) => Promise<Output>;
+/** SvelteKit's native `form` shape, re-exported for typing. */
 export type RemoteForm<Input extends RemoteFormInput | void, Output> = SvelteKitRemoteForm<Input, Output>;
 type RuntimeOperator = (self: Layer.Layer<unknown, unknown, unknown>) => Layer.Layer<unknown, unknown, unknown>;
 type RuntimeSeedLayer<Requirements> = Layer.Layer<Requirements, never, Requirements>;
@@ -33,24 +55,70 @@ type SchemaOutput<SchemaType extends EffectSchema> = Schema.Schema.Type<SchemaTy
 type FieldHelpers<FormShape, SchemaType> = FormShape extends Record<string, unknown> ? {
     [Key in keyof FormShape as Key extends string ? Key : never]: (message: string) => Effect.Effect<never, FormError<SchemaType>, never>;
 } : Record<PropertyKey, never>;
+/**
+ * Proxy passed into `Form` handlers for reporting validation issues. Call
+ * `invalid.form(message)` for a top-level issue, or `invalid.<field>(message)`
+ * to attach the issue to a specific field declared in the schema.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/form
+ */
 export type Invalid<SchemaType = unknown> = {
+    /** Attach a top-level form issue with the supplied message. */
     form: (message: string) => Effect.Effect<never, FormError<SchemaType>, never>;
 } & FieldHelpers<SchemaType extends EffectSchema ? SchemaOutput<SchemaType> : unknown, SchemaType>;
+/**
+ * Shape of an Effect-returning remote `query`. Callable with the validated
+ * input; exposes the underlying SvelteKit function via `native`.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/query
+ */
 export type EffectQueryFunction<Input, Output, Error = never> = ((arg: OptionalArgument<Input>) => Effect.Effect<Output, import("../internal/remote-shared.js").RemoteFailure<Error>, never>) & {
+    /** Underlying SvelteKit `query` function, for fallback direct usage. */
     native: RemoteQueryFunction<Input, Output>;
 };
+/**
+ * Shape of an Effect-returning remote `command`. Callable with the validated
+ * input; exposes the underlying SvelteKit command via `native` and tracks
+ * in-flight submissions through `pending`.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/command
+ */
 export type EffectCommand<Input, Output, Error = never> = ((arg: OptionalArgument<Input>) => Effect.Effect<Output, import("../internal/remote-shared.js").RemoteFailure<Error>, never>) & {
+    /** Underlying SvelteKit `command` function, for fallback direct usage. */
     native: RemoteCommand<Input, Output>;
+    /** Count of currently in-flight invocations of this command. */
     readonly pending: number;
 };
+/**
+ * Shape of an Effect-returning remote `prerender` function. Callable with the
+ * validated input; exposes the underlying SvelteKit function via `native`.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/prerender
+ */
 export type EffectPrerenderFunction<Input, Output, Error = never> = ((arg: OptionalArgument<Input>) => Effect.Effect<Output, import("../internal/remote-shared.js").RemoteFailure<Error>, never>) & {
+    /** Underlying SvelteKit `prerender` function, for fallback direct usage. */
     native: RemotePrerenderFunction<Input, Output>;
 };
+/**
+ * Shape of an Effect-returning remote `form`. Usable anywhere the native
+ * SvelteKit form is; additionally exposes `submit(data)` to run the form
+ * program as an Effect, and `for(...)` to clone the binding for a given
+ * input.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/form
+ */
 export type EffectForm<Input extends RemoteFormInput | void, Output, Error = never> = RemoteForm<Input, Output> & {
+    /** Underlying SvelteKit `form` object, for fallback direct usage. */
     native: RemoteForm<Input, Output>;
+    /** Submit the form programmatically and receive the result as an Effect. */
     submit(data: OptionalArgument<Input>): Effect.Effect<Output, import("../internal/remote-shared.js").RemoteFailure<Error>, never>;
+    /** Clone the form binding for a specific value - mirrors `RemoteForm.for`. */
     for: RemoteForm<Input, Output>["for"] extends (...args: infer Args) => infer Result ? (...args: Args) => EffectForm<Input, Output, Error> : never;
 };
+/**
+ * Type of the SvelteKit `RequestEvent` exposed through the {@link RequestEvent}
+ * Effect service.
+ */
 export type RequestEventService = ReturnType<typeof get_native_request_event>;
 /**
  * Effect `Context.Tag` for the current SvelteKit `RequestEvent`.
@@ -100,10 +168,20 @@ export declare function normalize_remote_helper_error(error: unknown): unknown;
  * @see https://ser.barekey.dev/content/reference/transport
  */
 export declare function create_effect_transport<const Schemas extends Record<string, EffectSchema>>(schemas: Schemas): Transport;
+/**
+ * Overload set for the {@link Query} factory. Supports no-arg, `"unchecked"`,
+ * and Effect.Schema-validated definitions, plus `Query.batch(...)`.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/query
+ */
 export interface EffectQueryFactory {
+    /** Define a void-input query. */
     <Output, ErrorType, Requirements>(fn: () => Effect.Effect<Output, ErrorType, Requirements>): EffectQueryFunction<void, Output, ErrorType>;
+    /** Define a query that bypasses schema validation. */
     <Input, Output, ErrorType, Requirements>(validate: "unchecked", fn: (arg: Input) => Effect.Effect<Output, ErrorType, Requirements>): EffectQueryFunction<Input, Output, ErrorType>;
+    /** Define a query whose input is validated by an Effect.Schema. */
     <SchemaType extends EffectSchema, Output, ErrorType, Requirements>(validate: SchemaType, fn: (arg: SchemaOutput<SchemaType>) => Effect.Effect<Output, ErrorType, Requirements>): EffectQueryFunction<SchemaInput<SchemaType>, Output, ErrorType>;
+    /** Define a batched query - mirrors SvelteKit's `query.batch`. */
     batch: typeof query_batch_factory;
 }
 type RemotePrerenderInputsGenerator<Input> = (event: RequestEventService) => AsyncIterable<Input> | Iterable<Input>;
@@ -114,9 +192,18 @@ declare function query_batch_factory(validate_or_fn: unknown, maybe_fn?: unknown
  * @see https://ser.barekey.dev/content/remote-functions/query
  */
 export declare const Query: EffectQueryFactory;
+/**
+ * Overload set for the {@link Command} factory. Supports no-arg,
+ * `"unchecked"`, and Effect.Schema-validated definitions.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/command
+ */
 export interface EffectCommandFactory {
+    /** Define a void-input command. */
     <Output, ErrorType, Requirements>(fn: () => Effect.Effect<Output, ErrorType, Requirements>): EffectCommand<void, Output, ErrorType>;
+    /** Define a command that bypasses schema validation. */
     <Input, Output, ErrorType, Requirements>(validate: "unchecked", fn: (arg: Input) => Effect.Effect<Output, ErrorType, Requirements>): EffectCommand<Input, Output, ErrorType>;
+    /** Define a command whose input is validated by an Effect.Schema. */
     <SchemaType extends EffectSchema, Output, ErrorType, Requirements>(validate: SchemaType, fn: (arg: SchemaOutput<SchemaType>) => Effect.Effect<Output, ErrorType, Requirements>): EffectCommand<SchemaInput<SchemaType>, Output, ErrorType>;
 }
 /**
@@ -126,12 +213,21 @@ export interface EffectCommandFactory {
  * @see https://ser.barekey.dev/content/remote-functions/command
  */
 export declare const Command: EffectCommandFactory;
+/**
+ * Overload set for the {@link Form} factory. Supports no-arg, `"unchecked"`,
+ * and Effect.Schema-validated form handlers.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/form
+ */
 export interface EffectFormFactory {
+    /** Define a form handler with no input data. */
     <Output, ErrorType, Requirements>(fn: () => Effect.Effect<Output, ErrorType, Requirements>): EffectForm<void, Output, ErrorType>;
+    /** Define a form handler that bypasses schema validation. */
     <Input extends RemoteFormInput, Output, ErrorType, Requirements>(validate: "unchecked", fn: (args: {
         data: Input;
         invalid: Invalid;
     }) => Effect.Effect<Output, ErrorType | FormError, Requirements>): EffectForm<Input, Output, ErrorType>;
+    /** Define a form handler whose submitted data is validated by a schema. */
     <SchemaType extends EffectSchema, Output, ErrorType, Requirements>(validate: SchemaType, fn: (args: {
         data: SchemaOutput<SchemaType>;
         invalid: Invalid<SchemaType>;
@@ -144,15 +240,25 @@ export interface EffectFormFactory {
  * @see https://ser.barekey.dev/content/remote-functions/form
  */
 export declare const Form: EffectFormFactory;
+/**
+ * Overload set for the {@link Prerender} factory. Accepts the same three
+ * validation flavours as the other factories, plus a SvelteKit `options` bag
+ * with `inputs` / `dynamic` flags.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/prerender
+ */
 export interface EffectPrerenderFactory {
+    /** Define a void-input prerender function. */
     <Output, ErrorType, Requirements>(fn: () => Effect.Effect<Output, ErrorType, Requirements>, options?: {
         inputs?: RemotePrerenderInputsGenerator<void>;
         dynamic?: boolean;
     }): EffectPrerenderFunction<void, Output, ErrorType>;
+    /** Define a prerender function that bypasses schema validation. */
     <Input, Output, ErrorType, Requirements>(validate: "unchecked", fn: (arg: Input) => Effect.Effect<Output, ErrorType, Requirements>, options?: {
         inputs?: RemotePrerenderInputsGenerator<Input>;
         dynamic?: boolean;
     }): EffectPrerenderFunction<Input, Output, ErrorType>;
+    /** Define a prerender function whose input is validated by a schema. */
     <SchemaType extends EffectSchema, Output, ErrorType, Requirements>(validate: SchemaType, fn: (arg: SchemaOutput<SchemaType>) => Effect.Effect<Output, ErrorType, Requirements>, options?: {
         inputs?: RemotePrerenderInputsGenerator<SchemaInput<SchemaType>>;
         dynamic?: boolean;

package/dist/v4/effect.js

@@ -1,4 +1,4 @@
-import { t as effect$1 } from "../chunks/effect-CL8GJs8A.js";
+import { t as effect$1 } from "../chunks/effect-Cx8OzrcW.js";
 import { with_v4_effect_preprocess_options } from "./preprocess.js";
 //#region v4/effect.ts
 /**

package/dist/v4/mod.d.ts

@@ -1,3 +1,27 @@
+/**
+ * v4 public entrypoint for `svelte-effect-runtime`.
+ *
+ * Targets Effect v4 (beta) while sharing the underlying client helpers with
+ * v3. Importing from `svelte-effect-runtime/v4` opts into the v4 preprocess /
+ * Vite pipeline and the v4-flavoured server helpers exposed through the
+ * `/v4/_server` subpath.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   ClientRuntime,
+ *   run_component_effect,
+ * } from "svelte-effect-runtime/v4";
+ * import { Effect } from "effect";
+ *
+ * const runtime = ClientRuntime.make();
+ * run_component_effect(runtime, Effect.log("hi from v4"));
+ * ```
+ *
+ * @see https://ser.barekey.dev/
+ *
+ * @module
+ */
 export type { EffectPreprocessOptions } from "./preprocess.js";
 export type { ClientRuntimeService, EffectRuntime, FormError, FormIssue, RemoteDomainError, RemoteFailure, RemoteHttpError, RemoteTransportError, RemoteValidationError, } from "./client.js";
 export { ClientRuntime, get_effect_runtime_or_throw, run_component_effect, run_inline_effect, to_effect, to_native, } from "./client.js";

package/dist/v4/mod.js

@@ -1,3 +1,3 @@
-import { a as run_component_effect, c as to_native, o as run_inline_effect, r as get_effect_runtime_or_throw, s as to_effect, t as ClientRuntime } from "../chunks/client-DkW4e4dD.js";
-import "../chunks/v4-DIhYCbb_.js";
+import { a as run_component_effect, c as to_native, o as run_inline_effect, r as get_effect_runtime_or_throw, s as to_effect, t as ClientRuntime } from "../chunks/client-vV6UAwoP.js";
+import "../chunks/v4-MMhHmzIG.js";
 export { ClientRuntime, get_effect_runtime_or_throw, run_component_effect, run_inline_effect, to_effect, to_native };

package/dist/v4/preprocess.d.ts

@@ -28,3 +28,7 @@ export declare function with_v4_effect_preprocess_options(options?: EffectPrepro
  * @see https://ser.barekey.dev/content/reference/preprocess
  */
 export declare function effect_preprocess(options?: EffectPreprocessOptions): PreprocessorGroup;
+/**
+ * Backwards-compatible camelCase alias retained for older downstream imports.
+ */
+export declare const effectPreprocess: typeof effect_preprocess;

package/dist/v4/preprocess.js

@@ -1,4 +1,4 @@
-import { t as effect_preprocess$1 } from "../chunks/preprocess-CtLrnJcK.js";
+import { t as effect_preprocess$1 } from "../chunks/preprocess-CGKEA3Py.js";
 //#region v4/preprocess.ts
 const V4_RUNTIME_MODULE_ID = "svelte-effect-runtime/v4";
 /**
@@ -22,7 +22,11 @@ function with_v4_effect_preprocess_options(options = {}) {
 function effect_preprocess(options = {}) {
 	return effect_preprocess$1(with_v4_effect_preprocess_options(options));
 }
+/**
+* Backwards-compatible camelCase alias retained for older downstream imports.
+*/
+const effectPreprocess = effect_preprocess;
 //#endregion
-export { V4_RUNTIME_MODULE_ID, effect_preprocess, with_v4_effect_preprocess_options };
+export { V4_RUNTIME_MODULE_ID, effectPreprocess, effect_preprocess, with_v4_effect_preprocess_options };
 
 //# sourceMappingURL=preprocess.js.map

package/dist/v4/preprocess.js.map

@@ -1 +1 @@
-{"version":3,"file":"preprocess.js","names":["create_effect_preprocess"],"sources":["../../../modules/svelte-effect-runtime/v4/preprocess.ts"],"sourcesContent":["/**\n * v4-specific preprocess entrypoints and helpers.\n *\n * @example\n * ```ts\n * import { effect_preprocess } from \"svelte-effect-runtime/v4/preprocess\";\n *\n * const preprocess = effect_preprocess();\n * ```\n *\n * @module\n */\nimport type { PreprocessorGroup } from \"svelte/compiler\";\nimport {\n  effect_preprocess as create_effect_preprocess,\n  type EffectPreprocessOptions,\n} from \"$/v3/preprocess.ts\";\n\nexport type { EffectPreprocessOptions } from \"$/v3/preprocess.ts\";\n\nexport const V4_RUNTIME_MODULE_ID = \"svelte-effect-runtime/v4\";\n\n/**\n * Apply the default v4 runtime module id to a preprocess options bag.\n *\n * @internal Internal — do not use.\n */\nexport function with_v4_effect_preprocess_options(\n  options: EffectPreprocessOptions = {},\n): EffectPreprocessOptions {\n  return {\n    ...options,\n    runtimeModuleId: options.runtimeModuleId ?? V4_RUNTIME_MODULE_ID,\n  };\n}\n\n/**\n * Low-level Svelte preprocessor for the v4 runtime entry.\n *\n * Advanced entry point used by tooling and custom build setups.\n *\n * @see https://ser.barekey.dev/content/reference/preprocess\n */\nexport function effect_preprocess(\n  options: EffectPreprocessOptions = {},\n): PreprocessorGroup {\n  return create_effect_preprocess(with_v4_effect_preprocess_options(options));\n}\n"],"mappings":";;AAoBA,MAAa,uBAAuB;;;;;;AAOpC,SAAgB,kCACd,UAAmC,EAAE,EACZ;AACzB,QAAO;EACL,GAAG;EACH,iBAAiB,QAAQ,mBAAA;EAC1B;;;;;;;;;AAUH,SAAgB,kBACd,UAAmC,EAAE,EAClB;AACnB,QAAOA,oBAAyB,kCAAkC,QAAQ,CAAC"}
+{"version":3,"file":"preprocess.js","names":["create_effect_preprocess"],"sources":["../../../modules/svelte-effect-runtime/v4/preprocess.ts"],"sourcesContent":["/**\n * v4-specific preprocess entrypoints and helpers.\n *\n * @example\n * ```ts\n * import { effect_preprocess } from \"svelte-effect-runtime/v4/preprocess\";\n *\n * const preprocess = effect_preprocess();\n * ```\n *\n * @module\n */\nimport type { PreprocessorGroup } from \"svelte/compiler\";\nimport {\n  effect_preprocess as create_effect_preprocess,\n  type EffectPreprocessOptions,\n} from \"$/v3/preprocess.ts\";\n\nexport type { EffectPreprocessOptions } from \"$/v3/preprocess.ts\";\n\nexport const V4_RUNTIME_MODULE_ID = \"svelte-effect-runtime/v4\";\n\n/**\n * Apply the default v4 runtime module id to a preprocess options bag.\n *\n * @internal Internal — do not use.\n */\nexport function with_v4_effect_preprocess_options(\n  options: EffectPreprocessOptions = {},\n): EffectPreprocessOptions {\n  return {\n    ...options,\n    runtimeModuleId: options.runtimeModuleId ?? V4_RUNTIME_MODULE_ID,\n  };\n}\n\n/**\n * Low-level Svelte preprocessor for the v4 runtime entry.\n *\n * Advanced entry point used by tooling and custom build setups.\n *\n * @see https://ser.barekey.dev/content/reference/preprocess\n */\nexport function effect_preprocess(\n  options: EffectPreprocessOptions = {},\n): PreprocessorGroup {\n  return create_effect_preprocess(with_v4_effect_preprocess_options(options));\n}\n\n/**\n * Backwards-compatible camelCase alias retained for older downstream imports.\n */\nexport const effectPreprocess = effect_preprocess;\n"],"mappings":";;AAoBA,MAAa,uBAAuB;;;;;;AAOpC,SAAgB,kCACd,UAAmC,EAAE,EACZ;AACzB,QAAO;EACL,GAAG;EACH,iBAAiB,QAAQ,mBAAA;EAC1B;;;;;;;;;AAUH,SAAgB,kBACd,UAAmC,EAAE,EAClB;AACnB,QAAOA,oBAAyB,kCAAkC,QAAQ,CAAC;;;;;AAM7E,MAAa,mBAAmB"}

package/dist/v4/root-node.js

@@ -1,4 +1,4 @@
-import { a as run_component_effect, c as to_native, o as run_inline_effect, r as get_effect_runtime_or_throw, s as to_effect, t as ClientRuntime } from "../chunks/client-DkW4e4dD.js";
-import "../chunks/v4-DIhYCbb_.js";
+import { a as run_component_effect, c as to_native, o as run_inline_effect, r as get_effect_runtime_or_throw, s as to_effect, t as ClientRuntime } from "../chunks/client-vV6UAwoP.js";
+import "../chunks/v4-MMhHmzIG.js";
 import { effect } from "./effect.js";
 export { ClientRuntime, effect, get_effect_runtime_or_throw, run_component_effect, run_inline_effect, to_effect, to_native };

package/dist/v4/server.d.ts

@@ -1,24 +1,71 @@
+/**
+ * v4 server-side entrypoint for `svelte-effect-runtime`.
+ *
+ * Provides Effect v4-flavoured remote-function helpers and the updated
+ * `ServerRuntime` builder whose `RuntimeOperator` signature accepts the
+ * v4-style `Layer.provide(...)` operator. Usually consumed indirectly: the
+ * Vite plugin rewrites `svelte-effect-runtime/v4` imports inside `.remote.ts`
+ * to resolve here at build time.
+ *
+ * @example
+ * ```ts
+ * import { Query, ServerRuntime } from "svelte-effect-runtime/v4/_server";
+ * import { Effect, Layer, Schema } from "effect";
+ *
+ * ServerRuntime.make(Layer.provide(MyServiceLayer));
+ *
+ * export const hello = Query(Schema.String, (name) =>
+ *   Effect.succeed(`hello ${name}`)
+ * );
+ * ```
+ *
+ * @see https://ser.barekey.dev/content/reference/server-runtime
+ *
+ * @module
+ */
 import type { RemoteForm as SvelteKitRemoteForm, RemoteFormInput as SvelteKitRemoteFormInput } from "@sveltejs/kit";
 import type { getRequestEvent as get_native_request_event } from "$app/server";
 import type { Effect as Effect_type, Layer as Layer_type } from "effect";
 import * as base_server from "../v3/server.js";
 import type { FormError, RemoteFailure } from "../internal/remote-shared.js";
 import { type EffectContextKey, type EffectSchemaLike } from "../internal/effect-compat.js";
+/**
+ * Single entry in a {@link Transport} table. Describes how to encode a value
+ * to a wire payload and decode it back.
+ *
+ * @see https://ser.barekey.dev/content/reference/transport
+ */
 export interface Transporter<T = unknown, U = {
     value: unknown;
 }> {
+    /** Restore the original value from the wire payload. */
     decode: (data: U) => T;
+    /**
+     * Encode the value to a wire payload, or return `false` when this transporter
+     * does not apply to the supplied value.
+     */
     encode: (value: T) => false | U;
 }
+/**
+ * Named collection of {@link Transporter}s used by devalue to round-trip
+ * custom types across the client/server boundary.
+ *
+ * @see https://ser.barekey.dev/content/reference/transport
+ */
 export type Transport = Record<string, Transporter>;
+/** Alias for SvelteKit's native remote-form input shape. */
 export type RemoteFormInput = SvelteKitRemoteFormInput;
+/** SvelteKit's native `query` function signature, re-exported for typing. */
 export type RemoteQueryFunction<Input, Output> = (arg: OptionalArgument<Input>) => Promise<Output>;
+/** SvelteKit's native `command` shape, re-exported for typing. */
 export type RemoteCommand<Input, Output> = ((arg: OptionalArgument<Input>) => Promise<Output> & {
     updates(...updates: Array<unknown>): Promise<Output>;
 }) & {
     readonly pending: number;
 };
+/** SvelteKit's native `prerender` function signature, re-exported for typing. */
 export type RemotePrerenderFunction<Input, Output> = (arg: OptionalArgument<Input>) => Promise<Output>;
+/** SvelteKit's native `form` shape, re-exported for typing. */
 export type RemoteForm<Input extends RemoteFormInput | void, Output> = SvelteKitRemoteForm<Input, Output>;
 type OptionalArgument<Input> = undefined extends Input ? Input | void : Input;
 type RuntimeOperator = (self: Layer_type.Layer<unknown, unknown, unknown>) => Layer_type.Layer<unknown, unknown, unknown>;
@@ -37,61 +84,161 @@ type SchemaOutput<SchemaType extends EffectSchemaLike> = SchemaType extends {
 type FieldHelpers<FormShape, SchemaType> = FormShape extends Record<string, unknown> ? {
     [Key in keyof FormShape as Key extends string ? Key : never]: (message: string) => Effect_type.Effect<never, FormError<SchemaType>, never>;
 } : Record<PropertyKey, never>;
+/**
+ * Proxy passed into v4 `Form` handlers for reporting validation issues. Call
+ * `invalid.form(message)` for a top-level issue, or `invalid.<field>(message)`
+ * to attach the issue to a specific field.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/form
+ */
 export type Invalid<SchemaType = unknown> = {
+    /** Attach a top-level form issue with the supplied message. */
     form: (message: string) => Effect_type.Effect<never, FormError<SchemaType>, never>;
 } & FieldHelpers<SchemaType extends EffectSchemaLike ? SchemaOutput<SchemaType> : unknown, SchemaType>;
+/**
+ * v4 shape of an Effect-returning remote `query`. Exposes the underlying
+ * SvelteKit function via `native`.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/query
+ */
 export type EffectQueryFunction<Input, Output, Error = never> = ((arg: OptionalArgument<Input>) => Effect_type.Effect<Output, RemoteFailure<Error>, never>) & {
+    /** Underlying SvelteKit `query` function, for fallback direct usage. */
     native: RemoteQueryFunction<Input, Output>;
 };
+/**
+ * v4 shape of an Effect-returning remote `command`. Tracks in-flight
+ * submissions via `pending`.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/command
+ */
 export type EffectCommand<Input, Output, Error = never> = ((arg: OptionalArgument<Input>) => Effect_type.Effect<Output, RemoteFailure<Error>, never>) & {
+    /** Underlying SvelteKit `command` function, for fallback direct usage. */
     native: RemoteCommand<Input, Output>;
+    /** Count of currently in-flight invocations of this command. */
     readonly pending: number;
 };
+/**
+ * v4 shape of an Effect-returning remote `prerender` function.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/prerender
+ */
 export type EffectPrerenderFunction<Input, Output, Error = never> = ((arg: OptionalArgument<Input>) => Effect_type.Effect<Output, RemoteFailure<Error>, never>) & {
+    /** Underlying SvelteKit `prerender` function, for fallback direct usage. */
     native: RemotePrerenderFunction<Input, Output>;
 };
+/**
+ * v4 shape of an Effect-returning remote `form`. Adds `submit(data)` and
+ * `for(...)` on top of the underlying SvelteKit form.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/form
+ */
 export type EffectForm<Input extends RemoteFormInput | void, Output, Error = never> = RemoteForm<Input, Output> & {
+    /** Underlying SvelteKit `form` object, for fallback direct usage. */
     native: RemoteForm<Input, Output>;
+    /** Submit the form programmatically and receive the result as an Effect. */
     submit(data: OptionalArgument<Input>): Effect_type.Effect<Output, RemoteFailure<Error>, never>;
+    /** Clone the form binding for a specific value - mirrors `RemoteForm.for`. */
     for: RemoteForm<Input, Output>["for"] extends (...args: infer Args) => infer Result ? (...args: Args) => EffectForm<Input, Output, Error> & Result : never;
 };
+/**
+ * v4 type of the SvelteKit `RequestEvent` exposed through the
+ * {@link RequestEvent} Effect service.
+ */
 export type RequestEventService = ReturnType<typeof get_native_request_event>;
+/**
+ * Builder shape returned by {@link ServerRuntime} in the v4 runtime. Accepts
+ * v4-style `Layer` operators and installs a singleton `ManagedRuntime`.
+ *
+ * @see https://ser.barekey.dev/content/reference/server-runtime
+ */
 export interface ServerRuntimeSeed {
+    /** Compose operators into a Layer without installing a runtime. */
     pipe(): Layer_type.Layer<never>;
+    /** Compose operators into a Layer without installing a runtime. */
     pipe<const Ops extends readonly [RuntimeOperator, ...Array<RuntimeOperator>]>(...ops: Ops): FinalRuntimeLayer<Ops>;
+    /** Build and install the singleton server runtime. */
     make(): void;
+    /** Build and install the singleton server runtime. */
     make<const Ops extends readonly [RuntimeOperator, ...Array<RuntimeOperator>]>(...ops: Ops): void;
 }
+/**
+ * Subset of `ManagedRuntime` surface used by generated v4 server wrappers.
+ *
+ * @internal Internal - do not use.
+ */
 export interface EffectManagedRuntime {
+    /** Execute an Effect and resolve with its raw `Exit`. */
     runPromiseExit<A, E, R>(effect: Effect_type.Effect<A, E, R>): Promise<unknown>;
+    /** Tear down the runtime and release its root scope. */
     dispose(): Promise<void>;
 }
+/**
+ * Signature of `Query.batch` in the v4 runtime - kept loosely typed because
+ * the v4 server-side implementation delegates to the v3 batch factory.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/query
+ */
 export interface EffectQueryBatchFactory {
+    /** Build a batched query from validator + handler arguments. */
     (...args: Array<unknown>): unknown;
 }
+/**
+ * v4 overload set for the {@link Query} factory. Mirrors
+ * {@link import("../v3/server.js").EffectQueryFactory} using v4 schema-like
+ * inference.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/query
+ */
 export interface EffectQueryFactory {
+    /** Define a void-input query. */
     <Output, Error, Requirements>(fn: () => Effect_type.Effect<Output, Error, Requirements>): EffectQueryFunction<void, Output, Error>;
+    /** Define a query that bypasses schema validation. */
     <Input, Output, Error, Requirements>(validate: "unchecked", fn: (arg: Input) => Effect_type.Effect<Output, Error, Requirements>): EffectQueryFunction<Input, Output, Error>;
+    /** Define a query whose input is validated by an Effect.Schema. */
     <SchemaType extends EffectSchemaLike, Output, Error, Requirements>(validate: SchemaType, fn: (arg: SchemaOutput<SchemaType>) => Effect_type.Effect<Output, Error, Requirements>): EffectQueryFunction<SchemaInput<SchemaType>, Output, Error>;
+    /** Define a batched query - mirrors SvelteKit's `query.batch`. */
     batch: EffectQueryBatchFactory;
 }
+/**
+ * v4 overload set for the {@link Command} factory.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/command
+ */
 export interface EffectCommandFactory {
+    /** Define a void-input command. */
     <Output, Error, Requirements>(fn: () => Effect_type.Effect<Output, Error, Requirements>): EffectCommand<void, Output, Error>;
+    /** Define a command that bypasses schema validation. */
     <Input, Output, Error, Requirements>(validate: "unchecked", fn: (arg: Input) => Effect_type.Effect<Output, Error, Requirements>): EffectCommand<Input, Output, Error>;
+    /** Define a command whose input is validated by an Effect.Schema. */
     <SchemaType extends EffectSchemaLike, Output, Error, Requirements>(validate: SchemaType, fn: (arg: SchemaOutput<SchemaType>) => Effect_type.Effect<Output, Error, Requirements>): EffectCommand<SchemaInput<SchemaType>, Output, Error>;
 }
 type RemotePrerenderInputsGenerator<Input> = (event: RequestEventService) => AsyncIterable<Input> | Iterable<Input>;
+/**
+ * v4 overload set for the {@link Form} factory.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/form
+ */
 export interface EffectFormFactory {
+    /** Define a form handler with no input data. */
     <Output, Error, Requirements>(fn: () => Effect_type.Effect<Output, Error, Requirements>): EffectForm<void, Output, Error>;
+    /** Define a form handler that bypasses schema validation. */
     <Input extends RemoteFormInput, Output, Error, Requirements>(validate: "unchecked", fn: (args: {
         data: Input;
         invalid: Invalid;
     }) => Effect_type.Effect<Output, Error | FormError, Requirements>): EffectForm<Input, Output, Error>;
+    /** Define a form handler whose submitted data is validated by a schema. */
     <SchemaType extends EffectSchemaLike, Output, Error, Requirements>(validate: SchemaType, fn: (args: {
         data: SchemaOutput<SchemaType>;
         invalid: Invalid<SchemaType>;
     }) => Effect_type.Effect<Output, Error | FormError<SchemaType>, Requirements>): EffectForm<SchemaInput<SchemaType> & RemoteFormInput, Output, Error>;
 }
+/**
+ * v4 overload set for the {@link Prerender} factory. Supports the same three
+ * validation flavours as the other factories plus a SvelteKit `options` bag
+ * with `inputs` / `dynamic` flags.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/prerender
+ */
 export interface EffectPrerenderFactory {
     <Output, Error, Requirements>(fn: () => Effect_type.Effect<Output, Error, Requirements>, options?: {
         inputs?: RemotePrerenderInputsGenerator<void>;
@@ -106,13 +253,62 @@ export interface EffectPrerenderFactory {
         dynamic?: boolean;
     }): EffectPrerenderFunction<SchemaInput<SchemaType>, Output, Error>;
 }
+/**
+ * v4 flavour of {@link import("../v3/server.js").Query} - define a read-only
+ * remote function returning an Effect.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/query
+ */
 export declare const Query: EffectQueryFactory;
+/**
+ * v4 flavour of {@link import("../v3/server.js").Command} - define a
+ * write-oriented remote function returning an Effect.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/command
+ */
 export declare const Command: EffectCommandFactory;
+/**
+ * v4 flavour of {@link import("../v3/server.js").Form} - define a remote form
+ * handler that maps submitted data into an Effect program.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/form
+ */
 export declare const Form: EffectFormFactory;
+/**
+ * v4 flavour of {@link import("../v3/server.js").Prerender} - define a
+ * prerenderable remote function backed by an Effect program.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/prerender
+ */
 export declare const Prerender: EffectPrerenderFactory;
+/**
+ * v4 Effect `Context.Tag` for the current SvelteKit `RequestEvent`. Shaped
+ * like an `Effect` so handlers can `yield* RequestEvent` directly.
+ *
+ * @see https://ser.barekey.dev/content/runtimes/server
+ */
 export declare const RequestEvent: EffectContextKey<RequestEventService, RequestEventService> & Effect_type.Effect<RequestEventService, never, RequestEventService>;
+/**
+ * v4 server-side runtime builder. Equivalent to the v3 builder but typed
+ * against the v4 `Layer` operator signature.
+ *
+ * @see https://ser.barekey.dev/content/reference/server-runtime
+ */
 export declare const ServerRuntime: ServerRuntimeSeed;
+/**
+ * Build a devalue transport table from Effect schemas so remote payloads can
+ * round-trip custom data across the client/server boundary.
+ *
+ * @see https://ser.barekey.dev/content/reference/transport
+ */
 export declare const create_effect_transport: typeof base_server.create_effect_transport;
+/**
+ * Resolve the active v4 server runtime, lazily creating a default empty
+ * runtime when none has been registered.
+ *
+ * @internal Internal - do not use.
+ * @see https://ser.barekey.dev/content/reference/server-runtime
+ */
 export declare const get_server_runtime_or_throw: () => EffectManagedRuntime;
 /**
  * Remap low-level request-store crashes into a clearer setup error when remote