svelte-effect-runtime 1.0.0

package/dist/root-node.d.ts

@@ -0,0 +1,14 @@
+import type * as Server_module from "./server.ts";
+export * from "./mod.ts";
+export * from "./vite.ts";
+export type * from "./server.ts";
+export type { EffectPluginOptions } from "./effect.ts";
+export { effect } from "./effect.ts";
+export declare const Query: typeof Server_module.Query;
+export declare const Command: typeof Server_module.Command;
+export declare const Form: typeof Server_module.Form;
+export declare const Prerender: typeof Server_module.Prerender;
+export declare const RequestEvent: typeof Server_module.RequestEvent;
+export declare const ServerRuntime: typeof Server_module.ServerRuntime;
+export declare const create_effect_transport: typeof Server_module.create_effect_transport;
+export declare const get_server_runtime_or_throw: typeof Server_module.get_server_runtime_or_throw;

package/dist/root-node.js

@@ -0,0 +1,8 @@
+import { transformEffectMarkup } from "./internal/markup.js";
+import { transformEffectScript } from "./internal/transform.js";
+import { effectPreprocess } from "./preprocess.js";
+import { ClientRuntime, ClientRuntimeTag, getEffectRuntimeOrThrow, provideEffectRuntime, registerHotDispose, runComponentEffect, runInlineEffect, to_effect, to_native } from "./client.js";
+import "./mod.js";
+import { svelteEffectRuntime, sveltekitEffectRuntime } from "./vite.js";
+import { effect } from "./effect.js";
+export { ClientRuntime, ClientRuntimeTag, effect, effectPreprocess, getEffectRuntimeOrThrow, provideEffectRuntime, registerHotDispose, runComponentEffect, runInlineEffect, svelteEffectRuntime, sveltekitEffectRuntime, to_effect, to_native, transformEffectMarkup, transformEffectScript };

package/dist/server.d.ts

