@finesoft/front 0.5.1 → 0.5.2

package/dist/fetch-policy-BHT8RtrL.mjs

@@ -0,0 +1,82 @@
+import { i as __toESM } from "./rolldown-runtime-B4iAMlE-.mjs";
+import { r as HostGuardError, t as classifyHost } from "./host-guard-DDWxLpFL.mjs";
+import "./src-Ftl_0rhu.mjs";
+import { lookup } from "node:dns/promises";
+import { isIP } from "node:net";
+//#region ../server/src/dynamic-import.ts
+/** Cache for stable (non-file://) modules — avoids redundant resolution. */
+const moduleCache = /* @__PURE__ */ new Map();
+/**
+* Opaque dynamic import wrapper.
+*
+* Uses native `import()` directly — compatible with all JS runtimes
+* including Cloudflare Workers (which forbid `new Function`).
+*
+* This may produce "dynamic import cannot be analyzed" warnings in Vite dev
+* mode when the `@vite-ignore` comment is stripped by tsdown during bundling.
+* These warnings are harmless: all specifiers are either well-known Node.js
+* built-ins (externalized) or absolute file:// URLs constructed by the framework.
+*/
+const rawImport = (specifier) => import(
+	/* @vite-ignore */
+	specifier
+);
+const debugEnabled = typeof process !== "undefined" && process.env?.FINESOFT_DEBUG === "1";
+function logDebug(msg) {
+	if (debugEnabled) console.debug(`[finesoft:dynamic-import] ${msg}`);
+}
+async function dynamicImport(specifier) {
+	const cacheable = !specifier.startsWith("file:") && !specifier.startsWith("/");
+	if (cacheable) {
+		const cached = moduleCache.get(specifier);
+		if (cached) {
+			logDebug(`cache hit  → ${specifier}`);
+			return cached;
+		}
+	}
+	logDebug(`importing  → ${specifier}`);
+	const mod = await rawImport(specifier);
+	if (cacheable) moduleCache.set(specifier, mod);
+	return mod;
+}
+//#endregion
+//#region ../server/src/node/dns.ts
+/** Uses the OS resolver, including hosts-file entries, matching Node fetch. */
+const nodeDnsLookup = async (hostname) => (await lookup(hostname, { all: true })).map(({ address }) => address);
+//#endregion
+//#region ../server/src/node/fetch-policy.ts
+let dispatcher;
+const guardedLookup = (hostname, options, callback) => {
+	nodeDnsLookup(hostname).then((addresses) => {
+		const records = addresses.map((address) => {
+			const family = isIP(address);
+			const verdict = classifyHost(address);
+			if (!family || !verdict.ok) throw new HostGuardError(hostname, `host resolves to forbidden address ${address}`);
+			return {
+				address,
+				family
+			};
+		});
+		const selected = options.family ? records.filter((record) => record.family === options.family) : records;
+		if (!selected.length) throw new HostGuardError(hostname, "DNS lookup returned no addresses");
+		if (options.all) callback(null, selected);
+		else callback(null, selected[0].address, selected[0].family);
+	}).catch((error) => callback(error, "", 0));
+};
+/** Node fetch policy: validate DNS at socket creation, retaining hostname/TLS SNI. */
+const nodeSafeFetchOptions = Object.freeze({
+	validateDns: false,
+	wrapFetch: (baseFetch) => async (input, init) => {
+		const url = typeof input === "object" && "url" in input ? input.url : String(input);
+		if (!URL.canParse(url)) return baseFetch(input, init);
+		const agent = await (dispatcher ??= import("./undici-CPfL25Hr.mjs").then((m) => /* @__PURE__ */ __toESM(m.default, 1)).then(({ Agent }) => new Agent({ connect: { lookup: guardedLookup } })));
+		return baseFetch(input, {
+			...init,
+			dispatcher: agent
+		});
+	}
+});
+//#endregion
+export { nodeDnsLookup as n, dynamicImport as r, nodeSafeFetchOptions as t };
+
+//# sourceMappingURL=fetch-policy-BHT8RtrL.mjs.map

package/dist/host-guard-DDWxLpFL.mjs

