@thomasfosterau/effect-sveltekit 0.5.0 → 0.7.0

package/dist/remote-functions.d.ts

@@ -1,47 +1,63 @@
 import { SvelteKitRequestEvent } from "./runtime.js";
 import { ErrorTranslator, RequestRuntimeProvider } from "./request-runtime.js";
 import { FormErrorMapper } from "./internal/remote-run.js";
-import { Effect, Schema } from "effect";
+import * as Effect from "effect/Effect";
 import * as HttpClient from "effect/http/HttpClient";
-import { RemoteCommand, RemoteForm, RemoteFormInput, RemoteFormInvalidField, RemotePrerenderFunction, RemoteQueryFunction } from "$app/server";
+import * as Schema from "effect/Schema";
+import { RemoteCommand, RemoteForm, RemoteFormInput, RemoteFormInvalidField, RemoteLiveQueryFunction, RemotePrerenderFunction, RemoteQueryFunction } from "$app/server";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/remote-functions.d.ts
 type SvelteKitEffectEnv = HttpClient.HttpClient | SvelteKitRequestEvent;
+declare const RemoteFunctionUsageError_base: Schema.Class<RemoteFunctionUsageError, Schema.TaggedStruct<"RemoteFunctionUsageError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Thrown synchronously, when a remote function is DEFINED, by a
+ * `RemoteFunction` factory called with arguments no overload accepts (a
+ * schema with no handler), or that needs an API the installed SvelteKit lacks.
+ * It is a programming error in the `*.remote.ts` module, never a request
+ * failure.
+ */
+export declare class RemoteFunctionUsageError extends RemoteFunctionUsageError_base {}
 /** The public shape of the `query` helper, parameterised by its handler env. */
