svelte-effect-runtime 4.0.0 → 4.0.1

package/.dist/chunks/client-BrZka6DW.js

@@ -0,0 +1,530 @@
+import { A as UnsupportedRemoteFormResponseError, c as InvalidLiveQueryFactoryError, d as InvalidQueryFactoryError, f as InvalidRemoteFormResponseError, g as RemoteFormEndpointMissingError, s as InvalidCommandFactoryError, u as InvalidPrerenderFactoryError } from "./errors-CLsbGjIa.js";
+import { n as get_dispatcher } from "./dispatcher-_x0MQZBS.js";
+import { create_remote_http_error, create_remote_transport_error, create_remote_validation_error } from "../remote/shared.js";
+import { i as make_remote_live_stream, r as make_failed_remote_live_stream } from "./live-BundLSoY.js";
+import { a as normalize_validator, c as attach_remote_resource_getters, d as MakeEffectFromPromise, f as MakeEffectFromSync, h as normalize_native_error, i as is_standard_schema, l as is_remote_resource, m as is_decoded_remote_failure, n as attach_native_remote_query_update, o as attach_failed_remote_query_resource, p as decode_remote_error, r as resolve_native_remote_query_updates, s as attach_failed_remote_resource_getters, t as copy_property_descriptors, u as FailWithRemoteError } from "./descriptors-B4otDlm1.js";
+import { Effect, Option, Result, Schema } from "effect";
+import { parse } from "devalue";
+//#region src/remote/client/utils.ts
+function has_method(value, key) {
+	const value_type = typeof value;
+	return (value_type === "object" && value !== null || value_type === "function") && typeof value[key] === "function";
+}
+//#endregion
+//#region src/remote/client/responses.ts
+const DecodeResponseFailure = (response) => Effect.gen(function* () {
+	const body = yield* MakeEffectFromPromise(() => response.json()).pipe(Effect.orElseSucceed(() => void 0));
+	const decoded = decode_remote_error(body);
+	if (is_decoded_remote_failure(decoded)) return decoded;
+	return create_remote_http_error(response.status, body);
+});
+const DecodeResponseOrValue = (value, decode_payload) => Effect.gen(function* () {
+	if (value instanceof Response) {
+		if (!value.ok) {
+			const failure = yield* DecodeResponseFailure(value);
+			return yield* Effect.fail(failure);
+		}
+		const data = yield* DecodeSuccessResponseBody(value);
+		return yield* MakeEffectFromSync(() => decode_payload(data));
+	}
+	return yield* MakeEffectFromSync(() => decode_payload(value));
+});
+const DecodeSuccessResponseBody = (response) => Effect.gen(function* () {
+	if (response.status === 204 || response.status === 205) return;
+	const text = yield* MakeEffectFromPromise(() => response.text());
+	if (text.length === 0) return;
+	return yield* MakeEffectFromSync(() => JSON.parse(text));
+});
+//#endregion
+//#region src/remote/client/command.ts
+/** Adapts a generated SvelteKit command to SER's Effect-based client ABI. */
+function create_remote_command_adapter(native_factory, decode_payload, _base = "", pending) {
+	const invoke = has_method(native_factory, "invoke") ? native_factory.invoke : void 0;
+	if (typeof native_factory !== "function" && !invoke) throw new InvalidCommandFactoryError();
+	const count = pending ?? { value: 0 };
+	const adapter = (input) => MakeCommandEffect(native_factory, invoke, input, decode_payload, count);
+	copy_property_descriptors(native_factory, adapter);
+	if (!Object.prototype.hasOwnProperty.call(adapter, "pending")) Object.defineProperty(adapter, "pending", { get: () => count.value });
+	return adapter;
+}
+const MakeCommandEffect = (native_factory, invoke, input, decode_payload, pending) => {
+	let updates_args;
+	const CommandEffect = Effect.acquireUseRelease(AcquirePending(pending), () => InvokeCommand(native_factory, invoke, input, decode_payload, () => updates_args), () => ReleasePending(pending));
+	Object.defineProperty(CommandEffect, "updates", {
+		configurable: true,
+		enumerable: false,
+		value: (...args) => {
+			updates_args ??= args;
+			return CommandEffect;
+		}
+	});
+	return CommandEffect;
+};
+const AcquirePending = (pending) => Effect.sync(() => {
+	pending.value += 1;
+});
+const ReleasePending = (pending) => Effect.sync(() => {
+	pending.value -= 1;
+});
+const InvokeCommand = (native_factory, invoke, input, decode_payload, read_updates_args) => Effect.gen(function* () {
+	const invocation = yield* MakeEffectFromSync(() => {
+		const result = invoke ? invoke.call(native_factory, input) : native_factory(input);
+		const updates_args = read_updates_args();
+		if (updates_args && has_method(result, "updates")) return result.updates(...resolve_native_remote_query_updates(updates_args));
+		return result;
+	});
+	return yield* DecodeResponseOrValue(yield* MakeEffectFromPromise(() => Promise.resolve(invocation)), decode_payload);
+});
+//#endregion
+//#region src/remote/client/form-data.ts
+function to_form_data(input) {
+	const form_data = new FormData();
+	append_form_value(form_data, "", input);
+	return form_data;
+}
+function append_form_value(form_data, path, value) {
+	if (value === void 0) return;
+	if (Array.isArray(value)) {
+		for (const [index, item] of value.entries()) append_form_value(form_data, `${path}[${index}]`, item);
+		return;
+	}
+	if (value instanceof Blob) {
+		form_data.append(path, value);
+		return;
+	}
+	if (typeof value === "object" && value !== null) {
+		for (const [key, child] of Object.entries(value)) append_form_value(form_data, path.length === 0 ? key : `${path}.${key}`, child);
+		return;
+	}
+	if (typeof value === "number") {
+		form_data.append(`n:${path}`, String(value));
+		return;
+	}
+	if (typeof value === "boolean") {
+		form_data.append(`b:${path}`, value ? "on" : "off");
+		return;
+	}
+	form_data.append(path, value === null ? "" : String(value));
+}
+//#endregion
+//#region src/remote/client/form-transport.ts
+const FormIssuePathSegmentSchema = Schema.Union([Schema.String, Schema.Number]);
+const FormIssueSchema = Schema.Struct({
+	message: Schema.String,
+	path: Schema.Array(FormIssuePathSegmentSchema)
+});
+const RemoteFormErrorEnvelopeSchema = Schema.Struct({
+	type: Schema.Literal("error"),
+	error: Schema.optional(Schema.Unknown),
+	status: Schema.optional(Schema.Number)
+});
+const RemoteFormResultEnvelopeSchema = Schema.Struct({
+	type: Schema.Literal("result"),
+	data: Schema.String
+});
+const RemoteFormRedirectEnvelopeSchema = Schema.Struct({
+	type: Schema.Literal("redirect"),
+	location: Schema.String
+});
+const RemoteFormResponseEnvelopeSchema = Schema.Union([
+	RemoteFormErrorEnvelopeSchema,
+	RemoteFormResultEnvelopeSchema,
+	RemoteFormRedirectEnvelopeSchema
+]);
+const RemoteFormDecodedPayloadSchema = Schema.Struct({
+	issues: Schema.optional(Schema.Array(FormIssueSchema)),
+	result: Schema.optional(Schema.Unknown)
+});
+const RemoteFormRedirectDataSchema = Schema.Struct({ redirect: Schema.String });
+const RemoteFormResultDataSchema = Schema.Struct({ _: Schema.Unknown });
+const KitRemoteFormDataSchema = Schema.Struct({
+	_: Schema.optional(Schema.Unknown),
+	redirect: Schema.optional(Schema.String),
+	r: Schema.optional(Schema.Literal(true))
+});
+const DecodeRemoteFormResponseEnvelope = Schema.decodeUnknownOption(RemoteFormResponseEnvelopeSchema);
+const DecodeRemoteFormPayload = Schema.decodeUnknownOption(RemoteFormDecodedPayloadSchema);
+const DecodeRemoteFormRedirectData = Schema.decodeUnknownOption(RemoteFormRedirectDataSchema);
+const DecodeRemoteFormResultData = Schema.decodeUnknownOption(RemoteFormResultDataSchema);
+const DecodeKitRemoteFormData = Schema.decodeUnknownOption(KitRemoteFormDataSchema);
+const SubmitRemoteForm = (form_obj, input, decode_payload, remote_base, remote_transport, preflight_schema) => Effect.gen(function* () {
+	const action_id = yield* MakeEffectFromSync(() => get_remote_action_id(form_obj));
+	if (!action_id || remote_base.length === 0) return yield* Effect.fail(create_remote_transport_error(new RemoteFormEndpointMissingError()));
+	yield* ValidatePreflightInput(preflight_schema, input);
+	if (is_kit_remote_form_transport(remote_transport)) return yield* SubmitRemoteFormWithKit(action_id, input, decode_payload, remote_base, remote_transport);
+	const response = yield* MakeEffectFromPromise((signal) => fetch(to_remote_form_url(remote_base, action_id), {
+		method: "POST",
+		headers: get_remote_request_headers(),
+		body: to_form_data(to_remote_form_input(input, action_id)),
+		signal
+	}));
+	if (!response.ok) {
+		const failure = yield* DecodeResponseFailure(response);
+		return yield* Effect.fail(failure);
+	}
+	const envelope = yield* MakeEffectFromPromise(() => response.json());
+	return yield* DecodeFormResponse(envelope, decode_payload, remote_transport);
+});
+const SubmitRemoteFormWithKit = (action_id, input, decode_payload, remote_base, remote_transport) => Effect.gen(function* () {
+	const url = to_remote_form_url(remote_base, action_id);
+	const body = yield* MakeEffectFromSync(() => remote_transport.serialize_binary_form(to_remote_form_input(input, action_id), { remote_refreshes: [] }).blob);
+	const data = yield* MakeEffectFromPromise((signal) => remote_transport.remote_request(url, {
+		method: "POST",
+		headers: {
+			...get_remote_request_headers(),
+			"Content-Type": remote_transport.binary_form_content_type
+		},
+		body,
+		signal
+	}));
+	return yield* DecodeKitFormData(data, decode_payload, remote_transport);
+});
+function get_remote_action_id(form_obj) {
+	const action = form_obj.action;
+	if (typeof action !== "string") return;
+	const href = typeof location === "undefined" ? "http://localhost/" : location.href;
+	const url = new URL(action, href);
+	return url.searchParams.get("/remote") ?? url.searchParams.get("remote") ?? void 0;
+}
+function to_remote_form_url(remote_base, action_id) {
+	const head = action_id.split("/").slice(0, 2).join("/");
+	return `${remote_base.replace(/\/$/, "")}/${head}`;
+}
+function to_remote_form_input(input, action_id) {
+	const data = is_record(input) ? input : {};
+	const serialized_key = action_id.split("/").slice(2).join("/");
+	const key = serialized_key.length === 0 ? void 0 : JSON.parse(serialized_key);
+	if (key === void 0 || data.id !== void 0) return data;
+	return {
+		...data,
+		id: key
+	};
+}
+function get_remote_request_headers() {
+	if (typeof location === "undefined") return {};
+	return {
+		"x-sveltekit-pathname": location.pathname,
+		"x-sveltekit-search": location.search
+	};
+}
+const ValidatePreflightInput = (schema, input) => Effect.gen(function* () {
+	if (!schema) return;
+	const validated = yield* MakeEffectFromPromise(() => Promise.resolve(schema["~standard"].validate(input)));
+	if (!is_record(validated) || !Array.isArray(validated.issues)) return;
+	const issues = validated.issues.map(normalize_standard_issue);
+	return yield* Effect.fail(create_remote_validation_error(issues, { issues }, 400));
+});
+function normalize_standard_issue(issue) {
+	if (!is_record(issue)) return {
+		message: String(issue),
+		path: []
+	};
+	return {
+		message: typeof issue.message === "string" ? issue.message : "Invalid input",
+		path: Array.isArray(issue.path) ? issue.path.flatMap(normalize_path_segment) : []
+	};
+}
+function normalize_path_segment(segment) {
+	if (typeof segment === "string" || typeof segment === "number") return [segment];
+	if (!is_record(segment)) return [];
+	const key = segment.key;
+	if (typeof key === "string" || typeof key === "number") return [key];
+	return [];
+}
+function is_record(value) {
+	return typeof value === "object" && value !== null;
+}
+const DecodeFormResponse = (envelope, decode_payload, remote_transport) => Effect.gen(function* () {
+	const response = decode_remote_form_response_envelope(envelope);
+	if (!response) return yield* Effect.fail(create_remote_transport_error(new InvalidRemoteFormResponseError(envelope), envelope));
+	if (response._tag === "RemoteFormErrorEnvelope") {
+		const decoded = decode_remote_error(response.error);
+		if (is_decoded_remote_failure(decoded)) return yield* Effect.fail(decoded);
+		return yield* Effect.fail(create_remote_http_error(get_remote_form_error_status(response), response.error));
+	}
+	if (response._tag === "RemoteFormRedirectEnvelope") return yield* NavigateRemoteForm(response.location, true, remote_transport, envelope);
+	const parsed = yield* MakeEffectFromSync(() => parse(response.data, remote_transport.decoders));
+	const redirect_data = DecodeRemoteFormRedirectData(parsed);
+	if (Option.isSome(redirect_data)) return yield* NavigateRemoteForm(redirect_data.value.redirect, true, remote_transport, envelope);
+	const result_data = DecodeRemoteFormResultData(parsed);
+	if (!Option.isSome(result_data)) return yield* Effect.fail(create_remote_transport_error(new UnsupportedRemoteFormResponseError(envelope), envelope));
+	const decoded = decode_remote_form_payload(yield* MakeEffectFromSync(() => decode_payload(result_data.value._)));
+	if (!decoded) return yield* Effect.fail(create_remote_transport_error(new UnsupportedRemoteFormResponseError(envelope), envelope));
+	if (decoded.issues && decoded.issues.length > 0) return yield* Effect.fail(create_remote_validation_error(decoded.issues, decoded, 400));
+	yield* RefreshRemoteFormState(remote_transport);
+	return decoded.result;
+});
+const DecodeKitFormData = (data, decode_payload, remote_transport) => Effect.gen(function* () {
+	const decoded_data = DecodeKitRemoteFormData(data);
+	if (!Option.isSome(decoded_data)) return yield* Effect.fail(create_remote_transport_error(new UnsupportedRemoteFormResponseError(data), data));
+	const should_invalidate = decoded_data.value.r !== true;
+	if (decoded_data.value.redirect) return yield* NavigateRemoteForm(decoded_data.value.redirect, should_invalidate, remote_transport, data);
+	if (!("_" in decoded_data.value)) return yield* Effect.fail(create_remote_transport_error(new UnsupportedRemoteFormResponseError(data), data));
+	const decoded = decode_remote_form_payload(yield* MakeEffectFromSync(() => decode_payload(decoded_data.value._)));
+	if (!decoded) return yield* Effect.fail(create_remote_transport_error(new UnsupportedRemoteFormResponseError(data), data));
+	if (decoded.issues && decoded.issues.length > 0) return yield* Effect.fail(create_remote_validation_error(decoded.issues, decoded, 400));
+	if (should_invalidate) yield* RefreshRemoteFormState(remote_transport);
+	return decoded.result;
+});
+const NavigateRemoteForm = (location, invalidate_all, remote_transport, envelope) => Effect.gen(function* () {
+	const navigate = remote_transport.navigate;
+	if (!navigate) return yield* Effect.fail(create_remote_transport_error(new UnsupportedRemoteFormResponseError(envelope), envelope));
+	yield* MakeEffectFromPromise(() => Promise.resolve(navigate(location, invalidate_all)));
+	return yield* Effect.interrupt;
+});
+const RefreshRemoteFormState = (remote_transport) => Effect.gen(function* () {
+	const refresh = remote_transport.refresh;
+	if (!refresh) return;
+	yield* MakeEffectFromPromise(() => Promise.resolve(refresh()));
+});
+function decode_remote_form_response_envelope(envelope) {
+	const decoded = DecodeRemoteFormResponseEnvelope(envelope);
+	if (!Option.isSome(decoded)) return;
+	if (decoded.value.type === "error") return {
+		_tag: "RemoteFormErrorEnvelope",
+		error: decoded.value.error,
+		status: decoded.value.status
+	};
+	if (decoded.value.type === "redirect") return {
+		_tag: "RemoteFormRedirectEnvelope",
+		location: decoded.value.location
+	};
+	return {
+		_tag: "RemoteFormResultEnvelope",
+		data: decoded.value.data
+	};
+}
+function get_remote_form_error_status(response) {
+	const nested_status = is_record(response.error) ? response.error.status : void 0;
+	if (response.status !== void 0) return response.status;
+	return typeof nested_status === "number" ? nested_status : 500;
+}
+function is_kit_remote_form_transport(remote_transport) {
+	return typeof remote_transport.binary_form_content_type === "string" && typeof remote_transport.remote_request === "function" && typeof remote_transport.serialize_binary_form === "function";
+}
+function decode_remote_form_payload(payload) {
+	const decoded = DecodeRemoteFormPayload(payload);
+	if (!Option.isSome(decoded)) return;
+	return decoded.value;
+}
+//#endregion
+//#region src/remote/client/form-enhance.ts
+function wrap_enhance_callback(callback) {
+	if (!callback) return;
+	return (event) => {
+		const result = callback(wrap_submit_callback(event));
+		if (Effect.isEffect(result)) return get_dispatcher().run(result);
+		return result;
+	};
+}
+function wrap_submit_callback(event) {
+	if (typeof event !== "object" || event === null || !has_method(event, "submit")) return event;
+	const original_submit = event.submit;
+	const { submit: _submit, ...descriptors } = Object.getOwnPropertyDescriptors(event);
+	return Object.defineProperties({}, {
+		...descriptors,
+		submit: {
+			configurable: true,
+			enumerable: false,
+			value: () => MakeSubmitEffect(original_submit, event)
+		}
+	});
+}
+function MakeSubmitEffect(original_submit, event) {
+	let updates_args;
+	const SubmitEffect = Effect.gen(function* () {
+		const result = yield* MakeEffectFromSync(() => original_submit.call(event));
+		const value = yield* ResolveSubmitResult(result, updates_args);
+		if (typeof value === "boolean") return read_submit_result(event);
+		return value;
+	});
+	Object.defineProperty(SubmitEffect, "updates", {
+		configurable: true,
+		enumerable: false,
+		value: (...args) => {
+			updates_args ??= args;
+			return SubmitEffect;
+		}
+	});
+	return SubmitEffect;
+}
+const ResolveSubmitResult = (result, updates_args) => Effect.gen(function* () {
+	if (updates_args && has_method(result, "updates")) return yield* MakeEffectFromPromise(() => Promise.resolve(result.updates(...resolve_native_remote_query_updates(updates_args))));
+	return yield* MakeEffectFromPromise(() => Promise.resolve(result));
+});
+function read_submit_result(event) {
+	if (typeof event !== "object" || event === null || !("result" in event)) return;
+	return Reflect.get(event, "result");
+}
+//#endregion
+//#region src/remote/client/form.ts
+/** Adapts a generated SvelteKit form to SER's Effect-based client ABI. */
+function create_remote_form_adapter(native_factory, decode_payload, remote_base = "", remote_transport = {}, adapter_state = {}, keyed = false) {
+	const form_obj = native_factory;
+	let local_preflight_schema;
+	const SubmitForm = (input) => Effect.gen(function* () {
+		const action_id = yield* MakeEffectFromSync(() => get_remote_action_id(form_obj));
+		const can_use_remote_endpoint = remote_base.length > 0 && action_id !== void 0;
+		if (has_method(form_obj, "submit") && !can_use_remote_endpoint) return yield* DecodeResponseOrValue(yield* MakeEffectFromPromise(() => Promise.resolve(form_obj.submit(input))), decode_payload);
+		return yield* SubmitRemoteForm(form_obj, input, decode_payload, remote_base, remote_transport, local_preflight_schema ?? adapter_state.shared_preflight_schema);
+	});
+	const callable = ((input) => SubmitForm(input));
+	copy_property_descriptors(form_obj, callable, /* @__PURE__ */ new Set([
+		"submit",
+		"validate",
+		"enhance",
+		"for",
+		"preflight"
+	]));
+	Object.defineProperty(callable, "submit", {
+		configurable: true,
+		enumerable: false,
+		value: SubmitForm
+	});
+	if (has_method(form_obj, "validate")) {
+		const validate = form_obj.validate;
+		Object.defineProperty(callable, "validate", {
+			configurable: true,
+			enumerable: false,
+			value: (options) => ValidateRemoteForm(form_obj, validate, options)
+		});
+	}
+	if (has_method(form_obj, "enhance")) Object.defineProperty(callable, "enhance", {
+		configurable: true,
+		enumerable: false,
+		value: (callback) => form_obj.enhance(wrap_enhance_callback(callback))
+	});
+	if (has_method(form_obj, "for")) Object.defineProperty(callable, "for", {
+		configurable: true,
+		enumerable: false,
+		value: (key) => create_remote_form_adapter(form_obj.for(key), decode_payload, remote_base, remote_transport, adapter_state, true)
+	});
+	if (has_method(form_obj, "preflight")) Object.defineProperty(callable, "preflight", {
+		configurable: true,
+		enumerable: false,
+		value: (schema) => {
+			const normalized_schema = normalize_validator(schema);
+			if (is_standard_schema(normalized_schema)) {
+				local_preflight_schema = normalized_schema;
+				if (!keyed) adapter_state.shared_preflight_schema = normalized_schema;
+			}
+			form_obj.preflight(normalized_schema);
+			return callable;
+		}
+	});
+	return callable;
+}
+const ValidateRemoteForm = (form_obj, validate, options) => Effect.gen(function* () {
+	yield* MakeEffectFromPromise(() => Promise.resolve(validate.call(form_obj, normalize_validate_options(validate, options))));
+});
+function normalize_validate_options(validate, options) {
+	if (!options || !("all" in options) || "includeUntouched" in options) return options;
+	const source = Function.prototype.toString.call(validate);
+	if (!(source.includes("includeUntouched") && !/\ball\s*=/.test(source))) return options;
+	return {
+		...options,
+		includeUntouched: options.all
+	};
+}
+//#endregion
+//#region src/remote/client/query-result.ts
+const ResolveQueryResult = (value, decode_payload) => Effect.gen(function* () {
+	if (has_method(value, "then")) return yield* DecodeResponseOrValue(yield* MakeEffectFromPromise(() => Promise.resolve(value)), decode_payload);
+	if (has_method(value, "run")) return yield* DecodeResponseOrValue(yield* MakeEffectFromPromise(() => Promise.resolve(value.run())), decode_payload);
+	return yield* DecodeResponseOrValue(value, decode_payload);
+});
+//#endregion
+//#region src/remote/client/prerender.ts
+function create_remote_prerender_adapter(native_factory, decode_payload) {
+	if (typeof native_factory !== "function") throw new InvalidPrerenderFactoryError();
+	const prerender = native_factory;
+	const wrapped = ((input) => {
+		const resource_attempt = Result.try(() => prerender(input));
+		if (Result.isFailure(resource_attempt)) {
+			const PrerenderEffect = FailWithRemoteError(resource_attempt.failure);
+			attach_failed_remote_resource_getters(resource_attempt.failure, PrerenderEffect);
+			return PrerenderEffect;
+		}
+		const resource = resource_attempt.success;
+		const PrerenderEffect = ResolveQueryResult(resource, decode_payload);
+		attach_remote_resource_getters(resource, PrerenderEffect);
+		return PrerenderEffect;
+	});
+	copy_property_descriptors(native_factory, wrapped);
+	return wrapped;
+}
+//#endregion
+//#region src/remote/client/query.ts
+function create_remote_query_adapter(native_factory, decode_payload, _base = "", mode = "standard") {
+	const load = has_method(native_factory, "load") ? native_factory.load : void 0;
+	const query = typeof native_factory === "function" ? native_factory : void 0;
+	if (!query && !load) throw new InvalidQueryFactoryError();
+	const wrapped = ((input) => {
+		if (!query) return Effect.gen(function* () {
+			return yield* ResolveQueryResult(yield* MakeEffectFromPromise(() => Promise.resolve(load?.call(native_factory, input))), decode_payload);
+		});
+		const resource_attempt = Result.try(() => query(input));
+		if (Result.isFailure(resource_attempt)) {
+			const QueryEffect = FailWithRemoteError(resource_attempt.failure);
+			attach_failed_remote_query_resource(resource_attempt.failure, QueryEffect);
+			return QueryEffect;
+		}
+		const resource = resource_attempt.success;
+		const QueryEffect = ResolveQueryResult(mode === "batch" ? begin_batch_query_result(resource) : resource, decode_payload);
+		attach_native_remote_query_update(QueryEffect, resource);
+		attach_query_resource(resource, QueryEffect);
+		return QueryEffect;
+	});
+	copy_property_descriptors(native_factory, wrapped);
+	attach_native_remote_query_update(wrapped, native_factory);
+	return wrapped;
+}
+function begin_batch_query_result(resource) {
+	if (!has_method(resource, "then")) return resource;
+	const result = Promise.resolve(resource);
+	result.catch(() => {});
+	return result;
+}
+/** Adapts a generated SvelteKit live query to SER's Effect-based client ABI. */
+function create_remote_live_query_adapter(native_factory, _decode_payload, _base = "") {
+	const query = typeof native_factory === "function" ? native_factory : void 0;
+	if (!query) throw new InvalidLiveQueryFactoryError();
+	const wrapped = ((input) => {
+		const resource_attempt = Result.try(() => query(input));
+		if (Result.isFailure(resource_attempt)) return make_failed_remote_live_stream(resource_attempt.failure, normalize_native_error);
+		const resource = resource_attempt.success;
+		const stream = make_remote_live_stream(resource, normalize_native_error);
+		attach_native_remote_query_update(stream, resource);
+		return stream;
+	});
+	copy_property_descriptors(native_factory, wrapped);
+	attach_native_remote_query_update(wrapped, native_factory);
+	return wrapped;
+}
+function attach_query_resource(resource, effect) {
+	const methods = is_remote_resource(resource) ? resource : void 0;
+	const refresh = methods?.refresh;
+	const set = methods?.set;
+	const with_override = methods?.withOverride;
+	attach_remote_resource_getters(resource, effect);
+	if (!methods) return;
+	if (typeof refresh === "function") Object.defineProperty(effect, "refresh", {
+		configurable: true,
+		value: () => RefreshRemoteResource(resource, refresh)
+	});
+	if (typeof set === "function") Object.defineProperty(effect, "set", {
+		configurable: true,
+		value: (value) => set.call(resource, value)
+	});
+	if (typeof with_override === "function") Object.defineProperty(effect, "withOverride", {
+		configurable: true,
+		value: (update) => with_override.call(resource, update)
+	});
+}
+const RefreshRemoteResource = (resource, refresh) => Effect.gen(function* () {
+	yield* MakeEffectFromPromise(() => Promise.resolve(refresh.call(resource)));
+});
+//#endregion
+export { create_remote_command_adapter as a, create_remote_form_adapter as i, create_remote_query_adapter as n, create_remote_prerender_adapter as r, create_remote_live_query_adapter as t };
+
+//# sourceMappingURL=client-BrZka6DW.js.map