@@ -0,0 +1,222 @@
+//#region ../core/src/http/errors.ts
+/** HTTP 请求错误 */
+var HttpError = class extends Error {
+	status;
+	statusText;
+	body;
+	constructor(status, statusText, body) {
+		super(`HTTP ${status}: ${statusText}`);
+		this.status = status;
+		this.statusText = statusText;
+		this.body = body;
+		this.name = "HttpError";
+	}
+};
+/**
+* SSRF 防护拦截到不安全的目标地址时抛出。应用层可以 catch 它来给出业务友好的错误，
+* 不需要靠 message 字符串匹配。
+*/
+var HostGuardError = class extends Error {
+	url;
+	reason;
+	constructor(url, reason) {
+		super(`Refused to fetch ${url}: ${reason}`);
+		this.url = url;
+		this.reason = reason;
+		this.name = "HostGuardError";
+	}
+};
+//#endregion
+//#region ../core/src/http/host-guard.ts
+/**
+* Inspect a hostname string (the `URL.hostname` value, without brackets, port,
+* or userinfo). Returns `{ok: false}` for anything in a private/loopback/
+* reserved range; `{ok: true}` if the literal looks like a public address or a
+* non-IP name (the caller may then DNS-resolve and re-check).
+*/
+function classifyHost(rawHost) {
+	if (!rawHost) return {
+		ok: false,
+		reason: "empty host"
+	};
+	const host = rawHost.toLowerCase();
+	const stripped = host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+	if (stripped === "localhost" || stripped.endsWith(".localhost")) return {
+		ok: false,
+		reason: "loopback host forbidden"
+	};
+	if (stripped.includes(":")) return classifyIPv6(stripped);
+	const v4 = parseIPv4Loose(stripped);
+	if (v4) return classifyIPv4Octets(v4);
+	return { ok: true };
+}
+/**
+* Convenience wrapper for callers holding a full URL string. Also rejects
+* non-http(s) schemes (gopher, file, data, …).
+*/
+function classifyUrl(rawUrl) {
+	let url;
+	try {
+		url = new URL(rawUrl);
+	} catch {
+		return {
+			ok: false,
+			reason: "invalid URL"
+		};
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") return {
+		ok: false,
+		reason: `scheme "${url.protocol}" not allowed (only http/https)`
+	};
+	return classifyHost(url.hostname);
+}
+/**
+* Parse an IPv4 host in the various forms web platforms historically accept:
+*
+* - "127.0.0.1"          (dotted decimal, the only RFC-correct form)
+* - "2130706433"         (one big decimal — equals 0x7F000001)
+* - "0x7f000001"         (one big hex)
+* - "0177.0.0.1"         (per-octet octal, leading 0)
+* - "0xff.0xff.0xff.0xff" (per-octet hex)
+*
+* Returns the 4 octets if parseable, else null. We do NOT mark these as
+* "invalid host" — bypass attempts via decimal/hex/octal are valid IP literals
+* and Node's fetch will resolve them. We just need their octets to check
+* against private ranges.
+*/
+function parseIPv4Loose(host) {
+	if (host.length === 0) return null;
+	if (!host.includes(".")) {
+		const n = parsePartLoose(host);
+		if (n === null || n < 0 || n > 4294967295) return null;
+		return [
+			n >>> 24 & 255,
+			n >>> 16 & 255,
+			n >>> 8 & 255,
+			n & 255
+		];
+	}
+	const parts = host.split(".");
+	if (parts.length !== 4) return null;
+	const out = [];
+	for (const part of parts) {
+		const n = parsePartLoose(part);
+		if (n === null || n < 0 || n > 255) return null;
+		out.push(n);
+	}
+	return out;
+}
+function parsePartLoose(part) {
+	if (part.length === 0) return null;
+	if (part.startsWith("0x") || part.startsWith("0X")) {
+		const hex = part.slice(2);
+		if (!/^[0-9a-f]+$/i.test(hex)) return null;
+		return parseInt(hex, 16);
+	}
+	if (part.length > 1 && part.startsWith("0")) {
+		if (!/^[0-7]+$/.test(part)) return null;
+		return parseInt(part, 8);
+	}
+	if (!/^[0-9]+$/.test(part)) return null;
+	return parseInt(part, 10);
+}
+function classifyIPv4Octets(o) {
+	const [a, b] = o;
+	if (a === 0) return {
+		ok: false,
+		reason: "unspecified IPv4 forbidden"
+	};
+	if (a === 127) return {
+		ok: false,
+		reason: "loopback IPv4 forbidden"
+	};
+	if (a === 10) return {
+		ok: false,
+		reason: "private IPv4 (10/8) forbidden"
+	};
+	if (a === 172 && b >= 16 && b <= 31) return {
+		ok: false,
+		reason: "private IPv4 (172.16/12) forbidden"
+	};
+	if (a === 192 && b === 168) return {
+		ok: false,
+		reason: "private IPv4 (192.168/16) forbidden"
+	};
+	if (a === 169 && b === 254) return {
+		ok: false,
+		reason: "link-local IPv4 forbidden"
+	};
+	if (a === 100 && b >= 64 && b <= 127) return {
+		ok: false,
+		reason: "CGNAT IPv4 forbidden"
+	};
+	if (a >= 224 && a <= 239) return {
+		ok: false,
+		reason: "multicast IPv4 forbidden"
+	};
+	if (a >= 240) return {
+		ok: false,
+		reason: "reserved IPv4 forbidden"
+	};
+	return { ok: true };
+}
+/**
+* Best-effort IPv6 classification. We only need to recognise loopback,
+* link-local, ULA, and IPv4-mapped/-compatible forms; we don't need to
+* canonicalise arbitrary IPv6.
+*/
+function classifyIPv6(host) {
+	const lower = host.toLowerCase();
+	if (lower === "::" || lower === "::0") return {
+		ok: false,
+		reason: "unspecified IPv6 forbidden"
+	};
+	if (lower === "::1") return {
+		ok: false,
+		reason: "loopback IPv6 forbidden"
+	};
+	if (lower.startsWith("fe8") || lower.startsWith("fe9") || lower.startsWith("fea") || lower.startsWith("feb")) return {
+		ok: false,
+		reason: "link-local IPv6 forbidden"
+	};
+	if (lower.startsWith("fc") || lower.startsWith("fd")) return {
+		ok: false,
+		reason: "ULA IPv6 forbidden"
+	};
+	if (lower.startsWith("ff")) return {
+		ok: false,
+		reason: "multicast IPv6 forbidden"
+	};
+	const v4 = extractIPv4FromIPv6(lower);
+	if (v4) {
+		const verdict = classifyIPv4Octets(v4);
+		if (!verdict.ok) return {
+			ok: false,
+			reason: `IPv4-in-IPv6 ${verdict.reason}`
+		};
+	}
+	return { ok: true };
+}
+function extractIPv4FromIPv6(lower) {
+	const dottedMatch = lower.match(/(?:^|:)((?:\d{1,3}\.){3}\d{1,3})$/);
+	if (dottedMatch) {
+		const v4 = parseIPv4Loose(dottedMatch[1]);
+		if (v4) return v4;
+	}
+	const hexMatch = lower.match(/(?:^|:)([0-9a-f]{1,4}):([0-9a-f]{1,4})$/);
+	if (hexMatch && (lower.startsWith("::ffff:") || lower.includes(":ffff:"))) {
+		const hi = parseInt(hexMatch[1], 16);
+		const lo = parseInt(hexMatch[2], 16);
+		return [
+			hi >>> 8 & 255,
+			hi & 255,
+			lo >>> 8 & 255,
+			lo & 255
+		];
+	}
+	return null;
+}
+//#endregion
+export { HttpError as i, classifyUrl as n, HostGuardError as r, classifyHost as t };
+
+//# sourceMappingURL=host-guard-DDWxLpFL.mjs.map