-interface QueryFn<Env> {
+export interface QueryFn<Env> {
   <Output>(fn: () => Effect.Effect<Output, unknown, Env>): RemoteQueryFunction<void, Output>;
   <Input, Output>(validate: "unchecked", fn: (arg: Input) => Effect.Effect<Output, unknown, Env>): RemoteQueryFunction<Input, Output>;
   <Sch extends StandardSchemaV1, Output>(schema: Sch, fn: (arg: StandardSchemaV1.InferOutput<Sch>) => Effect.Effect<Output, unknown, Env>): RemoteQueryFunction<StandardSchemaV1.InferInput<Sch>, Output>;
   <S extends Schema.Top, Output>(schema: S, fn: (arg: S["Type"]) => Effect.Effect<Output, unknown, Env>): RemoteQueryFunction<S["Encoded"], Output>;
 }
 /** The public shape of `query.batch`, parameterised by its handler env. */
-interface QueryBatchFn<Env> {
+export interface QueryBatchFn<Env> {
   <Input, Output>(validate: "unchecked", fn: (args: Input[]) => Effect.Effect<(arg: Input, idx: number) => Output, unknown, Env>): RemoteQueryFunction<Input, Output>;
   <Sch extends StandardSchemaV1, Output>(schema: Sch, fn: (args: StandardSchemaV1.InferOutput<Sch>[]) => Effect.Effect<(arg: StandardSchemaV1.InferOutput<Sch>, idx: number) => Output, unknown, Env>): RemoteQueryFunction<StandardSchemaV1.InferInput<Sch>, Output>;
   <S extends Schema.Top, Output>(schema: S, fn: (args: S["Type"][]) => Effect.Effect<(arg: S["Type"], idx: number) => Output, unknown, Env>): RemoteQueryFunction<S["Encoded"], Output>;
 }
-/** The public shape of `query.live`, parameterised by its handler env. */
-interface QueryLiveFn<Env> {
-  <Input, Output>(validate: "unchecked", fn: (arg: Input) => Effect.Effect<AsyncIterable<Output>, unknown, Env>): RemoteQueryFunction<Input, Output>;
-  <Sch extends StandardSchemaV1, Output>(schema: Sch, fn: (arg: StandardSchemaV1.InferOutput<Sch>) => Effect.Effect<AsyncIterable<Output>, unknown, Env>): RemoteQueryFunction<StandardSchemaV1.InferInput<Sch>, Output>;
-  <S extends Schema.Top, Output>(schema: S, fn: (arg: S["Type"]) => Effect.Effect<AsyncIterable<Output>, unknown, Env>): RemoteQueryFunction<S["Encoded"], Output>;
+/**
+ * The public shape of `query.live`, parameterised by its handler env: kit 3's
+ * `query.live` overloads with an Effect handler that produces the
+ * `AsyncIterable` of values.
+ */
+export interface QueryLiveFn<Env> {
+  <Input, Output>(validate: "unchecked", fn: (arg: Input) => Effect.Effect<AsyncIterable<Output>, unknown, Env>): RemoteLiveQueryFunction<Input, Output>;
+  <Sch extends StandardSchemaV1, Output>(schema: Sch, fn: (arg: StandardSchemaV1.InferOutput<Sch>) => Effect.Effect<AsyncIterable<Output>, unknown, Env>): RemoteLiveQueryFunction<StandardSchemaV1.InferInput<Sch>, Output, StandardSchemaV1.InferOutput<Sch>>;
+  <S extends Schema.Top, Output>(schema: S, fn: (arg: S["Type"]) => Effect.Effect<AsyncIterable<Output>, unknown, Env>): RemoteLiveQueryFunction<S["Encoded"], Output, S["Type"]>;
 }
 /** The public shape of the `form` helper, parameterised by its handler env. */
-interface FormFn<Env> {
+export interface FormFn<Env> {
   <Output>(fn: () => Effect.Effect<Output, unknown, Env>): RemoteForm<void, Output>;
   <Input, Output>(validate: "unchecked", fn: (data: Input, issue: RemoteFormInvalidField<Input & RemoteFormInput>) => Effect.Effect<Output, unknown, Env>): RemoteForm<Input & RemoteFormInput, Output>;
   <Sch extends StandardSchemaV1, Output>(validate: Sch, fn: (data: StandardSchemaV1.InferOutput<Sch>, issue: RemoteFormInvalidField<StandardSchemaV1.InferInput<Sch> & RemoteFormInput>) => Effect.Effect<Output, unknown, Env>): RemoteForm<StandardSchemaV1.InferInput<Sch> & RemoteFormInput, Output>;
   <S extends Schema.Top, Output>(validate: S, fn: (data: S["Type"], issue: RemoteFormInvalidField<S["Encoded"] & RemoteFormInput>) => Effect.Effect<Output, unknown, Env>): RemoteForm<S["Encoded"] & RemoteFormInput, Output>;
 }
 /** The public shape of the `command` helper, parameterised by its handler env. */
-interface CommandFn<Env> {
+export interface CommandFn<Env> {
   <Output>(fn: () => Effect.Effect<Output, unknown, Env>): RemoteCommand<void, Output>;
   <Input, Output>(validate: "unchecked", fn: (arg: Input) => Effect.Effect<Output, unknown, Env>): RemoteCommand<Input, Output>;
   <Sch extends StandardSchemaV1, Output>(validate: Sch, fn: (arg: StandardSchemaV1.InferOutput<Sch>) => Effect.Effect<Output, unknown, Env>): RemoteCommand<StandardSchemaV1.InferInput<Sch>, Output>;
   <S extends Schema.Top, Output>(validate: S, fn: (arg: S["Type"]) => Effect.Effect<Output, unknown, Env>): RemoteCommand<S["Encoded"], Output>;
 }
 /** The public shape of the `prerender` helper, parameterised by its handler env. */
-interface PrerenderFn<Env> {
+export interface PrerenderFn<Env> {
   <Output>(fn: () => Effect.Effect<Output, unknown, Env>, options?: {
     inputs?: () => Promise<void[]> | void[];
     dynamic?: boolean;
@@ -63,14 +79,14 @@ interface PrerenderFn<Env> {
  * SvelteKit's `requested` from `$app/server`, passed through. Throws when the
  * installed SvelteKit version does not provide it.
  */
-declare function requested<Result = unknown>(...args: unknown[]): Result;
+export declare function requested<Result = unknown>(...args: unknown[]): Result;
 /** A `query` with its `batch` / `live` helpers attached. */
-type QueryNamespace<Env> = QueryFn<Env> & {
+export type QueryNamespace<Env> = QueryFn<Env> & {
   batch: QueryBatchFn<Env>;
   live: QueryLiveFn<Env>;
 };
 /** The set of remote-function helpers bound to a particular runner. */
-interface RemoteFunctions<Env> {
+export interface RemoteFunctions<Env> {
   readonly query: QueryNamespace<Env>;
   readonly form: FormFn<Env>;
   readonly command: CommandFn<Env>;
@@ -111,7 +127,7 @@ interface RemoteFunctions<Env> {
  * );
  * ```
  */
-declare function withRuntime<R>(provider: RequestRuntimeProvider<R, any>, opts?: {
+export declare function withRuntime<R>(provider: RequestRuntimeProvider<R, any>, opts?: {
   translateError?: ErrorTranslator;
   formError?: FormErrorMapper;
 }): RemoteFunctions<R>;
@@ -120,7 +136,7 @@ declare function withRuntime<R>(provider: RequestRuntimeProvider<R, any>, opts?:
  * `requested`) bound to the default per-request runtime; `withRuntime` binds
  * them to your own services.
  */
-declare const RemoteFunction: {
+export declare const RemoteFunction: {
   query: QueryNamespace<SvelteKitEffectEnv>;
   form: FormFn<SvelteKitEffectEnv>;
   command: CommandFn<SvelteKitEffectEnv>;
@@ -129,5 +145,5 @@ declare const RemoteFunction: {
   withRuntime: typeof withRuntime;
 };
 //#endregion
-export { CommandFn, FormFn, PrerenderFn, QueryBatchFn, QueryFn, QueryLiveFn, QueryNamespace, RemoteFunction, RemoteFunctions, requested, withRuntime };
+export {};
 //# sourceMappingURL=remote-functions.d.ts.map

package/dist/remote-functions.js

@@ -1,8 +1,10 @@
 import { SvelteKitRuntime } from "./runtime.js";
 import { isBareHandler as isBareHandler$1, toStandardValidator } from "./internal/remote-validators.js";
 import { defaultTranslate, makeRunHelpers } from "./internal/remote-run.js";
-import "effect";
+import "effect/Effect";
+import * as Predicate from "effect/Predicate";
 import "effect/http/HttpClient";
+import * as Schema from "effect/Schema";
 import * as AppServer from "$app/server";
 //#region src/remote-functions.ts
 /** The default helpers: a fresh SvelteKit per-request runtime, passthrough translation. */
@@ -18,62 +20,92 @@ const helpersFromProvider = (provider, translate, formError) => makeRunHelpers((
 		dispose: () => provider.disposeAfterResponse?.(event)
 	};
 }, translate, formError);
+/**
+* Thrown synchronously, when a remote function is DEFINED, by a
+* `RemoteFunction` factory called with arguments no overload accepts (a
+* schema with no handler), or that needs an API the installed SvelteKit lacks.
+* It is a programming error in the `*.remote.ts` module, never a request
+* failure.
+*/
+var RemoteFunctionUsageError = class extends Schema.TaggedError()("RemoteFunctionUsageError", { message: Schema.String }) {};
 function unavailable(name) {
-	throw new Error(`${name} is not available in the installed SvelteKit version. Update @sveltejs/kit to use this API.`);
+	throw new RemoteFunctionUsageError({ message: `${name} is not available in the installed SvelteKit version. Update @sveltejs/kit to use this API.` });
 }
 /** True when the argument is the no-validation handler overload (typed narrowing). */
 const isBareHandler = (value) => isBareHandler$1(value);
-const makeQuery = (run) => ((arg1, arg2) => {
-	if (isBareHandler(arg1)) {
-		const handler = arg1;
-		return AppServer.query(() => run(handler()));
-	}
-	if (!arg2) throw new Error("query requires a handler function when a schema is provided");
-	return AppServer.query(toStandardValidator(arg1), (arg) => run(arg2(arg)));
-});
-const makeQueryBatch = (run) => ((validate, fn) => AppServer.query.batch(toStandardValidator(validate), (args) => run(fn(args))));
+/**
+* Normalise a validator for kit's `$app/server` helpers, typed as the
+* `"unchecked"` overload so one call site serves every validator kind.
+*/
+const toKitValidator = (validator) => toStandardValidator(validator);
+const makeQuery = (run) => {
+	const impl = (arg1, arg2) => {
+		if (isBareHandler(arg1)) {
+			const handler = arg1;
+			return AppServer.query(() => run(handler()));
+		}
+		if (!arg2) throw new RemoteFunctionUsageError({ message: "query requires a handler function when a schema is provided" });
+		return AppServer.query(toKitValidator(arg1), (arg) => run(arg2(arg)));
+	};
+	return impl;
+};
+const makeQueryBatch = (run) => {
+	const impl = (validate, fn) => AppServer.query.batch(toKitValidator(validate), (args) => run(fn(args)));
+	return impl;
+};
 const appServerCompat = AppServer;
-const queryCompat = AppServer.query;
 function getQueryLive() {
-	const live = queryCompat.live;
-	if (typeof live !== "function") unavailable("query.live");
+	const live = AppServer.query.live;
+	if (!Predicate.isFunction(live)) unavailable("query.live");
 	return live;
 }
 function getRequested() {
 	const requestedFn = appServerCompat.requested;
-	if (typeof requestedFn !== "function") unavailable("requested");
+	if (!Predicate.isFunction(requestedFn)) unavailable("requested");
 	return requestedFn;
 }
-const makeQueryLive = (run) => ((validate, fn) => {
-	return getQueryLive()(toStandardValidator(validate), (arg) => run(fn(arg)));
-});
-const makeForm = (helpers) => ((arg1, arg2) => {
-	if (isBareHandler(arg1)) {
-		const handler = arg1;
-		return AppServer.form(() => helpers.run(handler()));
-	}
-	if (!arg2) throw new Error("form requires a handler function when a schema is provided");
-	return AppServer.form(toStandardValidator(arg1), (data, issue) => helpers.runForm(arg2(data, issue), {
-		issue,
-		data
-	}));
-});
-const makeCommand = (run) => ((arg1, arg2) => {
-	if (isBareHandler(arg1)) {
-		const handler = arg1;
-		return AppServer.command(() => run(handler()));
-	}
-	if (!arg2) throw new Error("command requires a handler function when a schema is provided");
-	return AppServer.command(toStandardValidator(arg1), (arg) => run(arg2(arg)));
-});
-const makePrerender = (run) => ((arg1, arg2, arg3) => {
-	if (isBareHandler(arg1)) {
-		const handler = arg1;
-		return AppServer.prerender(() => run(handler()), arg2);
-	}
-	if (typeof arg2 !== "function") throw new Error("prerender requires a handler function when a schema is provided");
-	return AppServer.prerender(toStandardValidator(arg1), (arg) => run(arg2(arg)), arg3);
-});
+const makeQueryLive = (run) => {
+	const impl = (validate, fn) => {
+		return getQueryLive()(toKitValidator(validate), (arg) => run(fn(arg)));
+	};
+	return impl;
+};
+const makeForm = (helpers) => {
+	const impl = (arg1, arg2) => {
+		if (isBareHandler(arg1)) {
+			const handler = arg1;
+			return AppServer.form(() => helpers.run(handler()));
+		}
+		if (!arg2) throw new RemoteFunctionUsageError({ message: "form requires a handler function when a schema is provided" });
+		return AppServer.form(toKitValidator(arg1), (data, issue) => helpers.runForm(arg2(data, issue), {
+			issue,
+			data
+		}));
+	};
+	return impl;
+};
+const makeCommand = (run) => {
+	const impl = (arg1, arg2) => {
+		if (isBareHandler(arg1)) {
+			const handler = arg1;
+			return AppServer.command(() => run(handler()));
+		}
+		if (!arg2) throw new RemoteFunctionUsageError({ message: "command requires a handler function when a schema is provided" });
+		return AppServer.command(toKitValidator(arg1), (arg) => run(arg2(arg)));
+	};
+	return impl;
+};
+const makePrerender = (run) => {
+	const impl = (arg1, arg2, arg3) => {
+		if (isBareHandler(arg1)) {
+			const handler = arg1;
+			return AppServer.prerender(() => run(handler()), arg2);
+		}
+		if (!Predicate.isFunction(arg2)) throw new RemoteFunctionUsageError({ message: "prerender requires a handler function when a schema is provided" });
+		return AppServer.prerender(toKitValidator(arg1), (arg) => run(arg2(arg)), arg3);
+	};
+	return impl;
+};
 /**
 * SvelteKit's `requested` from `$app/server`, passed through. Throws when the
 * installed SvelteKit version does not provide it.
@@ -183,6 +215,6 @@ const RemoteFunction = {
 	withRuntime
 };
 //#endregion
-export { RemoteFunction, command, form, prerender, query, requested, withRuntime };
+export { RemoteFunction, RemoteFunctionUsageError, command, form, prerender, query, requested, withRuntime };
 
 //# sourceMappingURL=remote-functions.js.map

package/dist/remote-functions.js.map

@@ -1 +1 @@
-{"version":3,"file":"remote-functions.js","names":["isBareHandlerValue"],"sources":["../src/remote-functions.ts"],"sourcesContent":["// NOTE: This module builds the `query` / `form` / `command` / `prerender`\n// *factories* that consumers call inside their own `*.remote.ts` files — it is\n// NOT itself a SvelteKit remote module, and its exports (e.g. `RemoteFunction`)\n// are deliberately not remote functions. Its filename must therefore never match\n// SvelteKit's remote-module matcher `/[/.]remote(\\.[^/]+)+$/`\n// (kit `src/exports/vite/utils.js`), or kit's build-time validation will reject\n// the built file with \"all exports from this file must be remote functions\".\n// That is why this is `remote-functions.ts` and never `remote.server.ts` /\n// `*.remote.ts`. See `tests/remote-module-naming.test.ts` for the guard.\nimport * as AppServer from \"$app/server\";\nimport type {\n  RemoteCommand,\n  RemoteForm,\n  RemoteFormInput,\n  RemotePrerenderFunction,\n  RemoteQueryFunction,\n  RemoteFormInvalidField as InvalidField,\n} from \"$app/server\";\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport * as HttpClient from \"effect/http/HttpClient\";\nimport { Effect, type Schema } from \"effect\";\nimport { SvelteKitRuntime, SvelteKitRequestEvent } from \"./runtime.js\";\nimport {\n  isBareHandler as isBareHandlerValue,\n  toStandardValidator,\n} from \"./internal/remote-validators.js\";\nimport {\n  defaultTranslate,\n  makeRunHelpers,\n  type FormErrorMapper,\n  type RunHelpers,\n  type Runner,\n} from \"./internal/remote-run.js\";\nimport type { ErrorTranslator, RequestRuntimeProvider } from \"./request-runtime.js\";\n\nexport type { FormErrorMapper } from \"./internal/remote-run.js\";\n\ntype SvelteKitEffectEnv = HttpClient.HttpClient | SvelteKitRequestEvent;\n\n/** The default helpers: a fresh SvelteKit per-request runtime, passthrough translation. */\nconst defaultHelpers: RunHelpers = makeRunHelpers(() => {\n  const event = AppServer.getRequestEvent();\n  return { runExit: (effect) => SvelteKitRuntime.forRequest(event).runPromiseExit(effect) };\n}, defaultTranslate);\n\n/** Build helpers from a {@link RequestRuntimeProvider}, translator, and form-error mapper. */\nconst helpersFromProvider = (\n  provider: RequestRuntimeProvider<any, any>,\n  translate: ErrorTranslator,\n  formError?: FormErrorMapper,\n): RunHelpers =>\n  makeRunHelpers(\n    () => {\n      const event = AppServer.getRequestEvent();\n      return {\n        runExit: (effect) => provider.run(event).runPromiseExit(effect),\n        dispose: () => provider.disposeAfterResponse?.(event),\n      };\n    },\n    translate,\n    formError,\n  );\n\nfunction unavailable(name: string): never {\n  throw new Error(\n    `${name} is not available in the installed SvelteKit version. Update @sveltejs/kit to use this API.`,\n  );\n}\n\ntype EffectHandler<Env> = (arg: unknown) => Effect.Effect<unknown, unknown, Env>;\ntype EffectFormHandler<Env> = (\n  data: unknown,\n  issue: unknown,\n) => Effect.Effect<unknown, unknown, Env>;\ntype EffectVoidHandler<Env> = () => Effect.Effect<unknown, unknown, Env>;\n\n/** True when the argument is the no-validation handler overload (typed narrowing). */\nconst isBareHandler = <Env>(value: unknown): value is EffectVoidHandler<Env> =>\n  isBareHandlerValue(value);\n\n/** The public shape of the `query` helper, parameterised by its handler env. */\nexport interface QueryFn<Env> {\n  <Output>(fn: () => Effect.Effect<Output, unknown, Env>): RemoteQueryFunction<void, Output>;\n  <Input, Output>(\n    validate: \"unchecked\",\n    fn: (arg: Input) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteQueryFunction<Input, Output>;\n  <Sch extends StandardSchemaV1, Output>(\n    schema: Sch,\n    fn: (arg: StandardSchemaV1.InferOutput<Sch>) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteQueryFunction<StandardSchemaV1.InferInput<Sch>, Output>;\n  <S extends Schema.Top, Output>(\n    schema: S,\n    fn: (arg: S[\"Type\"]) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteQueryFunction<S[\"Encoded\"], Output>;\n}\n\nconst makeQuery = <Env>(run: Runner): QueryFn<Env> =>\n  ((arg1: unknown, arg2?: (arg: unknown) => Effect.Effect<unknown, unknown, Env>): any => {\n    if (isBareHandler<Env>(arg1)) {\n      const handler = arg1;\n      return AppServer.query(() => run(handler()));\n    }\n\n    if (!arg2) {\n      throw new Error(\"query requires a handler function when a schema is provided\");\n    }\n\n    return AppServer.query(toStandardValidator(arg1) as \"unchecked\", (arg: unknown) =>\n      run(arg2(arg)),\n    );\n  }) as QueryFn<Env>;\n\n/** The public shape of `query.batch`, parameterised by its handler env. */\nexport interface QueryBatchFn<Env> {\n  <Input, Output>(\n    validate: \"unchecked\",\n    fn: (args: Input[]) => Effect.Effect<(arg: Input, idx: number) => Output, unknown, Env>,\n  ): RemoteQueryFunction<Input, Output>;\n  <Sch extends StandardSchemaV1, Output>(\n    schema: Sch,\n    fn: (\n      args: StandardSchemaV1.InferOutput<Sch>[],\n    ) => Effect.Effect<\n      (arg: StandardSchemaV1.InferOutput<Sch>, idx: number) => Output,\n      unknown,\n      Env\n    >,\n  ): RemoteQueryFunction<StandardSchemaV1.InferInput<Sch>, Output>;\n  <S extends Schema.Top, Output>(\n    schema: S,\n    fn: (args: S[\"Type\"][]) => Effect.Effect<(arg: S[\"Type\"], idx: number) => Output, unknown, Env>,\n  ): RemoteQueryFunction<S[\"Encoded\"], Output>;\n}\n\nconst makeQueryBatch = <Env>(run: Runner): QueryBatchFn<Env> =>\n  ((\n    validate: unknown,\n    fn: (args: unknown[]) => Effect.Effect<(arg: unknown, idx: number) => unknown, unknown, Env>,\n  ): any =>\n    AppServer.query.batch(toStandardValidator(validate) as \"unchecked\", (args: unknown[]) =>\n      run(fn(args)),\n    )) as QueryBatchFn<Env>;\n\ntype QueryLiveFactory = (\n  validate: unknown,\n  fn: (arg: unknown) => Promise<AsyncIterable<unknown>> | AsyncIterable<unknown>,\n) => unknown;\n\ntype QueryWithCompat = typeof AppServer.query & {\n  live?: QueryLiveFactory;\n};\n\ntype AppServerWithCompat = typeof AppServer & {\n  requested?: (...args: unknown[]) => unknown;\n};\n\nconst appServerCompat = AppServer as AppServerWithCompat;\nconst queryCompat = AppServer.query as QueryWithCompat;\n\nfunction getQueryLive(): QueryLiveFactory {\n  const live = queryCompat.live;\n\n  if (typeof live !== \"function\") {\n    unavailable(\"query.live\");\n  }\n\n  return live;\n}\n\nfunction getRequested(): (...args: unknown[]) => unknown {\n  const requestedFn = appServerCompat.requested;\n\n  if (typeof requestedFn !== \"function\") {\n    unavailable(\"requested\");\n  }\n\n  return requestedFn;\n}\n\n/** The public shape of `query.live`, parameterised by its handler env. */\nexport interface QueryLiveFn<Env> {\n  <Input, Output>(\n    validate: \"unchecked\",\n    fn: (arg: Input) => Effect.Effect<AsyncIterable<Output>, unknown, Env>,\n  ): RemoteQueryFunction<Input, Output>;\n  <Sch extends StandardSchemaV1, Output>(\n    schema: Sch,\n    fn: (\n      arg: StandardSchemaV1.InferOutput<Sch>,\n    ) => Effect.Effect<AsyncIterable<Output>, unknown, Env>,\n  ): RemoteQueryFunction<StandardSchemaV1.InferInput<Sch>, Output>;\n  <S extends Schema.Top, Output>(\n    schema: S,\n    fn: (arg: S[\"Type\"]) => Effect.Effect<AsyncIterable<Output>, unknown, Env>,\n  ): RemoteQueryFunction<S[\"Encoded\"], Output>;\n}\n\nconst makeQueryLive = <Env>(run: Runner): QueryLiveFn<Env> =>\n  ((\n    validate: unknown,\n    fn: (arg: unknown) => Effect.Effect<AsyncIterable<unknown>, unknown, Env>,\n  ): any => {\n    const live = getQueryLive();\n    return live(toStandardValidator(validate), (arg) => run(fn(arg)));\n  }) as QueryLiveFn<Env>;\n\n/** The public shape of the `form` helper, parameterised by its handler env. */\nexport interface FormFn<Env> {\n  <Output>(fn: () => Effect.Effect<Output, unknown, Env>): RemoteForm<void, Output>;\n  <Input, Output>(\n    validate: \"unchecked\",\n    fn: (\n      data: Input,\n      issue: InvalidField<Input & RemoteFormInput>,\n    ) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteForm<Input & RemoteFormInput, Output>;\n  <Sch extends StandardSchemaV1, Output>(\n    validate: Sch,\n    fn: (\n      data: StandardSchemaV1.InferOutput<Sch>,\n      issue: InvalidField<StandardSchemaV1.InferInput<Sch> & RemoteFormInput>,\n    ) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteForm<StandardSchemaV1.InferInput<Sch> & RemoteFormInput, Output>;\n  <S extends Schema.Top, Output>(\n    validate: S,\n    fn: (\n      data: S[\"Type\"],\n      issue: InvalidField<S[\"Encoded\"] & RemoteFormInput>,\n    ) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteForm<S[\"Encoded\"] & RemoteFormInput, Output>;\n}\n\nconst makeForm = <Env>(helpers: RunHelpers): FormFn<Env> =>\n  ((arg1: unknown, arg2?: unknown): any => {\n    if (isBareHandler<Env>(arg1)) {\n      const handler = arg1;\n      return AppServer.form(() => helpers.run(handler()));\n    }\n\n    if (!arg2) {\n      throw new Error(\"form requires a handler function when a schema is provided\");\n    }\n\n    return AppServer.form(\n      toStandardValidator(arg1) as \"unchecked\",\n      (data: unknown, issue: unknown) =>\n        helpers.runForm((arg2 as EffectFormHandler<Env>)(data, issue), {\n          issue: issue as InvalidField<any>,\n          data,\n        }),\n    );\n  }) as FormFn<Env>;\n\n/** The public shape of the `command` helper, parameterised by its handler env. */\nexport interface CommandFn<Env> {\n  <Output>(fn: () => Effect.Effect<Output, unknown, Env>): RemoteCommand<void, Output>;\n  <Input, Output>(\n    validate: \"unchecked\",\n    fn: (arg: Input) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteCommand<Input, Output>;\n  <Sch extends StandardSchemaV1, Output>(\n    validate: Sch,\n    fn: (arg: StandardSchemaV1.InferOutput<Sch>) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteCommand<StandardSchemaV1.InferInput<Sch>, Output>;\n  <S extends Schema.Top, Output>(\n    validate: S,\n    fn: (arg: S[\"Type\"]) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteCommand<S[\"Encoded\"], Output>;\n}\n\nconst makeCommand = <Env>(run: Runner): CommandFn<Env> =>\n  ((arg1: unknown, arg2?: (arg: unknown) => Effect.Effect<unknown, unknown, Env>): any => {\n    if (isBareHandler<Env>(arg1)) {\n      const handler = arg1;\n      return AppServer.command(() => run(handler()));\n    }\n\n    if (!arg2) {\n      throw new Error(\"command requires a handler function when a schema is provided\");\n    }\n\n    return AppServer.command(toStandardValidator(arg1) as \"unchecked\", (arg: unknown) =>\n      run(arg2(arg)),\n    );\n  }) as CommandFn<Env>;\n\n/** The public shape of the `prerender` helper, parameterised by its handler env. */\nexport interface PrerenderFn<Env> {\n  <Output>(\n    fn: () => Effect.Effect<Output, unknown, Env>,\n    options?: {\n      inputs?: () => Promise<void[]> | void[];\n      dynamic?: boolean;\n    },\n  ): RemotePrerenderFunction<void, Output>;\n  <Input, Output>(\n    validate: \"unchecked\",\n    fn: (arg: Input) => Effect.Effect<Output, unknown, Env>,\n    options?: {\n      inputs?: () => Promise<Input[]> | Input[];\n      dynamic?: boolean;\n    },\n  ): RemotePrerenderFunction<Input, Output>;\n  <Sch extends StandardSchemaV1, Output>(\n    schema: Sch,\n    fn: (arg: StandardSchemaV1.InferOutput<Sch>) => Effect.Effect<Output, unknown, Env>,\n    options?: {\n      inputs?: () =>\n        | Promise<StandardSchemaV1.InferInput<Sch>[]>\n        | StandardSchemaV1.InferInput<Sch>[];\n      dynamic?: boolean;\n    },\n  ): RemotePrerenderFunction<StandardSchemaV1.InferInput<Sch>, Output>;\n  <S extends Schema.Top, Output>(\n    schema: S,\n    fn: (arg: S[\"Type\"]) => Effect.Effect<Output, unknown, Env>,\n    options?: {\n      inputs?: () => Promise<S[\"Encoded\"][]> | S[\"Encoded\"][];\n      dynamic?: boolean;\n    },\n  ): RemotePrerenderFunction<S[\"Encoded\"], Output>;\n}\n\nconst makePrerender = <Env>(run: Runner): PrerenderFn<Env> =>\n  ((\n    arg1: unknown,\n    arg2?:\n      | ((arg: unknown) => Effect.Effect<unknown, unknown, Env>)\n      | {\n          inputs?: () => Promise<unknown[]> | unknown[];\n          dynamic?: boolean;\n        },\n    arg3?: {\n      inputs?: () => Promise<unknown[]> | unknown[];\n      dynamic?: boolean;\n    },\n  ): any => {\n    if (isBareHandler<Env>(arg1)) {\n      const handler = arg1;\n      return AppServer.prerender(\n        () => run(handler()),\n        arg2 as { inputs?: () => Promise<void[]> | void[]; dynamic?: boolean } | undefined,\n      );\n    }\n\n    if (typeof arg2 !== \"function\") {\n      throw new Error(\"prerender requires a handler function when a schema is provided\");\n    }\n\n    return AppServer.prerender(\n      toStandardValidator(arg1) as \"unchecked\",\n      (arg: unknown) => run((arg2 as EffectHandler<Env>)(arg)),\n      arg3,\n    );\n  }) as PrerenderFn<Env>;\n\n/**\n * SvelteKit's `requested` from `$app/server`, passed through. Throws when the\n * installed SvelteKit version does not provide it.\n */\nexport function requested<Result = unknown>(...args: unknown[]): Result {\n  const requestedFn = getRequested();\n  return requestedFn(...args) as Result;\n}\n\n/** A `query` with its `batch` / `live` helpers attached. */\nexport type QueryNamespace<Env> = QueryFn<Env> & {\n  batch: QueryBatchFn<Env>;\n  live: QueryLiveFn<Env>;\n};\n\nconst makeQueryNamespace = <Env>(run: Runner): QueryNamespace<Env> =>\n  Object.assign(makeQuery<Env>(run), {\n    batch: makeQueryBatch<Env>(run),\n    live: makeQueryLive<Env>(run),\n  }) as QueryNamespace<Env>;\n\n// ── Standalone exports (default SvelteKit per-request runtime) ──────────────\n\n/**\n * SvelteKit's remote `query` with an Effect handler. Accepts `\"unchecked\"`, a\n * Standard Schema or a bare Effect `Schema` as the validator; `query.batch`\n * and `query.live` are attached.\n *\n * Handlers run on the default per-request runtime (`HttpClient` plus\n * `SvelteKitRequestEvent`); a failure that is not a SvelteKit `error()` /\n * `redirect()` becomes a 500. Use {@link withRuntime} to run on your own\n * services.\n */\nexport const query: QueryNamespace<SvelteKitEffectEnv> = makeQueryNamespace(defaultHelpers.run);\n/**\n * SvelteKit's remote `query.batch` with an Effect handler (the same function\n * as `query.batch`).\n *\n * Handlers run on the default per-request runtime (`HttpClient` plus\n * `SvelteKitRequestEvent`); a failure that is not a SvelteKit `error()` /\n * `redirect()` becomes a 500. Use {@link withRuntime} to run on your own\n * services.\n */\nexport const queryBatch: QueryBatchFn<SvelteKitEffectEnv> = query.batch;\n/**\n * SvelteKit's remote `query.live` with an Effect handler that returns an\n * `AsyncIterable` (the same function as `query.live`).\n *\n * Handlers run on the default per-request runtime (`HttpClient` plus\n * `SvelteKitRequestEvent`); a failure that is not a SvelteKit `error()` /\n * `redirect()` becomes a 500. Use {@link withRuntime} to run on your own\n * services.\n */\nexport const queryLive: QueryLiveFn<SvelteKitEffectEnv> = query.live;\n/**\n * SvelteKit's remote `form` with an Effect handler.\n *\n * Handlers run on the default per-request runtime (`HttpClient` plus\n * `SvelteKitRequestEvent`); a failure that is not a SvelteKit `error()` /\n * `redirect()` becomes a 500. Use {@link withRuntime} to run on your own\n * services.\n */\nexport const form: FormFn<SvelteKitEffectEnv> = makeForm(defaultHelpers);\n/**\n * SvelteKit's remote `command` with an Effect handler.\n *\n * Handlers run on the default per-request runtime (`HttpClient` plus\n * `SvelteKitRequestEvent`); a failure that is not a SvelteKit `error()` /\n * `redirect()` becomes a 500. Use {@link withRuntime} to run on your own\n * services.\n */\nexport const command: CommandFn<SvelteKitEffectEnv> = makeCommand(defaultHelpers.run);\n/**\n * SvelteKit's remote `prerender` with an Effect handler.\n *\n * Handlers run on the default per-request runtime (`HttpClient` plus\n * `SvelteKitRequestEvent`); a failure that is not a SvelteKit `error()` /\n * `redirect()` becomes a 500. Use {@link withRuntime} to run on your own\n * services.\n */\nexport const prerender: PrerenderFn<SvelteKitEffectEnv> = makePrerender(defaultHelpers.run);\n\n/** The set of remote-function helpers bound to a particular runner. */\nexport interface RemoteFunctions<Env> {\n  readonly query: QueryNamespace<Env>;\n  readonly form: FormFn<Env>;\n  readonly command: CommandFn<Env>;\n  readonly prerender: PrerenderFn<Env>;\n}\n\n/**\n * Bind the remote-function helpers to a {@link RequestRuntimeProvider} (and an\n * optional boundary error translator), so their handlers run on the provider's\n * services `Env` — your own application catalogue — instead of the fixed\n * {@link SvelteKitServices}. The Standard-Schema / `\"unchecked\"` validation\n * argument and the native return types (`RemoteQueryFunction`, `RemoteForm`,\n * ...) are exactly as the standalone helpers.\n *\n * For remote forms, the failure path runs `opts.formError` when provided —\n * mapping a structured/nested error shape into SvelteKit's field issues (via the\n * `issue` helper / `invalid()`) so a domain validation failure drives\n * field-level invalidation rather than a generic failure. Otherwise the form\n * falls back to `translateError`.\n *\n * @example\n * ```ts\n * const { query, form, command } = RemoteFunction.withRuntime(\n *   RequestRuntime.fromLocals((event) => event.locals.runtime),\n *   {\n *     translateError: toSvelteKit,\n *     formError: (error, { issue }) => {\n *       if (error instanceof ValidationFailure) issue.field(error.field, error.message);\n *       invalid();\n *     },\n *   },\n * );\n *\n * export const items = query(() =>\n *   Effect.gen(function* () {\n *     const db = yield* Database;\n *     return yield* db.list();\n *   }),\n * );\n * ```\n */\nexport function withRuntime<R>(\n  provider: RequestRuntimeProvider<R, any>,\n  opts?: { translateError?: ErrorTranslator; formError?: FormErrorMapper },\n): RemoteFunctions<R> {\n  const helpers = helpersFromProvider(\n    provider,\n    opts?.translateError ?? defaultTranslate,\n    opts?.formError,\n  );\n  return {\n    query: makeQueryNamespace<R>(helpers.run),\n    form: makeForm<R>(helpers),\n    command: makeCommand<R>(helpers.run),\n    prerender: makePrerender<R>(helpers.run),\n  };\n}\n\n/**\n * The remote-function helpers (`query`, `form`, `command`, `prerender`,\n * `requested`) bound to the default per-request runtime; `withRuntime` binds\n * them to your own services.\n */\nexport const RemoteFunction = {\n  query,\n  form,\n  command,\n  prerender,\n  requested,\n  withRuntime,\n};\n"],"mappings":"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"}
+{"version":3,"file":"remote-functions.js","names":["isBareHandlerValue"],"sources":["../src/remote-functions.ts"],"sourcesContent":["// NOTE: This module builds the `query` / `form` / `command` / `prerender`\n// *factories* that consumers call inside their own `*.remote.ts` files — it is\n// NOT itself a SvelteKit remote module, and its exports (e.g. `RemoteFunction`)\n// are deliberately not remote functions. Its filename must therefore never match\n// SvelteKit's remote-module matcher `/[/.]remote(\\.[^/]+)+$/`\n// (kit `src/exports/vite/utils.js`), or kit's build-time validation will reject\n// the built file with \"all exports from this file must be remote functions\".\n// That is why this is `remote-functions.ts` and never `remote.server.ts` /\n// `*.remote.ts`. See `tests/remote-module-naming.test.ts` for the guard.\nimport * as AppServer from \"$app/server\";\nimport type {\n  RemoteCommand,\n  RemoteForm,\n  RemoteFormInput,\n  RemoteLiveQueryFunction,\n  RemotePrerenderFunction,\n  RemoteQueryFunction,\n  RemoteFormInvalidField as InvalidField,\n} from \"$app/server\";\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport * as HttpClient from \"effect/http/HttpClient\";\nimport * as Effect from \"effect/Effect\";\nimport * as Predicate from \"effect/Predicate\";\nimport * as Schema from \"effect/Schema\";\nimport { SvelteKitRuntime, SvelteKitRequestEvent } from \"./runtime.js\";\nimport {\n  isBareHandler as isBareHandlerValue,\n  toStandardValidator,\n} from \"./internal/remote-validators.js\";\nimport {\n  defaultTranslate,\n  makeRunHelpers,\n  type FormErrorMapper,\n  type RunHelpers,\n  type Runner,\n} from \"./internal/remote-run.js\";\nimport type { ErrorTranslator, RequestRuntimeProvider } from \"./request-runtime.js\";\n\nexport type { FormErrorMapper } from \"./internal/remote-run.js\";\n\ntype SvelteKitEffectEnv = HttpClient.HttpClient | SvelteKitRequestEvent;\n\n/** The default helpers: a fresh SvelteKit per-request runtime, passthrough translation. */\nconst defaultHelpers: RunHelpers = makeRunHelpers(() => {\n  const event = AppServer.getRequestEvent();\n  return { runExit: (effect) => SvelteKitRuntime.forRequest(event).runPromiseExit(effect) };\n}, defaultTranslate);\n\n/** Build helpers from a {@link RequestRuntimeProvider}, translator, and form-error mapper. */\nconst helpersFromProvider = (\n  provider: RequestRuntimeProvider<any, any>,\n  translate: ErrorTranslator,\n  formError?: FormErrorMapper,\n): RunHelpers =>\n  makeRunHelpers(\n    () => {\n      const event = AppServer.getRequestEvent();\n      return {\n        runExit: (effect) => provider.run(event).runPromiseExit(effect),\n        dispose: () => provider.disposeAfterResponse?.(event),\n      };\n    },\n    translate,\n    formError,\n  );\n\n/**\n * Thrown synchronously, when a remote function is DEFINED, by a\n * `RemoteFunction` factory called with arguments no overload accepts (a\n * schema with no handler), or that needs an API the installed SvelteKit lacks.\n * It is a programming error in the `*.remote.ts` module, never a request\n * failure.\n */\nexport class RemoteFunctionUsageError extends Schema.TaggedError<RemoteFunctionUsageError>()(\n  \"RemoteFunctionUsageError\",\n  { message: Schema.String },\n) {}\n\nfunction unavailable(name: string): never {\n  throw new RemoteFunctionUsageError({\n    message: `${name} is not available in the installed SvelteKit version. Update @sveltejs/kit to use this API.`,\n  });\n}\n\n/** Any validator argument the remote helpers accept in the handler-with-validation position. */\ntype Validator = \"unchecked\" | StandardSchemaV1 | Schema.Top;\n\ntype EffectHandler<In, Out, Env> = (arg: In) => Effect.Effect<Out, unknown, Env>;\ntype EffectVoidHandler<Out, Env> = () => Effect.Effect<Out, unknown, Env>;\n\n/** `inputs` / `dynamic` options of a remote `prerender`, for input type `In`. */\ninterface PrerenderOptions<In> {\n  inputs?: () => Promise<In[]> | In[];\n  dynamic?: boolean;\n}\n\n/** True when the argument is the no-validation handler overload (typed narrowing). */\nconst isBareHandler = <Out, Env>(\n  value: Validator | EffectVoidHandler<Out, Env>,\n): value is EffectVoidHandler<Out, Env> => isBareHandlerValue(value);\n\n/**\n * Normalise a validator for kit's `$app/server` helpers, typed as the\n * `\"unchecked\"` overload so one call site serves every validator kind.\n */\n// SAFETY: `toStandardValidator` returns either the `\"unchecked\"` marker or a\n// Standard Schema (a bare Effect `Schema` is wrapped); kit accepts both at\n// runtime, and the `\"unchecked\"` typing only selects the overload whose handler\n// input is the generic `In` the public overloads already fixed.\nconst toKitValidator = (validator: Validator): \"unchecked\" =>\n  toStandardValidator(validator) as \"unchecked\";\n\n/** The public shape of the `query` helper, parameterised by its handler env. */\nexport interface QueryFn<Env> {\n  <Output>(fn: () => Effect.Effect<Output, unknown, Env>): RemoteQueryFunction<void, Output>;\n  <Input, Output>(\n    validate: \"unchecked\",\n    fn: (arg: Input) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteQueryFunction<Input, Output>;\n  <Sch extends StandardSchemaV1, Output>(\n    schema: Sch,\n    fn: (arg: StandardSchemaV1.InferOutput<Sch>) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteQueryFunction<StandardSchemaV1.InferInput<Sch>, Output>;\n  <S extends Schema.Top, Output>(\n    schema: S,\n    fn: (arg: S[\"Type\"]) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteQueryFunction<S[\"Encoded\"], Output>;\n}\n\nconst makeQuery = <Env>(run: Runner): QueryFn<Env> => {\n  const impl = <In, Out>(\n    arg1: Validator | EffectVoidHandler<Out, Env>,\n    arg2?: EffectHandler<In, Out, Env>,\n  ) => {\n    if (isBareHandler<Out, Env>(arg1)) {\n      const handler = arg1;\n      return AppServer.query(() => run(handler()));\n    }\n\n    if (!arg2) {\n      throw new RemoteFunctionUsageError({\n        message: \"query requires a handler function when a schema is provided\",\n      });\n    }\n\n    return AppServer.query(toKitValidator(arg1), (arg: In) => run(arg2(arg)));\n  };\n  // SAFETY: `impl` dispatches on the argument kind exactly as the `QueryFn`\n  // overloads distinguish them (bare handler, or validator then handler), and\n  // returns kit's `RemoteQueryFunction` for that overload.\n  return impl as QueryFn<Env>;\n};\n\n/** The public shape of `query.batch`, parameterised by its handler env. */\nexport interface QueryBatchFn<Env> {\n  <Input, Output>(\n    validate: \"unchecked\",\n    fn: (args: Input[]) => Effect.Effect<(arg: Input, idx: number) => Output, unknown, Env>,\n  ): RemoteQueryFunction<Input, Output>;\n  <Sch extends StandardSchemaV1, Output>(\n    schema: Sch,\n    fn: (\n      args: StandardSchemaV1.InferOutput<Sch>[],\n    ) => Effect.Effect<\n      (arg: StandardSchemaV1.InferOutput<Sch>, idx: number) => Output,\n      unknown,\n      Env\n    >,\n  ): RemoteQueryFunction<StandardSchemaV1.InferInput<Sch>, Output>;\n  <S extends Schema.Top, Output>(\n    schema: S,\n    fn: (args: S[\"Type\"][]) => Effect.Effect<(arg: S[\"Type\"], idx: number) => Output, unknown, Env>,\n  ): RemoteQueryFunction<S[\"Encoded\"], Output>;\n}\n\nconst makeQueryBatch = <Env>(run: Runner): QueryBatchFn<Env> => {\n  const impl = <In, Out>(\n    validate: Validator,\n    fn: (args: In[]) => Effect.Effect<(arg: In, idx: number) => Out, unknown, Env>,\n  ) => AppServer.query.batch(toKitValidator(validate), (args: In[]) => run(fn(args)));\n  // SAFETY: every `QueryBatchFn` overload is (validator, batch handler), which\n  // `impl` forwards to kit's `query.batch` unchanged.\n  return impl as QueryBatchFn<Env>;\n};\n\n/** `$app/server`, with `requested` typed as a generic passthrough. */\ntype AppServerWithRequested = Omit<typeof AppServer, \"requested\"> & {\n  readonly requested?: <Result>(...args: unknown[]) => Result;\n};\n\n// SAFETY: widens `requested` to optional (older kits may lack it, so the call\n// site checks before calling) and erases its overloads, which `requested` below\n// re-exposes with the caller-chosen `Result`.\nconst appServerCompat = AppServer as AppServerWithRequested;\n\nfunction getQueryLive(): typeof AppServer.query.live {\n  const live: typeof AppServer.query.live | undefined = AppServer.query.live;\n\n  if (!Predicate.isFunction(live)) {\n    unavailable(\"query.live\");\n  }\n\n  return live;\n}\n\nfunction getRequested(): <Result>(...args: unknown[]) => Result {\n  const requestedFn = appServerCompat.requested;\n\n  if (!Predicate.isFunction(requestedFn)) {\n    unavailable(\"requested\");\n  }\n\n  return requestedFn;\n}\n\n/**\n * The public shape of `query.live`, parameterised by its handler env: kit 3's\n * `query.live` overloads with an Effect handler that produces the\n * `AsyncIterable` of values.\n */\nexport interface QueryLiveFn<Env> {\n  <Input, Output>(\n    validate: \"unchecked\",\n    fn: (arg: Input) => Effect.Effect<AsyncIterable<Output>, unknown, Env>,\n  ): RemoteLiveQueryFunction<Input, Output>;\n  <Sch extends StandardSchemaV1, Output>(\n    schema: Sch,\n    fn: (\n      arg: StandardSchemaV1.InferOutput<Sch>,\n    ) => Effect.Effect<AsyncIterable<Output>, unknown, Env>,\n  ): RemoteLiveQueryFunction<\n    StandardSchemaV1.InferInput<Sch>,\n    Output,\n    StandardSchemaV1.InferOutput<Sch>\n  >;\n  <S extends Schema.Top, Output>(\n    schema: S,\n    fn: (arg: S[\"Type\"]) => Effect.Effect<AsyncIterable<Output>, unknown, Env>,\n  ): RemoteLiveQueryFunction<S[\"Encoded\"], Output, S[\"Type\"]>;\n}\n\nconst makeQueryLive = <Env>(run: Runner): QueryLiveFn<Env> => {\n  const impl = <In, Out>(\n    validate: Validator,\n    fn: (arg: In) => Effect.Effect<AsyncIterable<Out>, unknown, Env>,\n  ) => {\n    const live = getQueryLive();\n    return live(toKitValidator(validate), (arg: In) => run(fn(arg)));\n  };\n  // SAFETY: every `QueryLiveFn` overload is (validator, handler), which `impl`\n  // forwards unchanged to kit's `query.live`, so each overload returns exactly\n  // what the matching kit overload returns; `impl`'s single generic signature\n  // cannot name the validated-input type parameter each overload fixes.\n  return impl as QueryLiveFn<Env>;\n};\n\n/** The public shape of the `form` helper, parameterised by its handler env. */\nexport interface FormFn<Env> {\n  <Output>(fn: () => Effect.Effect<Output, unknown, Env>): RemoteForm<void, Output>;\n  <Input, Output>(\n    validate: \"unchecked\",\n    fn: (\n      data: Input,\n      issue: InvalidField<Input & RemoteFormInput>,\n    ) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteForm<Input & RemoteFormInput, Output>;\n  <Sch extends StandardSchemaV1, Output>(\n    validate: Sch,\n    fn: (\n      data: StandardSchemaV1.InferOutput<Sch>,\n      issue: InvalidField<StandardSchemaV1.InferInput<Sch> & RemoteFormInput>,\n    ) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteForm<StandardSchemaV1.InferInput<Sch> & RemoteFormInput, Output>;\n  <S extends Schema.Top, Output>(\n    validate: S,\n    fn: (\n      data: S[\"Type\"],\n      issue: InvalidField<S[\"Encoded\"] & RemoteFormInput>,\n    ) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteForm<S[\"Encoded\"] & RemoteFormInput, Output>;\n}\n\nconst makeForm = <Env>(helpers: RunHelpers): FormFn<Env> => {\n  const impl = <In extends RemoteFormInput, Out>(\n    arg1: Validator | EffectVoidHandler<Out, Env>,\n    arg2?: (data: In, issue: InvalidField<In>) => Effect.Effect<Out, unknown, Env>,\n  ) => {\n    if (isBareHandler<Out, Env>(arg1)) {\n      const handler = arg1;\n      return AppServer.form(() => helpers.run(handler()));\n    }\n\n    if (!arg2) {\n      throw new RemoteFunctionUsageError({\n        message: \"form requires a handler function when a schema is provided\",\n      });\n    }\n\n    return AppServer.form(toKitValidator(arg1), (data: In, issue: InvalidField<In>) =>\n      helpers.runForm(arg2(data, issue), { issue, data }),\n    );\n  };\n  // SAFETY: `impl` dispatches on the argument kind exactly as the `FormFn`\n  // overloads distinguish them (bare handler, or validator then handler), and\n  // returns kit's `RemoteForm` for that overload.\n  return impl as FormFn<Env>;\n};\n\n/** The public shape of the `command` helper, parameterised by its handler env. */\nexport interface CommandFn<Env> {\n  <Output>(fn: () => Effect.Effect<Output, unknown, Env>): RemoteCommand<void, Output>;\n  <Input, Output>(\n    validate: \"unchecked\",\n    fn: (arg: Input) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteCommand<Input, Output>;\n  <Sch extends StandardSchemaV1, Output>(\n    validate: Sch,\n    fn: (arg: StandardSchemaV1.InferOutput<Sch>) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteCommand<StandardSchemaV1.InferInput<Sch>, Output>;\n  <S extends Schema.Top, Output>(\n    validate: S,\n    fn: (arg: S[\"Type\"]) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteCommand<S[\"Encoded\"], Output>;\n}\n\nconst makeCommand = <Env>(run: Runner): CommandFn<Env> => {\n  const impl = <In, Out>(\n    arg1: Validator | EffectVoidHandler<Out, Env>,\n    arg2?: EffectHandler<In, Out, Env>,\n  ) => {\n    if (isBareHandler<Out, Env>(arg1)) {\n      const handler = arg1;\n      return AppServer.command(() => run(handler()));\n    }\n\n    if (!arg2) {\n      throw new RemoteFunctionUsageError({\n        message: \"command requires a handler function when a schema is provided\",\n      });\n    }\n\n    return AppServer.command(toKitValidator(arg1), (arg: In) => run(arg2(arg)));\n  };\n  // SAFETY: `impl` dispatches on the argument kind exactly as the `CommandFn`\n  // overloads distinguish them (bare handler, or validator then handler), and\n  // returns kit's `RemoteCommand` for that overload.\n  return impl as CommandFn<Env>;\n};\n\n/** The public shape of the `prerender` helper, parameterised by its handler env. */\nexport interface PrerenderFn<Env> {\n  <Output>(\n    fn: () => Effect.Effect<Output, unknown, Env>,\n    options?: {\n      inputs?: () => Promise<void[]> | void[];\n      dynamic?: boolean;\n    },\n  ): RemotePrerenderFunction<void, Output>;\n  <Input, Output>(\n    validate: \"unchecked\",\n    fn: (arg: Input) => Effect.Effect<Output, unknown, Env>,\n    options?: {\n      inputs?: () => Promise<Input[]> | Input[];\n      dynamic?: boolean;\n    },\n  ): RemotePrerenderFunction<Input, Output>;\n  <Sch extends StandardSchemaV1, Output>(\n    schema: Sch,\n    fn: (arg: StandardSchemaV1.InferOutput<Sch>) => Effect.Effect<Output, unknown, Env>,\n    options?: {\n      inputs?: () =>\n        | Promise<StandardSchemaV1.InferInput<Sch>[]>\n        | StandardSchemaV1.InferInput<Sch>[];\n      dynamic?: boolean;\n    },\n  ): RemotePrerenderFunction<StandardSchemaV1.InferInput<Sch>, Output>;\n  <S extends Schema.Top, Output>(\n    schema: S,\n    fn: (arg: S[\"Type\"]) => Effect.Effect<Output, unknown, Env>,\n    options?: {\n      inputs?: () => Promise<S[\"Encoded\"][]> | S[\"Encoded\"][];\n      dynamic?: boolean;\n    },\n  ): RemotePrerenderFunction<S[\"Encoded\"], Output>;\n}\n\nconst makePrerender = <Env>(run: Runner): PrerenderFn<Env> => {\n  const impl = <In, Out>(\n    arg1: Validator | EffectVoidHandler<Out, Env>,\n    arg2?: EffectHandler<In, Out, Env> | PrerenderOptions<void>,\n    arg3?: PrerenderOptions<In>,\n  ) => {\n    if (isBareHandler<Out, Env>(arg1)) {\n      const handler = arg1;\n      return AppServer.prerender(\n        () => run(handler()),\n        // SAFETY: in the bare-handler overload the second argument is the\n        // (optional) options object, never a handler.\n        arg2 as PrerenderOptions<void> | undefined,\n      );\n    }\n\n    if (!Predicate.isFunction(arg2)) {\n      throw new RemoteFunctionUsageError({\n        message: \"prerender requires a handler function when a schema is provided\",\n      });\n    }\n\n    return AppServer.prerender(toKitValidator(arg1), (arg: In) => run(arg2(arg)), arg3);\n  };\n  // SAFETY: `impl` dispatches on the argument kind exactly as the\n  // `PrerenderFn` overloads distinguish them (bare handler plus options, or\n  // validator, handler and options), and returns kit's\n  // `RemotePrerenderFunction` for that overload.\n  return impl as PrerenderFn<Env>;\n};\n\n/**\n * SvelteKit's `requested` from `$app/server`, passed through. Throws when the\n * installed SvelteKit version does not provide it.\n */\nexport function requested<Result = unknown>(...args: unknown[]): Result {\n  const requestedFn = getRequested();\n  return requestedFn<Result>(...args);\n}\n\n/** A `query` with its `batch` / `live` helpers attached. */\nexport type QueryNamespace<Env> = QueryFn<Env> & {\n  batch: QueryBatchFn<Env>;\n  live: QueryLiveFn<Env>;\n};\n\nconst makeQueryNamespace = <Env>(run: Runner): QueryNamespace<Env> =>\n  Object.assign(makeQuery<Env>(run), {\n    batch: makeQueryBatch<Env>(run),\n    live: makeQueryLive<Env>(run),\n  });\n\n// ── Standalone exports (default SvelteKit per-request runtime) ──────────────\n\n/**\n * SvelteKit's remote `query` with an Effect handler. Accepts `\"unchecked\"`, a\n * Standard Schema or a bare Effect `Schema` as the validator; `query.batch`\n * and `query.live` are attached.\n *\n * Handlers run on the default per-request runtime (`HttpClient` plus\n * `SvelteKitRequestEvent`); a failure that is not a SvelteKit `error()` /\n * `redirect()` becomes a 500. Use {@link withRuntime} to run on your own\n * services.\n */\nexport const query: QueryNamespace<SvelteKitEffectEnv> = makeQueryNamespace(defaultHelpers.run);\n/**\n * SvelteKit's remote `query.batch` with an Effect handler (the same function\n * as `query.batch`).\n *\n * Handlers run on the default per-request runtime (`HttpClient` plus\n * `SvelteKitRequestEvent`); a failure that is not a SvelteKit `error()` /\n * `redirect()` becomes a 500. Use {@link withRuntime} to run on your own\n * services.\n */\nexport const queryBatch: QueryBatchFn<SvelteKitEffectEnv> = query.batch;\n/**\n * SvelteKit's remote `query.live` with an Effect handler that returns an\n * `AsyncIterable` (the same function as `query.live`).\n *\n * Handlers run on the default per-request runtime (`HttpClient` plus\n * `SvelteKitRequestEvent`); a failure that is not a SvelteKit `error()` /\n * `redirect()` becomes a 500. Use {@link withRuntime} to run on your own\n * services.\n */\nexport const queryLive: QueryLiveFn<SvelteKitEffectEnv> = query.live;\n/**\n * SvelteKit's remote `form` with an Effect handler.\n *\n * Handlers run on the default per-request runtime (`HttpClient` plus\n * `SvelteKitRequestEvent`); a failure that is not a SvelteKit `error()` /\n * `redirect()` becomes a 500. Use {@link withRuntime} to run on your own\n * services.\n */\nexport const form: FormFn<SvelteKitEffectEnv> = makeForm(defaultHelpers);\n/**\n * SvelteKit's remote `command` with an Effect handler.\n *\n * Handlers run on the default per-request runtime (`HttpClient` plus\n * `SvelteKitRequestEvent`); a failure that is not a SvelteKit `error()` /\n * `redirect()` becomes a 500. Use {@link withRuntime} to run on your own\n * services.\n */\nexport const command: CommandFn<SvelteKitEffectEnv> = makeCommand(defaultHelpers.run);\n/**\n * SvelteKit's remote `prerender` with an Effect handler.\n *\n * Handlers run on the default per-request runtime (`HttpClient` plus\n * `SvelteKitRequestEvent`); a failure that is not a SvelteKit `error()` /\n * `redirect()` becomes a 500. Use {@link withRuntime} to run on your own\n * services.\n */\nexport const prerender: PrerenderFn<SvelteKitEffectEnv> = makePrerender(defaultHelpers.run);\n\n/** The set of remote-function helpers bound to a particular runner. */\nexport interface RemoteFunctions<Env> {\n  readonly query: QueryNamespace<Env>;\n  readonly form: FormFn<Env>;\n  readonly command: CommandFn<Env>;\n  readonly prerender: PrerenderFn<Env>;\n}\n\n/**\n * Bind the remote-function helpers to a {@link RequestRuntimeProvider} (and an\n * optional boundary error translator), so their handlers run on the provider's\n * services `Env` — your own application catalogue — instead of the fixed\n * {@link SvelteKitServices}. The Standard-Schema / `\"unchecked\"` validation\n * argument and the native return types (`RemoteQueryFunction`, `RemoteForm`,\n * ...) are exactly as the standalone helpers.\n *\n * For remote forms, the failure path runs `opts.formError` when provided —\n * mapping a structured/nested error shape into SvelteKit's field issues (via the\n * `issue` helper / `invalid()`) so a domain validation failure drives\n * field-level invalidation rather than a generic failure. Otherwise the form\n * falls back to `translateError`.\n *\n * @example\n * ```ts\n * const { query, form, command } = RemoteFunction.withRuntime(\n *   RequestRuntime.fromLocals((event) => event.locals.runtime),\n *   {\n *     translateError: toSvelteKit,\n *     formError: (error, { issue }) => {\n *       if (error instanceof ValidationFailure) issue.field(error.field, error.message);\n *       invalid();\n *     },\n *   },\n * );\n *\n * export const items = query(() =>\n *   Effect.gen(function* () {\n *     const db = yield* Database;\n *     return yield* db.list();\n *   }),\n * );\n * ```\n */\nexport function withRuntime<R>(\n  provider: RequestRuntimeProvider<R, any>,\n  opts?: { translateError?: ErrorTranslator; formError?: FormErrorMapper },\n): RemoteFunctions<R> {\n  const helpers = helpersFromProvider(\n    provider,\n    opts?.translateError ?? defaultTranslate,\n    opts?.formError,\n  );\n  return {\n    query: makeQueryNamespace<R>(helpers.run),\n    form: makeForm<R>(helpers),\n    command: makeCommand<R>(helpers.run),\n    prerender: makePrerender<R>(helpers.run),\n  };\n}\n\n/**\n * The remote-function helpers (`query`, `form`, `command`, `prerender`,\n * `requested`) bound to the default per-request runtime; `withRuntime` binds\n * them to your own services.\n */\nexport const RemoteFunction = {\n  query,\n  form,\n  command,\n  prerender,\n  requested,\n  withRuntime,\n};\n"],"mappings":"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"}

package/dist/remote-reactive.d.ts

@@ -1,6 +1,13 @@
 import { RemoteResource } from "$app/server";
 import * as AsyncResult from "effect/reactivity/AsyncResult";
 //#region src/remote-reactive.d.ts
+/**
+ * What {@link useRemoteQuery} returns: the remote resource's state as an
+ * {@link AsyncResult.AsyncResult}, read reactively through `current`.
+ */
+export interface RemoteQueryResult<T> {
+  readonly current: AsyncResult.AsyncResult<T, unknown>;
+}
 /**
  * Bridges a SvelteKit remote resource (`query(...)`, `query.live(...)`,
  * `prerender(...)`) into Effect's native
@@ -29,9 +36,6 @@ import * as AsyncResult from "effect/reactivity/AsyncResult";
  * {/if}
  * ```
  */
-declare function useRemoteQuery<T>(query: RemoteResource<T>): {
-  readonly current: AsyncResult.AsyncResult<T, unknown>;
-};
+export declare function useRemoteQuery<T>(query: RemoteResource<T>): RemoteQueryResult<T>;
 //#endregion
-export { useRemoteQuery };
 //# sourceMappingURL=remote-reactive.d.ts.map

package/dist/remote-reactive.js.map

@@ -1 +1 @@
-{"version":3,"file":"remote-reactive.js","names":[],"sources":["../src/remote-reactive.ts"],"sourcesContent":["import type { RemoteResource } from \"$app/server\";\nimport * as AsyncResult from \"effect/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"}
+{"version":3,"file":"remote-reactive.js","names":[],"sources":["../src/remote-reactive.ts"],"sourcesContent":["import type { RemoteResource } from \"$app/server\";\nimport * as AsyncResult from \"effect/reactivity/AsyncResult\";\n\n/**\n * What {@link useRemoteQuery} returns: the remote resource's state as an\n * {@link AsyncResult.AsyncResult}, read reactively through `current`.\n */\nexport interface RemoteQueryResult<T> {\n  readonly current: AsyncResult.AsyncResult<T, unknown>;\n}\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>): RemoteQueryResult<T> {\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, { waiting: loading });\n      }\n      return AsyncResult.initial<T, unknown>(loading);\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,eAAkB,OAAgD;CAChF,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,SAAS,EAAE,SAAS,QAAQ,CAAC;EAE5E,OAAO,YAAY,QAAoB,OAAO;CAChD,EACF;AACF"}

package/dist/request-parse.d.ts

@@ -1,17 +1,19 @@
 import { SvelteKitRequestEvent } from "./runtime.js";
-import { Effect, Schema } from "effect";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/request-parse.d.ts
 /** A single issue reported by a Standard Schema validator. */
-interface ParseIssue {
+export interface ParseIssue {
   readonly message: string;
   readonly path?: ReadonlyArray<PropertyKey | {
     readonly key: PropertyKey;
   }>;
 }
-declare const ParseError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-  readonly _tag: "ParseError";
-} & Readonly<A>;
+declare const ParseError_base: Schema.Class<ParseError, Schema.TaggedStruct<"ParseError", {
+  /** The validator's issues, in the order it reported them. */
+  readonly issues: Schema.$Array<Schema.Codec<ParseIssue, ParseIssue, never, never>>;
+}>, import("effect/Cause").YieldableError>;
 /**
  * Raised when a schema validator rejects the request data.
  *
@@ -28,9 +30,7 @@ declare const ParseError_base: new <A extends Record<string, any> = {}>(args: im
  * );
  * ```
  */
-declare class ParseError extends ParseError_base<{
-  readonly issues: ReadonlyArray<ParseIssue>;
-}> {}
+export declare class ParseError extends ParseError_base {}
 /**
  * Decode the route `params` object against `schema`.
  *
@@ -43,7 +43,7 @@ declare class ParseError extends ParseError_base<{
  * const { id } = yield* decodeParams(Params);
  * ```
  */
-declare const decodeParams: <O>(schema: Schema.Schema<O> | StandardSchemaV1<unknown, O>) => Effect.Effect<O, ParseError, SvelteKitRequestEvent>;
+export declare const decodeParams: <O>(schema: Schema.Schema<O> | StandardSchemaV1<unknown, O>) => Effect.Effect<O, ParseError, SvelteKitRequestEvent>;
 /**
  * Decode the URL search / query parameters against `schema`.
  *
@@ -56,7 +56,7 @@ declare const decodeParams: <O>(schema: Schema.Schema<O> | StandardSchemaV1<unkn
  * const { page } = yield* decodeSearchParams(Query);
  * ```
  */
-declare const decodeSearchParams: <O>(schema: Schema.Schema<O> | StandardSchemaV1<unknown, O>) => Effect.Effect<O, ParseError, SvelteKitRequestEvent>;
+export declare const decodeSearchParams: <O>(schema: Schema.Schema<O> | StandardSchemaV1<unknown, O>) => Effect.Effect<O, ParseError, SvelteKitRequestEvent>;
 /**
  * Parse the request body as JSON and decode it against `schema`.
  *
@@ -69,7 +69,7 @@ declare const decodeSearchParams: <O>(schema: Schema.Schema<O> | StandardSchemaV
  * const { name } = yield* decodeJson(Body);
  * ```
  */
-declare const decodeJson: <O>(schema: Schema.Schema<O> | StandardSchemaV1<unknown, O>) => Effect.Effect<O, ParseError, SvelteKitRequestEvent>;
+export declare const decodeJson: <O>(schema: Schema.Schema<O> | StandardSchemaV1<unknown, O>) => Effect.Effect<O, ParseError, SvelteKitRequestEvent>;
 /**
  * Parse the request body as `FormData` and decode it against `schema`.
  *
@@ -82,7 +82,7 @@ declare const decodeJson: <O>(schema: Schema.Schema<O> | StandardSchemaV1<unknow
  * const { email } = yield* decodeFormData(Form);
  * ```
  */
-declare const decodeFormData: <O>(schema: Schema.Schema<O> | StandardSchemaV1<unknown, O>) => Effect.Effect<O, ParseError, SvelteKitRequestEvent>;
+export declare const decodeFormData: <O>(schema: Schema.Schema<O> | StandardSchemaV1<unknown, O>) => Effect.Effect<O, ParseError, SvelteKitRequestEvent>;
 //#endregion
-export { ParseError, ParseIssue, decodeFormData, decodeJson, decodeParams, decodeSearchParams };
+export {};
 //# sourceMappingURL=request-parse.d.ts.map

package/dist/request-parse.js

@@ -1,7 +1,15 @@
 import { SvelteKitRequestEvent } from "./runtime.js";
 import { toStandardValidator } from "./internal/remote-validators.js";
-import { Data, Effect } from "effect";
+import * as Effect from "effect/Effect";
+import * as Rec from "effect/Record";
+import * as Arr from "effect/Array";
+import * as Schema from "effect/Schema";
 //#region src/request-parse.ts
+/** The schema of a {@link ParseIssue}, so {@link ParseError} can carry it. */
+const ParseIssue = Schema.Struct({
+	message: Schema.String,
+	path: Schema.optionalKey(Schema.Array(Schema.Union([Schema.PropertyKey, Schema.Struct({ key: Schema.PropertyKey })])))
+});
 /**
 * Raised when a schema validator rejects the request data.
 *
@@ -18,13 +26,17 @@ import { Data, Effect } from "effect";
 * );
 * ```
 */
-var ParseError = class extends Data.TaggedError("ParseError") {};
+var ParseError = class extends Schema.TaggedError()("ParseError", { 
+/** The validator's issues, in the order it reported them. */
+issues: Schema.Array(ParseIssue) }) {};
 /** Validate `value` against `schema` and return the typed output or fail. */
 const validate = (schema, value) => Effect.callback((resume) => {
 	const resultOrPromise = schema["~standard"].validate(value);
 	const settle = (result) => {
-		if ("issues" in result && result.issues !== void 0) resume(Effect.fail(new ParseError({ issues: result.issues })));
-		else resume(Effect.succeed(result.value));
+		if (result.issues !== void 0) {
+			const issues = result.issues;
+			resume(Effect.fail(new ParseError({ issues })));
+		} else resume(Effect.succeed(result.value));
 	};
 	if (resultOrPromise instanceof Promise) resultOrPromise.then(settle, (err) => {
 		resume(Effect.fail(new ParseError({ issues: [{ message: String(err) }] })));
@@ -33,6 +45,16 @@ const validate = (schema, value) => Effect.callback((resume) => {
 });
 /** Normalise an Effect Schema or Standard Schema V1 to Standard Schema V1. */
 const normalise = (schema) => toStandardValidator(schema);
+/** A field's values: the sole value of a single-valued field, else all of them. */
+const fieldValue = (values) => {
+	const [first, ...others] = values;
+	return first !== void 0 && Arr.isReadonlyArrayEmpty(others) ? first : values;
+};
+/**
+* Collect multi-valued fields (search params, form data) into a plain object,
+* keyed in first-occurrence order.
+*/
+const collectFields = (keys, getAll) => Rec.fromIterableWith(keys, (key) => [key, fieldValue(getAll(key))]);
 /**
 * Decode the route `params` object against `schema`.
 *
@@ -62,12 +84,8 @@ const decodeParams = (schema) => Effect.gen(function* () {
 * ```
 */
 const decodeSearchParams = (schema) => Effect.gen(function* () {
-	const event = yield* SvelteKitRequestEvent;
-	const raw = {};
-	for (const key of event.url.searchParams.keys()) {
-		const values = event.url.searchParams.getAll(key);
-		raw[key] = values.length === 1 ? values[0] : values;
-	}
+	const { searchParams } = (yield* SvelteKitRequestEvent).url;
+	const raw = collectFields(searchParams.keys(), (key) => searchParams.getAll(key));
 	return yield* validate(normalise(schema), raw);
 });
 /**
@@ -108,11 +126,7 @@ const decodeFormData = (schema) => Effect.gen(function* () {
 		try: () => event.request.formData(),
 		catch: (err) => new ParseError({ issues: [{ message: `Failed to read form data: ${String(err)}` }] })
 	});
-	const raw = {};
-	for (const key of formData.keys()) {
-		const values = formData.getAll(key).map(String);
-		raw[key] = values.length === 1 ? values[0] : values;
-	}
+	const raw = collectFields(formData.keys(), (key) => Arr.map(formData.getAll(key), String));
 	return yield* validate(normalise(schema), raw);
 });
 //#endregion