@ryanatkn/gro 0.147.1 → 0.149.0

package/src/lib/input_path.ts

@@ -41,9 +41,9 @@ export const to_input_path = (
 };
 
 export const to_input_paths = (
-	raw_input_paths: Raw_Input_Path[],
+	raw_input_paths: Array<Raw_Input_Path>,
 	root_path?: string, // TODO @many isn't passed in anywhere, maybe hoist to `invoke_task` and others
-): Input_Path[] => raw_input_paths.map((p) => to_input_path(p, root_path));
+): Array<Input_Path> => raw_input_paths.map((p) => to_input_path(p, root_path));
 
 export interface Possible_Path {
 	id: Path_Id;
@@ -57,9 +57,9 @@ export interface Possible_Path {
  */
 export const get_possible_paths = (
 	input_path: Input_Path,
-	root_dirs: Path_Id[],
-	extensions: string[],
-): Possible_Path[] => {
+	root_dirs: Array<Path_Id>,
+	extensions: Array<string>,
+): Array<Possible_Path> => {
 	const possible_paths: Set<Possible_Path> = new Set();
 
 	const add_possible_paths = (path: string, root_dir: Path_Id) => {
@@ -113,9 +113,9 @@ export interface Resolved_Input_File {
 }
 
 export interface Resolved_Input_Paths {
-	resolved_input_paths: Resolved_Input_Path[];
-	possible_paths_by_input_path: Map<Input_Path, Possible_Path[]>;
-	unmapped_input_paths: Input_Path[];
+	resolved_input_paths: Array<Resolved_Input_Path>;
+	possible_paths_by_input_path: Map<Input_Path, Array<Possible_Path>>;
+	unmapped_input_paths: Array<Input_Path>;
 }
 
 /**
@@ -124,13 +124,13 @@ export interface Resolved_Input_Paths {
  * If none is found for an input path, it's added to `unmapped_input_paths`.
  */
 export const resolve_input_paths = (
-	input_paths: Input_Path[],
-	root_dirs: Path_Id[],
-	extensions: string[],
+	input_paths: Array<Input_Path>,
+	root_dirs: Array<Path_Id>,
+	extensions: Array<string>,
 ): Resolved_Input_Paths => {
-	const resolved_input_paths: Resolved_Input_Path[] = [];
-	const possible_paths_by_input_path: Map<Input_Path, Possible_Path[]> = new Map();
-	const unmapped_input_paths: Input_Path[] = [];
+	const resolved_input_paths: Array<Resolved_Input_Path> = [];
+	const possible_paths_by_input_path: Map<Input_Path, Array<Possible_Path>> = new Map();
+	const unmapped_input_paths: Array<Input_Path> = [];
 	for (const input_path of input_paths) {
 		let found_file: [Path_Info, Possible_Path] | null = null;
 		let found_dirs: Array<[Path_Info, Possible_Path]> | null = null;
@@ -177,9 +177,9 @@ export const resolve_input_paths = (
 };
 
 export interface Resolved_Input_Files {
-	resolved_input_files: Resolved_Input_File[];
-	resolved_input_files_by_root_dir: Map<Path_Id, Resolved_Input_File[]>;
-	input_directories_with_no_files: Input_Path[];
+	resolved_input_files: Array<Resolved_Input_File>;
+	resolved_input_files_by_root_dir: Map<Path_Id, Array<Resolved_Input_File>>;
+	input_directories_with_no_files: Array<Input_Path>;
 }
 
 /**
@@ -187,10 +187,10 @@ export interface Resolved_Input_Files {
  * De-dupes source ids.
  */
 export const resolve_input_files = (
-	resolved_input_paths: Resolved_Input_Path[],
-	search: (dir: string) => Resolved_Path[] = search_fs,
+	resolved_input_paths: Array<Resolved_Input_Path>,
+	search: (dir: string) => Array<Resolved_Path> = search_fs,
 ): Resolved_Input_Files => {
-	const resolved_input_files: Resolved_Input_File[] = [];
+	const resolved_input_files: Array<Resolved_Input_File> = [];
 	// Add all input paths initially, and remove each when resolved to a file.
 	const existing_path_ids: Set<Path_Id> = new Set();
 
@@ -208,7 +208,7 @@ export const resolve_input_files = (
 			// Handle input paths that resolve to directories.
 			const files = search(id);
 			if (!files.length) continue;
-			const path_ids: Path_Id[] = [];
+			const path_ids: Array<Path_Id> = [];
 			for (const {path, is_directory} of files) {
 				if (is_directory) continue;
 				const path_id = join(id, path);
@@ -219,7 +219,7 @@ export const resolve_input_files = (
 				handle_found(input_path, path_id);
 			}
 			if (!path_ids.length) continue;
-			const resolved_input_files_for_input_path: Resolved_Input_File[] = [];
+			const resolved_input_files_for_input_path: Array<Resolved_Input_File> = [];
 			for (const path_id of path_ids) {
 				const resolved_input_file: Resolved_Input_File = {
 					id: path_id,
@@ -249,7 +249,7 @@ export const resolve_input_files = (
 				map.set(root_dir, [resolved_input_file]);
 			}
 			return map;
-		}, new Map<Path_Id, Resolved_Input_File[]>()),
+		}, new Map<Path_Id, Array<Resolved_Input_File>>()),
 		input_directories_with_no_files: remaining.map((r) => r.input_path),
 	};
 };

package/src/lib/invoke.ts

@@ -1,5 +1,6 @@
 import {attach_process_error_handlers} from '@ryanatkn/belt/process.js';
 import {configure_log_colors} from '@ryanatkn/belt/log.js';
+import {set_colors} from '@ryanatkn/belt/print.js';
 import {styleText} from 'node:util';
 
 import {invoke_task} from './invoke_task.js';
@@ -25,6 +26,7 @@ attach_process_error_handlers(
 );
 
 configure_log_colors(styleText);
+set_colors(styleText);
 
 await sveltekit_sync_if_obviously_needed();
 

package/src/lib/modules.ts

@@ -44,15 +44,15 @@ export const load_module = async <T_Module extends Record<string, any>>(
 
 export interface Load_Modules_Failure<T_Module_Meta extends Module_Meta> {
 	type: 'load_module_failures';
-	load_module_failures: Load_Module_Failure[];
-	reasons: string[];
+	load_module_failures: Array<Load_Module_Failure>;
+	reasons: Array<string>;
 	// still return the modules and timings, deferring to the caller
-	modules: T_Module_Meta[];
+	modules: Array<T_Module_Meta>;
 }
 
 export type Load_Modules_Result<T_Module_Meta extends Module_Meta> = Result<
 	{
-		modules: T_Module_Meta[];
+		modules: Array<T_Module_Meta>;
 	},
 	Load_Modules_Failure<T_Module_Meta>
 >;
@@ -62,15 +62,15 @@ export const load_modules = async <
 	T_Module extends Record<string, any>,
 	T_Module_Meta extends Module_Meta<T_Module>,
 >(
-	resolved_input_files: Resolved_Input_File[],
+	resolved_input_files: Array<Resolved_Input_File>,
 	validate: (mod: any) => mod is T_Module,
 	map_module_meta: (resolved_input_file: Resolved_Input_File, mod: T_Module) => T_Module_Meta,
 	timings?: Timings,
 ): Promise<Load_Modules_Result<T_Module_Meta>> => {
 	const timing_to_load_modules = timings?.start('load modules');
-	const modules: T_Module_Meta[] = [];
-	const load_module_failures: Load_Module_Failure[] = [];
-	const reasons: string[] = [];
+	const modules: Array<T_Module_Meta> = [];
+	const load_module_failures: Array<Load_Module_Failure> = [];
+	const reasons: Array<string> = [];
 	for (const resolved_input_file of resolved_input_files.values()) {
 		const {id, input_path} = resolved_input_file;
 		const result = await load_module(id, validate); // eslint-disable-line no-await-in-loop

package/src/lib/package.ts

@@ -5,7 +5,7 @@ import type {Src_Json} from './src_json.js';
 
 export const package_json = {
 	name: '@ryanatkn/gro',
-	version: '0.147.1',
+	version: '0.149.0',
 	description: 'task runner and toolkit extending SvelteKit',
 	motto: 'generate, run, optimize',
 	glyph: '🌰',
@@ -30,7 +30,7 @@ export const package_json = {
 		deploy: 'gro deploy',
 	},
 	type: 'module',
-	engines: {node: '>=20.17'},
+	engines: {node: '>=22.11'},
 	bin: {gro: 'dist/gro.js'},
 	keywords: [
 		'web',
@@ -44,38 +44,37 @@ export const package_json = {
 		'typescript',
 	],
 	dependencies: {
-		'@ryanatkn/belt': '^0.26.1',
-		chokidar: '^4.0.1',
-		dotenv: '^16.4.5',
-		'esm-env': '^1.1.4',
+		'@ryanatkn/belt': '^0.30.0',
+		chokidar: '^4.0.3',
+		dotenv: '^16.4.7',
+		'esm-env': '^1.2.2',
 		mri: '^1.2.0',
-		'oxc-parser': '^0.34.0',
-		prettier: '^3.3.3',
-		'prettier-plugin-svelte': '^3.2.7',
-		'ts-morph': '^24.0.0',
+		'oxc-parser': '^0.62.0',
+		prettier: '^3.5.3',
+		'prettier-plugin-svelte': '^3.3.3',
+		'ts-morph': '^25.0.1',
 		tslib: '^2.8.1',
-		zod: '^3.23.8',
+		zod: '^3.24.2',
 	},
-	peerDependencies: {esbuild: '^0.21.0', svelte: '^5'},
+	peerDependencies: {esbuild: '^0.25', svelte: '^5'},
 	devDependencies: {
-		'@changesets/changelog-git': '^0.2.0',
-		'@changesets/types': '^6.0.0',
-		'@ryanatkn/eslint-config': '^0.5.6',
-		'@ryanatkn/fuz': '^0.130.3',
-		'@ryanatkn/moss': '^0.20.2',
-		'@sveltejs/adapter-static': '^3.0.6',
-		'@sveltejs/kit': '^2.7.4',
-		'@sveltejs/package': '^2.3.7',
-		'@sveltejs/vite-plugin-svelte': '^4.0.0',
-		'@types/fs-extra': '^11.0.4',
-		'@types/node': '^22.8.6',
-		esbuild: '^0.21.5',
-		eslint: '^9.14.0',
-		'eslint-plugin-svelte': '^2.46.0',
-		svelte: '^5.1.9',
-		'svelte-check': '^4.0.5',
-		typescript: '^5.6.3',
-		'typescript-eslint': '^8.12.2',
+		'@changesets/changelog-git': '^0.2.1',
+		'@changesets/types': '^6.1.0',
+		'@ryanatkn/eslint-config': '^0.8.0',
+		'@ryanatkn/fuz': '^0.135.0',
+		'@ryanatkn/moss': '^0.24.2',
+		'@sveltejs/adapter-static': '^3.0.8',
+		'@sveltejs/kit': '^2.20.4',
+		'@sveltejs/package': '^2.3.10',
+		'@sveltejs/vite-plugin-svelte': '^5.0.3',
+		'@types/node': '^22.14.0',
+		esbuild: '^0.25.2',
+		eslint: '^9.24.0',
+		'eslint-plugin-svelte': '^3.5.1',
+		svelte: '^5.25.6',
+		'svelte-check': '^4.1.5',
+		typescript: '^5.8.2',
+		'typescript-eslint': '^8.29.0',
 		uvu: '^0.5.6',
 	},
 	prettier: {
@@ -103,6 +102,10 @@ export const package_json = {
 			default: './dist/changeset.task.js',
 		},
 		'./check.task.js': {types: './dist/check.task.d.ts', default: './dist/check.task.js'},
+		'./child_process_logging.js': {
+			types: './dist/child_process_logging.d.ts',
+			default: './dist/child_process_logging.js',
+		},
 		'./clean_fs.js': {types: './dist/clean_fs.d.ts', default: './dist/clean_fs.js'},
 		'./clean.task.js': {types: './dist/clean.task.d.ts', default: './dist/clean.task.js'},
 		'./cli.js': {types: './dist/cli.d.ts', default: './dist/cli.js'},
@@ -266,7 +269,7 @@ export const package_json = {
 
 export const src_json = {
 	name: '@ryanatkn/gro',
-	version: '0.147.1',
+	version: '0.149.0',
 	modules: {
 		'.': {
 			path: 'index.ts',
@@ -335,6 +338,13 @@ export const src_json = {
 				{name: 'task', kind: 'variable'},
 			],
 		},
+		'./child_process_logging.js': {
+			path: 'child_process_logging.ts',
+			declarations: [
+				{name: 'map_child_process_output', kind: 'function'},
+				{name: 'configure_colored_output_with_path_replacement', kind: 'function'},
+			],
+		},
 		'./clean_fs.js': {path: 'clean_fs.ts', declarations: [{name: 'clean_fs', kind: 'function'}]},
 		'./clean.task.js': {
 			path: 'clean.task.ts',
@@ -388,6 +398,7 @@ export const src_json = {
 				{name: 'TS_MATCHER', kind: 'variable'},
 				{name: 'JS_MATCHER', kind: 'variable'},
 				{name: 'JSON_MATCHER', kind: 'variable'},
+				{name: 'SVELTE_SCRIPT_MATCHER', kind: 'variable'},
 				{name: 'EVERYTHING_MATCHER', kind: 'variable'},
 				{name: 'JS_CLI_DEFAULT', kind: 'variable'},
 				{name: 'PM_CLI_DEFAULT', kind: 'variable'},

package/src/lib/package_json.ts

@@ -250,7 +250,7 @@ export const update_package_json = async (
 
 const is_index = (path: string): boolean => path === 'index.ts' || path === 'index.js';
 
-export const to_package_exports = (paths: string[]): Package_Json_Exports => {
+export const to_package_exports = (paths: Array<string>): Package_Json_Exports => {
 	const sorted = paths
 		.slice()
 		.sort((a, b) => (is_index(a) ? -1 : is_index(b) ? 1 : a.localeCompare(b)));
@@ -360,7 +360,7 @@ export interface Package_Json_Dep {
 	version: string;
 }
 
-export const extract_deps = (package_json: Package_Json): Package_Json_Dep[] => {
+export const extract_deps = (package_json: Package_Json): Array<Package_Json_Dep> => {
 	const deps_by_name: Map<string, Package_Json_Dep> = new Map();
 	// Earlier versions override later ones, so peer deps goes last.
 	const add_deps = (deps: Record<string, string> | undefined) => {

package/src/lib/parse_imports.ts

@@ -1,40 +1,177 @@
-import {moduleLexerSync} from 'oxc-parser';
+import {parseSync, type ImportDeclaration} from 'oxc-parser';
 import type {Flavored} from '@ryanatkn/belt/types.js';
+import {Unreachable_Error} from '@ryanatkn/belt/error.js';
 
 import type {Path_Id} from './path.js';
 import {SVELTE_MATCHER} from './svelte_helpers.js';
-import {JS_MATCHER, TS_MATCHER} from './constants.js';
+import {JS_MATCHER, TS_MATCHER, SVELTE_SCRIPT_MATCHER} from './constants.js';
 
 export type Import_Specifier = Flavored<string, 'Import_Specifier'>;
 
-const script_matcher = /<script.*?>(.*?)<\/script>/gimsu;
+// TODO this is probably way more complicated that it should be, maybe report the issues upstream unless I made a mistake here
+
+/**
+ * Extracts the string value from a module request, handling different quote styles.
+ * Returns null if the value is not a valid string literal.
+ */
+const extract_string_literal = (content: string, start: number, end: number): string | null => {
+	const value = content.substring(start, end);
+
+	// Check if it's a string literal (starts and ends with quotes)
+	if (
+		(value.startsWith("'") && value.endsWith("'")) ||
+		(value.startsWith('"') && value.endsWith('"')) ||
+		(value.startsWith('`') && value.endsWith('`'))
+	) {
+		// Remove the quotes
+		return value.slice(1, -1);
+	}
+
+	// Not a valid string literal
+	return null;
+};
 
 export const parse_imports = (
 	id: Path_Id,
 	contents: string,
 	ignore_types = true,
-): Import_Specifier[] => {
-	const specifiers: string[] = [];
-
+): Array<Import_Specifier> => {
+	const specifiers: Array<string> = [];
 	const is_svelte = SVELTE_MATCHER.test(id);
 
 	const parse_from = (s: string): void => {
-		const parsed = moduleLexerSync(s, {sourceFilename: is_svelte ? id + '.ts' : id});
-		for (const p of parsed.imports) {
+		const parsed = parseSync(is_svelte ? id + '.ts' : id, s, {});
+
+		// Process static imports
+		for (const static_import of parsed.module.staticImports) {
+			// Get the module source node
+			const import_decl = parsed.program.body.find(
+				(node) => node.type === 'ImportDeclaration' && node.start === static_import.start,
+			) as ImportDeclaration | undefined;
+
+			if (!import_decl?.source) continue;
+
+			// Extract the module request string value
+			const value = extract_string_literal(s, import_decl.source.start, import_decl.source.end);
+
+			if (!value) continue;
+
+			// Skip type-only imports if ignore_types is true
 			if (ignore_types) {
-				const import_statement = s.slice(p.ss, p.se);
-				if (import_statement.startsWith('import type')) {
+				// Handle import type {...} (type-only imports)
+				if (import_decl.importKind === 'type') {
+					continue;
+				}
+
+				// Handle inline type imports ({type foo})
+				if (static_import.entries.length > 0) {
+					// If all imports are type imports, skip this import
+					const has_non_type_specifier = static_import.entries.some((entry) => !entry.isType);
+					if (!has_non_type_specifier) {
+						continue;
+					}
+				}
+			}
+
+			specifiers.push(value);
+		}
+
+		// Process dynamic imports
+		for (const dynamic_import of parsed.module.dynamicImports) {
+			// Find the corresponding AST node
+			let found = false;
+			for (const node of parsed.program.body) {
+				if (
+					node.type === 'ExpressionStatement' &&
+					node.expression.type === 'AwaitExpression' &&
+					node.expression.argument.type === 'ImportExpression'
+				) {
+					const import_expr = node.expression.argument;
+					if (import_expr.start === dynamic_import.start) {
+						// Only process string literals (not expressions or variables)
+						if (import_expr.source.type === 'Literal') {
+							const value = String(import_expr.source.value);
+							if (value) {
+								specifiers.push(value);
+							}
+						}
+						found = true;
+						break;
+					}
+				}
+			}
+
+			// If we didn't find a match through AST, fall back to the original approach
+			// but only for simple string literals
+			if (!found) {
+				const value = extract_string_literal(
+					s,
+					dynamic_import.moduleRequest.start,
+					dynamic_import.moduleRequest.end,
+				);
+				if (value) {
+					specifiers.push(value);
+				}
+			}
+		}
+
+		// Process re-exports
+		for (const node of parsed.program.body) {
+			if (node.type === 'ExportNamedDeclaration' && node.source) {
+				// Skip type-only exports if ignore_types is true
+				if (ignore_types && node.exportKind === 'type') {
 					continue;
 				}
+
+				// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+				if (node.source.type === 'Literal') {
+					const value = String(node.source.value);
+					if (value) {
+						specifiers.push(value);
+					}
+				} else {
+					throw new Unreachable_Error(node.source.type);
+				}
 			}
-			if (p.n) specifiers.push(p.n);
 		}
 	};
 
 	if (is_svelte) {
-		const matches = contents.matchAll(script_matcher);
-		for (const m of matches) {
-			parse_from(m[1]);
+		// Reset the regex state between calls
+		SVELTE_SCRIPT_MATCHER.lastIndex = 0;
+
+		// Capture script tags at the top level (not nested in HTML)
+		let last_index = 0;
+		const script_blocks: Array<{content: string; start: number; end: number}> = [];
+
+		// First collect all script blocks
+		let match;
+		while ((match = SVELTE_SCRIPT_MATCHER.exec(contents)) !== null) {
+			// Save position of the script tag
+			const start = match.index;
+			const end = SVELTE_SCRIPT_MATCHER.lastIndex;
+
+			// Only process top-level script tags (skip nested ones)
+			// A nested script would be inside another HTML tag between lastIndex and start
+			const text_between = contents.substring(last_index, start);
+			const contains_opening_tag = /<[a-z][^>]*>/i.test(text_between);
+			const contains_closing_tag = /<\/[a-z][^>]*>/i.test(text_between);
+
+			// If we're not nested (no HTML tag nesting), process this script
+			if (!(contains_opening_tag && !contains_closing_tag)) {
+				script_blocks.push({
+					content: match[1],
+					start,
+					end,
+				});
+			}
+
+			last_index = end;
+		}
+
+		// Process all the collected script blocks
+		for (const block of script_blocks) {
+			parse_from(block.content);
 		}
 	} else if (TS_MATCHER.test(id) || JS_MATCHER.test(id)) {
 		parse_from(contents);

package/src/lib/plugin.ts

@@ -24,7 +24,7 @@ export class Plugins<T_Plugin_Context extends Plugin_Context> {
 	/* prefer `Plugins.create` to the constructor */
 	constructor(
 		private ctx: T_Plugin_Context,
-		private instances: Plugin[],
+		private instances: Array<Plugin>,
 	) {}
 
 	static async create<T_Plugin_Context extends Plugin_Context>(
@@ -32,7 +32,7 @@ export class Plugins<T_Plugin_Context extends Plugin_Context> {
 	): Promise<Plugins<T_Plugin_Context>> {
 		const {timings} = ctx;
 		const timing_to_create = timings.start('plugins.create');
-		const instances: Plugin[] = await ctx.config.plugins(ctx);
+		const instances: Array<Plugin> = await ctx.config.plugins(ctx);
 		const plugins = new Plugins(ctx, instances);
 		timing_to_create();
 		return plugins;
@@ -91,10 +91,10 @@ export class Plugins<T_Plugin_Context extends Plugin_Context> {
  * @returns `plugins` with `new_plugin` at the index of the plugin with `name`
  */
 export const replace_plugin = (
-	plugins: Plugin[],
+	plugins: Array<Plugin>,
 	new_plugin: Plugin,
 	name = new_plugin.name,
-): Plugin[] => {
+): Array<Plugin> => {
 	const index = plugins.findIndex((p) => p.name === name);
 	if (index === -1) throw Error('Failed to find plugin to replace: ' + name);
 	const replaced = plugins.slice();

package/src/lib/run_gen.ts

@@ -19,7 +19,7 @@ import {default_sveltekit_config} from './sveltekit_config.js';
 export const GEN_NO_PROD_MESSAGE = 'gen runs only during development';
 
 export const run_gen = async (
-	gen_modules: Genfile_Module_Meta[],
+	gen_modules: Array<Genfile_Module_Meta>,
 	config: Gro_Config,
 	log: Logger,
 	timings: Timings,

package/src/lib/search_fs.ts

@@ -10,11 +10,11 @@ export interface Search_Fs_Options {
 	/**
 	 * One or more filter functions, any of which can short-circuit the search by returning `false`.
 	 */
-	filter?: Path_Filter | Path_Filter[];
+	filter?: Path_Filter | Array<Path_Filter>;
 	/**
 	 * One or more file filter functions. Every filter must pass for a file to be included.
 	 */
-	file_filter?: File_Filter | File_Filter[];
+	file_filter?: File_Filter | Array<File_Filter>;
 	/**
 	 * Pass `null` or `false` to speed things up at the cost of volatile ordering.
 	 */
@@ -32,7 +32,7 @@ export interface Search_Fs_Options {
 export const search_fs = (
 	dir: string,
 	options: Search_Fs_Options = EMPTY_OBJECT,
-): Resolved_Path[] => {
+): Array<Resolved_Path> => {
 	const {
 		filter,
 		file_filter,
@@ -52,7 +52,7 @@ export const search_fs = (
 
 	if (!existsSync(final_dir)) return [];
 
-	const paths: Resolved_Path[] = [];
+	const paths: Array<Resolved_Path> = [];
 	crawl(final_dir, paths, filters, file_filters, include_directories, null);
 
 	return sort ? paths.sort(typeof sort === 'boolean' ? default_sort : sort) : paths;
@@ -62,12 +62,12 @@ const default_sort = (a: Resolved_Path, b: Resolved_Path): number => a.path.loca
 
 const crawl = (
 	dir: string,
-	paths: Resolved_Path[],
-	filters: Path_Filter[] | undefined,
-	file_filter: File_Filter[] | undefined,
+	paths: Array<Resolved_Path>,
+	filters: Array<Path_Filter> | undefined,
+	file_filter: Array<File_Filter> | undefined,
 	include_directories: boolean,
 	base_dir: string | null,
-): Resolved_Path[] => {
+): Array<Resolved_Path> => {
 	// This sync version is significantly faster than using the `fs/promises` version -
 	// it doesn't parallelize but that's not the common case in Gro.
 	const dirents = readdirSync(dir, {withFileTypes: true});

package/src/lib/src_json.ts

@@ -88,7 +88,7 @@ export const to_src_modules = (
 				);
 			}
 
-			const declarations: Src_Module_Declaration[] = [];
+			const declarations: Array<Src_Module_Declaration> = [];
 
 			const source_file = project.getSourceFile(source_file_id);
 			if (source_file) {

package/src/lib/sveltekit_config.ts

@@ -58,7 +58,7 @@ export interface Parsed_Sveltekit_Config {
 	public_prefix: string | undefined;
 	svelte_compile_options: CompileOptions;
 	svelte_compile_module_options: ModuleCompileOptions;
-	svelte_preprocessors: PreprocessorGroup | PreprocessorGroup[] | undefined;
+	svelte_preprocessors: PreprocessorGroup | Array<PreprocessorGroup> | undefined;
 }
 
 // TODO currently incomplete and hack - maybe rethink

package/src/lib/sveltekit_shim_app_stores.ts

@@ -1,6 +1,9 @@
 // shim for $app/stores
 // @see https://github.com/sveltejs/kit/issues/1485
 
+// TODO support `$app/state`
+/* eslint-disable @typescript-eslint/no-deprecated */
+
 import type {
 	getStores as base_getStores,
 	navigating as base_navigating,

package/src/lib/sveltekit_shim_env.ts

@@ -12,7 +12,7 @@ export const render_env_shim_module = (
 	public_prefix = 'PUBLIC_',
 	private_prefix = '',
 	env_dir?: string,
-	env_files?: string[],
+	env_files?: Array<string>,
 	ambient_env?: Record<string, string | undefined>,
 ): string => {
 	const env = load_env(