package/dist/http-B6CJqDyf.d.mts

@@ -0,0 +1,46 @@
+import { E as ParamSchema, c as ExecutionContext, d as ExecutionHandle, h as Operation, p as Invocation, t as CompiledPath, y as RuntimeHandle } from "./path-CXT6xGPO.mjs";
+//#region ../server/src/http.d.ts
+interface HttpEndpoint {
+  readonly method: string;
+  readonly path: string;
+  readonly compiledPath: CompiledPath;
+  readonly paramCodecs?: Record<string, ParamSchema>;
+  readonly respond: (request: Request, execution: ExecutionHandle, params: Readonly<Record<string, unknown>>) => Promise<Response>;
+}
+interface EndpointOptions<I, O> {
+  readonly method: string;
+  /** Segment pathname pattern. Supports `:param` and optional `:param?`. */
+  readonly path: string;
+  readonly operation: Operation<I, O>;
+  readonly paramCodecs?: Record<string, ParamSchema>;
+  readonly decode: (request: Request, context: ExecutionContext, params: Readonly<Record<string, unknown>>) => I | Promise<I>;
+  /** Explicit public projection. No automatic serialization of operation results. */
+  readonly encode: (output: O, context: ExecutionContext) => Response | Promise<Response>;
+}
+declare function defineEndpoint<I, O>(options: EndpointOptions<I, O>): HttpEndpoint;
+interface HttpHost {
+  /** The host must retain the supplied promise, including its resource cleanup. */
+  waitUntil(promise: Promise<unknown>): void;
+  /** Retain the complete invocation, including encoding, body consumption/cancel and cleanup. */
+  trackRequest?(completion: Promise<void>): void;
+}
+interface HttpHandlerOptions {
+  readonly runtime: RuntimeHandle;
+  readonly endpoints: readonly HttpEndpoint[];
+  /** Identity/locale must be derived from trusted authentication, not arbitrary client claims. */
+  readonly context?: (request: Request, bindings: Readonly<Record<string, unknown>>) => Omit<Invocation, "signal"> | Promise<Omit<Invocation, "signal">>;
+}
+/** The execution owner directly satisfies the native Worker fetch contract. */
+interface HttpHandler {
+  fetch(request: Request, bindings?: Readonly<Record<string, unknown>>, host?: HttpHost): Promise<Response>;
+}
+type ManagedTask = (context: ExecutionContext) => void | Promise<void>;
+/** Run work in its own execution scope. Use the supplied task context to acquire resources.
+ * Its signal is independent of response cancellation; cleanup is part of host waitUntil.
+ * The callback must await all its work and may not return streams or retain request resources.
+ */
+declare function runManagedTask(context: ExecutionContext, task: ManagedTask): void;
+declare function createHttpHandler(input: HttpHandlerOptions | (() => HttpHandlerOptions)): HttpHandler;
+//#endregion
+export { HttpHost as a, defineEndpoint as c, HttpHandlerOptions as i, runManagedTask as l, HttpEndpoint as n, ManagedTask as o, HttpHandler as r, createHttpHandler as s, EndpointOptions as t };
+//# sourceMappingURL=http-B6CJqDyf.d.mts.map

package/dist/http-CaxrMD1A.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/http-D70PL72H.mjs

