@jpkme/diff-review 0.1.0

package/web/build/server/chunks/remote-1g4ayag-ipWXvkjB.js

@@ -0,0 +1,2239 @@
+import { e as error, g as get_request_store, b as stringify_remote_arg, M as MUTATIVE_METHODS, w as with_request_store, c as create_remote_key, n as noop, H as HttpError, S as SvelteKitError, h as handle_error_and_jsonify, _ as __exportAll, i as init_remote_functions } from './index.js-A_Q670iW.js';
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { execFileSync, spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { tmpdir, platform } from 'node:os';
+import process from 'node:process';
+
+//#region node_modules/@sveltejs/kit/src/runtime/app/server/remote/shared.js
+/** @import { RequestEvent } from '@sveltejs/kit' */
+/** @import { ServerHooks, MaybePromise, RequestState, RemoteInternals, RequestStore, RemoteLiveQueryUserFunctionReturnType } from 'types' */
+/**
+* @param {any} validate_or_fn
+* @param {((arg?: any) => any) | undefined} [maybe_fn]
+* @returns {(arg?: any) => MaybePromise<any>}
+*/
+function create_validator(validate_or_fn, maybe_fn) {
+	if (!maybe_fn) return (arg) => {
+		if (arg !== void 0) error(400, "Bad Request");
+	};
+	if (validate_or_fn === "unchecked") return (arg) => arg;
+	if ("~standard" in validate_or_fn) return async (arg) => {
+		const { event, state } = get_request_store();
+		const result = await validate_or_fn["~standard"].validate(arg);
+		if (result.issues) error(400, await state.handleValidationError({
+			issues: result.issues,
+			event
+		}));
+		return result.value;
+	};
+	throw new Error("Invalid validator passed to remote function. Expected \"unchecked\" or a Standard Schema (https://standardschema.dev)");
+}
+/**
+* In case of a single remote function call, just returns the result.
+*
+* In case of a full page reload, returns the response for a remote function call,
+* either from the cache or by invoking the function.
+* Also saves an uneval'ed version of the result for later HTML inlining for hydration.
+*
+* @template {MaybePromise<any>} T
+* @param {RemoteInternals} internals
+* @param {string} payload — the stringified raw argument (i.e. the cache key the client will use)
+* @param {RequestState} state
+* @param {() => Promise<T>} get_result
+* @returns {Promise<T>}
+*/
+async function get_response(internals, payload, state, get_result) {
+	await 0;
+	const cache = get_cache(internals, state);
+	if (!state.is_in_remote_query) get_implicit_lookup(internals, state)[payload] = get_result;
+	return cache[payload] ??= get_result();
+}
+/**
+* @param {RequestEvent} event
+* @param {RequestState} state
+* @param {boolean} allow_cookies
+* @returns {RequestStore}
+*/
+function derive_remote_function_event(event, state, allow_cookies) {
+	return {
+		event: {
+			...event,
+			setHeaders: () => {
+				throw new Error("setHeaders is not allowed in remote functions");
+			},
+			cookies: {
+				...event.cookies,
+				set: (name, value, opts) => {
+					if (!allow_cookies) throw new Error("Cannot set cookies in `query` or `prerender` functions");
+					if (opts.path && !opts.path.startsWith("/")) throw new Error("Cookies set in remote functions must have an absolute path");
+					return event.cookies.set(name, value, opts);
+				},
+				delete: (name, opts) => {
+					if (!allow_cookies) throw new Error("Cannot delete cookies in `query` or `prerender` functions");
+					if (opts.path && !opts.path.startsWith("/")) throw new Error("Cookies deleted in remote functions must have an absolute path");
+					return event.cookies.delete(name, opts);
+				}
+			}
+		},
+		state: {
+			...state,
+			is_in_remote_function: true
+		}
+	};
+}
+/**
+* Like `with_event` but removes things from `event` you cannot see/call in remote functions, such as `setHeaders`.
+* @template T
+* @param {RequestEvent} event
+* @param {RequestState} state
+* @param {boolean} allow_cookies
+* @param {() => any} get_input
+* @param {(arg?: any) => T} fn
+*/
+async function run_remote_function(event, state, allow_cookies, get_input, fn) {
+	const store = derive_remote_function_event(event, state, allow_cookies);
+	const input = await with_request_store(store, get_input);
+	return with_request_store(store, () => fn(input));
+}
+/**
+* Like `with_event` but removes things from `event` you cannot see/call in remote functions, such as `setHeaders`.
+* @template T
+* @param {RequestEvent} event
+* @param {RequestState} state
+* @param {boolean} allow_cookies
+* @param {() => any} get_input
+* @param {(arg?: any) => RemoteLiveQueryUserFunctionReturnType<T>} fn
+* @param {string} name
+*/
+async function* run_remote_generator(event, state, allow_cookies, get_input, fn, name) {
+	const store = derive_remote_function_event(event, state, allow_cookies);
+	const input = await with_request_store(store, get_input);
+	const iterator = to_iterator(await with_request_store(store, () => fn(input)), name);
+	let done = false;
+	try {
+		while (true) {
+			const result = await with_request_store(store, () => iterator.next());
+			if (result.done) {
+				done = true;
+				return result.value;
+			}
+			yield result.value;
+		}
+	} finally {
+		if (!done && typeof iterator.return === "function") await with_request_store(store, () => iterator.return?.(void 0));
+	}
+}
+/**
+* @template T
+* @param {Awaited<RemoteLiveQueryUserFunctionReturnType<T>>} source
+* @param {string} name
+* @returns {Iterator<T> | AsyncIterator<T>}
+*/
+function to_iterator(source, name) {
+	if ("next" in source && typeof source.next === "function") return source;
+	if (Symbol.asyncIterator in source && typeof source[Symbol.asyncIterator] === "function") return source[Symbol.asyncIterator]();
+	if (Symbol.iterator in source && typeof source[Symbol.iterator] === "function") return source[Symbol.iterator]();
+	throw new Error(`query.live '${name}' must return an Iterator, Iterable, AsyncIterator or AsyncIterable`);
+}
+/**
+* Note that `state` is deliberately not optional: resources that capture the request
+* state at creation must pass it explicitly, because reading it from the request store
+* at call time is only equivalent on runtimes with `AsyncLocalStorage` support.
+* Callers without a captured state (such as the module-level `form` instance getters)
+* should pass `get_request_store().state` themselves.
+* @param {RemoteInternals} internals
+* @param {RequestState} state
+*/
+function get_cache(internals, state) {
+	let cache = state.remote.data?.get(internals);
+	if (cache === void 0) {
+		cache = {};
+		(state.remote.data ??= /* @__PURE__ */ new Map()).set(internals, cache);
+	}
+	return cache;
+}
+/**
+* @param {RemoteInternals} internals
+* @param {RequestState} state
+*/
+function get_implicit_lookup(internals, state) {
+	let cache = state.remote.implicit?.get(internals);
+	if (cache === void 0) {
+		cache = {};
+		(state.remote.implicit ??= /* @__PURE__ */ new Map()).set(internals, cache);
+	}
+	return cache;
+}
+//#endregion
+//#region node_modules/@sveltejs/kit/src/runtime/app/server/remote/command.js
+/** @import { RemoteCommand } from '@sveltejs/kit' */
+/** @import { MaybePromise, RemoteCommandInternals } from 'types' */
+/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
+/**
+* Creates a remote command. When called from the browser, the function will be invoked on the server via a `fetch` call.
+*
+* See [Remote functions](https://svelte.dev/docs/kit/remote-functions#command) for full documentation.
+*
+* @template Output
+* @overload
+* @param {() => MaybePromise<Output>} fn
+* @returns {RemoteCommand<void, Output>}
+* @since 2.27
+*/
+/**
+* Creates a remote command. When called from the browser, the function will be invoked on the server via a `fetch` call.
+*
+* See [Remote functions](https://svelte.dev/docs/kit/remote-functions#command) for full documentation.
+*
+* @template Input
+* @template Output
+* @overload
+* @param {'unchecked'} validate
+* @param {(arg: Input) => MaybePromise<Output>} fn
+* @returns {RemoteCommand<Input, Output>}
+* @since 2.27
+*/
+/**
+* Creates a remote command. When called from the browser, the function will be invoked on the server via a `fetch` call.
+*
+* See [Remote functions](https://svelte.dev/docs/kit/remote-functions#command) for full documentation.
+*
+* @template {StandardSchemaV1} Schema
+* @template Output
+* @overload
+* @param {Schema} validate
+* @param {(arg: StandardSchemaV1.InferOutput<Schema>) => MaybePromise<Output>} fn
+* @returns {RemoteCommand<StandardSchemaV1.InferInput<Schema>, Output>}
+* @since 2.27
+*/
+/**
+* @template Input
+* @template Output
+* @param {any} validate_or_fn
+* @param {(arg?: Input) => MaybePromise<Output>} [maybe_fn]
+* @returns {RemoteCommand<Input, Output>}
+* @since 2.27
+*/
+/*@__NO_SIDE_EFFECTS__*/
+function command(validate_or_fn, maybe_fn) {
+	/** @type {(arg?: Input) => MaybePromise<Output>} */
+	const fn = maybe_fn ?? validate_or_fn;
+	/** @type {(arg?: any) => MaybePromise<Input>} */
+	const validate = create_validator(validate_or_fn, maybe_fn);
+	/** @type {RemoteCommandInternals} */
+	const __ = {
+		type: "command",
+		id: "",
+		name: ""
+	};
+	/** @type {RemoteCommand<Input, Output> & { __: RemoteCommandInternals }} */
+	const wrapper = (arg) => {
+		const { event, state } = get_request_store();
+		if (!MUTATIVE_METHODS.includes(event.request.method)) throw new Error(`Cannot call a command (\`${__.name}(${maybe_fn ? "..." : ""})\`) from a ${event.request.method} handler`);
+		if (state.is_in_render) throw new Error(`Cannot call a command (\`${__.name}(${maybe_fn ? "..." : ""})\`) during server-side rendering`);
+		const promise = Promise.resolve(run_remote_function(event, state, true, () => validate(arg), fn));
+		promise.updates = () => {
+			throw new Error(`Cannot call '${__.name}(...).updates(...)' on the server`);
+		};
+		return promise;
+	};
+	Object.defineProperty(wrapper, "__", { value: __ });
+	Object.defineProperty(wrapper, "pending", { get: () => 0 });
+	return wrapper;
+}
+//#endregion
+//#region node_modules/@sveltejs/kit/src/utils/shared-iterator.js
+/**
+* A pull-style async iterator that fans out a single stream of values to
+* multiple `for await (...)` consumers. Each subscriber gets its own
+* `AsyncGenerator` whose `.next()` resolves whenever a value is pushed via
+* `push(value)`. Multiple consumers see the same values without each one
+* driving an independent underlying source.
+*
+* Backpressure is **latest-wins**: if values arrive faster than a particular
+* consumer drains its iterator, only the most-recently-pushed value is kept
+* pending for that subscriber. Earlier undrained values are dropped. This is
+* appropriate for live data streams (reactive state replication), not for
+* event logs where every value must be delivered.
+*
+* Lifecycle hooks are exposed via the constructor:
+*
+*   - `start()` is called when the subscriber count transitions
+*     from 0 to 1 (e.g. to start a pump pulling from a real source).
+*   - `stop()` is called when the subscriber count transitions
+*     from non-zero back to 0 (e.g. to tear down that pump).
+*
+* Either hook may be omitted.
+*
+* The owner is responsible for calling `push(value)` to broadcast values,
+* `done()` to signal natural completion to all subscribers, and `fail(error)`
+* to broadcast a terminal error. After `done()` or `fail()`, the iterator
+* rejects further `subscribe()` calls with the terminal state appropriately.
+*
+* @template T
+*/
+var SharedIterator = class {
+	/**
+	* @typedef {object} Subscriber
+	* @property {{ value: any } | null} pending
+	* @property {{ error: unknown } | null} pending_error
+	* @property {boolean} finished
+	* @property {((result: IteratorResult<any, void>) => void) | null} waiting_resolve
+	* @property {((reason: unknown) => void) | null} waiting_reject
+	*/
+	/** @type {Set<Subscriber>} */
+	#subscribers = /* @__PURE__ */ new Set();
+	/** @type {((instance: SharedIterator<T>) => (() => void)) | undefined} */
+	#start = void 0;
+	/** @type {(() => void) | undefined} */
+	#stop = void 0;
+	/** Once `done()` or `fail()` has been broadcast, no new values are accepted. */
+	#closed = false;
+	/** @type {unknown} */
+	#terminal_error = void 0;
+	/** Whether `done()` or `fail()` has been broadcast. */
+	get closed() {
+		return this.#closed;
+	}
+	/**
+	* @param {(instance: SharedIterator<T>) => (() => void)} [start]
+	*/
+	constructor(start) {
+		this.#start = start;
+	}
+	/** @param {T} value */
+	push(value) {
+		if (this.#closed) return;
+		for (const subscriber of this.#subscribers) if (subscriber.waiting_resolve) {
+			const resolve = subscriber.waiting_resolve;
+			subscriber.waiting_resolve = null;
+			subscriber.waiting_reject = null;
+			resolve({
+				value,
+				done: false
+			});
+		} else subscriber.pending = { value };
+	}
+	/**
+	* Signal natural completion to all current subscribers, and to any future
+	* subscriber (which will receive an immediately-done iterator).
+	*/
+	done() {
+		if (this.#closed) return;
+		this.#closed = true;
+		for (const subscriber of this.#subscribers) {
+			subscriber.finished = true;
+			if (subscriber.waiting_resolve) {
+				const resolve = subscriber.waiting_resolve;
+				subscriber.waiting_resolve = null;
+				subscriber.waiting_reject = null;
+				resolve({
+					value: void 0,
+					done: true
+				});
+			}
+		}
+		this.#subscribers.clear();
+	}
+	/**
+	* Broadcast a terminal error. All current subscribers will reject their
+	* next `.next()` call with `error`. Future subscribers will also reject
+	* their first `.next()`.
+	*
+	* @param {unknown} error
+	*/
+	fail(error) {
+		if (this.#closed) return;
+		this.#closed = true;
+		this.#terminal_error = error;
+		for (const subscriber of this.#subscribers) {
+			subscriber.finished = true;
+			if (subscriber.waiting_reject) {
+				const reject = subscriber.waiting_reject;
+				subscriber.waiting_resolve = null;
+				subscriber.waiting_reject = null;
+				reject(error);
+			} else subscriber.pending_error = { error };
+		}
+		this.#subscribers.clear();
+	}
+	/**
+	* Subscribe to the shared stream. Returns an `AsyncGenerator<T>` that
+	* yields every value pushed after this call (and, if `initial_value` is
+	* provided, that value as the first yield).
+	*
+	* @param {{ initial_value?: { value: T } }} [options]
+	*   `initial_value` lets the caller seed the iterator with a synchronously-
+	*   available current value before any new pushes arrive (e.g. the
+	*   "last-seen value" of a reactive resource). Pass it wrapped in an
+	*   object so `undefined` can be distinguished from "no initial value".
+	* @returns {AsyncGenerator<T, void, void>}
+	*/
+	subscribe(options) {
+		/** @type {Subscriber} */
+		const subscriber = {
+			pending: options?.initial_value ? { value: options.initial_value.value } : null,
+			pending_error: this.#closed && this.#terminal_error !== void 0 ? { error: this.#terminal_error } : null,
+			finished: this.#closed && this.#terminal_error === void 0,
+			waiting_resolve: null,
+			waiting_reject: null
+		};
+		if (!subscriber.finished && subscriber.pending_error === null) this.#subscribers.add(subscriber);
+		if (!this.#closed) this.#stop ??= this.#start?.(this);
+		const unsubscribe = () => {
+			subscriber.finished = true;
+			if (this.#subscribers.delete(subscriber) && this.#subscribers.size === 0) this.#stop?.();
+		};
+		/** @type {AsyncGenerator<T, void, void>} */
+		const iterator = {
+			next() {
+				if (subscriber.pending_error) {
+					const { error } = subscriber.pending_error;
+					subscriber.pending_error = null;
+					unsubscribe();
+					return Promise.reject(error);
+				}
+				if (subscriber.pending) {
+					const { value } = subscriber.pending;
+					subscriber.pending = null;
+					return Promise.resolve({
+						value,
+						done: false
+					});
+				}
+				if (subscriber.finished) return Promise.resolve({
+					value: void 0,
+					done: true
+				});
+				return new Promise((resolve, reject) => {
+					subscriber.waiting_resolve = resolve;
+					subscriber.waiting_reject = reject;
+				});
+			},
+			return(value) {
+				unsubscribe();
+				if (subscriber.waiting_resolve) {
+					const resolve = subscriber.waiting_resolve;
+					subscriber.waiting_resolve = null;
+					subscriber.waiting_reject = null;
+					resolve({
+						value: void 0,
+						done: true
+					});
+				}
+				return Promise.resolve({
+					value,
+					done: true
+				});
+			},
+			throw(error) {
+				unsubscribe();
+				if (subscriber.waiting_reject) {
+					const reject = subscriber.waiting_reject;
+					subscriber.waiting_resolve = null;
+					subscriber.waiting_reject = null;
+					reject(error);
+				}
+				return Promise.reject(error);
+			},
+			[Symbol.asyncIterator]() {
+				return iterator;
+			}
+		};
+		return iterator;
+	}
+};
+//#endregion
+//#region node_modules/@sveltejs/kit/src/runtime/app/server/remote/query.js
+/** @import { RemoteLiveQuery, RemoteLiveQueryFunction, RemoteQuery, RemoteQueryFunction, RequestEvent } from '@sveltejs/kit' */
+/** @import { RemoteInternals, MaybePromise, RequestState, RemoteQueryLiveInternals, RemoteQueryBatchInternals, RemoteQueryInternals, RemoteLiveQueryUserFunctionReturnType } from 'types' */
+/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
+/**
+* Creates a remote query. When called from the browser, the function will be invoked on the server via a `fetch` call.
+*
+* See [Remote functions](https://svelte.dev/docs/kit/remote-functions#query) for full documentation.
+*
+* @template Output
+* @overload
+* @param {() => MaybePromise<Output>} fn
+* @returns {RemoteQueryFunction<void, Output>}
+* @since 2.27
+*/
+/**
+* Creates a remote query. When called from the browser, the function will be invoked on the server via a `fetch` call.
+*
+* See [Remote functions](https://svelte.dev/docs/kit/remote-functions#query) for full documentation.
+*
+* @template Input
+* @template Output
+* @overload
+* @param {'unchecked'} validate
+* @param {(arg: Input) => MaybePromise<Output>} fn
+* @returns {RemoteQueryFunction<Input, Output>}
+* @since 2.27
+*/
+/**
+* Creates a remote query. When called from the browser, the function will be invoked on the server via a `fetch` call.
+*
+* See [Remote functions](https://svelte.dev/docs/kit/remote-functions#query) for full documentation.
+*
+* @template {StandardSchemaV1} Schema
+* @template Output
+* @overload
+* @param {Schema} schema
+* @param {(arg: StandardSchemaV1.InferOutput<Schema>) => MaybePromise<Output>} fn
+* @returns {RemoteQueryFunction<StandardSchemaV1.InferInput<Schema>, Output, StandardSchemaV1.InferOutput<Schema>>}
+* @since 2.27
+*/
+/**
+* @template Input
+* @template Output
+* @param {any} validate_or_fn
+* @param {(args?: Input) => MaybePromise<Output>} [maybe_fn]
+* @returns {RemoteQueryFunction<Input, Output>}
+* @since 2.27
+*/
+/*@__NO_SIDE_EFFECTS__*/
+function query(validate_or_fn, maybe_fn) {
+	/** @type {(arg?: Input) => Output} */
+	const fn = maybe_fn ?? validate_or_fn;
+	/** @type {(arg?: any) => MaybePromise<Input>} */
+	const validate = create_validator(validate_or_fn, maybe_fn);
+	/** @type {RemoteQueryInternals} */
+	const __ = {
+		type: "query",
+		id: "",
+		name: "",
+		validate,
+		bind(payload, validated_arg) {
+			const { event, state } = get_request_store();
+			return create_query_resource(__, payload, event, state, () => run_remote_function(event, {
+				...state,
+				is_in_remote_query: true
+			}, false, () => validated_arg, fn));
+		}
+	};
+	/** @type {RemoteQueryFunction<Input, Output> & { __: RemoteQueryInternals }} */
+	const wrapper = (arg) => {
+		const { event, state } = get_request_store();
+		const payload = stringify_remote_arg(arg, state.transport);
+		return create_query_resource(__, payload, event, state, () => run_remote_function(event, {
+			...state,
+			is_in_remote_query: true
+		}, false, () => validate(arg), fn));
+	};
+	Object.defineProperty(wrapper, "__", { value: __ });
+	return wrapper;
+}
+/**
+* Creates a live remote query. When called from the browser, the function will be invoked on the server via a streaming `fetch` call.
+*
+* See [Remote functions](https://svelte.dev/docs/kit/remote-functions#query.live) for full documentation.
+*
+* @template Output
+* @overload
+* @param {(arg: void) => RemoteLiveQueryUserFunctionReturnType<Output>} fn
+* @returns {RemoteLiveQueryFunction<void, Output>}
+*/
+/**
+* @template Input
+* @template Output
+* @overload
+* @param {'unchecked'} validate
+* @param {(arg: Input) => RemoteLiveQueryUserFunctionReturnType<Output>} fn
+* @returns {RemoteLiveQueryFunction<Input, Output>}
+*/
+/**
+* @template {StandardSchemaV1} Schema
+* @template Output
+* @overload
+* @param {Schema} schema
+* @param {(arg: StandardSchemaV1.InferOutput<Schema>) => RemoteLiveQueryUserFunctionReturnType<Output>} fn
+* @returns {RemoteLiveQueryFunction<StandardSchemaV1.InferInput<Schema>, Output, StandardSchemaV1.InferOutput<Schema>>}
+*/
+/**
+* @template Input
+* @template Output
+* @param {any} validate_or_fn
+* @param {(args: Input) => RemoteLiveQueryUserFunctionReturnType<Output>} [maybe_fn]
+* @returns {RemoteLiveQueryFunction<Input, Output>}
+*/
+/*@__NO_SIDE_EFFECTS__*/
+function live(validate_or_fn, maybe_fn) {
+	/** @type {(arg: Input) => RemoteLiveQueryUserFunctionReturnType<Output>} */
+	const fn = maybe_fn ?? validate_or_fn;
+	/** @type {(arg?: any) => MaybePromise<Input>} */
+	const validate = create_validator(validate_or_fn, maybe_fn);
+	/**
+	* @param {any} event
+	* @param {any} state
+	* @param {any} get_input
+	*/
+	const run = (event, state, get_input) => run_remote_generator(event, {
+		...state,
+		is_in_remote_query: true
+	}, false, get_input, fn, __.name);
+	/** @type {RemoteQueryLiveInternals} */
+	const __ = {
+		type: "query_live",
+		id: "",
+		name: "",
+		run: (event, state, arg) => run(event, state, () => validate(arg)),
+		validate,
+		bind(payload, validated_arg) {
+			const { event, state } = get_request_store();
+			return create_live_query_resource(__, payload, event, state, () => run(event, state, () => validated_arg));
+		}
+	};
+	/** @type {RemoteLiveQueryFunction<Input, Output> & { __: RemoteQueryLiveInternals }} */
+	const wrapper = (arg) => {
+		const { event, state } = get_request_store();
+		const payload = stringify_remote_arg(arg, state.transport);
+		return create_live_query_resource(__, payload, event, state, () => run(event, state, () => validate(arg)));
+	};
+	Object.defineProperty(wrapper, "__", { value: __ });
+	return wrapper;
+}
+/**
+* Creates a batch query function that collects multiple calls and executes them in a single request
+*
+* See [Remote functions](https://svelte.dev/docs/kit/remote-functions#query.batch) for full documentation.
+*
+* @template Input
+* @template Output
+* @overload
+* @param {'unchecked'} validate
+* @param {(args: Input[]) => MaybePromise<(arg: Input, idx: number) => Output>} fn
+* @returns {RemoteQueryFunction<Input, Output>}
+* @since 2.35
+*/
+/**
+* Creates a batch query function that collects multiple calls and executes them in a single request
+*
+* See [Remote functions](https://svelte.dev/docs/kit/remote-functions#query.batch) for full documentation.
+*
+* @template {StandardSchemaV1} Schema
+* @template Output
+* @overload
+* @param {Schema} schema
+* @param {(args: StandardSchemaV1.InferOutput<Schema>[]) => MaybePromise<(arg: StandardSchemaV1.InferOutput<Schema>, idx: number) => Output>} fn
+* @returns {RemoteQueryFunction<StandardSchemaV1.InferInput<Schema>, Output, StandardSchemaV1.InferOutput<Schema>>}
+* @since 2.35
+*/
+/**
+* @template Input
+* @template Output
+* @param {any} validate_or_fn
+* @param {(args?: Input[]) => MaybePromise<(arg: Input, idx: number) => Output>} [maybe_fn]
+* @returns {RemoteQueryFunction<Input, Output>}
+* @since 2.35
+*/
+/*@__NO_SIDE_EFFECTS__*/
+function batch(validate_or_fn, maybe_fn) {
+	/** @type {(args?: Input[]) => MaybePromise<(arg: Input, idx: number) => Output>} */
+	const fn = maybe_fn ?? validate_or_fn;
+	/** @type {(arg?: any) => MaybePromise<Input>} */
+	const validate = create_validator(validate_or_fn, maybe_fn);
+	/**
+	* Enqueues a single call into the current batch (creating one if necessary)
+	* and returns a promise that resolves with the result for this entry.
+	*
+	* @param {string} payload — the stringified raw argument (cache key)
+	* @param {() => MaybePromise<any>} get_validated — produces the validated argument for this entry
+	* @returns {Promise<any>}
+	*/
+	const enqueue = (payload, get_validated) => {
+		const { event, state } = get_request_store();
+		return new Promise((resolve, reject) => {
+			const batches = state.remote.batches ??= /* @__PURE__ */ new Map();
+			let batched = batches.get(__.id);
+			if (!batched) {
+				batched = /* @__PURE__ */ new Map();
+				batches.set(__.id, batched);
+			}
+			const entry = batched.get(payload);
+			if (entry) {
+				entry.resolvers.push({
+					resolve,
+					reject
+				});
+				return;
+			}
+			batched.set(payload, {
+				get_validated,
+				resolvers: [{
+					resolve,
+					reject
+				}]
+			});
+			if (batched.size > 1) return;
+			setTimeout(async () => {
+				batches.delete(__.id);
+				const entries = Array.from(batched.values());
+				try {
+					return await run_remote_function(event, {
+						...state,
+						is_in_remote_query: true
+					}, false, async () => Promise.all(entries.map((entry) => entry.get_validated())), async (input) => {
+						const get_result = await fn(input);
+						for (let i = 0; i < entries.length; i++) try {
+							const result = get_result(input[i], i);
+							for (const resolver of entries[i].resolvers) resolver.resolve(result);
+						} catch (error) {
+							for (const resolver of entries[i].resolvers) resolver.reject(error);
+						}
+					});
+				} catch (error) {
+					for (const entry of batched.values()) for (const resolver of entry.resolvers) resolver.reject(error);
+				}
+			}, 0);
+		});
+	};
+	/** @type {RemoteQueryBatchInternals} */
+	const __ = {
+		type: "query_batch",
+		id: "",
+		name: "",
+		validate,
+		run: async (args, options) => {
+			const { event, state } = get_request_store();
+			return run_remote_function(event, {
+				...state,
+				is_in_remote_query: true
+			}, false, async () => Promise.all(args.map(validate)), async (input) => {
+				const get_result = await fn(input);
+				return Promise.all(input.map(async (arg, i) => {
+					try {
+						return {
+							type: "result",
+							data: get_result(arg, i)
+						};
+					} catch (error) {
+						return {
+							type: "error",
+							error: await handle_error_and_jsonify(event, state, options, error),
+							status: error instanceof HttpError || error instanceof SvelteKitError ? error.status : 500
+						};
+					}
+				}));
+			});
+		},
+		bind(payload, validated_arg) {
+			const { event, state } = get_request_store();
+			return create_query_resource(__, payload, event, state, () => enqueue(payload, () => validated_arg));
+		}
+	};
+	/** @type {RemoteQueryFunction<Input, Output> & { __: RemoteQueryBatchInternals }} */
+	const wrapper = (arg) => {
+		const { event, state } = get_request_store();
+		const payload = stringify_remote_arg(arg, state.transport);
+		return create_query_resource(__, payload, event, state, () => enqueue(payload, () => validate(arg)));
+	};
+	Object.defineProperty(wrapper, "__", { value: __ });
+	return wrapper;
+}
+/**
+* Include this value in the returned payload...
+* @param {RequestEvent} event
+* @param {RequestState} state
+* @param {RemoteInternals} internals
+* @param {string} payload
+* @param {() => Promise<any>} fn
+*/
+function refresh(event, state, internals, payload, fn) {
+	if (!internals.id) return;
+	if (!event.isRemoteRequest) return;
+	const key = create_remote_key(internals.id, payload);
+	const promise = fn();
+	promise.catch(() => {});
+	(state.remote.explicit ??= /* @__PURE__ */ new Map()).set(key, {
+		internals,
+		promise
+	});
+}
+/**
+* @param {RemoteInternals} __
+* @param {string} payload — the stringified raw argument (i.e. the cache key the client will use)
+* @param {RequestEvent} event
+* @param {RequestState} state
+* @param {() => Promise<any>} fn
+* @returns {RemoteQuery<any>}
+*/
+function create_query_resource(__, payload, event, state, fn) {
+	/** @type {Promise<any> | null} */
+	let promise = null;
+	const get_promise = () => {
+		return promise ??= get_response(__, payload, state, fn);
+	};
+	const populate_hydratable = () => {
+		if (__.id && state.is_in_render) get_promise().catch(noop);
+	};
+	return {
+		/** @type {Promise<any>['catch']} */
+		catch(onrejected) {
+			return get_promise().catch(onrejected);
+		},
+		get current() {
+			populate_hydratable();
+		},
+		get error() {
+			populate_hydratable();
+		},
+		/** @type {Promise<any>['finally']} */
+		finally(onfinally) {
+			return get_promise().finally(onfinally);
+		},
+		get loading() {
+			populate_hydratable();
+			return true;
+		},
+		get ready() {
+			populate_hydratable();
+			return false;
+		},
+		refresh() {
+			promise = null;
+			delete get_cache(__, state)[payload];
+			refresh(event, state, __, payload, get_promise);
+			return Promise.resolve();
+		},
+		/** @param {any} value */
+		set(value) {
+			const p = promise = Promise.resolve(value);
+			get_cache(__, state)[payload] = p;
+			refresh(event, state, __, payload, () => p);
+		},
+		run() {
+			throw new Error(`\`myQuery().run()\` has been removed — please replace it with \`myQuery()\`. See https://github.com/sveltejs/kit/pull/15779 for more details`);
+		},
+		/** @type {Promise<any>['then']} */
+		then(onfulfilled, onrejected) {
+			return get_promise().then(onfulfilled, onrejected);
+		},
+		withOverride() {
+			throw new Error(`Cannot call '${__.name}.withOverride()' on the server`);
+		},
+		get [Symbol.toStringTag]() {
+			return "QueryResource";
+		}
+	};
+}
+/**
+* @param {RemoteQueryLiveInternals} __
+* @param {string} payload — the stringified raw argument (i.e. the cache key the client will use)
+* @param {RequestEvent} event
+* @param {RequestState} state
+* @param {() => AsyncGenerator<any, void, void>} get_generator
+* @returns {RemoteLiveQuery<any>}
+*/
+function create_live_query_resource(__, payload, event, state, get_generator) {
+	/** @type {Promise<any> | null} */
+	let promise = null;
+	const get_first_value = async () => {
+		for await (const value of get_generator()) return value;
+		throw new Error(`query.live '${__.name}' did not yield a value`);
+	};
+	const get_promise = () => {
+		return promise ??= get_response(__, payload, state, get_first_value);
+	};
+	const populate_hydratable = () => {
+		if (__.id && state.is_in_render) get_promise().catch(noop);
+	};
+	return {
+		/** @type {Promise<any>['catch']} */
+		catch(onrejected) {
+			return get_promise().catch(onrejected);
+		},
+		get current() {
+			populate_hydratable();
+		},
+		get error() {
+			populate_hydratable();
+		},
+		/** @type {Promise<any>['finally']} */
+		finally(onfinally) {
+			return get_promise().finally(onfinally);
+		},
+		get done() {
+			populate_hydratable();
+			return false;
+		},
+		get loading() {
+			populate_hydratable();
+			return true;
+		},
+		get ready() {
+			populate_hydratable();
+			return false;
+		},
+		get connected() {
+			populate_hydratable();
+			return false;
+		},
+		reconnect() {
+			promise = null;
+			delete get_cache(__, state)[payload];
+			refresh(event, state, __, payload, get_promise);
+			return Promise.resolve();
+		},
+		/** @ts-expect-error This method no longer exists */
+		run() {
+			throw new Error("`.run()` has been removed from live queries. Use `for await (const value of liveQuery())` instead.");
+		},
+		/** @type {Promise<any>['then']} */
+		then(onfulfilled, onrejected) {
+			return get_promise().then(onfulfilled, onrejected);
+		},
+		[Symbol.asyncIterator]() {
+			const key = create_remote_key(__.id, payload);
+			const cache = state.remote.live_iterators ??= /* @__PURE__ */ new Map();
+			let cached = cache.get(key);
+			if (!cached) {
+				cached = create_shared_live_iterator(event.request.signal, get_generator);
+				cache.set(key, cached);
+			}
+			return cached.subscribe();
+		},
+		get [Symbol.toStringTag]() {
+			return "LiveQueryResource";
+		}
+	};
+}
+/**
+* Wraps a lazily-created live-query generator so that multiple `for await`
+* consumers within the same request share one underlying iteration. The first
+* subscriber starts the generator; values are broadcast to all subscribers
+* via a `SharedIterator`. When the last subscriber unsubscribes, the generator
+* is closed via `generator.return(undefined)`.
+*
+* If `signal` aborts (typically because the client has disconnected), the
+* pump is torn down and any in-flight `next()` calls on consumer iterators
+* resolve with `{ done: true }`, so suspended `for await` loops unwind
+* cleanly rather than leaking.
+*
+* @param {AbortSignal} signal
+* @param {() => AsyncGenerator<any, void, void>} get_generator
+*/
+function create_shared_live_iterator(signal, get_generator) {
+	return new SharedIterator((instance) => {
+		if (signal.aborted) {
+			instance.done();
+			return noop;
+		}
+		const generator = get_generator();
+		let aborted = false;
+		const close = () => {
+			aborted = true;
+			generator.return().catch(noop);
+		};
+		signal.addEventListener("abort", () => (close(), instance.done()), { once: true });
+		(async () => {
+			try {
+				while (true) {
+					const result = await generator.next();
+					if (result.done) {
+						instance.done();
+						return;
+					}
+					instance.push(result.value);
+				}
+			} catch (error) {
+				if (!aborted) instance.fail(error);
+			} finally {
+				close();
+			}
+		})();
+		return close;
+	});
+}
+Object.defineProperty(query, "batch", {
+	value: batch,
+	enumerable: true
+});
+Object.defineProperty(query, "live", {
+	value: live,
+	enumerable: true
+});
+
+//#region ../lib/config.mjs
+var DEFAULT_IGNORE = [
+	"**/package-lock.json",
+	"**/pnpm-lock.yaml",
+	"**/yarn.lock",
+	"**/bun.lock",
+	"**/bun.lockb",
+	"**/*.g.cs",
+	"**/*Snapshot.cs",
+	"**/*.Designer.cs",
+	"**/node_modules/**",
+	"**/.svelte-kit/**",
+	"**/dist/**",
+	"**/build/**",
+	"**/*.min.js",
+	"**/*.min.css",
+	"**/CODE_REVIEW_CORRECTNESS_FINDINGS.md"
+];
+var STORE_DIFF_MAX = 4e5;
+var GUIDELINE_FILES = [
+	"REVIEW.md",
+	"CLAUDE.md",
+	"AGENTS.md"
+];
+function unquote(s) {
+	const t = String(s || "").trim();
+	if (t.startsWith("\"") && t.endsWith("\"") || t.startsWith("'") && t.endsWith("'")) return t.slice(1, -1);
+	return t;
+}
+/** Minimal YAML: `key: value` and `key:\n  - item`. */
+function parseSimpleYaml(text) {
+	const result = {};
+	let key = null;
+	for (const raw of String(text || "").split(/\r?\n/)) {
+		if (!raw.trim() || raw.trim().startsWith("#")) continue;
+		const list = raw.match(/^\s+-\s+(.*)$/);
+		if (list && key) {
+			if (!Array.isArray(result[key])) result[key] = [];
+			result[key].push(unquote(list[1]));
+			continue;
+		}
+		const kv = raw.match(/^([A-Za-z][\w]*)\s*:\s*(.*)$/);
+		if (!kv) continue;
+		key = kv[1];
+		const v = kv[2].trim();
+		result[key] = v === "" ? [] : unquote(v);
+	}
+	return result;
+}
+function globToRegExp(glob) {
+	let g = String(glob || "").replace(/\\/g, "/");
+	if (!g.includes("/")) g = `**/${g}`;
+	let s = "";
+	for (let i = 0; i < g.length; i++) {
+		const c = g[i];
+		if (c === "*" && g[i + 1] === "*") if (g[i + 2] === "/") {
+			s += "(?:.*/)?";
+			i += 2;
+		} else {
+			s += ".*";
+			i += 1;
+		}
+		else if (c === "*") s += "[^/]*";
+		else if (c === "?") s += "[^/]";
+		else if ("+()[]{}|.^$".includes(c)) s += `\\${c}`;
+		else s += c;
+	}
+	return new RegExp(`^${s}$`, "i");
+}
+function globMatch(filePath, pattern) {
+	const norm = String(filePath || "").replace(/\\/g, "/");
+	return globToRegExp(pattern).test(norm);
+}
+function isIgnored(filePath, patterns) {
+	return (patterns || []).some((p) => globMatch(filePath, p));
+}
+function isTestPath(filePath) {
+	const p = String(filePath || "").replace(/\\/g, "/");
+	return /(^|\/)(__tests__|tests?|spec)s?(\/|$)/i.test(p) || /\.(test|spec)\.[^.]+$/i.test(p);
+}
+function readIfExists(path) {
+	try {
+		return existsSync(path) ? readFileSync(path, "utf8") : null;
+	} catch {
+		return null;
+	}
+}
+function loadReviewConfig(repo) {
+	const jsonText = readIfExists(join(repo, ".diff-review.json"));
+	const yamlText = readIfExists(join(repo, ".diff-review.yml")) || readIfExists(join(repo, ".diff-review.yaml"));
+	let extra = {};
+	if (jsonText) try {
+		extra = JSON.parse(jsonText);
+	} catch {
+		extra = {};
+	}
+	else if (yamlText) extra = parseSimpleYaml(yamlText);
+	const extraIgnore = Array.isArray(extra.ignore) ? extra.ignore.map(String) : [];
+	const rulesFile = extra.rulesFile ? String(extra.rulesFile) : "REVIEW.md";
+	const rules = readIfExists(join(repo, rulesFile)) || "";
+	const model = extra.model && extra.model !== "default" ? String(extra.model) : null;
+	return {
+		ignore: [...DEFAULT_IGNORE, ...extraIgnore],
+		model,
+		rulesFile,
+		rules: rules.trim()
+	};
+}
+/** CLAUDE.md / REVIEW.md / AGENTS.md from repo root and immediate parent dirs of touched files. */
+function collectGuidelines(repo, filePaths, { rulesFile = "REVIEW.md", maxChars = 8e3, maxTotalChars = 12e3, maxDepth = 1, skipNames = [] } = {}) {
+	const skip = new Set(skipNames);
+	const names = [.../* @__PURE__ */ new Set([rulesFile, ...GUIDELINE_FILES])].filter((name) => !skip.has(name));
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	const addRel = (rel) => {
+		const norm = String(rel || "").replace(/\\/g, "/").replace(/^\/+/, "");
+		if (!norm || seen.has(norm)) return;
+		const text = readIfExists(join(repo, ...norm.split("/")));
+		if (!text || !text.trim()) return;
+		seen.add(norm);
+		out.push({
+			path: norm,
+			text: text.trim()
+		});
+	};
+	for (const name of names) addRel(name);
+	const depth = Math.max(1, Number(maxDepth) || 1);
+	for (const filePath of filePaths || []) {
+		const parts = String(filePath || "").replace(/\\/g, "/").split("/").filter(Boolean);
+		const minLen = Math.max(1, parts.length - depth);
+		for (let len = parts.length - 1; len >= minLen; len--) {
+			const dir = parts.slice(0, len).join("/");
+			for (const name of names) addRel(`${dir}/${name}`);
+		}
+	}
+	let total = 0;
+	const capped = [];
+	for (const item of out) {
+		if (total >= maxTotalChars) break;
+		const room = maxTotalChars - total;
+		const slice = item.text.slice(0, Math.min(maxChars, room));
+		if (!slice) continue;
+		capped.push({
+			path: item.path,
+			text: slice
+		});
+		total += slice.length;
+	}
+	return capped;
+}
+function capDiff(diff, max = STORE_DIFF_MAX) {
+	const text = String(diff || "");
+	if (text.length <= max) return {
+		diff: text,
+		diffChars: text.length,
+		truncated: false
+	};
+	return {
+		diff: `${text.slice(0, max)}\n\n… [diff recortado: se guardan ${max} de ${text.length} caracteres]`,
+		diffChars: text.length,
+		truncated: true
+	};
+}
+//#endregion
+//#region ../lib/git.mjs
+function assertGitRepo(repo) {
+	const raw = String(repo || "").trim();
+	if (!raw) throw new Error("Indicá la ruta absoluta de un repositorio git.");
+	if (!/[\\/]/.test(raw) && !/^[A-Za-z]:/.test(raw)) throw new Error(`"${raw}" no es una ruta. Pegá la ruta absoluta del repo (ej. C:\\tienda-argenta\\tienda-argenta-2).`);
+	const resolved = resolve(raw);
+	if (!resolved || resolved === ".") throw new Error("Indicá la ruta absoluta de un repositorio git.");
+	if (!existsSync(resolved)) throw new Error(`No existe la carpeta: ${resolved}`);
+	if (!existsSync(join(resolved, ".git"))) throw new Error(`No es un repositorio git (falta .git): ${resolved}`);
+	return resolved;
+}
+function git(repo, args, { maxBuffer = 64 * 1024 * 1024 } = {}) {
+	return execFileSync("git", args, {
+		cwd: repo,
+		encoding: "utf8",
+		maxBuffer,
+		windowsHide: true
+	});
+}
+function commitLog(repo, mergeBase, branch, limit = 25) {
+	try {
+		return git(repo, [
+			"log",
+			"--oneline",
+			"--no-merges",
+			"-n",
+			String(limit),
+			`${mergeBase}..${branch}`
+		]).trim().split("\n").filter(Boolean);
+	} catch {
+		return [];
+	}
+}
+var FILE_LINE_CACHE = /* @__PURE__ */ new Map();
+var FILE_LINE_CACHE_MAX = 48;
+function rememberFileLines(key, lines) {
+	if (FILE_LINE_CACHE.has(key)) FILE_LINE_CACHE.delete(key);
+	FILE_LINE_CACHE.set(key, lines);
+	while (FILE_LINE_CACHE.size > FILE_LINE_CACHE_MAX) {
+		const oldest = FILE_LINE_CACHE.keys().next().value;
+		FILE_LINE_CACHE.delete(oldest);
+	}
+}
+function showFileLines(repo, rev, path) {
+	const resolved = assertGitRepo(repo);
+	const safeRev = String(rev || "").trim();
+	const safePath = String(path || "").replace(/\\/g, "/").trim();
+	if (!safeRev || !/^[A-Za-z0-9._/\-]+$/.test(safeRev)) throw new Error("Rev inválido.");
+	if (!safePath || safePath.startsWith("/") || safePath.includes("..") || safePath.includes("\0")) throw new Error("Ruta inválida.");
+	const key = `${resolved}\0${safeRev}\0${safePath}`;
+	if (FILE_LINE_CACHE.has(key)) return FILE_LINE_CACHE.get(key);
+	let text;
+	try {
+		text = git(resolved, ["show", `${safeRev}:${safePath}`]);
+	} catch {
+		rememberFileLines(key, null);
+		return null;
+	}
+	if (text.includes("\0")) {
+		rememberFileLines(key, null);
+		return null;
+	}
+	const raw = text.replace(/\r\n/g, "\n");
+	const lines = raw.endsWith("\n") ? raw.slice(0, -1).split("\n") : raw.split("\n");
+	rememberFileLines(key, lines);
+	return lines;
+}
+function listBranches(repo) {
+	const names = git(repo, [
+		"for-each-ref",
+		"--sort=-committerdate",
+		"--format=%(refname:short)",
+		"refs/heads",
+		"refs/remotes"
+	]).split("\n").map((s) => s.trim()).filter(Boolean).map((name) => name.replace(/^origin\//, "")).filter((name) => name !== "HEAD" && !name.endsWith("/HEAD"));
+	const unique = [...new Set(names)];
+	const current = git(repo, [
+		"rev-parse",
+		"--abbrev-ref",
+		"HEAD"
+	]).trim();
+	const bases = unique.filter((n) => n === "develop" || n === "main" || n === "master");
+	return {
+		branches: unique,
+		current,
+		defaultBase: bases.includes("develop") ? "develop" : bases.includes("main") ? "main" : bases[0] || "develop"
+	};
+}
+/** URL del remote (origin, o el primero disponible). Vacío si no hay. */
+function getRemoteUrl(repo, preferred = "origin") {
+	try {
+		const url = git(repo, [
+			"remote",
+			"get-url",
+			preferred
+		]).trim();
+		if (url) return url;
+	} catch {}
+	try {
+		const remotes = git(repo, ["remote"]).split("\n").map((s) => s.trim()).filter(Boolean);
+		if (!remotes.length) return "";
+		return git(repo, [
+			"remote",
+			"get-url",
+			remotes[0]
+		]).trim();
+	} catch {
+		return "";
+	}
+}
+//#endregion
+//#region ../lib/extract.mjs
+function extractBranchDiff({ repo, branch, base = "develop" }) {
+	if (!branch) throw new Error("Falta el branch a revisar.");
+	const config = loadReviewConfig(repo);
+	const mergeBase = git(repo, [
+		"merge-base",
+		base,
+		branch
+	]).trim();
+	const branchSha = git(repo, ["rev-parse", branch]).trim();
+	const baseSha = git(repo, ["rev-parse", base]).trim();
+	const nameStatus = git(repo, [
+		"diff",
+		mergeBase,
+		branch,
+		"--name-status"
+	]).trim().split("\n").filter(Boolean).map((line) => {
+		const [status, ...rest] = line.split("	");
+		const path = rest[rest.length - 1];
+		const oldPath = rest.length > 1 ? rest[0] : null;
+		let changeType = "modified";
+		if (status.startsWith("A")) changeType = "added";
+		else if (status.startsWith("D")) changeType = "deleted";
+		else if (status.startsWith("R")) changeType = "renamed";
+		return {
+			path,
+			oldPath,
+			changeType
+		};
+	});
+	const ignored = [];
+	const included = [];
+	for (const f of nameStatus) if (isIgnored(f.path, config.ignore)) ignored.push(f.path);
+	else included.push(f);
+	const files = included.map((f) => {
+		let raw = "";
+		try {
+			raw = git(repo, [
+				"diff",
+				mergeBase,
+				branch,
+				"--",
+				f.path
+			]);
+			const idx = raw.indexOf("\n@@");
+			if (idx !== -1) raw = raw.slice(idx + 1);
+		} catch {
+			raw = "";
+		}
+		const capped = capDiff(raw);
+		return {
+			path: f.path,
+			oldPath: f.oldPath || void 0,
+			changeType: f.changeType,
+			diff: capped.diff,
+			diffChars: capped.diffChars,
+			truncated: capped.truncated,
+			modelChars: capped.diff.length,
+			group: ""
+		};
+	});
+	const shortstat = git(repo, [
+		"diff",
+		mergeBase,
+		branch,
+		"--shortstat"
+	]).trim();
+	const insMatch = shortstat.match(/(\d+) insertion/);
+	const delMatch = shortstat.match(/(\d+) deletion/);
+	return {
+		version: 2,
+		repo,
+		branch,
+		baseBranch: base,
+		mergeBase,
+		branchSha,
+		baseSha,
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		intent: "",
+		stats: {
+			filesChanged: files.length,
+			filesIgnored: ignored.length,
+			filesTruncated: files.filter((f) => f.truncated).length,
+			insertions: insMatch ? Number(insMatch[1]) : 0,
+			deletions: delMatch ? Number(delMatch[1]) : 0
+		},
+		context: {
+			commits: commitLog(repo, mergeBase, branch),
+			rules: config.rules,
+			rulesFile: config.rulesFile,
+			ignored: ignored.slice(0, 40),
+			testsTouched: files.filter((f) => isTestPath(f.path)).map((f) => f.path),
+			testsMissing: files.filter((f) => !isTestPath(f.path)).length,
+			guidelines: collectGuidelines(repo, files.map((f) => f.path), {
+				rulesFile: config.rulesFile,
+				skipNames: config.rules.trim() ? [config.rulesFile] : [],
+				maxDepth: 1,
+				maxChars: 8e3,
+				maxTotalChars: 12e3
+			})
+		},
+		files,
+		groups: [],
+		blocks: [],
+		findings: [],
+		skipped: []
+	};
+}
+//#endregion
+//#region ../lib/remote-repo.mjs
+var CACHE_ROOT = join(tmpdir(), "diff-review-clones");
+var MAX_DEEPEN_ROUNDS = 8;
+var DEEPEN_BY = "50";
+function looksLikeGitUrl(value) {
+	const v = String(value || "").trim();
+	if (!v) return false;
+	if (/^(https?:\/\/|git@|ssh:\/\/)/i.test(v)) return true;
+	if (/\.git$/i.test(v) && !/^[A-Za-z]:/.test(v) && !v.startsWith("/") && !v.startsWith("\\")) return true;
+	return false;
+}
+function normalizeGitUrl(url) {
+	const raw = String(url || "").trim();
+	if (!raw) throw new Error("Indicá la URL del repositorio.");
+	if (!looksLikeGitUrl(raw)) throw new Error(`"${raw}" no parece una URL git. Usá https://…, git@… o ssh://…`);
+	if (/^(file:|javascript:|data:)/i.test(raw)) throw new Error("Esquema de URL no permitido.");
+	return raw.replace(/\/$/, "");
+}
+function cacheDirFor(url) {
+	return join(CACHE_ROOT, createHash("sha1").update(url).digest("hex").slice(0, 16));
+}
+function runGit(args, { cwd, timeout = 300 * 1e3 } = {}) {
+	return execFileSync("git", args, {
+		cwd,
+		encoding: "utf8",
+		windowsHide: true,
+		timeout,
+		maxBuffer: 64 * 1024 * 1024
+	});
+}
+/** Lista heads del remote sin clonar. */
+function listRemoteBranches(url) {
+	const remote = normalizeGitUrl(url);
+	let raw;
+	try {
+		raw = runGit([
+			"ls-remote",
+			"--heads",
+			remote
+		]);
+	} catch (err) {
+		const stderr = String(
+			/** @type {{ stderr?: string }} */
+			err.stderr || err.message || err
+		);
+		throw new Error("No se pudo listar branches del remote: " + stderr.split("\n").find(Boolean));
+	}
+	const branches = [...new Set(raw.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => {
+		return (line.split("	")[1] || "").replace(/^refs\/heads\//, "");
+	}).filter(Boolean))].sort((a, b) => a.localeCompare(b));
+	if (!branches.length) throw new Error("El remote no expone branches (refs/heads).");
+	return {
+		branches,
+		current: "",
+		defaultBase: branches.includes("develop") ? "develop" : branches.includes("main") ? "main" : branches.includes("master") ? "master" : branches[0]
+	};
+}
+function fetchRef(repo, ref) {
+	const name = String(ref || "").trim();
+	if (!name) return;
+	try {
+		runGit([
+			"rev-parse",
+			"--verify",
+			name
+		], { cwd: repo });
+		return;
+	} catch {}
+	runGit([
+		"fetch",
+		"--depth",
+		DEEPEN_BY,
+		"origin",
+		`refs/heads/${name}:refs/heads/${name}`
+	], { cwd: repo });
+}
+function deepenUntilMergeBase(repo, base, branch) {
+	for (let i = 0; i < MAX_DEEPEN_ROUNDS; i++) try {
+		git(repo, [
+			"merge-base",
+			base,
+			branch
+		]);
+		return;
+	} catch {
+		runGit([
+			"fetch",
+			"--deepen",
+			DEEPEN_BY,
+			"origin",
+			`refs/heads/${base}:refs/heads/${base}`,
+			`refs/heads/${branch}:refs/heads/${branch}`
+		], { cwd: repo });
+	}
+	throw new Error(`No se encontró merge-base entre "${base}" y "${branch}" (historial shallow insuficiente). Probá con más historia o usá una carpeta local.`);
+}
+/**
+* Asegura un worktree local (cache en tmp) con branch y base disponibles para diff.
+* @returns {string} ruta absoluta del clone
+*/
+function ensureRemoteWorktree(url, branch, base = "develop") {
+	const remote = normalizeGitUrl(url);
+	const b = String(branch || "").trim();
+	const baseRef = String(base || "develop").trim() || "develop";
+	if (!b) throw new Error("Falta el branch a revisar.");
+	mkdirSync(CACHE_ROOT, { recursive: true });
+	const dir = cacheDirFor(remote);
+	if (!existsSync(join(dir, ".git"))) {
+		if (existsSync(dir)) rmSync(dir, {
+			recursive: true,
+			force: true
+		});
+		try {
+			runGit([
+				"clone",
+				"--filter=blob:none",
+				"--depth",
+				DEEPEN_BY,
+				"--branch",
+				b,
+				remote,
+				dir
+			], { timeout: 600 * 1e3 });
+		} catch (err) {
+			if (existsSync(dir)) rmSync(dir, {
+				recursive: true,
+				force: true
+			});
+			const stderr = String(
+				/** @type {{ stderr?: string }} */
+				err.stderr || err.message || err
+			);
+			throw new Error("No se pudo clonar el repo: " + stderr.split("\n").find(Boolean));
+		}
+	} else {
+		try {
+			runGit([
+				"remote",
+				"set-url",
+				"origin",
+				remote
+			], { cwd: dir });
+		} catch {}
+		fetchRef(dir, b);
+		try {
+			runGit([
+				"checkout",
+				"--force",
+				b
+			], { cwd: dir });
+		} catch {}
+	}
+	if (baseRef !== b) fetchRef(dir, baseRef);
+	deepenUntilMergeBase(dir, baseRef, b);
+	return dir;
+}
+//#endregion
+//#region ../lib/validate.mjs
+var GROUP_KINDS = [
+	"feat",
+	"fix",
+	"refactor",
+	"perf",
+	"test",
+	"chore",
+	"docs",
+	"infra"
+];
+var BLOCK_OPS = [
+	"add",
+	"mod",
+	"del",
+	"rename"
+];
+var WHY_SOURCES = [
+	"code",
+	"commit",
+	"pr",
+	"issue",
+	"inferred"
+];
+var FINDING_CLASSES = ["risk", "quality"];
+var FINDING_SEVERITIES = [
+	"high",
+	"med",
+	"low",
+	"nit"
+];
+var FINDING_KINDS = [
+	"bug",
+	"race",
+	"auth",
+	"security",
+	"api-break",
+	"missing-test",
+	"perf",
+	"maintainability",
+	"docs",
+	"other"
+];
+var SKIP_REASONS = [
+	"generated",
+	"lockfile",
+	"format",
+	"vendored",
+	"binary",
+	"trivial",
+	"ignored"
+];
+//#endregion
+//#region ../lib/review.mjs
+var MAX = {
+	intent: 700,
+	groupTitle: 100,
+	groupIntent: 300,
+	what: 240,
+	why: 240,
+	finding: 360
+};
+function text$1(value, max) {
+	const raw = String(value ?? "").replace(/\s+/g, " ").trim();
+	return raw.length > max ? `${raw.slice(0, max - 1).trimEnd()}…` : raw;
+}
+function oneOf(value, allowed, fallback) {
+	const raw = String(value ?? "").trim().toLowerCase();
+	return allowed.includes(raw) ? raw : fallback;
+}
+/**
+* Rango de líneas de un bloque. `L40-58` es post-imagen (lo que quedó);
+* `-L88-95` es pre-imagen, que es la única forma de señalar líneas borradas.
+*/
+function parseLineRange(value) {
+	const raw = String(value ?? "").trim();
+	const match = /^(-)?L?(\d+)(?:\s*[-–]\s*L?(\d+))?$/i.exec(raw);
+	if (!match) return null;
+	const start = Number(match[2]);
+	const end = match[3] ? Number(match[3]) : start;
+	return {
+		side: match[1] ? "old" : "new",
+		start: Math.min(start, end),
+		end: Math.max(start, end)
+	};
+}
+function formatLineRange(range) {
+	if (!range) return "";
+	const prefix = range.side === "old" ? "-L" : "L";
+	return range.start === range.end ? `${prefix}${range.start}` : `${prefix}${range.start}-${range.end}`;
+}
+function countHunks(files) {
+	let total = 0;
+	for (const file of files || []) for (const line of String(file.diff || "").split("\n")) if (line.startsWith("@@")) total += 1;
+	return total;
+}
+function normalizeGroups(raw) {
+	const seen = /* @__PURE__ */ new Set();
+	const groups = [];
+	for (const item of raw || []) {
+		const id = String(item?.id || "").trim();
+		if (!id || seen.has(id)) continue;
+		seen.add(id);
+		groups.push({
+			id,
+			kind: oneOf(item.kind, GROUP_KINDS, "chore"),
+			title: text$1(item.title, MAX.groupTitle) || `${oneOf(item.kind, GROUP_KINDS, "chore")}: cambios`,
+			intent: text$1(item.intent, MAX.groupIntent)
+		});
+	}
+	return groups;
+}
+function normalizeBlocks(raw, { groupIds, knownPaths }) {
+	const seen = /* @__PURE__ */ new Set();
+	const blocks = [];
+	for (const item of raw || []) {
+		const id = String(item?.id || "").trim();
+		const group = String(item?.group || "").trim();
+		const file = String(item?.file || "").trim();
+		if (!id || seen.has(id)) continue;
+		if (!groupIds.has(group)) continue;
+		if (knownPaths.size && !knownPaths.has(file)) continue;
+		const range = parseLineRange(item.lines);
+		seen.add(id);
+		blocks.push({
+			id,
+			group,
+			file,
+			lines: range ? formatLineRange(range) : text$1(item.lines, 24),
+			side: range?.side || "new",
+			start: range?.start ?? 0,
+			end: range?.end ?? 0,
+			op: oneOf(item.op, BLOCK_OPS, "mod"),
+			what: text$1(item.what, MAX.what),
+			why: text$1(item.why, MAX.why),
+			source: oneOf(item.source, WHY_SOURCES, "inferred")
+		});
+	}
+	blocks.sort((a, b) => a.file.localeCompare(b.file) || a.start - b.start);
+	return blocks;
+}
+function findingKey(finding) {
+	return [
+		finding.file,
+		finding.line ?? "",
+		finding.kind,
+		finding.what
+	].join("|");
+}
+function normalizeFindings(raw, { blockIds, knownPaths }) {
+	const seen = /* @__PURE__ */ new Set();
+	const findings = [];
+	for (const item of raw || []) {
+		const file = String(item?.file || item?.path || "").trim();
+		const what = text$1(item?.what || item?.title, MAX.finding);
+		if (!file || !what) continue;
+		if (knownPaths.size && !knownPaths.has(file)) continue;
+		const cls = oneOf(item.class, FINDING_CLASSES, "risk");
+		const severity = oneOf(item.severity, FINDING_SEVERITIES, "med");
+		const block = String(item?.block || "").trim();
+		const line = Number.isFinite(Number(item?.line)) ? Number(item.line) : null;
+		const finding = {
+			id: "",
+			class: cls,
+			severity,
+			blocking: cls === "risk" && (item?.blocking === true || severity === "high"),
+			kind: oneOf(item.kind, FINDING_KINDS, "other"),
+			file,
+			line,
+			block: blockIds.has(block) ? block : "",
+			what,
+			fix: text$1(item.fix || item.detail, MAX.finding)
+		};
+		const key = findingKey(finding);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		findings.push(finding);
+	}
+	const rank = {
+		high: 0,
+		med: 1,
+		low: 2,
+		nit: 3
+	};
+	findings.sort((a, b) => Number(b.blocking) - Number(a.blocking) || (a.class === b.class ? 0 : a.class === "risk" ? -1 : 1) || rank[a.severity] - rank[b.severity] || a.file.localeCompare(b.file));
+	findings.forEach((finding, i) => {
+		finding.id = `f${i + 1}`;
+	});
+	return findings;
+}
+function normalizeSkipped(raw, ignored) {
+	const byFile = /* @__PURE__ */ new Map();
+	for (const path of ignored || []) byFile.set(String(path), {
+		file: String(path),
+		reason: "ignored"
+	});
+	for (const item of raw || []) {
+		const file = String(item?.file || "").trim();
+		if (!file) continue;
+		byFile.set(file, {
+			file,
+			reason: oneOf(item.reason, SKIP_REASONS, "trivial")
+		});
+	}
+	return [...byFile.values()];
+}
+/** Tema donde se dibuja el archivo: el que aporta más bloques, desempatando por orden de tema. */
+function dominantGroup(blocks, path, groupOrder) {
+	const tally = /* @__PURE__ */ new Map();
+	for (const block of blocks) {
+		if (block.file !== path) continue;
+		tally.set(block.group, (tally.get(block.group) || 0) + 1);
+	}
+	if (!tally.size) return "";
+	return [...tally.entries()].sort((a, b) => b[1] - a[1] || groupOrder.indexOf(a[0]) - groupOrder.indexOf(b[0]))[0][0];
+}
+/**
+* Documento final: lo que dijo el modelo, saneado y cruzado contra los archivos
+* reales del diff. Todo lo que no cierra se descarta acá en vez de romper la UI.
+*/
+function buildReview({ skeleton, payload, notes = [] }) {
+	const files = skeleton.files || [];
+	const knownPaths = new Set(files.map((f) => f.path));
+	const groups = normalizeGroups(payload?.groups);
+	const groupIds = new Set(groups.map((g) => g.id));
+	const blocks = normalizeBlocks(payload?.blocks, {
+		groupIds,
+		knownPaths
+	});
+	const blockIds = new Set(blocks.map((b) => b.id));
+	const findings = normalizeFindings(payload?.findings, {
+		blockIds,
+		knownPaths
+	});
+	const skipped = normalizeSkipped(payload?.skipped, skeleton.context?.ignored);
+	const usedGroups = new Set(blocks.map((b) => b.group));
+	const liveGroups = groups.filter((g) => usedGroups.has(g.id));
+	const groupOrder = liveGroups.map((g) => g.id);
+	const skippedFiles = new Set(skipped.map((s) => s.file));
+	const orphans = files.filter((f) => !blocks.some((b) => b.file === f.path) && !skippedFiles.has(f.path));
+	if (orphans.length) notes = [...notes, `${orphans.length} archivo(s) quedaron sin explicación del modelo.`];
+	const decorated = files.map((file) => ({
+		...file,
+		group: dominantGroup(blocks, file.path, groupOrder)
+	}));
+	return {
+		...skeleton,
+		version: 2,
+		intent: text$1(payload?.intent, MAX.intent),
+		groups: liveGroups,
+		blocks,
+		findings,
+		skipped,
+		files: decorated,
+		stats: {
+			...skeleton.stats,
+			hunks: countHunks(files)
+		},
+		notes,
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+//#endregion
+//#region src/lib/server/pick-folder.ts
+/**
+* Diálogo nativo de carpetas.
+* Windows: PowerShell DPI-aware (exit 2 = canceló; 1 = error → fallback).
+* Otros: @bindrs/rfd; si falla, shell (VBS / osascript / zenity).
+*/
+async function pickFolder() {
+	if (platform() === "win32") try {
+		return pickWindowsDpiAware();
+	} catch (err) {
+		console.warn("[diff-review] picker DPI-aware falló, probando rfd/fallback:", err instanceof Error ? err.message : err);
+	}
+	try {
+		return pickWithRfdWorker();
+	} catch (err) {
+		console.warn("[diff-review] @bindrs/rfd no disponible, usando fallback:", err instanceof Error ? err.message : err);
+		return pickFolderFallback();
+	}
+}
+function resolveNodeBin() {
+	if (process.execPath && /node(\.exe)?$/i.test(process.execPath)) return process.execPath;
+	return "node";
+}
+function writeUtf8Bom(path, content) {
+	writeFileSync(path, `\uFEFF${content}`, "utf8");
+}
+/**
+* IFileOpenDialog nativo (Vista+) + DPI Per-Monitor V2 ANTES de cualquier UI.
+* Exit: 0 ok, 2 canceló, otro error → fallback.
+*/
+function pickWindowsDpiAware() {
+	const dir = mkdtempSync(join(tmpdir(), "diff-review-pick-"));
+	const script = join(dir, "pick.ps1");
+	const outFile = join(dir, "path.txt");
+	try {
+		writeUtf8Bom(script, `
+$ErrorActionPreference = 'Stop'
+
+# 1) DPI awareness ANTES de cargar WinForms / crear ventanas.
+Add-Type @'
+using System;
+using System.Runtime.InteropServices;
+public static class DiffReviewDpi {
+  [DllImport("user32.dll")] public static extern IntPtr SetThreadDpiAwarenessContext(IntPtr dpiContext);
+  [DllImport("shcore.dll")] public static extern int SetProcessDpiAwareness(int value);
+  [DllImport("user32.dll")] public static extern bool SetProcessDPIAware();
+  public static readonly IntPtr PerMonitorV2 = unchecked((IntPtr)(-4));
+  public static void Enable() {
+    try { SetThreadDpiAwarenessContext(PerMonitorV2); return; } catch { }
+    try { SetProcessDpiAwareness(2); return; } catch { }
+    try { SetProcessDPIAware(); } catch { }
+  }
+}
+'@
+[DiffReviewDpi]::Enable()
+
+# 2) IFileOpenDialog COM (mismo dialogo nitido que el Explorer).
+Add-Type @'
+using System;
+using System.Runtime.InteropServices;
+
+[ComImport, Guid("DC1C5A9C-E88A-4DDE-A5A1-60F82A20AEF7")]
+internal class FileOpenDialogRCW { }
+
+[ComImport, Guid("42F85136-DB7E-439C-85F1-E4075D135FC8"),
+ InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+internal interface IFileDialog {
+  [PreserveSig] int Show(IntPtr parent);
+  void SetFileTypes(uint cFileTypes, IntPtr rgFilterSpec);
+  void SetFileTypeIndex(uint iFileType);
+  void GetFileTypeIndex(out uint piFileType);
+  void Advise(IntPtr pfde, out uint pdwCookie);
+  void Unadvise(uint dwCookie);
+  void SetOptions(uint fos);
+  void GetOptions(out uint pfos);
+  void SetDefaultFolder(IShellItem psi);
+  void SetFolder(IShellItem psi);
+  void GetFolder(out IShellItem ppsi);
+  void GetCurrentSelection(out IShellItem ppsi);
+  void SetFileName([MarshalAs(UnmanagedType.LPWStr)] string pszName);
+  void GetFileName([MarshalAs(UnmanagedType.LPWStr)] out string pszName);
+  void SetTitle([MarshalAs(UnmanagedType.LPWStr)] string pszTitle);
+  void SetOkButtonLabel([MarshalAs(UnmanagedType.LPWStr)] string pszText);
+  void SetFileNameLabel([MarshalAs(UnmanagedType.LPWStr)] string pszLabel);
+  void GetResult(out IShellItem ppsi);
+  void AddPlace(IShellItem psi, int fdap);
+  void SetDefaultExtension([MarshalAs(UnmanagedType.LPWStr)] string pszDefaultExtension);
+  void Close(int hr);
+  void SetClientGuid(ref Guid guid);
+  void ClearClientData();
+  void SetFilter(IntPtr pFilter);
+}
+
+[ComImport, Guid("43826D1E-E718-42EE-BC55-A1E261C37BFE"),
+ InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+internal interface IShellItem {
+  void BindToHandler(IntPtr pbc, ref Guid bhid, ref Guid riid, out IntPtr ppv);
+  void GetParent(out IShellItem ppsi);
+  void GetDisplayName(uint sigdnName, out IntPtr ppszName);
+  void GetAttributes(uint sfgaoMask, out uint psfgaoAttribs);
+  void Compare(IShellItem psi, uint hint, out int piOrder);
+}
+
+public static class DiffReviewFolderPicker {
+  const uint FOS_PICKFOLDERS = 0x00000020;
+  const uint FOS_FORCEFILESYSTEM = 0x00000040;
+  const uint FOS_PATHMUSTEXIST = 0x00000800;
+  const uint SIGDN_FILESYSPATH = 0x80058000;
+
+  [DllImport("ole32.dll")]
+  static extern void CoTaskMemFree(IntPtr pv);
+
+  public static string Pick(string title) {
+    var dialog = (IFileDialog)new FileOpenDialogRCW();
+    uint options;
+    dialog.GetOptions(out options);
+    dialog.SetOptions(options | FOS_PICKFOLDERS | FOS_FORCEFILESYSTEM | FOS_PATHMUSTEXIST);
+    if (!string.IsNullOrEmpty(title)) dialog.SetTitle(title);
+    int hr = dialog.Show(IntPtr.Zero);
+    if (hr != 0) return null; // cancel / error
+    IShellItem item;
+    dialog.GetResult(out item);
+    IntPtr psz;
+    item.GetDisplayName(SIGDN_FILESYSPATH, out psz);
+    string path = Marshal.PtrToStringUni(psz);
+    CoTaskMemFree(psz);
+    return path;
+  }
+}
+'@
+
+$path = [DiffReviewFolderPicker]::Pick('Elegi el repositorio git')
+if ([string]::IsNullOrWhiteSpace($path)) { exit 2 }
+[System.IO.File]::WriteAllText(${JSON.stringify(outFile)}, $path)
+exit 0
+`.trim() + "\r\n");
+		const result = spawnSync("powershell.exe", [
+			"-STA",
+			"-NoProfile",
+			"-ExecutionPolicy",
+			"Bypass",
+			"-File",
+			script
+		], {
+			encoding: "utf8",
+			windowsHide: false,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			timeout: 600 * 1e3
+		});
+		if (result.status === 2) return null;
+		if (result.status !== 0) {
+			const err = (result.stderr || result.stdout || result.error?.message || `exit ${result.status}`).toString().trim();
+			throw new Error(err || "powershell picker fallo");
+		}
+		if (!existsSync(outFile)) throw new Error("powershell picker no escribio la ruta");
+		const path = readFileSync(outFile, "utf8").replace(/^\uFEFF/, "").trim();
+		if (!path) throw new Error("powershell picker devolvio ruta vacia");
+		return path;
+	} finally {
+		try {
+			rmSync(dir, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	}
+}
+function pickWithRfdWorker() {
+	const dir = mkdtempSync(join(tmpdir(), "diff-review-rfd-"));
+	const worker = join(dir, "pick.mjs");
+	const outFile = join(dir, "path.txt");
+	try {
+		writeFileSync(worker, `import { createRequire } from 'node:module';
+import { existsSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+const require = createRequire(import.meta.url);
+const outFile = ${JSON.stringify(outFile)};
+
+function findRfdIndex() {
+  const seen = new Set();
+  let dir = process.cwd();
+  for (let i = 0; i < 16; i++) {
+    if (seen.has(dir)) break;
+    seen.add(dir);
+    const indexJs = join(dir, 'node_modules', '@bindrs', 'rfd', 'index.js');
+    if (existsSync(indexJs)) return indexJs;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error('No se encontro @bindrs/rfd en node_modules');
+}
+
+const { AsyncFileDialog } = require(findRfdIndex());
+const handle = await new AsyncFileDialog().setTitle('Elegi el repositorio git').pickFolder();
+if (!handle) process.exit(2);
+writeFileSync(outFile, handle.path(), 'utf8');
+`, "utf8");
+		const result = spawnSync(resolveNodeBin(), [worker], {
+			encoding: "utf8",
+			windowsHide: false,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			timeout: 600 * 1e3,
+			cwd: process.cwd(),
+			env: process.env
+		});
+		if (result.status === 2 || result.status === 1) return null;
+		if (result.status !== 0) {
+			const err = (result.stderr || result.stdout || result.error?.message || `exit ${result.status}`).toString().trim();
+			throw new Error(err || "worker rfd fallo");
+		}
+		if (!existsSync(outFile)) return null;
+		return readFileSync(outFile, "utf8").replace(/^\uFEFF/, "").trim() || null;
+	} finally {
+		try {
+			rmSync(dir, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	}
+}
+function pickFolderFallback() {
+	const os = platform();
+	if (os === "win32") return pickWindowsVbs();
+	if (os === "darwin") return pickMac();
+	return pickLinux();
+}
+function pickWindowsVbs() {
+	const dir = mkdtempSync(join(tmpdir(), "diff-review-pick-"));
+	const vbs = join(dir, "pick.vbs");
+	const outFile = join(dir, "path.txt");
+	try {
+		writeFileSync(vbs, [
+			"Set shell = CreateObject(\"Shell.Application\")",
+			"Set folder = shell.BrowseForFolder(0, \"Elegi el repositorio git\", 0)",
+			"If folder Is Nothing Then",
+			"  WScript.Quit 1",
+			"End If",
+			"Set fso = CreateObject(\"Scripting.FileSystemObject\")",
+			`Set file = fso.CreateTextFile(${JSON.stringify(outFile)}, True, True)`,
+			"file.Write folder.Self.Path",
+			"file.Close"
+		].join("\r\n"), "utf8");
+		const result = spawnSync("cscript.exe", [
+			"//nologo",
+			"//E:VBScript",
+			vbs
+		], {
+			encoding: "utf8",
+			windowsHide: false,
+			stdio: [
+				"ignore",
+				"ignore",
+				"pipe"
+			],
+			timeout: 600 * 1e3
+		});
+		if (result.status === 1) return null;
+		if (result.status !== 0) {
+			const err = (result.stderr || result.error?.message || `exit ${result.status}`).toString().trim();
+			throw new Error(err || "cscript fallo");
+		}
+		if (!existsSync(outFile)) return null;
+		const buf = readFileSync(outFile);
+		return (buf.length >= 2 && buf[0] === 255 && buf[1] === 254 ? buf.subarray(2).toString("utf16le").trim() : buf.toString("utf8").replace(/^\uFEFF/, "").trim()) || null;
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		if (/canceled|cancelled|abort/i.test(msg)) return null;
+		throw new Error("No se pudo abrir el dialogo de carpetas: " + msg);
+	} finally {
+		try {
+			rmSync(dir, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	}
+}
+function pickMac() {
+	try {
+		const out = execFileSync("osascript", ["-e", "POSIX path of (choose folder with prompt \"Elegi el repositorio git\")"], {
+			encoding: "utf8",
+			timeout: 600 * 1e3
+		});
+		return String(out || "").trim().replace(/\/$/, "");
+	} catch (err) {
+		if (err.status === 1 || /User canceled|-128/i.test(String(err))) return null;
+		throw new Error("No se pudo abrir el dialogo de carpetas: " + (err instanceof Error ? err.message : String(err)));
+	}
+}
+function pickLinux() {
+	try {
+		const out = execFileSync("zenity", [
+			"--file-selection",
+			"--directory",
+			"--title=Elegi el repositorio git"
+		], {
+			encoding: "utf8",
+			timeout: 600 * 1e3
+		});
+		return String(out || "").trim() || null;
+	} catch (zenityErr) {
+		if (zenityErr.status === 1) return null;
+		try {
+			const out = execFileSync("kdialog", [
+				"--getexistingdirectory",
+				".",
+				"Elegi el repositorio git"
+			], {
+				encoding: "utf8",
+				timeout: 600 * 1e3
+			});
+			return String(out || "").trim() || null;
+		} catch (kErr) {
+			if (kErr.status === 1) return null;
+			throw new Error("No hay dialogo de carpetas disponible. Instala zenity o kdialog, o pega la ruta a mano.");
+		}
+	}
+}
+//#endregion
+//#region src/lib/server/git-review.ts
+function describeGitError(err) {
+	if (err && typeof err === "object") {
+		const rec = err;
+		const stderr = String(rec.stderr || "").trim().split("\n").find(Boolean);
+		if (stderr) return stderr;
+		if (rec.message) return rec.message;
+	}
+	return err instanceof Error ? err.message : String(err);
+}
+function resolveSource(source, repo) {
+	if (source === "local" || source === "url") return source;
+	return looksLikeGitUrl(repo) ? "url" : "local";
+}
+function loadRepoInfo(source, repo) {
+	if (resolveSource(source, repo) === "url") {
+		const url = normalizeGitUrl(repo);
+		return {
+			repo: url,
+			source: "url",
+			remoteUrl: url,
+			...listRemoteBranches(url)
+		};
+	}
+	const resolved = assertGitRepo(repo);
+	const listed = listBranches(resolved);
+	return {
+		repo: resolved,
+		source: "local",
+		remoteUrl: getRemoteUrl(resolved) || void 0,
+		...listed
+	};
+}
+async function pickLocalFolder$1() {
+	return pickFolder();
+}
+function resolveWorktree(source, repo, branch, base) {
+	if (source === "url") return ensureRemoteWorktree(repo, branch, base);
+	return assertGitRepo(repo);
+}
+function toReviewFile(file) {
+	const changeType = file.changeType;
+	const typed = changeType === "added" || changeType === "deleted" || changeType === "renamed" || changeType === "modified" ? changeType : "modified";
+	return {
+		path: file.path,
+		oldPath: file.oldPath || void 0,
+		changeType: typed,
+		diff: String(file.diff ?? "").replaceAll("\0", ""),
+		group: file.group ?? ""
+	};
+}
+/**
+* Contenido del archivo en la punta del branch, para rellenar en el viewer las líneas
+* que el diff no trae. Devuelve null (en vez de reventar) cuando el repo no está a mano
+* o el archivo es binario: ahí el viewer apaga los botones de expandir.
+*/
+function loadFileLines(input) {
+	try {
+		return showFileLines(resolveWorktree(resolveSource(input.source, input.repo), input.repo, input.branch, input.base || "develop"), input.branch, input.path);
+	} catch (err) {
+		console.error("[diff-review git] no se pudo leer", input.path, describeGitError(err));
+		return null;
+	}
+}
+function hydrateReviewPayload(input) {
+	const skeleton = extractBranchDiff({
+		repo: resolveWorktree(resolveSource(input.source, input.repo), input.repo, input.branch, input.base || "develop"),
+		branch: input.branch,
+		base: input.base || "develop"
+	});
+	const extraNotes = Array.isArray(input.payload?.notes) ? input.payload.notes.filter((n) => typeof n === "string") : [];
+	const built = buildReview({
+		skeleton,
+		payload: input.payload,
+		notes: extraNotes
+	});
+	const doc = {
+		intent: built.intent,
+		groups: built.groups,
+		blocks: built.blocks,
+		findings: built.findings,
+		skipped: built.skipped,
+		files: (built.files || []).map(toReviewFile),
+		notes: built.notes || []
+	};
+	return JSON.parse(JSON.stringify(doc));
+}
+//#endregion
+//#region src/lib/report/git.remote.ts
+var git_remote_exports = /* @__PURE__ */ __exportAll({
+	fileLines: () => fileLines,
+	hydrateFromGit: () => hydrateFromGit,
+	loadRepo: () => loadRepo,
+	pickLocalFolder: () => pickLocalFolder
+});
+function fail(err) {
+	const message = describeGitError(err) || "No se pudo hablar con git.";
+	console.error("[diff-review git]", message, err);
+	error(400, message);
+}
+var loadRepo = /* @__PURE__ */ query("unchecked", async (input) => {
+	try {
+		return loadRepoInfo(input?.source, String(input?.repo || "").trim());
+	} catch (err) {
+		fail(err);
+	}
+});
+var pickLocalFolder = /* @__PURE__ */ command("unchecked", async (_input) => {
+	try {
+		return await pickLocalFolder$1();
+	} catch (err) {
+		fail(err);
+	}
+});
+/** Líneas del archivo en el branch revisado, para expandir el contexto oculto de un diff. */
+var fileLines = /* @__PURE__ */ query("unchecked", async (input) => loadFileLines({
+	repo: String(input?.repo || "").trim(),
+	branch: String(input?.branch || "").trim(),
+	base: String(input?.base || "develop").trim(),
+	source: input?.source,
+	path: String(input?.path || "").trim()
+}));
+var hydrateFromGit = /* @__PURE__ */ command("unchecked", async (input) => {
+	try {
+		return hydrateReviewPayload({
+			repo: String(input?.repo || "").trim(),
+			branch: String(input?.branch || "").trim(),
+			base: String(input?.base || "develop").trim(),
+			source: input?.source,
+			payload: input?.payload
+		});
+	} catch (err) {
+		fail(err);
+	}
+});
+init_remote_functions(git_remote_exports, "src/lib/report/git.remote.ts", "1g4ayag");
+for (const [name, fn] of Object.entries(git_remote_exports)) {
+	fn.__.id = "1g4ayag/" + name;
+	fn.__.name = name;
+}
+
+//#region \0sveltekit-remote:1g4ayag
+var _sveltekit_remote_1g4ayag_default = git_remote_exports;
+
+export { _sveltekit_remote_1g4ayag_default as default };
+//# sourceMappingURL=remote-1g4ayag-ipWXvkjB.js.map