@finesoft/front 0.5.1 → 0.5.2

package/dist/public-types-BcJM-AYc.mjs

@@ -0,0 +1,835 @@
+import { t as LruMap } from "./lru-map-BKoUAySU.mjs";
+import "./src-Ftl_0rhu.mjs";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+//#region ../server/src/controller-types.ts
+const OUTPUT = ".finesoft/controller-types.d.ts";
+const GENERATED = "// Generated by @finesoft/front. Edit route schemas, not this file.\n";
+const PROBE = "__finesoftRouteInputProbe";
+const moduleNames = /* @__PURE__ */ new Set([
+	"@finesoft/front",
+	"@finesoft/core",
+	"@finesoft/web",
+	"@finesoft/ssr"
+]);
+const cached = /* @__PURE__ */ new Map();
+const hash = (content) => createHash("sha256").update(content === void 0 ? "missing" : `file:${content}`).digest("hex");
+let retained;
+const slash$1 = (value) => value.replaceAll("\\", "/");
+const inside = (root, file) => {
+	const relative = path.relative(root, file);
+	return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+};
+function assertEditablePath(root, file) {
+	let existing = file;
+	while (!fs.existsSync(existing)) {
+		if (fs.lstatSync(existing, { throwIfNoEntry: false })) throw Error(`Controller type generation cannot edit outside ${root}`);
+		existing = path.dirname(existing);
+	}
+	if (!inside(root, fs.realpathSync(existing))) throw Error(`Controller type generation cannot edit outside ${root}`);
+}
+function applyEdits(source, edits) {
+	let boundary = source.length;
+	for (const edit of edits.sort((a, b) => b.start - a.start)) {
+		if (edit.end > boundary) throw Error("Overlapping controller type edits");
+		source = source.slice(0, edit.start) + edit.text + source.slice(edit.end);
+		boundary = edit.start;
+	}
+	return source;
+}
+function stamp(files) {
+	return files.map((file) => {
+		try {
+			const stat = fs.statSync(file);
+			return `${file}:${stat.mtimeMs}:${stat.size}`;
+		} catch {
+			return `${file}:missing`;
+		}
+	}).join("\n");
+}
+/** Generates type-only references; never imports or executes application modules. */
+function generateControllerTypes(options = {}) {
+	return generateTypes(options);
+}
+function generateTypes(options, observe, force = false) {
+	const requestedRoot = path.resolve(options.root ?? process.cwd());
+	const requestedConfig = path.resolve(requestedRoot, options.tsconfig ?? "tsconfig.json");
+	if (!fs.existsSync(requestedConfig) || !fs.existsSync(path.join(requestedRoot, "src"))) return {
+		controllers: 0,
+		changed: []
+	};
+	const root = fs.realpathSync(requestedRoot);
+	const configFile = fs.realpathSync(requestedConfig);
+	const compiler = createRequire(path.join(root, "package.json"))("typescript");
+	const tokens = (source) => {
+		const scanner = compiler.createScanner(compiler.ScriptTarget.Latest, true);
+		scanner.setText(source);
+		const result = [];
+		while (scanner.scan() !== compiler.SyntaxKind.EndOfFileToken) result.push(`${scanner.getToken()}:${scanner.getTokenValue() || scanner.getTokenText()}`);
+		return result.join("\n");
+	};
+	const configFiles = /* @__PURE__ */ new Set([configFile]);
+	const configContents = /* @__PURE__ */ new Map();
+	const readConfig = (file) => {
+		configFiles.add(file);
+		const content = compiler.sys.readFile(file);
+		configContents.set(file, content);
+		return content;
+	};
+	const config = compiler.readConfigFile(configFile, readConfig);
+	if (config.error) throw Error(compiler.flattenDiagnosticMessageText(config.error.messageText, "\n"));
+	const parsed = compiler.parseJsonConfigFileContent(config.config, {
+		...compiler.sys,
+		readFile: readConfig
+	}, path.dirname(configFile));
+	if (parsed.errors.length) throw Error(parsed.errors.map((error) => compiler.flattenDiagnosticMessageText(error.messageText, "\n")).join("\n"));
+	if (!parsed.fileNames.length && parsed.projectReferences?.length) {
+		const projects = [];
+		const seen = /* @__PURE__ */ new Set();
+		const inspect = (reference) => {
+			const file = compiler.resolveProjectReferencePath(reference);
+			if (seen.has(file)) return;
+			seen.add(file);
+			const project = compiler.getParsedCommandLineOfConfigFile(file, {}, {
+				...compiler.sys,
+				onUnRecoverableConfigFileDiagnostic: (error) => {
+					throw Error(compiler.flattenDiagnosticMessageText(error.messageText, "\n"));
+				}
+			});
+			if (project?.fileNames.some((file) => inside(path.join(root, "src"), file))) projects.push(file);
+			else project?.projectReferences?.forEach(inspect);
+		};
+		parsed.projectReferences.forEach(inspect);
+		if (projects.length === 1) return generateTypes({
+			...options,
+			tsconfig: projects[0]
+		}, observe, force);
+		throw Error("Select the application project with controllerTypes.tsconfig; the solution config must reference exactly one project containing src.");
+	}
+	const cacheKey = `${root}#${configFile}`;
+	const rootFiles = parsed.fileNames.filter((file) => inside(root, file));
+	const previous = cached.get(cacheKey);
+	const initialFiles = [.../* @__PURE__ */ new Set([
+		...configFiles,
+		...rootFiles,
+		...previous?.files ?? []
+	])].sort();
+	const inputStamps = new Map(initialFiles.map((file) => [file, stamp([file])]));
+	if (!force && previous && previous.stamp === [...inputStamps.values()].join("\n")) {
+		observe?.(previous);
+		return {
+			...previous.result,
+			changed: []
+		};
+	}
+	const output = path.join(root, OUTPUT);
+	const typeImports = (source) => source.statements.filter((statement) => compiler.isImportDeclaration(statement) && compiler.isStringLiteral(statement.moduleSpecifier) && path.resolve(path.dirname(source.fileName), statement.moduleSpecifier.text) === output.replace(/\.d\.ts$/, "") && statement.importClause?.isTypeOnly === true && !!statement.importClause.namedBindings && compiler.isNamedImports(statement.importClause.namedBindings));
+	const typeImport = (type) => {
+		if (!compiler.isTypeReferenceNode(type) || !compiler.isIdentifier(type.typeName)) return;
+		let owner = type.parent;
+		while (owner && !compiler.isClassDeclaration(owner)) owner = owner.parent;
+		if (!owner?.name) return;
+		const className = owner.name.text;
+		const source = type.getSourceFile();
+		const key = `${slash$1(path.relative(root, source.fileName))}#${className}`;
+		const hash = createHash("sha256").update(key).digest("hex").slice(0, 12);
+		const exports = ["Input", "Failure"].flatMap((suffix) => {
+			const name = `${className}${suffix}`;
+			return [name, `${name}_${hash}`];
+		});
+		return typeImports(source).flatMap((statement) => statement.importClause.namedBindings.elements).find((element) => element.name.text === type.getText() && exports.includes((element.propertyName ?? element.name).text) && checker.getSymbolAtLocation(type.typeName) === checker.getSymbolAtLocation(element.name));
+	};
+	const settings = {
+		...parsed.options,
+		noEmit: true,
+		skipLibCheck: true
+	};
+	const memoize = (read) => {
+		const values = /* @__PURE__ */ new Map();
+		return (file) => {
+			if (!values.has(file)) values.set(file, read(file));
+			return values.get(file);
+		};
+	};
+	const readFiles = /* @__PURE__ */ new Set();
+	const readFile = memoize((file) => {
+		readFiles.add(file);
+		if (!inputStamps.has(file)) inputStamps.set(file, stamp([file]));
+		return compiler.sys.readFile(file);
+	});
+	const fileExists = memoize(compiler.sys.fileExists.bind(compiler.sys));
+	const directoryExists = memoize(compiler.sys.directoryExists.bind(compiler.sys));
+	const realpath = compiler.sys.realpath && memoize(compiler.sys.realpath.bind(compiler.sys));
+	const resolutions = compiler.createModuleResolutionCache(root, (file) => compiler.sys.useCaseSensitiveFileNames ? file : file.toLowerCase(), settings);
+	let lastProgram = retained?.key === cacheKey && retained.compiler === compiler ? retained.program : void 0;
+	let firstPhase = true;
+	const programFiles = [...rootFiles, output];
+	const buildProgram = (options, overrides = /* @__PURE__ */ new Map()) => {
+		const host = compiler.createCompilerHost(options);
+		const getSourceFile = host.getSourceFile.bind(host);
+		let previous = lastProgram;
+		host.readFile = (file) => overrides.get(file) ?? readFile(file);
+		host.fileExists = (file) => overrides.has(file) || fileExists(file);
+		host.directoryExists = (directory) => directory === path.dirname(output) && overrides.has(output) || directoryExists(directory);
+		host.realpath = realpath;
+		if (overrides.has(output) && !lastProgram?.getSourceFile(output)) resolutions.clear();
+		host.getModuleResolutionCache = () => resolutions;
+		host.resolveModuleNameLiterals = (imports, file, redirected, options, source) => imports.map((specifier) => compiler.resolveModuleName(specifier.text, file, options, host, resolutions, redirected, compiler.getModeForUsageLocation(source, specifier, options)));
+		const refreshResolutions = firstPhase;
+		firstPhase = false;
+		host.hasInvalidatedResolutions = () => refreshResolutions;
+		host.getSourceFile = (file, language, onError, fresh) => {
+			const source = previous?.getSourceFile(file);
+			const target = typeof language === "number" ? language : language.languageVersion;
+			const format = typeof language === "number" ? void 0 : language.impliedNodeFormat;
+			if (!fresh && source && source.languageVersion === target && source.impliedNodeFormat === format && source.text === host.readFile(file)) return source;
+			return getSourceFile(file, language, onError, fresh);
+		};
+		try {
+			return lastProgram = compiler.createProgram(programFiles, options, host, previous);
+		} finally {
+			previous = void 0;
+		}
+	};
+	const sourceProgram = buildProgram(settings);
+	const syntaxErrors = sourceProgram.getSyntacticDiagnostics();
+	if (syntaxErrors.length) throw Error(`Fix source syntax before generating controller types: ${syntaxErrors.map((error) => `${error.file?.fileName}: ${compiler.flattenDiagnosticMessageText(error.messageText, "\n")}`).join("\n")}`);
+	const checker = sourceProgram.getTypeChecker();
+	const resolve = (symbol) => symbol && (symbol.flags & compiler.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol);
+	const definitions = /* @__PURE__ */ new Set();
+	const bases = /* @__PURE__ */ new Set();
+	const serverBases = /* @__PURE__ */ new Set();
+	for (const source of sourceProgram.getSourceFiles()) {
+		if (!inside(root, source.fileName) || source.isDeclarationFile) continue;
+		for (const statement of source.statements) {
+			if (!compiler.isImportDeclaration(statement) || !compiler.isStringLiteral(statement.moduleSpecifier) || !moduleNames.has(statement.moduleSpecifier.text)) continue;
+			const symbol = checker.getSymbolAtLocation(statement.moduleSpecifier);
+			if (!symbol) continue;
+			for (const exported of checker.getExportsOfModule(symbol)) {
+				const resolved = resolve(exported);
+				if (resolved && exported.name === "definePage") definitions.add(resolved);
+				if (resolved && exported.name === "BaseController") bases.add(resolved);
+				if (resolved && exported.name === "BaseServerController") {
+					bases.add(resolved);
+					serverBases.add(resolved);
+				}
+			}
+		}
+	}
+	const registrations = [];
+	const serverController = (node) => {
+		const base = node.heritageClauses?.find((clause) => clause.token === compiler.SyntaxKind.ExtendsKeyword)?.types[0];
+		return !!base && serverBases.has(resolve(checker.getSymbolAtLocation(base.expression)));
+	};
+	const classes = [];
+	const visit = (node) => {
+		if (compiler.isClassDeclaration(node) && node.name) {
+			const base = node.heritageClauses?.find((clause) => clause.token === compiler.SyntaxKind.ExtendsKeyword)?.types[0];
+			if (base && bases.has(resolve(checker.getSymbolAtLocation(base.expression)))) classes.push(node);
+		}
+		if (compiler.isCallExpression(node) && definitions.has(resolve(checker.getSymbolAtLocation(node.expression))) && node.arguments[0]) {
+			const input = checker.getTypeAtLocation(node.arguments[0]);
+			const routes = input.getProperty("routes");
+			const create = input.getProperty("create");
+			if (routes && create) {
+				const factory = checker.getTypeOfSymbolAtLocation(create, node);
+				for (const signature of factory.getCallSignatures()) {
+					const result = signature.getReturnType();
+					for (const type of result.isUnion() ? result.types : [result]) {
+						const declaration = type.getSymbol()?.valueDeclaration;
+						if (!declaration || !compiler.isClassDeclaration(declaration) || !declaration.name) continue;
+						const base = declaration.heritageClauses?.find((clause) => clause.token === compiler.SyntaxKind.ExtendsKeyword)?.types[0];
+						if (!base || !bases.has(resolve(checker.getSymbolAtLocation(base.expression)))) continue;
+						if (!inside(root, declaration.getSourceFile().fileName)) throw Error(`Controller type generation cannot edit outside ${root}`);
+						registrations.push({
+							call: node,
+							controller: declaration
+						});
+					}
+				}
+			}
+		}
+		compiler.forEachChild(node, visit);
+	};
+	for (const source of sourceProgram.getSourceFiles()) if (inside(root, source.fileName) && !source.isDeclarationFile && !source.fileName.includes(`${path.sep}node_modules${path.sep}`)) visit(source);
+	const virtual = /* @__PURE__ */ new Map();
+	const calls = /* @__PURE__ */ new Map();
+	for (const { call } of registrations) {
+		const file = call.getSourceFile().fileName;
+		let positions = calls.get(file);
+		if (!positions) calls.set(file, positions = /* @__PURE__ */ new Set());
+		positions.add(call.expression.getStart());
+	}
+	for (const [file, positions] of calls) {
+		const source = sourceProgram.getSourceFile(file);
+		const edits = [];
+		const replace = (node) => {
+			if (compiler.isCallExpression(node) && positions.has(node.expression.getStart())) edits.push({
+				start: node.expression.getStart(),
+				end: node.expression.end,
+				text: PROBE
+			});
+			compiler.forEachChild(node, replace);
+		};
+		replace(source);
+		virtual.set(file, applyEdits(source.text, edits) + `\ndeclare function ${PROBE}<const R extends readonly (string | import("@finesoft/front").PageRoute)[]>(input: { routes: R; [key: string]: unknown }): import("@finesoft/front").RouteInputFor<R>;\n`);
+	}
+	virtual.set(output, "export {};\n");
+	const program = buildProgram(settings, virtual);
+	const types = program.getTypeChecker();
+	const inferred = /* @__PURE__ */ new Map();
+	for (const [file] of calls) {
+		const found = [];
+		const collect = (node) => {
+			if (compiler.isCallExpression(node) && compiler.isIdentifier(node.expression) && node.expression.text === PROBE) found.push(types.getTypeAtLocation(node));
+			compiler.forEachChild(node, collect);
+		};
+		collect(program.getSourceFile(file));
+		inferred.set(file, found);
+	}
+	const byCall = /* @__PURE__ */ new Map();
+	for (const [file] of calls) [...new Set(registrations.filter((entry) => entry.call.getSourceFile().fileName === file).map((entry) => entry.call))].forEach((call, index) => byCall.set(call, inferred.get(file)[index]));
+	const printer = compiler.createPrinter();
+	const outputSource = program.getSourceFile(output);
+	const factory = compiler.factory;
+	const schemaOutputs = /* @__PURE__ */ new Map();
+	let schemaOutputsReady = false;
+	const propertyType = (type, key, location) => {
+		const property = types.getNonNullableType(type).getProperty(key);
+		return property && types.getTypeOfSymbolAtLocation(property, location);
+	};
+	const schemaOutput = (type) => {
+		if (!(type.flags & (compiler.TypeFlags.Object | compiler.TypeFlags.Intersection))) return;
+		if (!schemaOutputsReady) {
+			schemaOutputsReady = true;
+			for (const source of program.getSourceFiles()) {
+				const symbol = types.getSymbolAtLocation(source);
+				if (!symbol || source.fileName === output) continue;
+				for (const exported of types.getExportsOfModule(symbol)) {
+					const type = types.getTypeOfSymbolAtLocation(exported, source);
+					const signatures = type.getCallSignatures();
+					const schema = signatures.length ? signatures[0].getReturnType() : type;
+					const standard = propertyType(schema, "~standard", source);
+					const metadata = standard && propertyType(standard, "types", source);
+					const result = metadata && propertyType(metadata, "output", source);
+					if (!result || !(result.flags & (compiler.TypeFlags.Object | compiler.TypeFlags.Intersection))) continue;
+					let modulePath = slash$1(path.relative(path.dirname(output), source.fileName)).replace(/(\.d)?\.([cm]?)tsx?$/, ".$2js");
+					if (!modulePath.startsWith(".")) modulePath = `./${modulePath}`;
+					const reference = factory.createImportTypeNode(factory.createLiteralTypeNode(factory.createStringLiteral(modulePath)), void 0, factory.createIdentifier(exported.name), void 0, true);
+					const schemaReference = signatures.length ? factory.createTypeReferenceNode("ReturnType", [reference]) : reference;
+					schemaOutputs.set(result, factory.createImportTypeNode(factory.createLiteralTypeNode(factory.createStringLiteral("@finesoft/front")), void 0, factory.createIdentifier("InferOutput"), [schemaReference]));
+				}
+			}
+		}
+		return schemaOutputs.get(type);
+	};
+	const buildTypeNode = (type, depth = 0) => {
+		const schema = depth >= 2 ? schemaOutput(type) : void 0;
+		if (schema) return schema;
+		if (type.isUnion()) return factory.createUnionTypeNode(type.types.map((value) => buildTypeNode(value, depth)));
+		const node = types.typeToTypeNode(type, outputSource, compiler.NodeBuilderFlags.NoTruncation | compiler.NodeBuilderFlags.UseFullyQualifiedType | compiler.NodeBuilderFlags.InTypeAlias);
+		if (!node) throw Error("Cannot serialize inferred controller input");
+		if (!compiler.isTypeLiteralNode(node)) return node;
+		return factory.updateTypeLiteralNode(node, factory.createNodeArray(node.members.map((member) => {
+			if (!compiler.isPropertySignature(member) || !member.type || !(compiler.isIdentifier(member.name) || compiler.isStringLiteral(member.name))) return member;
+			const value = propertyType(type, member.name.text, outputSource);
+			return value ? factory.updatePropertySignature(member, member.modifiers, member.name, member.questionToken, buildTypeNode(value, depth + 1)) : member;
+		})));
+	};
+	const printType = (type) => {
+		if (!type || type.flags & (compiler.TypeFlags.Any | compiler.TypeFlags.Unknown)) throw Error("Cannot infer controller input. Check route schemas and @finesoft/front types.");
+		const node = buildTypeNode(type);
+		const rejectAny = (value) => {
+			if (value.kind === compiler.SyntaxKind.AnyKeyword) throw Error("Cannot generate an any controller input. Check route schemas and their imports.");
+			compiler.forEachChild(value, rejectAny);
+		};
+		rejectAny(node);
+		const transformed = compiler.transform(node, [(context) => {
+			const visitType = (value) => {
+				if (compiler.isImportTypeNode(value) && compiler.isLiteralTypeNode(value.argument) && compiler.isStringLiteral(value.argument.literal) && path.isAbsolute(value.argument.literal.text)) {
+					let relative = slash$1(path.relative(path.dirname(output), value.argument.literal.text));
+					if (!relative.startsWith(".")) relative = `./${relative}`;
+					return context.factory.updateImportTypeNode(value, context.factory.createLiteralTypeNode(context.factory.createStringLiteral(relative)), value.attributes, value.qualifier, value.typeArguments, value.isTypeOf);
+				}
+				return compiler.visitEachChild(value, visitType, context);
+			};
+			return (node) => compiler.visitNode(node, visitType);
+		}]);
+		try {
+			return printer.printNode(compiler.EmitHint.Unspecified, transformed.transformed[0], outputSource);
+		} finally {
+			transformed.dispose();
+		}
+	};
+	const managed = /* @__PURE__ */ new Map();
+	for (const { call, controller } of registrations) {
+		const file = controller.getSourceFile();
+		if (!controller.members.filter((member) => compiler.isMethodDeclaration(member) && compiler.isIdentifier(member.name) && ["execute", "fallback"].includes(member.name.text)).some((method) => method.parameters.some((parameter) => !parameter.type || typeImport(parameter.type)))) continue;
+		const name = controller.name.text;
+		let entry = managed.get(controller);
+		if (!entry) managed.set(controller, entry = {
+			node: controller,
+			key: `${slash$1(path.relative(root, file.fileName))}#${name}`,
+			name,
+			inputs: []
+		});
+		entry.inputs.push(printType(byCall.get(call)));
+	}
+	const saved = fs.existsSync(output) ? fs.readFileSync(output, "utf8") : "";
+	let replayable = true;
+	if (saved.startsWith(GENERATED)) {
+		const previous = compiler.createSourceFile(output, saved, compiler.ScriptTarget.Latest, true);
+		const inputs = /* @__PURE__ */ new Map();
+		for (const statement of previous.statements) if (compiler.isInterfaceDeclaration(statement) && statement.name.text === "ControllerInputs") {
+			for (const member of statement.members) if (compiler.isPropertySignature(member) && compiler.isStringLiteral(member.name) && member.type) inputs.set(member.name.text, member.type.getText(previous));
+		}
+		for (const controller of classes) {
+			if (managed.has(controller)) continue;
+			const source = controller.getSourceFile();
+			const name = controller.name.text;
+			const key = `${slash$1(path.relative(root, source.fileName))}#${name}`;
+			if (inputs.has(key) && controller.members.some((member) => compiler.isMethodDeclaration(member) && member.parameters.some((parameter) => parameter.type && typeImport(parameter.type)))) {
+				replayable = false;
+				managed.set(controller, {
+					node: controller,
+					key,
+					name,
+					inputs: [inputs.get(key)]
+				});
+			}
+		}
+	}
+	const updates = /* @__PURE__ */ new Map();
+	const sourceEdits = /* @__PURE__ */ new Map();
+	const aliases = /* @__PURE__ */ new Map();
+	const names = /* @__PURE__ */ new Map();
+	for (const entry of managed.values()) names.set(entry.name, (names.get(entry.name) ?? 0) + 1);
+	const exportedName = (entry, suffix = "Input") => `${entry.name}${suffix}${names.get(entry.name) > 1 ? `_${createHash("sha256").update(entry.key).digest("hex").slice(0, 12)}` : ""}`;
+	const modulePaths = /* @__PURE__ */ new Map();
+	const localNames = /* @__PURE__ */ new Map();
+	const fileCounts = /* @__PURE__ */ new Map();
+	const ownedImports = /* @__PURE__ */ new Set();
+	for (const entry of managed.values()) {
+		const annotations = entry.node.members.flatMap((member) => compiler.isMethodDeclaration(member) && compiler.isIdentifier(member.name) && ["execute", "fallback"].includes(member.name.text) ? member.parameters.flatMap((parameter) => parameter.type ? [parameter.type] : []) : []);
+		for (const clause of entry.node.heritageClauses ?? []) if (clause.token === compiler.SyntaxKind.ExtendsKeyword) annotations.push(...clause.types[0].typeArguments?.slice(0, 1) ?? []);
+		for (const type of annotations) {
+			const imported = typeImport(type);
+			if (imported) ownedImports.add(imported);
+		}
+	}
+	for (const entry of managed.values()) {
+		const source = entry.node.getSourceFile();
+		fileCounts.set(source, (fileCounts.get(source) ?? 0) + 1);
+		if (localNames.has(source)) continue;
+		const imported = new Set(typeImports(source).flatMap((statement) => statement.importClause.namedBindings.elements.filter((element) => ownedImports.has(element)).map((element) => element.name.text)));
+		const used = /* @__PURE__ */ new Set();
+		const visit = (node) => {
+			if (compiler.isIdentifier(node) && !imported.has(node.text)) used.add(node.text);
+			compiler.forEachChild(node, visit);
+		};
+		visit(source);
+		localNames.set(source, used);
+	}
+	for (const entry of managed.values()) {
+		const source = entry.node.getSourceFile();
+		let edits = sourceEdits.get(source);
+		if (!edits) sourceEdits.set(source, edits = []);
+		const imports = typeImports(source).flatMap((statement) => statement.importClause.namedBindings.elements);
+		const alias = (suffix) => {
+			const used = localNames.get(source);
+			const exported = `${entry.name}${suffix}`;
+			let name = imports.find((element) => {
+				const name = (element.propertyName ?? element.name).text;
+				return ownedImports.has(element) && (name === exported || name.startsWith(exported) && /^_[a-f0-9]{12}$/.test(name.slice(exported.length)));
+			})?.name.text ?? (fileCounts.get(source) === 1 ? suffix : exported);
+			if (used.has(name)) name = `${entry.name}${suffix}`;
+			for (let i = 2; used.has(name); i++) name = `${entry.name}${suffix}${i}`;
+			used.add(name);
+			return name;
+		};
+		const parameterType = alias("Input");
+		const failureType = alias("Failure");
+		let modulePath = slash$1(path.relative(path.dirname(source.fileName), output)).replace(/\.d\.ts$/, "");
+		if (!modulePath.startsWith(".")) modulePath = `./${modulePath}`;
+		const list = aliases.get(source) ?? [];
+		const importAs = (suffix, local) => {
+			const name = exportedName(entry, suffix);
+			list.push(name === local ? name : `${name} as ${local}`);
+		};
+		importAs("Input", parameterType);
+		aliases.set(source, list);
+		modulePaths.set(source, modulePath);
+		for (const member of entry.node.members) {
+			if (!compiler.isMethodDeclaration(member) || !compiler.isIdentifier(member.name) || !["execute", "fallback"].includes(member.name.text)) continue;
+			if (member.parameters.length > 1) throw Error(`Use ${member.name.text}({ params, query, context${member.name.text === "fallback" ? ", error" : ""} }) in ${source.fileName}`);
+			const parameter = member.parameters[0];
+			if (!parameter || parameter.type && !typeImport(parameter.type)) continue;
+			const desired = member.name.text === "execute" ? parameterType : failureType;
+			if (member.name.text === "fallback") importAs("Failure", failureType);
+			edits.push(parameter.type ? {
+				start: parameter.type.getStart(),
+				end: parameter.type.end,
+				text: desired
+			} : {
+				start: parameter.questionToken?.end ?? parameter.name.end,
+				end: parameter.questionToken?.end ?? parameter.name.end,
+				text: `: ${desired}`
+			});
+		}
+		const base = entry.node.heritageClauses.find((clause) => clause.token === compiler.SyntaxKind.ExtendsKeyword).types[0];
+		const execute = entry.node.members.find((member) => compiler.isMethodDeclaration(member) && compiler.isIdentifier(member.name) && member.name.text === "execute");
+		let result = "import(\"@finesoft/front\").BasePage";
+		if (execute?.type) {
+			const type = checker.getTypeAtLocation(execute.type);
+			const awaited = checker.getAwaitedType(type);
+			result = awaited === type ? execute.type.getText() : `Awaited<${execute.type.getText()}>`;
+			if (compiler.isTypeReferenceNode(execute.type) && execute.type.typeName.getText() === "Promise" && execute.type.typeArguments?.length === 1) {
+				const value = execute.type.typeArguments[0];
+				if (checker.getTypeAtLocation(value) === awaited) result = value.getText();
+			}
+		}
+		const argumentsText = `<${parameterType}, ${result}>`;
+		if ((!base.typeArguments?.length || typeImport(base.typeArguments[0])) && tokens(source.text.slice(base.expression.end, base.end)) !== tokens(argumentsText)) edits.push({
+			start: base.expression.end,
+			end: base.end,
+			text: argumentsText
+		});
+	}
+	for (const [source, edits] of sourceEdits) {
+		const imports = typeImports(source);
+		const specifiers = [...aliases.get(source), ...imports.flatMap((statement) => statement.importClause.namedBindings.elements.filter((element) => !ownedImports.has(element)).map((element) => element.getText()))];
+		const desired = [...new Set(specifiers)].sort();
+		const declaration = `import type { ${desired.join(", ")} } from ${JSON.stringify(modulePaths.get(source))};`;
+		if (imports.length) {
+			const [first, ...rest] = imports;
+			if (first.importClause.namedBindings.elements.map((element) => tokens(element.getText())).sort().join("\n") !== desired.map(tokens).sort().join("\n")) edits.push({
+				start: first.getStart(),
+				end: first.end,
+				text: declaration
+			});
+			for (const statement of rest) edits.push({
+				start: statement.getStart(),
+				end: statement.end,
+				text: ""
+			});
+		} else {
+			const position = source.statements.filter(compiler.isImportDeclaration).at(-1)?.end ?? source.statements[0]?.getStart() ?? source.end;
+			edits.push({
+				start: position,
+				end: position,
+				text: `\n${declaration}\n`
+			});
+		}
+		updates.set(source.fileName, applyEdits(source.text, edits));
+	}
+	if (managed.size || fs.existsSync(output)) {
+		if (fs.existsSync(output) && !fs.readFileSync(output, "utf8").startsWith(GENERATED)) throw Error(`Refusing to overwrite unowned controller declarations: ${output}`);
+		updates.set(output, `${GENERATED}export interface ControllerInputs {\n${[...managed.values()].sort((a, b) => a.key.localeCompare(b.key)).map((entry) => `    ${JSON.stringify(entry.key)}: ${[...new Set(entry.inputs)].join(" | ")};`).join("\n")}\n}\n${[...managed.values()].sort((a, b) => a.key.localeCompare(b.key)).map((entry) => `export type ${exportedName(entry)} = ControllerInputs[${JSON.stringify(entry.key)}] & { readonly context: ${serverController(entry.node) ? "import(\"@finesoft/front\").ServerControllerContext" : "import(\"@finesoft/front\").ControllerContext"} };\nexport type ${exportedName(entry, "Failure")} = ${exportedName(entry)} & { readonly error: Error };`).join("\n")}\n`);
+	}
+	if (updates.has(output)) {
+		const validation = buildProgram({
+			...settings,
+			skipLibCheck: false
+		}, updates);
+		const generated = validation.getSourceFile(output);
+		const errors = [...validation.getSyntacticDiagnostics(generated), ...validation.getSemanticDiagnostics(generated)];
+		if (errors.length) throw Error(`Cannot generate controller declarations:\n${compiler.formatDiagnosticsWithColorAndContext(errors, {
+			getCanonicalFileName: (file) => file,
+			getCurrentDirectory: () => root,
+			getNewLine: () => "\n"
+		})}`);
+	}
+	for (const [source] of sourceEdits) if (fs.readFileSync(source.fileName, "utf8") !== source.text) throw Error(`Controller changed during type generation: ${source.fileName}`);
+	for (const file of updates.keys()) assertEditablePath(root, file);
+	const changed = [];
+	for (const [file, content] of updates) {
+		if (fs.existsSync(file)) {
+			const existing = fs.readFileSync(file, "utf8");
+			if (file === output ? tokens(existing) === tokens(content) : existing === content) continue;
+		}
+		fs.mkdirSync(path.dirname(file), { recursive: true });
+		fs.writeFileSync(file, content);
+		inputStamps.set(file, stamp([file]));
+		changed.push(file);
+	}
+	const files = [.../* @__PURE__ */ new Set([
+		...configFiles,
+		...rootFiles,
+		output,
+		...readFiles
+	])].sort();
+	const result = {
+		controllers: managed.size,
+		changed
+	};
+	const hashes = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		if (file === output) continue;
+		const unchanged = !force && inputStamps.get(file) === previous?.stamps.get(file);
+		hashes.set(file, unchanged && previous?.hashes.get(file) || hash(configContents.get(file) ?? updates.get(file) ?? readFile(file)));
+	}
+	const snapshot = {
+		compiler,
+		root,
+		files,
+		stamp: files.map((file) => inputStamps.get(file) ?? stamp([file])).join("\n"),
+		stamps: inputStamps,
+		hashes,
+		output,
+		content: changed.includes(output) ? updates.get(output) : saved,
+		replayable,
+		result
+	};
+	cached.set(cacheKey, snapshot);
+	retained = {
+		key: cacheKey,
+		compiler,
+		program: lastProgram
+	};
+	observe?.(snapshot);
+	return result;
+}
+/** Watch events are the invalidation source; one-shot calls still inspect the complete project. */
+function createControllerTypeWatcher(options) {
+	let snapshot;
+	let onChange;
+	const subscriptions = /* @__PURE__ */ new Map();
+	const directories = /* @__PURE__ */ new Map();
+	const versions = new LruMap(8);
+	const key = (hashes) => hash([...hashes.values()].join(""));
+	const subscribe = () => {
+		if (!onChange || !snapshot) return;
+		const { compiler, hashes } = snapshot;
+		if (!compiler.sys.watchFile || !compiler.sys.watchDirectory) throw Error("TypeScript file watching is unavailable");
+		for (const [file, subscription] of subscriptions) {
+			if (hashes.has(file)) continue;
+			subscription.close();
+			subscriptions.delete(file);
+		}
+		for (const file of hashes.keys()) if (!subscriptions.has(file)) subscriptions.set(file, compiler.sys.watchFile(file, () => onChange?.(file), 250, {
+			watchFile: inside(snapshot.root, file) && !slash$1(file).includes("/node_modules/") ? compiler.WatchFileKind.UseFsEvents : compiler.WatchFileKind.UseFsEventsOnParentDirectory,
+			fallbackPolling: compiler.PollingWatchKind.PriorityInterval,
+			synchronousWatchDirectory: true
+		}));
+		const desired = /* @__PURE__ */ new Set();
+		for (const file of hashes.keys()) {
+			const directory = path.dirname(file);
+			if (inside(snapshot.root, directory) && !slash$1(file).includes("/node_modules/")) continue;
+			desired.add(directory);
+			desired.add(path.dirname(directory));
+		}
+		for (const [directory, subscription] of directories) {
+			if (desired.has(directory)) continue;
+			subscription.close();
+			directories.delete(directory);
+		}
+		for (const directory of desired) if (!directories.has(directory)) directories.set(directory, compiler.sys.watchDirectory(directory, (file) => {
+			if (!snapshot?.hashes.has(file)) onChange?.(file);
+		}, false, {
+			watchDirectory: compiler.WatchDirectoryKind.UseFsEvents,
+			synchronousWatchDirectory: true
+		}));
+	};
+	const generate = (force) => {
+		return {
+			...generateTypes(options, (next) => {
+				if (snapshot?.files.join("\n") !== next.files.join("\n")) versions.clear();
+				snapshot = next;
+				subscribe();
+				if (!next.replayable) {
+					versions.clear();
+					return;
+				}
+				const fingerprint = key(next.hashes);
+				versions.set(fingerprint, {
+					content: next.content,
+					controllers: next.result.controllers
+				});
+			}, force),
+			cache: "generated"
+		};
+	};
+	generate(false);
+	return {
+		watch(listener) {
+			onChange = listener;
+			subscribe();
+			if (snapshot) {
+				for (const file of snapshot.hashes.keys()) if (stamp([file]) !== snapshot.stamps.get(file)) onChange(file);
+			}
+		},
+		update(files, cachedOnly = false) {
+			if (!snapshot) return cachedOnly ? void 0 : generate(true);
+			if (snapshot.content && !fs.existsSync(snapshot.output)) return cachedOnly ? void 0 : generate(true);
+			const hashes = new Map(snapshot.hashes);
+			let changed = false;
+			for (const file of files) {
+				if (!hashes.has(file) || file.endsWith(".json") || !fs.existsSync(file)) {
+					versions.clear();
+					return cachedOnly ? void 0 : generate(true);
+				}
+				const next = hash(fs.readFileSync(file, "utf8"));
+				changed ||= next !== hashes.get(file);
+				hashes.set(file, next);
+			}
+			if (!changed) return {
+				...snapshot.result,
+				changed: [],
+				cache: "unchanged"
+			};
+			const fingerprint = key(hashes);
+			const known = versions.get(fingerprint);
+			if (!known) return cachedOnly ? void 0 : generate(true);
+			const exists = fs.existsSync(snapshot.output);
+			const existing = exists ? fs.readFileSync(snapshot.output, "utf8") : "";
+			if (exists && !existing.startsWith(GENERATED)) throw Error(`Refusing to overwrite unowned controller declarations: ${snapshot.output}`);
+			const written = [];
+			if (existing !== known.content) {
+				assertEditablePath(snapshot.root, snapshot.output);
+				fs.mkdirSync(path.dirname(snapshot.output), { recursive: true });
+				fs.writeFileSync(snapshot.output, known.content);
+				written.push(snapshot.output);
+			}
+			const result = {
+				controllers: known.controllers,
+				changed: written
+			};
+			snapshot = {
+				...snapshot,
+				hashes,
+				content: known.content,
+				result
+			};
+			return {
+				...result,
+				cache: "reused"
+			};
+		},
+		close() {
+			onChange = void 0;
+			for (const subscription of subscriptions.values()) subscription.close();
+			for (const subscription of directories.values()) subscription.close();
+			subscriptions.clear();
+			directories.clear();
+			snapshot = void 0;
+			versions.clear();
+			releaseControllerTypes(options.root ?? process.cwd());
+		}
+	};
+}
+/** Release development-only compiler state when its host closes. */
+function releaseControllerTypes(root) {
+	const prefix = `${fs.existsSync(root) ? fs.realpathSync(root) : path.resolve(root)}#`;
+	for (const key of cached.keys()) if (key.startsWith(prefix)) cached.delete(key);
+	if (retained?.key.startsWith(prefix)) retained = void 0;
+}
+//#endregion
+//#region ../server/src/public-types.ts
+const slash = (value) => value.replaceAll("\\", "/");
+const relative = (from, to) => {
+	const name = slash(path.relative(from, to));
+	return name.startsWith("./") || name.startsWith("../") ? name : `./${name}`;
+};
+/** Maintain an exact root alias with only the project's installed platform/native contracts. */
+function generateFrontTypes(options = {}) {
+	const requestedRoot = path.resolve(options.root ?? process.cwd());
+	const requestedConfig = path.resolve(requestedRoot, options.tsconfig ?? "tsconfig.json");
+	if (!fs.existsSync(requestedConfig)) return [];
+	const root = fs.realpathSync(requestedRoot);
+	const configFile = fs.realpathSync(requestedConfig);
+	const require = createRequire(path.join(root, "package.json"));
+	let front;
+	try {
+		front = require.resolve("@finesoft/front");
+	} catch {
+		return [];
+	}
+	const c = require("typescript");
+	const input = fs.readFileSync(configFile, "utf8");
+	const parsed = c.parseConfigFileTextToJson(configFile, input);
+	if (parsed.error) throw Error(c.flattenDiagnosticMessageText(parsed.error.messageText, "\n"));
+	const output = path.join(root, ".finesoft/front.d.ts");
+	const resolved = c.parseJsonConfigFileContent(parsed.config, c.sys, path.dirname(configFile), void 0, configFile);
+	const configBase = resolved.options.baseUrl ?? path.dirname(configFile);
+	const alias = relative(configBase, output);
+	const existing = resolved.options.paths?.["@finesoft/front"];
+	if (existing && !(existing.length === 1 && path.resolve(configBase, existing[0]) === output)) return [];
+	const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+	if (pkg.name === "@finesoft/front") return [];
+	const deps = {
+		...pkg.dependencies,
+		...pkg.devDependencies,
+		...pkg.peerDependencies
+	};
+	const installed = (name) => {
+		if (!deps[name]) return false;
+		try {
+			require.resolve(`${name}/package.json`);
+			return true;
+		} catch {
+			try {
+				require.resolve(name);
+				return true;
+			} catch {
+				return false;
+			}
+		}
+	};
+	const entry = (name) => JSON.stringify(relative(path.dirname(output), path.join(path.dirname(front), `${name}.mjs`)));
+	const renderers = [
+		"react",
+		"vue",
+		"svelte"
+	].filter(installed);
+	const lines = [
+		"// Generated by @finesoft/front. Re-run finesoft-types after changing dependencies.",
+		`export * from ${entry("portable")};`,
+		`export { generateFrontTypes, generateControllerTypes } from ${entry("typegen")};`,
+		`export type { FrontTypeOptions, ControllerTypeOptions, ControllerTypeResult } from ${entry("typegen")};`
+	];
+	if (installed("@types/node") || installed("@hono/node-server")) lines.push(`export * from ${entry("node")};`);
+	if (installed("vite") || installed("vite-plus")) lines.push(`export * from ${entry("vite")};`);
+	if (renderers.length) {
+		lines.push(`import type { NativeAPI } from ${entry("native-contract")};`);
+		for (const name of renderers) lines.push(`import type * as ${name} from ${entry(name)};`);
+		lines.push(`export interface NativeBindings { ${renderers.map((name) => `${name}: typeof ${name};`).join(" ")} }`, "export type Renderer = keyof NativeBindings;", `interface NativeViewTypes { ${renderers.map((name) => `${name}: ${name}.NativeView;`).join(" ")} }`, "export type NativeView<R extends Renderer> = NativeViewTypes[R];", "export type NativeViews<R extends Renderer> = Readonly<Record<string, NativeView<R>>>;", "export declare const Outlet: NativeAPI<NativeBindings>[\"Outlet\"];", "export declare const useSnapshot: NativeAPI<NativeBindings>[\"useSnapshot\"];");
+	}
+	const changed = [];
+	const write = (file, content) => {
+		assertEditablePath(root, file);
+		if (fs.existsSync(file) && fs.readFileSync(file, "utf8") === content) return;
+		fs.mkdirSync(path.dirname(file), { recursive: true });
+		fs.writeFileSync(file, content);
+		changed.push(file);
+	};
+	write(output, lines.join("\n") + "\n");
+	if (!existing) {
+		const source = c.parseJsonText(configFile, input);
+		const object = source.statements[0]?.expression;
+		if (!object || !c.isObjectLiteralExpression(object)) throw Error(`Invalid tsconfig: ${configFile}`);
+		const property = (value, name) => value.properties.find((item) => c.isPropertyAssignment(item) && (c.isStringLiteral(item.name) || c.isIdentifier(item.name)) && item.name.text === name);
+		const compilerOptions = property(object, "compilerOptions");
+		const compilerObject = compilerOptions && c.isObjectLiteralExpression(compilerOptions.initializer) ? compilerOptions.initializer : void 0;
+		const paths = compilerObject && property(compilerObject, "paths");
+		const pathsObject = paths && c.isObjectLiteralExpression(paths.initializer) ? paths.initializer : void 0;
+		const target = pathsObject ?? compilerObject ?? object;
+		const inherited = !pathsObject && resolved.options.paths ? resolved.options.paths : {};
+		const pathsBase = resolved.options.baseUrl ?? (typeof resolved.options.pathsBasePath === "string" ? resolved.options.pathsBasePath : path.dirname(configFile));
+		const mapping = Object.entries({
+			...inherited,
+			"@finesoft/front": [alias]
+		}).map(([name, values]) => `${JSON.stringify(name)}: ${JSON.stringify(name === "@finesoft/front" ? values : values.map((value) => relative(configBase, path.resolve(pathsBase, value))))}`).join(",\n");
+		const addition = pathsObject ? mapping : compilerObject ? `"paths": { ${mapping} }` : `"compilerOptions": { "paths": { ${mapping} } }`;
+		const last = target.properties.at(-1);
+		const position = last?.end ?? target.getStart(source) + 1;
+		const insertion = last ? `,\n${addition}` : `\n${addition}\n`;
+		write(configFile, input.slice(0, position) + insertion + input.slice(position));
+	}
+	return changed;
+}
+//#endregion
+export { createControllerTypeWatcher as n, generateControllerTypes as r, generateFrontTypes as t };
+
+//# sourceMappingURL=public-types-BcJM-AYc.mjs.map