@@ -0,0 +1,257 @@
+import { n as ExecutionError, t as compilePath } from "./path-CGFl2w7D.mjs";
+import "./src-Ftl_0rhu.mjs";
+//#region ../server/src/http.ts
+function defineEndpoint(options) {
+	const { method, path, operation, decode, encode, paramCodecs } = options;
+	if (!/^[A-Za-z]+$/.test(method) || !path.startsWith("/") || typeof decode !== "function" || typeof encode !== "function") throw new ExecutionError("configuration");
+	let compiledPath;
+	try {
+		compiledPath = compilePath(path);
+	} catch (cause) {
+		throw new ExecutionError("configuration", void 0, { cause });
+	}
+	return Object.freeze({
+		method: method.toUpperCase(),
+		path,
+		compiledPath,
+		paramCodecs,
+		async respond(request, execution, params) {
+			let input;
+			try {
+				input = await decode(request, execution.context, params);
+			} catch (error) {
+				throw error instanceof ExecutionError ? error : new ExecutionError("validation", void 0, { cause: error });
+			}
+			const output = await execution.execute(operation, input);
+			const response = await encode(output, execution.context);
+			if (!(response instanceof Response)) throw new ExecutionError("failure");
+			return response;
+		}
+	});
+}
+const TASK_BINDING = "__finesoftManagedTask";
+/** Run work in its own execution scope. Use the supplied task context to acquire resources.
+* Its signal is independent of response cancellation; cleanup is part of host waitUntil.
+* The callback must await all its work and may not return streams or retain request resources.
+*/
+function runManagedTask(context, task) {
+	const schedule = context.bindings[TASK_BINDING];
+	if (typeof schedule !== "function") throw new ExecutionError("capability");
+	schedule(task);
+}
+function publicError(error) {
+	const classified = error instanceof ExecutionError ? error : new ExecutionError("failure");
+	const safe = new ExecutionError(classified.code);
+	return Response.json({ error: {
+		code: safe.code,
+		message: safe.message
+	} }, { status: safe.status });
+}
+function createHttpHandler(input) {
+	function prepare(options) {
+		const routes = [...options.endpoints];
+		for (const endpoint of routes) if (routes.some((other) => other !== endpoint && other.method === endpoint.method && other.compiledPath.descriptor.shape === endpoint.compiledPath.descriptor.shape)) throw new ExecutionError("configuration");
+		return {
+			options,
+			routes
+		};
+	}
+	let prepared = typeof input === "function" ? void 0 : prepare(input);
+	return { async fetch(request, bindings = {}, host) {
+		const { options, routes } = prepared ??= prepare(typeof input === "function" ? input() : input);
+		const pathname = new URL(request.url).pathname;
+		const shaped = routes.map((endpoint) => ({
+			endpoint,
+			params: endpoint.compiledPath.match(pathname)
+		})).filter((candidate) => candidate.params !== null);
+		if (shaped.length === 0) return publicError(new ExecutionError("not_found"));
+		const sameMethod = shaped.filter((candidate) => candidate.endpoint.method === request.method);
+		if (sameMethod.length === 0) {
+			const allow = [...new Set(shaped.map((candidate) => candidate.endpoint.method))];
+			return Response.json({ error: {
+				code: "method_not_allowed",
+				message: "Method not allowed"
+			} }, {
+				status: 405,
+				headers: { Allow: allow.join(", ") }
+			});
+		}
+		let selected;
+		for (const candidate of sameMethod) {
+			const params = Object.assign(Object.create(null), candidate.params);
+			let valid = true;
+			for (const parameter of candidate.endpoint.compiledPath.descriptor.parameters) {
+				const codec = candidate.endpoint.paramCodecs?.[parameter.name];
+				if (!codec) continue;
+				let result;
+				try {
+					result = await codec["~standard"].validate(candidate.params[parameter.name]);
+				} catch {
+					valid = false;
+					break;
+				}
+				if (result.issues) {
+					valid = false;
+					break;
+				}
+				params[parameter.name] = result.value;
+			}
+			if (valid) {
+				selected = {
+					endpoint: candidate.endpoint,
+					params
+				};
+				break;
+			}
+		}
+		if (!selected) return publicError(new ExecutionError("validation"));
+		const { endpoint, params } = selected;
+		const abort = new AbortController();
+		const signal = AbortSignal.any([request.signal, abort.signal]);
+		let execution;
+		let acceptingTasks = true;
+		let complete;
+		const completion = new Promise((resolve) => {
+			complete = resolve;
+		});
+		let responseOwnsCompletion = false;
+		try {
+			host?.trackRequest?.(completion);
+			const invocation = await options.context?.(request, bindings);
+			const requestBindings = {
+				...bindings,
+				...invocation?.bindings
+			};
+			const schedule = (task) => {
+				signal.throwIfAborted();
+				if (!host || !acceptingTasks) throw new ExecutionError("capability");
+				const taskExecution = options.runtime.createExecution({
+					...invocation,
+					traceId: execution.context.traceId,
+					bindings: {
+						...requestBindings,
+						[TASK_BINDING]: void 0
+					}
+				});
+				let registered = false;
+				const work = Promise.resolve().then(async () => {
+					let failed = false;
+					let taskError;
+					try {
+						if (registered) await task(taskExecution.context);
+					} catch (error) {
+						failed = true;
+						taskError = error;
+					}
+					try {
+						await taskExecution.dispose();
+					} catch (error) {
+						if (failed) throw new AggregateError([taskError, error], "Managed task and cleanup failed");
+						throw error;
+					}
+					if (failed) throw taskError;
+				});
+				try {
+					host.waitUntil(work);
+					registered = true;
+				} catch (error) {
+					work.catch(() => {});
+					throw new ExecutionError("capability", void 0, { cause: error });
+				}
+			};
+			execution = options.runtime.createExecution({
+				...invocation,
+				signal,
+				bindings: {
+					...requestBindings,
+					[TASK_BINDING]: schedule
+				}
+			});
+			const response = await endpoint.respond(request, execution, params);
+			if (signal.aborted) {
+				await response.body?.cancel(signal.reason);
+				throw new ExecutionError("cancelled");
+			}
+			acceptingTasks = false;
+			const ownedResponse = await ownResponse(response, execution, abort, signal, complete);
+			responseOwnsCompletion = true;
+			return ownedResponse;
+		} catch (error) {
+			acceptingTasks = false;
+			try {
+				await execution?.dispose();
+			} catch {}
+			return publicError(signal.aborted ? new ExecutionError("cancelled") : error);
+		} finally {
+			if (!responseOwnsCompletion) complete();
+		}
+	} };
+}
+/** The body reader, not Response creation, ends the execution. No prefetch into our wrapper. */
+async function ownResponse(response, execution, abort, signal, complete) {
+	if (!response.body) {
+		await execution.dispose();
+		complete();
+		return response;
+	}
+	const reader = response.body.getReader();
+	let finished;
+	let controller;
+	const finish = (cancellation) => {
+		if (finished) return finished;
+		finished = Promise.resolve().then(async () => {
+			signal.removeEventListener("abort", onAbort);
+			try {
+				if (cancellation) await reader.cancel(cancellation.reason);
+			} catch {}
+			try {
+				await execution.dispose();
+			} catch {} finally {
+				complete();
+			}
+		});
+		return finished;
+	};
+	const onAbort = () => {
+		finish({ reason: signal.reason }).then(() => controller.error(new ExecutionError("cancelled")));
+	};
+	const body = new ReadableStream({
+		start(c) {
+			controller = c;
+			signal.addEventListener("abort", onAbort, { once: true });
+			if (signal.aborted) onAbort();
+		},
+		async pull(c) {
+			try {
+				const result = await reader.read();
+				if (signal.aborted) {
+					await finish();
+					c.error(new ExecutionError("cancelled"));
+					return;
+				}
+				if (result.done) {
+					await finish();
+					c.close();
+				} else c.enqueue(result.value);
+			} catch (error) {
+				await finish();
+				c.error(error);
+			}
+		},
+		async cancel(reason) {
+			signal.removeEventListener("abort", onAbort);
+			const completion = finish({ reason });
+			abort.abort(reason);
+			await completion;
+		}
+	}, { highWaterMark: 0 });
+	return new Response(body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: response.headers
+	});
+}
+//#endregion
+export { defineEndpoint as n, runManagedTask as r, createHttpHandler as t };
+
+//# sourceMappingURL=http-D70PL72H.mjs.map