@@ -0,0 +1,129 @@
+import { getRequestEvent as get_native_request_event } from "$app/server";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as ManagedRuntime from "effect/ManagedRuntime";
+import * as Schema from "effect/Schema";
+import { type FormError } from "./internal/remote-shared.ts";
+type EffectSchema = Schema.Schema.Any;
+export interface Transporter<T = unknown, U = {
+    value: unknown;
+}> {
+    decode: (data: U) => T;
+    encode: (value: T) => false | U;
+}
+export type Transport = Record<string, Transporter>;
+export interface RemoteFormInput {
+    [key: string]: string | number | boolean | File | RemoteFormInput | Array<string | number | boolean | File | RemoteFormInput>;
+}
+export type RemoteQueryFunction<Input, Output> = (arg: OptionalArgument<Input>) => Promise<Output>;
+export type RemoteCommand<Input, Output> = ((arg: OptionalArgument<Input>) => Promise<Output> & {
+    updates(...updates: Array<unknown>): Promise<Output>;
+}) & {
+    readonly pending: number;
+};
+export type RemotePrerenderFunction<Input, Output> = (arg: OptionalArgument<Input>) => Promise<Output>;
+export type RemoteForm<Input extends RemoteFormInput | void, Output> = {
+    readonly action: string;
+    enhance: (...args: Array<unknown>) => {
+        readonly action: string;
+        readonly method: "POST";
+    };
+    fields: Record<string, unknown>;
+    for: (id: string | number) => RemoteForm<Input, Output>;
+    readonly method: "POST";
+    readonly pending: number;
+    preflight: (schema: unknown) => RemoteForm<Input, Output>;
+    readonly result: Output | undefined;
+    validate: (options?: {
+        includeUntouched?: boolean;
+        preflightOnly?: boolean;
+    }) => Promise<void>;
+    [attachment: symbol]: (node: HTMLFormElement) => void;
+};
+type RuntimeOperator = (self: Layer.Layer<unknown, unknown, unknown>) => Layer.Layer<unknown, unknown, unknown>;
+type RuntimeSeedLayer<Requirements> = Layer.Layer<Requirements, never, Requirements>;
+type ProvidedBy<Op> = Op extends (self: RuntimeSeedLayer<infer Requirements>) => Layer.Layer<unknown, unknown, infer Incoming> ? Exclude<Requirements, Incoming> : never;
+type ProvidedByAll<Ops extends ReadonlyArray<RuntimeOperator>> = Ops extends readonly [infer Head, ...infer Tail] ? ProvidedBy<Head> | ProvidedByAll<Extract<Tail, ReadonlyArray<RuntimeOperator>>> : never;
+type ApplyOperator<Seed, Op> = Op extends (self: Seed) => infer Out ? Out : never;
+type ApplyOperators<Seed, Ops extends ReadonlyArray<RuntimeOperator>> = Ops extends readonly [infer Head, ...infer Tail] ? ApplyOperators<ApplyOperator<Seed, Head>, Extract<Tail, ReadonlyArray<RuntimeOperator>>> : Seed;
+type FinalRuntimeLayer<Ops extends ReadonlyArray<RuntimeOperator>> = ApplyOperators<RuntimeSeedLayer<ProvidedByAll<Ops>>, Ops> extends infer Out ? Out extends Layer.Layer<unknown, unknown, infer Incoming> ? [Incoming] extends [never] ? Out : never : never : never;
+type OptionalArgument<Input> = undefined extends Input ? Input | void : Input;
+type SchemaInput<SchemaType extends EffectSchema> = Schema.Schema.Encoded<SchemaType>;
+type SchemaOutput<SchemaType extends EffectSchema> = Schema.Schema.Type<SchemaType>;
+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>;
+export type Invalid<SchemaType = unknown> = {
+    form: (message: string) => Effect.Effect<never, FormError<SchemaType>, never>;
+} & FieldHelpers<SchemaType extends EffectSchema ? SchemaOutput<SchemaType> : unknown, SchemaType>;
+export type EffectQueryFunction<Input, Output, Error = never> = ((arg: OptionalArgument<Input>) => Effect.Effect<Output, import("./internal/remote-shared.ts").RemoteFailure<Error>, never>) & {
+    native: RemoteQueryFunction<Input, Output>;
+};
+export type EffectCommand<Input, Output, Error = never> = ((arg: OptionalArgument<Input>) => Effect.Effect<Output, import("./internal/remote-shared.ts").RemoteFailure<Error>, never>) & {
+    native: RemoteCommand<Input, Output>;
+    readonly pending: number;
+};
+export type EffectPrerenderFunction<Input, Output, Error = never> = ((arg: OptionalArgument<Input>) => Effect.Effect<Output, import("./internal/remote-shared.ts").RemoteFailure<Error>, never>) & {
+    native: RemotePrerenderFunction<Input, Output>;
+};
+export type EffectForm<Input extends RemoteFormInput | void, Output, Error = never> = RemoteForm<Input, Output> & {
+    native: RemoteForm<Input, Output>;
+    submit(data: OptionalArgument<Input>): Effect.Effect<Output, import("./internal/remote-shared.ts").RemoteFailure<Error>, never>;
+    for: RemoteForm<Input, Output>["for"] extends (...args: infer Args) => infer Result ? (...args: Args) => EffectForm<Input, Output, Error> : never;
+};
+export type RequestEventService = ReturnType<typeof get_native_request_event>;
+export declare const RequestEvent: Context.Tag<import("@sveltejs/kit").RequestEvent<Record<string, string>, string | null>, import("@sveltejs/kit").RequestEvent<Record<string, string>, string | null>>;
+interface ServerRuntimeSeed {
+    pipe(): Layer.Layer<never>;
+    pipe<const Ops extends readonly [RuntimeOperator, ...Array<RuntimeOperator>]>(...ops: Ops): FinalRuntimeLayer<Ops>;
+    make(): void;
+    make<const Ops extends readonly [RuntimeOperator, ...Array<RuntimeOperator>]>(...ops: Ops): void;
+}
+type ServerManagedRuntime = ManagedRuntime.ManagedRuntime<unknown, unknown>;
+export declare const ServerRuntime: ServerRuntimeSeed;
+export declare function get_server_runtime_or_throw(): ServerManagedRuntime;
+export declare function create_effect_transport<const Schemas extends Record<string, EffectSchema>>(schemas: Schemas): Transport;
+export interface EffectQueryFactory {
+    <Output, ErrorType, Requirements>(fn: () => Effect.Effect<Output, ErrorType, Requirements>): EffectQueryFunction<void, Output, ErrorType>;
+    <Input, Output, ErrorType, Requirements>(validate: "unchecked", fn: (arg: Input) => Effect.Effect<Output, ErrorType, Requirements>): EffectQueryFunction<Input, Output, ErrorType>;
+    <SchemaType extends EffectSchema, Output, ErrorType, Requirements>(validate: SchemaType, fn: (arg: SchemaOutput<SchemaType>) => Effect.Effect<Output, ErrorType, Requirements>): EffectQueryFunction<SchemaInput<SchemaType>, Output, ErrorType>;
+    batch: typeof query_batch_factory;
+}
+type RemotePrerenderInputsGenerator<Input> = (event: RequestEventService) => AsyncIterable<Input> | Iterable<Input>;
+declare function query_batch_factory(validate_or_fn: unknown, maybe_fn?: unknown): unknown;
+export declare const Query: EffectQueryFactory;
+export interface EffectCommandFactory {
+    <Output, ErrorType, Requirements>(fn: () => Effect.Effect<Output, ErrorType, Requirements>): EffectCommand<void, Output, ErrorType>;
+    <Input, Output, ErrorType, Requirements>(validate: "unchecked", fn: (arg: Input) => Effect.Effect<Output, ErrorType, Requirements>): EffectCommand<Input, Output, ErrorType>;
+    <SchemaType extends EffectSchema, Output, ErrorType, Requirements>(validate: SchemaType, fn: (arg: SchemaOutput<SchemaType>) => Effect.Effect<Output, ErrorType, Requirements>): EffectCommand<SchemaInput<SchemaType>, Output, ErrorType>;
+}
+export declare const Command: EffectCommandFactory;
+export interface EffectFormFactory {
+    <Output, ErrorType, Requirements>(fn: () => Effect.Effect<Output, ErrorType, Requirements>): EffectForm<void, Output, ErrorType>;
+    <Input extends RemoteFormInput, Output, ErrorType, Requirements>(validate: "unchecked", fn: (args: {
+        data: Input;
+        invalid: Invalid;
+    }) => Effect.Effect<Output, ErrorType | FormError, Requirements>): EffectForm<Input, Output, ErrorType>;
+    <SchemaType extends EffectSchema, Output, ErrorType, Requirements>(validate: SchemaType, fn: (args: {
+        data: SchemaOutput<SchemaType>;
+        invalid: Invalid<SchemaType>;
+    }) => Effect.Effect<Output, ErrorType | FormError<SchemaType>, Requirements>): EffectForm<SchemaInput<SchemaType> & RemoteFormInput, Output, ErrorType>;
+}
+export declare const Form: EffectFormFactory;
+export interface EffectPrerenderFactory {
+    <Output, ErrorType, Requirements>(fn: () => Effect.Effect<Output, ErrorType, Requirements>, options?: {
+        inputs?: RemotePrerenderInputsGenerator<void>;
+        dynamic?: boolean;
+    }): EffectPrerenderFunction<void, Output, ErrorType>;
+    <Input, Output, ErrorType, Requirements>(validate: "unchecked", fn: (arg: Input) => Effect.Effect<Output, ErrorType, Requirements>, options?: {
+        inputs?: RemotePrerenderInputsGenerator<Input>;
+        dynamic?: boolean;
+    }): EffectPrerenderFunction<Input, Output, ErrorType>;
+    <SchemaType extends EffectSchema, Output, ErrorType, Requirements>(validate: SchemaType, fn: (arg: SchemaOutput<SchemaType>) => Effect.Effect<Output, ErrorType, Requirements>, options?: {
+        inputs?: RemotePrerenderInputsGenerator<SchemaInput<SchemaType>>;
+        dynamic?: boolean;
+    }): EffectPrerenderFunction<SchemaInput<SchemaType>, Output, ErrorType>;
+}
+export declare const Prerender: EffectPrerenderFactory;
+export {};