package/dist/http.d.mts

@@ -0,0 +1,3 @@
+import { a as HttpHost, c as defineEndpoint, i as HttpHandlerOptions, l as runManagedTask, n as HttpEndpoint, o as ManagedTask, r as HttpHandler, s as createHttpHandler, t as EndpointOptions } from "./http-B6CJqDyf.mjs";
+import "./http-CaxrMD1A.mjs";
+export { EndpointOptions, HttpEndpoint, HttpHandler, HttpHandlerOptions, HttpHost, ManagedTask, createHttpHandler, defineEndpoint, runManagedTask };

package/dist/http.mjs

@@ -0,0 +1,2 @@
+import { n as defineEndpoint, r as runManagedTask, t as createHttpHandler } from "./http-D70PL72H.mjs";
+export { createHttpHandler, defineEndpoint, runManagedTask };

package/dist/index-node.d.mts

@@ -0,0 +1,15 @@
+import { A as makeSchema, C as ImpressionEntry, D as StandardIssue, E as ParamSchema, F as Token, I as createToken, M as Provider, N as ProviderContext, O as StandardResult, P as provide, S as EventRecorder, T as InferOutput, _ as OperationPolicy, a as compilePath, b as RuntimeOptions, c as ExecutionContext, d as ExecutionHandle, f as Implementation, g as OperationHandler, h as Operation, i as PathParams, j as Container, k as StandardSchemaV1, l as ExecutionError, m as ModuleDefinition, n as PathDescriptor, o as AnyOperation, p as Invocation, r as PathParameterDescriptor, s as AppDefinition, t as CompiledPath, u as ExecutionErrorCode, v as QueryCache, w as MetricsFieldsProvider, x as executionErrorFromHttp, y as RuntimeHandle } from "./path-CXT6xGPO.mjs";
+import { $ as createActiveLeafCodec, $n as list, $t as MiddlewareResult, A as SessionStore, An as PlatformInfo, At as isCompoundAction, B as ControllerContext, Bn as ConsoleLoggerFactory, Bt as NavigationPath, C as SessionFailure, Cn as Storage, Ct as ACTION_KINDS, D as SessionSlice, Dn as LocaleInfo, Dt as ExternalUrlAction, E as SessionRestoreResult, En as LocaleAttributes, Et as CompoundAction, F as WebRuntime, Fn as ReportCallback, Ft as LeafNode, G as controllerContext, Gn as InferParams, Gt as SplitColumn, H as SERVER_CONTROLLER, Hn as Logger, Ht as NavigationSnapshot, I as WebRuntimeOptions, In as ReportingLogger, It as NAVIGATION_NODE_KINDS, J as resolveConfiguredMessages, Jn as QuerySchemaMap, Jt as StackNode, K as MessagesLoader, Kn as InferQuery, Kt as SplitNode, L as createWebRuntime, Ln as ReportingLoggerFactory, Lt as NavigationError, M as SessionWriteResult, Mn as BaseController, Mt as isFlowAction, N as StorageUnavailableError, Nn as ControllerFailure, Nt as makeExternalUrlAction, O as SessionSnapshot, On as TextDirection, Ot as FlowAction, P as WebConfiguration, Pn as ControllerInput, Pt as makeFlowAction, Q as NavigationRouterLike, Qn as isMultiValueSchema, Qt as DenyResult, R as PageControllerDefinition, Rn as ReportingLoggerOptions, Rt as NavigationNode, S as SessionErrorContext, Sn as FeatureFlagsProvider, St as ActionHandler, T as SessionNavigation, Tn as resolveMessages, Tt as ActionInvocation, U as SERVER_REQUEST, Un as LoggerFactory, Ut as ResolvedDestination, V as PageControllerInput, Vn as LogFilter, Vt as NavigationPathStep, W as ServerRequestState, Wn as ExtractParamNames, Wt as SPLIT_VISIBILITIES, X as FullStateCodecOptions, Xn as ListOptions, Xt as AfterLoadGuard, Y as DEFAULT_NAV_PARAM, Yn as StripOptional, Yt as TabsNode, Z as NavigationCodec, Zn as MultiValueSchema, Zt as BeforeLoadGuard, _ as AsyncStorage, _n as RouteInput, _t as PrefetchedIntents, a as NavigationCommitContext, an as deny, at as SerializedSplit, b as SESSION_DEFAULT_VERSION, bn as DEP_KEYS, bt as Router, c as NavigationTransactionContext, cn as rewrite, ct as SerializedTabs, d as createWebSession, dn as FINESOFT_PUBLIC, dt as serializeNavigationStable, en as NavigationContext, er as Intent, et as createFullStateCodec, f as AppSnapshot, fn as PublicProjection, ft as PageRoute, g as WebAppView, gn as markPublic, gt as PrefetchedIntent, h as ViewProps, hn as isPublicMarked, ht as route, i as BeforeNavigateResult, in as RewriteResult, it as SerializedNavigation, j as SessionStoreOptions, jn as detectPlatform, jt as isExternalUrlAction, k as SessionStateProvider, kn as Translator, kt as TreeAction, l as WebSession, ln as BASE_PAGE_FIELDS, lt as deserializeNavigation, m as ViewEntry, mn as getPublicFields, mt as RouteDefinition, n as BeforeCommitResult, nn as PostLoadContext, nt as encodeNavigationTreeParam, o as NavigationCommitError, on as next, ot as SerializedSplitColumn, p as NavigationSummary, pn as PublicValueCodec, pt as RenderMode, q as MessagesLoaderContext, qn as ParamsFor, qt as SplitVisibility, r as BeforeNavigatePolicy, rn as RedirectResult, rt as SerializedLeaf, s as NavigationContextInput, sn as redirect, st as SerializedStack, t as BeforeCommitPolicy, tn as NextResult, tt as decodeNavigationTreeParam, u as WebSessionOptions, un as BasePage, ut as serializeNavigation, v as NavigationScopedState, vn as RouteIntent, vt as RouteAddOptions, w as SessionLoadResult, wn as TranslationMessages, wt as Action, x as SessionError, xn as FeatureFlags, xt as ActionDispatcher, y as SESSION_DEFAULT_KEY, yn as RouteParams, yt as RouteMatch, z as WebAppDefinition, zn as ConsoleLogger, zt as NavigationNodeKind } from "./session-DnB4ZC3x.mjs";
+import { $ as SimpleTranslatorOptions, $t as uuid, A as setVisibility, At as fetchWithRedirects, B as split, Bt as HttpError, C as popTo, Ct as isSome, D as resolveActivePath, Dt as mapEach, E as replaceTop, Et as Mapper, F as isLeafNode, Ft as HttpClientConfig, G as safeErrorPage, Gt as withDefault, H as tabs, Ht as CompositeLogger, I as isSplitNode, It as HttpRequestOptions, J as defineModule, Jt as bool, K as createRuntime, Kt as NumOptions, L as isStackNode, Lt as RequestInterceptor, M as resourceKey, Mt as classifyHost, N as SplitColumnInit, Nt as classifyUrl, O as selectColumn, Ot as pipe, P as TabsInit, Pt as HttpClient, Q as SimpleTranslator, Qt as str, R as isTabsNode, Rt as ResponseInterceptor, S as pop, St as isNone, T as push, Tt as AsyncMapper, U as RouteInputFor, Ut as CompositeLoggerFactory, V as stack, Vt as stableStringify, W as SafeErrorPageOptions, Wt as optional, X as implementController, Xt as num, Y as defineOperation, Yt as int, Z as implementOperation, Zt as oneOf, _ as collectAllLeaves, _t as removeHost, a as LoadPageOptions, at as PluralCategory, b as findNode, bt as None, c as defineWebApp, ct as interpolate, d as runBeforeLoadGuards, dt as VoidEventRecorder, et as getLocaleAttributes, f as createSessionStore, ft as ConsoleEventRecorder, g as encodeSnapshot, gt as getBaseUrl, h as decodeSnapshot, ht as buildUrl, i as resolveInitialNavigation, it as resolveLocaleFromUrl, j as visibleSplitColumns, jt as HostCheckResult, k as selectTab, kt as pipeAsync, l as getWebPlan, lt as resolvePluralKey, m as createNavigationScopedState, mt as generateUuid, n as PageReference, nt as isRtl, o as PageLoadResult, ot as PluralRuleProvider, p as collectLeafKeys, pt as CompositeEventRecorder, q as defineApp, qt as StrOptions, r as definePage, rt as makeLocaleInfo, s as loadPage, st as englishPlural, t as parseCookieString, tt as getTextDirection, u as runAfterLoadGuards, ut as WithFieldsRecorder, v as collectVisibleDestinations, vt as removeQueryParams, w as popToRoot, wt as LruMap, x as mapNavigationLeaves, xt as Optional, y as findNearestStack, yt as removeScheme, z as leaf, zt as HostGuardError } from "./cookies-Bpf9VayB.mjs";
+import { a as enforceHostGuard, i as TargetGuardOptions, n as secureFetch, r as DnsLookup, t as SecureFetchOptions } from "./secure-fetch-Xlht2jd7.mjs";
+import { a as WebHydration, c as decodeWireEnvelope, i as FRAMEWORK_PROTOCOL_VERSION, l as getFrameworkBuildId, n as ServerControllerProxy, o as WireDecodeResult, r as ServerControllerRequest, s as WireEnvelope, t as SERVER_CONTROLLER_PATH } from "./server-controller-proxy-BkVuVWVD.mjs";
+import { A as createBrowserApp, C as defaultShouldRestore, D as BrowserAppConfig, E as createNavigationBridge, O as BrowserAppHandle, S as createSessionBridge, T as NavigationBridgeDependencies, _ as createDomRestore, a as IntersectionImpressionObserver, b as SESSION_DEFAULT_DEBOUNCE_MS, c as getPWADisplayMode, d as createPrefetchedIntentsFromDom, f as deserializeServerData, g as DomRestoreOptions, h as DomRestore, i as ImpressionObserverOptions, k as BrowserSessionConfig, l as resetFilterCache, m as History, n as createBrowserContext, o as ImpressionObserver, p as tryScroll, r as setHtmlLocaleAttributes, s as PWADisplayMode, t as BrowserContextOptions, u as shouldLog, v as createWebStorage, w as NavigationBridge, x as SessionBridgeOptions, y as BrowserSession } from "./browser-kFMjlLGT.mjs";
+import { a as HttpHost, c as defineEndpoint, i as HttpHandlerOptions, l as runManagedTask, n as HttpEndpoint, o as ManagedTask, r as HttpHandler, s as createHttpHandler, t as EndpointOptions } from "./http-B6CJqDyf.mjs";
+import { C as createSSRRender, E as SSRRenderResult, S as SSRRenderConfig, T as SSRContext, _ as serializeServerData, a as SSRRequestContext, b as injectCSRShell, c as matchRenderModeOverride, d as ServerControllerContext, f as ServerControllerInput, g as materializeServerData, h as SerializeServerDataOptions, i as SSRModule, l as BaseServerController, m as createServerContext, n as SSRHandler, o as SSRResponseResult, p as ServerContextOptions, r as SSRHandlerOptions, s as createSSRHandler, t as SSRCache, u as CookieOptions, v as InjectSSROptions, w as SSRAppResult, x as injectSSRContent, y as SSR_PLACEHOLDERS } from "./ssr-BEUNDvbj.mjs";
+import { a as registerProxyRoutes, n as ProxyRouteConfig, r as ProxyRouter, t as ProxyAuthConfig } from "./proxy-2dSWO-Xw.mjs";
+import { a as nodeDnsLookup, i as nodeSafeFetchOptions, n as NodeHandlerServer, r as startNodeHandler, t as NodeHandlerOptions } from "./node-D9hB4dsz.mjs";
+import { c as FinesoftFrontViteOptions, d as AdapterContext, u as Adapter } from "./vite-Cj4SPA8D.mjs";
+import { n as ControllerTypeResult, t as ControllerTypeOptions } from "./controller-types-CgmJ6-le.mjs";
+import { t as FrontTypeOptions } from "./typegen-C-WeJCtf.mjs";
+import { NativeBindings, NativeView, NativeViews, Outlet, Renderer, autoAdapter, cloudflareAdapter, finesoftFrontViteConfig, generateControllerTypes, generateFrontTypes, generateProxyCode, netlifyAdapter, nodeAdapter, resolveAdapter, staticAdapter, useSnapshot, vercelAdapter } from "./index.mjs";
+export { ACTION_KINDS, type Action, ActionDispatcher, type ActionHandler, type ActionInvocation, type Adapter, type AdapterContext, type AfterLoadGuard, AnyOperation, AppDefinition, AppSnapshot, type AsyncMapper, type AsyncStorage, BASE_PAGE_FIELDS, BaseController, type BasePage, BaseServerController, type BeforeCommitPolicy, type BeforeCommitResult, type BeforeLoadGuard, type BeforeNavigatePolicy, type BeforeNavigateResult, type BrowserAppConfig, type BrowserAppHandle, type BrowserContextOptions, type BrowserSession, type BrowserSessionConfig, type CompiledPath, CompositeEventRecorder, CompositeLogger, CompositeLoggerFactory, type CompoundAction, ConsoleEventRecorder, ConsoleLogger, ConsoleLoggerFactory, Container, ControllerContext, type ControllerFailure, type ControllerInput, type ControllerTypeOptions, type ControllerTypeResult, type CookieOptions, DEFAULT_NAV_PARAM, DEP_KEYS, type DenyResult, type DnsLookup, type DomRestore, type DomRestoreOptions, EndpointOptions, type EventRecorder, ExecutionContext, ExecutionError, ExecutionErrorCode, ExecutionHandle, type ExternalUrlAction, type ExtractParamNames, FINESOFT_PUBLIC, FRAMEWORK_PROTOCOL_VERSION, type FeatureFlags, type FeatureFlagsProvider, type FinesoftFrontViteOptions, type FlowAction, type FrontTypeOptions, type FullStateCodecOptions, History, type HostCheckResult, HostGuardError, HttpClient, type HttpClientConfig, HttpEndpoint, HttpError, HttpHandler, HttpHandlerOptions, HttpHost, type HttpRequestOptions, Implementation, type ImpressionEntry, type ImpressionObserver, type ImpressionObserverOptions, type InferOutput, type InferParams, type InferQuery, type InjectSSROptions, type Intent, IntersectionImpressionObserver, Invocation, type LeafNode, type ListOptions, type LoadPageOptions, type LocaleAttributes, type LocaleInfo, type LogFilter, type Logger, type LoggerFactory, LruMap, ManagedTask, type Mapper, type MessagesLoader, type MessagesLoaderContext, type MetricsFieldsProvider, type MiddlewareResult, ModuleDefinition, type MultiValueSchema, NAVIGATION_NODE_KINDS, NativeBindings, NativeView, NativeViews, type NavigationBridge, type NavigationBridgeDependencies, type NavigationCodec, type NavigationCommitContext, NavigationCommitError, type NavigationContext, type NavigationContextInput, NavigationError, type NavigationNode, type NavigationNodeKind, type NavigationPath, type NavigationPathStep, type NavigationRouterLike, type NavigationScopedState, type NavigationSnapshot, NavigationSummary, type NavigationTransactionContext, type NextResult, type NodeHandlerOptions, type NodeHandlerServer, type None, type NumOptions, Operation, OperationHandler, OperationPolicy, type Optional, Outlet, type PWADisplayMode, type PageControllerDefinition, PageControllerInput, type PageLoadResult, type PageReference, type PageRoute, type ParamSchema, type ParamsFor, type PathDescriptor, type PathParameterDescriptor, type PathParams, type PlatformInfo, type PluralCategory, type PluralRuleProvider, type PostLoadContext, type PrefetchedIntent, PrefetchedIntents, type Provider, type ProviderContext, type ProxyAuthConfig, type ProxyRouteConfig, type ProxyRouter, type PublicProjection, type PublicValueCodec, QueryCache, type QuerySchemaMap, type RedirectResult, type RenderMode, Renderer, type ReportCallback, ReportingLogger, ReportingLoggerFactory, type ReportingLoggerOptions, type RequestInterceptor, type ResolvedDestination, type ResponseInterceptor, type RewriteResult, type RouteAddOptions, type RouteDefinition, type RouteInput, type RouteInputFor, type RouteIntent, type RouteMatch, type RouteParams, Router, RuntimeHandle, RuntimeOptions, SERVER_CONTROLLER, SERVER_CONTROLLER_PATH, SERVER_REQUEST, SESSION_DEFAULT_DEBOUNCE_MS, SESSION_DEFAULT_KEY, SESSION_DEFAULT_VERSION, SPLIT_VISIBILITIES, type SSRAppResult, SSRCache, type SSRContext, SSRHandler, SSRHandlerOptions, SSRModule, type SSRRenderConfig, type SSRRenderResult, SSRRequestContext, SSRResponseResult, SSR_PLACEHOLDERS, type SafeErrorPageOptions, type SecureFetchOptions, type SerializeServerDataOptions, type SerializedLeaf, type SerializedNavigation, type SerializedSplit, type SerializedSplitColumn, type SerializedStack, type SerializedTabs, type ServerContextOptions, type ServerControllerContext, type ServerControllerInput, ServerControllerProxy, type ServerControllerRequest, ServerRequestState, type SessionBridgeOptions, SessionError, type SessionErrorContext, type SessionFailure, type SessionLoadResult, type SessionNavigation, type SessionRestoreResult, type SessionSlice, type SessionSnapshot, type SessionStateProvider, type SessionStore, type SessionStoreOptions, type SessionWriteResult, SimpleTranslator, type SimpleTranslatorOptions, type SplitColumn, type SplitColumnInit, type SplitNode, type SplitVisibility, type StackNode, type StandardIssue, type StandardResult, type StandardSchemaV1, type Storage, StorageUnavailableError, type StrOptions, type StripOptional, type TabsInit, type TabsNode, type TargetGuardOptions, type TextDirection, type Token, type TranslationMessages, type Translator, type TreeAction, ViewEntry, ViewProps, VoidEventRecorder, type WebAppDefinition, WebAppView, type WebConfiguration, type WebHydration, type WebRuntime, type WebRuntimeOptions, type WebSession, type WebSessionOptions, type WireDecodeResult, type WireEnvelope, WithFieldsRecorder, autoAdapter, bool, buildUrl, classifyHost, classifyUrl, cloudflareAdapter, collectAllLeaves, collectLeafKeys, collectVisibleDestinations, compilePath, controllerContext, createActiveLeafCodec, createBrowserApp, createBrowserContext, createDomRestore, createFullStateCodec, createHttpHandler, createNavigationBridge, createNavigationScopedState, createPrefetchedIntentsFromDom, createRuntime, createSSRHandler, createSSRRender, createServerContext, createSessionBridge, createSessionStore, createToken, createWebRuntime, createWebSession, createWebStorage, decodeNavigationTreeParam, decodeSnapshot, decodeWireEnvelope, defaultShouldRestore, defineApp, defineEndpoint, defineModule, defineOperation, definePage, defineWebApp, deny, deserializeNavigation, deserializeServerData, detectPlatform, encodeNavigationTreeParam, encodeSnapshot, enforceHostGuard, englishPlural, executionErrorFromHttp, fetchWithRedirects, findNearestStack, findNode, finesoftFrontViteConfig, generateControllerTypes, generateFrontTypes, generateProxyCode, generateUuid, getBaseUrl, getFrameworkBuildId, getLocaleAttributes, getPWADisplayMode, getPublicFields, getTextDirection, getWebPlan, implementController, implementOperation, injectCSRShell, injectSSRContent, int, interpolate, isCompoundAction, isExternalUrlAction, isFlowAction, isLeafNode, isMultiValueSchema, isNone, isPublicMarked, isRtl, isSome, isSplitNode, isStackNode, isTabsNode, leaf, list, loadPage, makeExternalUrlAction, makeFlowAction, makeLocaleInfo, makeSchema, mapEach, mapNavigationLeaves, markPublic, matchRenderModeOverride, materializeServerData, netlifyAdapter, next, nodeAdapter, nodeDnsLookup, nodeSafeFetchOptions, num, oneOf, optional, parseCookieString, pipe, pipeAsync, pop, popTo, popToRoot, provide, push, redirect, registerProxyRoutes, removeHost, removeQueryParams, removeScheme, replaceTop, resetFilterCache, resolveActivePath, resolveAdapter, resolveConfiguredMessages, resolveInitialNavigation, resolveLocaleFromUrl, resolveMessages, resolvePluralKey, resourceKey, rewrite, route, runAfterLoadGuards, runBeforeLoadGuards, runManagedTask, safeErrorPage, secureFetch, selectColumn, selectTab, serializeNavigation, serializeNavigationStable, serializeServerData, setHtmlLocaleAttributes, setVisibility, shouldLog, split, stableStringify, stack, startNodeHandler, staticAdapter, str, tabs, tryScroll, useSnapshot, uuid, vercelAdapter, visibleSplitColumns, withDefault };