package/dist/server.js

@@ -0,0 +1,494 @@
+import { create_form_error, create_serialized_remote_failure_envelope, is_form_error } from "./internal/remote-shared.js";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as ManagedRuntime from "effect/ManagedRuntime";
+import * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
+import { error, invalid } from "@sveltejs/kit";
+import { command, form, getRequestEvent, prerender, query } from "$app/server";
+import { get_request_store } from "@sveltejs/kit/internal/server";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as Schema_ast from "effect/SchemaAST";
+//#region node_modules/devalue/src/utils.js
+var DevalueError = class extends Error {
+	/**
+	* @param {string} message
+	* @param {string[]} keys
+	* @param {any} [value] - The value that failed to be serialized
+	* @param {any} [root] - The root value being serialized
+	*/
+	constructor(message, keys, value, root) {
+		super(message);
+		this.name = "DevalueError";
+		this.path = keys.join("");
+		this.value = value;
+		this.root = root;
+	}
+};
+/** @param {any} thing */
+function is_primitive(thing) {
+	return thing === null || typeof thing !== "object" && typeof thing !== "function";
+}
+const object_proto_names = /* @__PURE__ */ Object.getOwnPropertyNames(Object.prototype).sort().join("\0");
+/** @param {any} thing */
+function is_plain_object(thing) {
+	const proto = Object.getPrototypeOf(thing);
+	return proto === Object.prototype || proto === null || Object.getPrototypeOf(proto) === null || Object.getOwnPropertyNames(proto).sort().join("\0") === object_proto_names;
+}
+/** @param {any} thing */
+function get_type(thing) {
+	return Object.prototype.toString.call(thing).slice(8, -1);
+}
+/** @param {string} char */
+function get_escaped_char(char) {
+	switch (char) {
+		case "\"": return "\\\"";
+		case "<": return "\\u003C";
+		case "\\": return "\\\\";
+		case "\n": return "\\n";
+		case "\r": return "\\r";
+		case "	": return "\\t";
+		case "\b": return "\\b";
+		case "\f": return "\\f";
+		case "\u2028": return "\\u2028";
+		case "\u2029": return "\\u2029";
+		default: return char < " " ? `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}` : "";
+	}
+}
+/** @param {string} str */
+function stringify_string(str) {
+	let result = "";
+	let last_pos = 0;
+	const len = str.length;
+	for (let i = 0; i < len; i += 1) {
+		const char = str[i];
+		const replacement = get_escaped_char(char);
+		if (replacement) {
+			result += str.slice(last_pos, i) + replacement;
+			last_pos = i + 1;
+		}
+	}
+	return `"${last_pos === 0 ? str : result + str.slice(last_pos)}"`;
+}
+/** @param {Record<string | symbol, any>} object */
+function enumerable_symbols(object) {
+	return Object.getOwnPropertySymbols(object).filter((symbol) => Object.getOwnPropertyDescriptor(object, symbol).enumerable);
+}
+const is_identifier = /^[a-zA-Z_$][a-zA-Z_$0-9]*$/;
+/** @param {string} key */
+function stringify_key(key) {
+	return is_identifier.test(key) ? "." + key : "[" + JSON.stringify(key) + "]";
+}
+/** @param {string} s */
+function is_valid_array_index(s) {
+	if (s.length === 0) return false;
+	if (s.length > 1 && s.charCodeAt(0) === 48) return false;
+	for (let i = 0; i < s.length; i++) {
+		const c = s.charCodeAt(i);
+		if (c < 48 || c > 57) return false;
+	}
+	const n = +s;
+	if (n >= 2 ** 32 - 1) return false;
+	if (n < 0) return false;
+	return true;
+}
+/**
+* Finds the populated indices of an array.
+* @param {unknown[]} array
+*/
+function valid_array_indices(array) {
+	const keys = Object.keys(array);
+	for (var i = keys.length - 1; i >= 0; i--) if (is_valid_array_index(keys[i])) break;
+	keys.length = i + 1;
+	return keys;
+}
+//#endregion
+//#region node_modules/devalue/src/base64.js
+/**	@type {(array_buffer: ArrayBuffer) => string} */
+function encode_native(array_buffer) {
+	return new Uint8Array(array_buffer).toBase64();
+}
+/** @type {(array_buffer: ArrayBuffer) => string} */
+function encode_buffer(array_buffer) {
+	return Buffer.from(array_buffer).toString("base64");
+}
+/** @type {(array_buffer: ArrayBuffer) => string} */
+function encode_legacy(array_buffer) {
+	const array = new Uint8Array(array_buffer);
+	let binary = "";
+	const chunk_size = 32768;
+	for (let i = 0; i < array.length; i += chunk_size) {
+		const chunk = array.subarray(i, i + chunk_size);
+		binary += String.fromCharCode.apply(null, chunk);
+	}
+	return btoa(binary);
+}
+const native = typeof Uint8Array.fromBase64 === "function";
+const buffer = typeof process === "object" && process.versions?.node !== void 0;
+const encode64 = native ? encode_native : buffer ? encode_buffer : encode_legacy;
+//#endregion
+//#region node_modules/devalue/src/stringify.js
+/**
+* Turn a value into a JSON string that can be parsed with `devalue.parse`
+* @param {any} value
+* @param {Record<string, (value: any) => any>} [reducers]
+*/
+function stringify(value, reducers) {
+	/** @type {any[]} */
+	const stringified = [];
+	/** @type {Map<any, number>} */
+	const indexes = /* @__PURE__ */ new Map();
+	/** @type {Array<{ key: string, fn: (value: any) => any }>} */
+	const custom = [];
+	if (reducers) for (const key of Object.getOwnPropertyNames(reducers)) custom.push({
+		key,
+		fn: reducers[key]
+	});
+	/** @type {string[]} */
+	const keys = [];
+	let p = 0;
+	/** @param {any} thing */
+	function flatten(thing) {
+		if (thing === void 0) return -1;
+		if (Number.isNaN(thing)) return -3;
+		if (thing === Infinity) return -4;
+		if (thing === -Infinity) return -5;
+		if (thing === 0 && 1 / thing < 0) return -6;
+		if (indexes.has(thing)) return indexes.get(thing);
+		const index = p++;
+		indexes.set(thing, index);
+		for (const { key, fn } of custom) {
+			const value = fn(thing);
+			if (value) {
+				stringified[index] = `["${key}",${flatten(value)}]`;
+				return index;
+			}
+		}
+		if (typeof thing === "function") throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
+		else if (typeof thing === "symbol") throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
+		let str = "";
+		if (is_primitive(thing)) str = stringify_primitive(thing);
+		else {
+			const type = get_type(thing);
+			switch (type) {
+				case "Number":
+				case "String":
+				case "Boolean":
+				case "BigInt":
+					str = `["Object",${flatten(thing.valueOf())}]`;
+					break;
+				case "Date":
+					str = `["Date","${!isNaN(thing.getDate()) ? thing.toISOString() : ""}"]`;
+					break;
+				case "URL":
+					str = `["URL",${stringify_string(thing.toString())}]`;
+					break;
+				case "URLSearchParams":
+					str = `["URLSearchParams",${stringify_string(thing.toString())}]`;
+					break;
+				case "RegExp":
+					const { source, flags } = thing;
+					str = flags ? `["RegExp",${stringify_string(source)},"${flags}"]` : `["RegExp",${stringify_string(source)}]`;
+					break;
+				case "Array": {
+					let mostly_dense = false;
+					str = "[";
+					for (let i = 0; i < thing.length; i += 1) {
+						if (i > 0) str += ",";
+						if (Object.hasOwn(thing, i)) {
+							keys.push(`[${i}]`);
+							str += flatten(thing[i]);
+							keys.pop();
+						} else if (mostly_dense) str += -2;
+						else {
+							const populated_keys = valid_array_indices(thing);
+							const population = populated_keys.length;
+							const d = String(thing.length).length;
+							if ((thing.length - population) * 3 > 4 + d + population * (d + 1)) {
+								str = "[-7," + thing.length;
+								for (let j = 0; j < populated_keys.length; j++) {
+									const key = populated_keys[j];
+									keys.push(`[${key}]`);
+									str += "," + key + "," + flatten(thing[key]);
+									keys.pop();
+								}
+								break;
+							} else {
+								mostly_dense = true;
+								str += -2;
+							}
+						}
+					}
+					str += "]";
+					break;
+				}
+				case "Set":
+					str = "[\"Set\"";
+					for (const value of thing) str += `,${flatten(value)}`;
+					str += "]";
+					break;
+				case "Map":
+					str = "[\"Map\"";
+					for (const [key, value] of thing) {
+						keys.push(`.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`);
+						str += `,${flatten(key)},${flatten(value)}`;
+						keys.pop();
+					}
+					str += "]";
+					break;
+				case "Int8Array":
+				case "Uint8Array":
+				case "Uint8ClampedArray":
+				case "Int16Array":
+				case "Uint16Array":
+				case "Float16Array":
+				case "Int32Array":
+				case "Uint32Array":
+				case "Float32Array":
+				case "Float64Array":
+				case "BigInt64Array":
+				case "BigUint64Array":
+				case "DataView": {
+					/** @type {import("./types.js").TypedArray} */
+					const typedArray = thing;
+					str = "[\"" + type + "\"," + flatten(typedArray.buffer);
+					if (typedArray.byteLength !== typedArray.buffer.byteLength) str += `,${typedArray.byteOffset},${typedArray.length}`;
+					str += "]";
+					break;
+				}
+				case "ArrayBuffer":
+					str = `["ArrayBuffer","${encode64(thing)}"]`;
+					break;
+				case "Temporal.Duration":
+				case "Temporal.Instant":
+				case "Temporal.PlainDate":
+				case "Temporal.PlainTime":
+				case "Temporal.PlainDateTime":
+				case "Temporal.PlainMonthDay":
+				case "Temporal.PlainYearMonth":
+				case "Temporal.ZonedDateTime":
+					str = `["${type}",${stringify_string(thing.toString())}]`;
+					break;
+				default:
+					if (!is_plain_object(thing)) throw new DevalueError(`Cannot stringify arbitrary non-POJOs`, keys, thing, value);
+					if (enumerable_symbols(thing).length > 0) throw new DevalueError(`Cannot stringify POJOs with symbolic keys`, keys, thing, value);
+					if (Object.getPrototypeOf(thing) === null) {
+						str = "[\"null\"";
+						for (const key of Object.keys(thing)) {
+							if (key === "__proto__") throw new DevalueError(`Cannot stringify objects with __proto__ keys`, keys, thing, value);
+							keys.push(stringify_key(key));
+							str += `,${stringify_string(key)},${flatten(thing[key])}`;
+							keys.pop();
+						}
+						str += "]";
+					} else {
+						str = "{";
+						let started = false;
+						for (const key of Object.keys(thing)) {
+							if (key === "__proto__") throw new DevalueError(`Cannot stringify objects with __proto__ keys`, keys, thing, value);
+							if (started) str += ",";
+							started = true;
+							keys.push(stringify_key(key));
+							str += `${stringify_string(key)}:${flatten(thing[key])}`;
+							keys.pop();
+						}
+						str += "}";
+					}
+			}
+		}
+		stringified[index] = str;
+		return index;
+	}
+	const index = flatten(value);
+	if (index < 0) return `${index}`;
+	return `[${stringified.join(",")}]`;
+}
+/**
+* @param {any} thing
+* @returns {string}
+*/
+function stringify_primitive(thing) {
+	const type = typeof thing;
+	if (type === "string") return stringify_string(thing);
+	if (thing === void 0) return (-1).toString();
+	if (thing === 0 && 1 / thing < 0) return (-6).toString();
+	if (type === "bigint") return `["BigInt","${thing}"]`;
+	return String(thing);
+}
+//#endregion
+//#region server.ts
+const RequestEvent = Context.GenericTag("svelte-effect-runtime/RequestEvent");
+let current_server_runtime = null;
+function runtime_seed() {
+	return Layer.effectContext(Effect.context());
+}
+function pipe_server_runtime(...ops) {
+	if (ops.length === 0) return Layer.empty;
+	return ops.reduce((layer, op) => op(layer), runtime_seed());
+}
+function make_server_runtime(...ops) {
+	const layer = ops.length === 0 ? pipe_server_runtime() : pipe_server_runtime(...ops);
+	const previous_runtime = current_server_runtime;
+	current_server_runtime = ManagedRuntime.make(layer);
+	previous_runtime?.dispose().catch(() => void 0);
+}
+const ServerRuntime = {
+	pipe: pipe_server_runtime,
+	make: make_server_runtime
+};
+function get_server_runtime_or_throw() {
+	if (current_server_runtime === null) throw new Error("No server Effect runtime found. Call ServerRuntime.make(...) from src/hooks.server.ts via `export const init = () => { ... }` before executing remote functions.");
+	return current_server_runtime;
+}
+function is_effect_schema(value) {
+	return Schema.isSchema(value);
+}
+function get_effect_schema_validator(schema) {
+	return Schema.standardSchemaV1(schema);
+}
+function get_effect_form_validator(schema) {
+	return Schema.standardSchemaV1(schema);
+}
+function resolve_remote_args(validate_or_fn, maybe_fn) {
+	if (maybe_fn === void 0) return {
+		fn: validate_or_fn,
+		validate: void 0
+	};
+	if (validate_or_fn === "unchecked") return {
+		fn: maybe_fn,
+		validate: "unchecked"
+	};
+	if (!is_effect_schema(validate_or_fn)) throw new Error("Invalid schema passed to a remote function. Use Effect.Schema, 'unchecked', or omit the validator entirely.");
+	return {
+		fn: maybe_fn,
+		validate: validate_or_fn
+	};
+}
+function get_remote_failure_status(failure) {
+	if (failure && typeof failure === "object" && typeof failure.status === "number") return failure.status;
+	return 500;
+}
+function log_remote_server_step(step, details) {
+	console.log("[svelte-effect-runtime][server]", step, details ?? {});
+}
+function encode_remote_failure(failure) {
+	log_remote_server_step("encode_remote_failure:start", { failure });
+	const { state } = get_request_store();
+	const encoded = stringify(failure, Object.fromEntries(Object.entries(state.transport).map(([name, transporter]) => [name, transporter.encode])));
+	throw error(get_remote_failure_status(failure), {
+		message: "Effect remote failure",
+		...create_serialized_remote_failure_envelope(encoded)
+	});
+}
+function throw_form_error(form_error) {
+	log_remote_server_step("throw_form_error", { issues: form_error.issues });
+	invalid(...form_error.issues.map((issue) => ({
+		message: issue.message,
+		path: [...issue.path]
+	})));
+}
+async function run_remote_effect(program) {
+	const request_event = getRequestEvent();
+	const runtime = get_server_runtime_or_throw();
+	log_remote_server_step("run_remote_effect:start", {
+		method: request_event.request.method,
+		url: request_event.url.toString()
+	});
+	const provided_program = Effect.provideService(program, RequestEvent, request_event);
+	const exit = await runtime.runPromiseExit(provided_program);
+	if (Exit.isSuccess(exit)) {
+		log_remote_server_step("run_remote_effect:success", { value: exit.value });
+		return exit.value;
+	}
+	const failure = Cause.failureOption(exit.cause);
+	if (Option.isSome(failure)) {
+		log_remote_server_step("run_remote_effect:failure", { failure: failure.value });
+		if (is_form_error(failure.value)) throw_form_error(failure.value);
+		encode_remote_failure(failure.value);
+	}
+	log_remote_server_step("run_remote_effect:defect", { cause: exit.cause });
+	throw Cause.squash(exit.cause);
+}
+function get_schema_field_names(schema) {
+	return Schema_ast.getPropertySignatures(schema.ast).map((property_signature) => property_signature.name).filter((name) => typeof name === "string");
+}
+function create_invalid_helper(options = {}) {
+	const field_names = options.schema ? new Set(get_schema_field_names(options.schema)) : null;
+	const create_issue_effect = (message, path) => Effect.fail(create_form_error({
+		message,
+		path
+	}));
+	return new Proxy({ form(message) {
+		return create_issue_effect(message, []);
+	} }, { get(target, property) {
+		if (typeof property !== "string") return Reflect.get(target, property);
+		if (property in target) return target[property];
+		if (field_names !== null && !field_names.has(property)) throw new Error(`Unknown form field '${property}' in invalid helper. v1 only supports top-level fields declared in the Effect.Schema.`);
+		return (message) => create_issue_effect(message, [property]);
+	} });
+}
+function define_native_property(value, native) {
+	Object.defineProperty(value, "native", {
+		value: native,
+		enumerable: false
+	});
+	return value;
+}
+function create_effect_transport(schemas) {
+	return Object.fromEntries(Object.entries(schemas).map(([name, schema]) => {
+		return [name, {
+			encode(value) {
+				try {
+					return Schema.is(schema)(value) ? { value: Schema.encodeSync(schema)(value) } : false;
+				} catch {
+					return false;
+				}
+			},
+			decode(data) {
+				return Schema.decodeSync(schema)(data.value);
+			}
+		}];
+	}));
+}
+function create_native_wrapper(value) {
+	return define_native_property(value, value);
+}
+function query_batch_factory(validate_or_fn, maybe_fn) {
+	const resolved = resolve_remote_args(validate_or_fn, maybe_fn);
+	if (resolved.validate === void 0) throw new Error("Query.batch requires either 'unchecked' or an Effect.Schema validator to match SvelteKit's native API.");
+	return create_native_wrapper(resolved.validate === "unchecked" ? query.batch("unchecked", (args) => run_remote_effect(resolved.fn(args))) : query.batch(get_effect_schema_validator(resolved.validate), (args) => run_remote_effect(resolved.fn(args))));
+}
+const query_impl = (validate_or_fn, maybe_fn) => {
+	const resolved = resolve_remote_args(validate_or_fn, maybe_fn);
+	return create_native_wrapper(resolved.validate === void 0 ? query(() => run_remote_effect(resolved.fn())) : resolved.validate === "unchecked" ? query("unchecked", (arg) => run_remote_effect(resolved.fn(arg))) : query(get_effect_schema_validator(resolved.validate), (arg) => run_remote_effect(resolved.fn(arg))));
+};
+const Query = Object.assign(query_impl, { batch: query_batch_factory });
+const command_impl = (validate_or_fn, maybe_fn) => {
+	const resolved = resolve_remote_args(validate_or_fn, maybe_fn);
+	return create_native_wrapper(resolved.validate === void 0 ? command(() => run_remote_effect(resolved.fn())) : resolved.validate === "unchecked" ? command("unchecked", (arg) => run_remote_effect(resolved.fn(arg))) : command(get_effect_schema_validator(resolved.validate), (arg) => run_remote_effect(resolved.fn(arg))));
+};
+const Command = command_impl;
+const form_impl = (validate_or_fn, maybe_fn) => {
+	const resolved = resolve_remote_args(validate_or_fn, maybe_fn);
+	return create_native_wrapper(resolved.validate === void 0 ? form(() => run_remote_effect(resolved.fn())) : resolved.validate === "unchecked" ? form("unchecked", (data) => run_remote_effect(resolved.fn({
+		data,
+		invalid: create_invalid_helper()
+	}))) : form(get_effect_form_validator(resolved.validate), (data) => run_remote_effect(resolved.fn({
+		data,
+		invalid: create_invalid_helper({ schema: resolved.validate })
+	}))));
+};
+const Form = form_impl;
+const native_prerender_fn = prerender;
+const prerender_impl = (validate_or_fn, fn_or_options, maybe_options) => {
+	if (typeof validate_or_fn === "function" && typeof fn_or_options !== "function") return create_native_wrapper(native_prerender_fn(() => run_remote_effect(validate_or_fn()), fn_or_options));
+	const resolved = resolve_remote_args(validate_or_fn, fn_or_options);
+	return create_native_wrapper(resolved.validate === "unchecked" ? native_prerender_fn("unchecked", (arg) => run_remote_effect(resolved.fn(arg)), maybe_options) : native_prerender_fn(get_effect_schema_validator(resolved.validate), (arg) => run_remote_effect(resolved.fn(arg)), maybe_options));
+};
+const Prerender = prerender_impl;
+//#endregion
+export { Command, Form, Prerender, Query, RequestEvent, ServerRuntime, create_effect_transport, get_server_runtime_or_throw };
+
+//# sourceMappingURL=server.js.map