diff --git a/change/change-0b8bd43e-1dd3-4a10-af17-04c1ad59b3a4.json b/change/change-0b8bd43e-1dd3-4a10-af17-04c1ad59b3a4.json
new file mode 100644
index 000000000..68fa3ed38
--- /dev/null
+++ b/change/change-0b8bd43e-1dd3-4a10-af17-04c1ad59b3a4.json
@@ -0,0 +1,95 @@
+{
+  "changes": [
+    {
+      "type": "patch",
+      "comment": "Add explicit module boundary types and update typescript version",
+      "packageName": "@lage-run/cache",
+      "email": "elcraig@microsoft.com",
+      "dependentChangeType": "patch"
+    },
+    {
+      "type": "patch",
+      "comment": "Add explicit module boundary types and update typescript version",
+      "packageName": "@lage-run/cli",
+      "email": "elcraig@microsoft.com",
+      "dependentChangeType": "patch"
+    },
+    {
+      "type": "patch",
+      "comment": "Add explicit module boundary types and update typescript version",
+      "packageName": "@lage-run/config",
+      "email": "elcraig@microsoft.com",
+      "dependentChangeType": "patch"
+    },
+    {
+      "type": "patch",
+      "comment": "Add explicit module boundary types and update typescript version",
+      "packageName": "@lage-run/format-hrtime",
+      "email": "elcraig@microsoft.com",
+      "dependentChangeType": "patch"
+    },
+    {
+      "type": "patch",
+      "comment": "Add explicit module boundary types and update typescript version",
+      "packageName": "@lage-run/globby",
+      "email": "elcraig@microsoft.com",
+      "dependentChangeType": "patch"
+    },
+    {
+      "type": "patch",
+      "comment": "Add explicit module boundary types and update typescript version",
+      "packageName": "@lage-run/hasher",
+      "email": "elcraig@microsoft.com",
+      "dependentChangeType": "patch"
+    },
+    {
+      "type": "patch",
+      "comment": "Add explicit module boundary types and update typescript version",
+      "packageName": "@lage-run/logger",
+      "email": "elcraig@microsoft.com",
+      "dependentChangeType": "patch"
+    },
+    {
+      "type": "patch",
+      "comment": "Add explicit module boundary types and update typescript version",
+      "packageName": "@lage-run/reporters",
+      "email": "elcraig@microsoft.com",
+      "dependentChangeType": "patch"
+    },
+    {
+      "type": "patch",
+      "comment": "Add explicit module boundary types and update typescript version",
+      "packageName": "@lage-run/rpc",
+      "email": "elcraig@microsoft.com",
+      "dependentChangeType": "patch"
+    },
+    {
+      "type": "patch",
+      "comment": "Add explicit module boundary types and update typescript version",
+      "packageName": "@lage-run/runners",
+      "email": "elcraig@microsoft.com",
+      "dependentChangeType": "patch"
+    },
+    {
+      "type": "patch",
+      "comment": "Add explicit module boundary types and update typescript version",
+      "packageName": "@lage-run/scheduler",
+      "email": "elcraig@microsoft.com",
+      "dependentChangeType": "patch"
+    },
+    {
+      "type": "patch",
+      "comment": "Add explicit module boundary types and update typescript version",
+      "packageName": "@lage-run/target-graph",
+      "email": "elcraig@microsoft.com",
+      "dependentChangeType": "patch"
+    },
+    {
+      "type": "patch",
+      "comment": "Add explicit module boundary types and update typescript version",
+      "packageName": "@lage-run/worker-threads-pool",
+      "email": "elcraig@microsoft.com",
+      "dependentChangeType": "patch"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/package.json b/package.json
index e5bcfb0aa..b0617664d 100644
--- a/package.json
+++ b/package.json
@@ -46,11 +46,11 @@
     "prettier": "^3.0.0",
     "syncpack": "^13.0.0",
     "ts-node": "^10.9.1",
-    "typescript": "~5.0.3"
+    "typescript": "~5.9.3"
   },
   "resolutions": {
     "@types/node@npm:*": "^16.0.0",
-    "typescript@npm:>=5.0.2": "~5.0.3",
+    "typescript@npm:>=5.0.2": "~5.9.3",
     "node-gyp@npm:latest": "^11.0.0",
     "listr2@npm:^9.0.5": "9.0.3"
   },
diff --git a/packages/cache/src/backfillWrapper.ts b/packages/cache/src/backfillWrapper.ts
index ad453403b..ee8c5f44d 100644
--- a/packages/cache/src/backfillWrapper.ts
+++ b/packages/cache/src/backfillWrapper.ts
@@ -3,14 +3,14 @@
  */
 
 import * as os from "os";
-import { createDefaultConfig, getEnvConfig } from "backfill-config";
+import { type Config, createDefaultConfig, getEnvConfig } from "backfill-config";
 import { makeLogger } from "backfill-logger";
 import type { Logger as BackfillLogger } from "backfill-logger";
 import type { CacheOptions } from "@lage-run/config";
 import type { AzureCredentialName } from "@lage-run/config";
 import { CredentialCache } from "./CredentialCache.js";
 
-export function createBackfillLogger() {
+export function createBackfillLogger(): BackfillLogger {
   const stdout = process.stdout;
   const stderr = process.stderr;
   return makeLogger("error", {
@@ -28,13 +28,17 @@ export function createBackfillLogger() {
   });
 }
 
-export function createBackfillCacheConfig(cwd: string, cacheOptions: Partial<CacheOptions> = {}, backfillLogger: BackfillLogger) {
+export function createBackfillCacheConfig(
+  cwd: string,
+  cacheOptions: Partial<CacheOptions> | undefined = {},
+  backfillLogger: BackfillLogger
+): Config {
   const envConfig = getEnvConfig(backfillLogger);
   const mergedConfig = {
     ...createDefaultConfig(cwd),
     ...cacheOptions,
     ...envConfig,
-  };
+  } as Config;
 
   if (mergedConfig.cacheStorageConfig.provider === "azure-blob") {
     const azureOptions = mergedConfig.cacheStorageConfig.options;
diff --git a/packages/cache/src/chunkPromise.ts b/packages/cache/src/chunkPromise.ts
index 5d1269c47..605b28e1a 100644
--- a/packages/cache/src/chunkPromise.ts
+++ b/packages/cache/src/chunkPromise.ts
@@ -1,6 +1,6 @@
 type PromiseFn = () => Promise<unknown>;
 
-export async function chunkPromise(promises: (Promise<unknown> | PromiseFn)[], limit = 5) {
+export async function chunkPromise(promises: (Promise<unknown> | PromiseFn)[], limit = 5): Promise<void> {
   for (let i = 0; i < promises.length; i += limit) {
     await Promise.all(promises.slice(i, i + limit).map((p) => (typeof p === "function" ? p() : p)));
   }
diff --git a/packages/cache/src/getCacheDirectory.ts b/packages/cache/src/getCacheDirectory.ts
index 0b5fac2f4..67cdead6a 100644
--- a/packages/cache/src/getCacheDirectory.ts
+++ b/packages/cache/src/getCacheDirectory.ts
@@ -1,13 +1,13 @@
 import path from "path";
 
-export function getCacheDirectoryRoot(root: string) {
+export function getCacheDirectoryRoot(root: string): string {
   return path.join(root, "node_modules", ".cache", "lage");
 }
 
-export function getCacheDirectory(root: string, hash: string) {
+export function getCacheDirectory(root: string, hash: string): string {
   return path.join(getCacheDirectoryRoot(root), "cache", hash.substring(0, 4));
 }
 
-export function getLogsCacheDirectory(root: string, hash: string) {
+export function getLogsCacheDirectory(root: string, hash: string): string {
   return path.join(getCacheDirectoryRoot(root), "logs", hash.substring(0, 4));
 }
diff --git a/packages/cache/src/providers/BackfillCacheProvider.ts b/packages/cache/src/providers/BackfillCacheProvider.ts
index 2e9301ac6..3c122d020 100644
--- a/packages/cache/src/providers/BackfillCacheProvider.ts
+++ b/packages/cache/src/providers/BackfillCacheProvider.ts
@@ -127,7 +127,7 @@ export class BackfillCacheProvider implements CacheProvider {
     );
   }
 
-  getCachePath(packagePath: string, hash: string) {
+  getCachePath(packagePath: string, hash: string): string {
     return path.relative(packagePath, getCacheDirectory(this.options.root, hash));
   }
 }
diff --git a/packages/cache/src/providers/RemoteFallbackCacheProvider.ts b/packages/cache/src/providers/RemoteFallbackCacheProvider.ts
index 8b9c30fcb..9428289cb 100644
--- a/packages/cache/src/providers/RemoteFallbackCacheProvider.ts
+++ b/packages/cache/src/providers/RemoteFallbackCacheProvider.ts
@@ -24,7 +24,7 @@ export class RemoteFallbackCacheProvider implements CacheProvider {
 
   constructor(private options: RemoteFallbackCacheProviderOptions) {}
 
-  async fetch(hash: string, target: Target) {
+  async fetch(hash: string, target: Target): Promise<boolean> {
     const { logger, remoteCacheProvider, localCacheProvider } = this.options;
 
     if (localCacheProvider) {
@@ -48,7 +48,7 @@ export class RemoteFallbackCacheProvider implements CacheProvider {
     return RemoteFallbackCacheProvider.localHits[hash];
   }
 
-  async put(hash: string, target: Target) {
+  async put(hash: string, target: Target): Promise<void> {
     const { logger, remoteCacheProvider, localCacheProvider, writeRemoteCache } = this.options;
     const putPromises: Promise<void>[] = [];
 
diff --git a/packages/cli/src/cache/createCacheProvider.ts b/packages/cli/src/cache/createCacheProvider.ts
index f7c581f23..ab956f57d 100644
--- a/packages/cli/src/cache/createCacheProvider.ts
+++ b/packages/cli/src/cache/createCacheProvider.ts
@@ -10,7 +10,9 @@ interface CreateCacheOptions {
   cliArgs: string[];
 }
 
-export async function createCache(options: CreateCacheOptions) {
+export async function createCache(options: CreateCacheOptions): Promise<{
+  hasher: TargetHasher;
+}> {
   const { cacheOptions, root, cliArgs, logger } = options;
 
   const hasher = new TargetHasher({
diff --git a/packages/cli/src/cache/isRunningFromCI.ts b/packages/cli/src/cache/isRunningFromCI.ts
index b2ec496b7..dd86cb254 100644
--- a/packages/cli/src/cache/isRunningFromCI.ts
+++ b/packages/cli/src/cache/isRunningFromCI.ts
@@ -1 +1 @@
-export const isRunningFromCI = process.env.NODE_ENV !== "test" && (!!process.env.CI || !!process.env.TF_BUILD);
+export const isRunningFromCI: boolean = process.env.NODE_ENV !== "test" && (!!process.env.CI || !!process.env.TF_BUILD);
diff --git a/packages/cli/src/commands/addOptions.ts b/packages/cli/src/commands/addOptions.ts
index 955062482..b55528c1a 100644
--- a/packages/cli/src/commands/addOptions.ts
+++ b/packages/cli/src/commands/addOptions.ts
@@ -1,7 +1,7 @@
 import type { Command, Option } from "commander";
 import { options } from "./options.js";
 
-export function addOptions(category: keyof typeof options, command: Command) {
+export function addOptions(category: keyof typeof options, command: Command): Command {
   for (const option of Object.values<Option>(options[category])) {
     command.addOption(option);
   }
diff --git a/packages/cli/src/commands/affected/action.ts b/packages/cli/src/commands/affected/action.ts
index 03ab481a7..8c1f124ab 100644
--- a/packages/cli/src/commands/affected/action.ts
+++ b/packages/cli/src/commands/affected/action.ts
@@ -8,7 +8,7 @@ interface AffectedOptions extends FilterOptions {
   outputFormat?: "json" | "graph" | "default";
 }
 
-export async function affectedAction(options: AffectedOptions) {
+export async function affectedAction(options: AffectedOptions): Promise<void> {
   const { dependencies, dependents, since, scope, ignore, outputFormat } = options;
 
   const cwd = process.cwd();
diff --git a/packages/cli/src/commands/affected/index.ts b/packages/cli/src/commands/affected/index.ts
index 9b3ad4922..2c8850dae 100644
--- a/packages/cli/src/commands/affected/index.ts
+++ b/packages/cli/src/commands/affected/index.ts
@@ -2,7 +2,7 @@ import { Command } from "commander";
 import { affectedAction } from "./action.js";
 import { addOptions } from "../addOptions.js";
 
-const affectedCommand = new Command("affected");
+const affectedCommand: Command = new Command("affected");
 addOptions("filter", affectedCommand).action(affectedAction);
 
 export { affectedCommand };
diff --git a/packages/cli/src/commands/cache/action.ts b/packages/cli/src/commands/cache/action.ts
index 5a6b3b494..07698a352 100644
--- a/packages/cli/src/commands/cache/action.ts
+++ b/packages/cli/src/commands/cache/action.ts
@@ -10,7 +10,7 @@ interface CacheOptions extends ReporterInitOptions {
   clear?: boolean;
 }
 
-export async function cacheAction(options: CacheOptions, command: Command) {
+export async function cacheAction(options: CacheOptions, command: Command): Promise<void> {
   const cwd = process.cwd();
   const config = await getConfig(cwd);
   const logger = createLogger();
diff --git a/packages/cli/src/commands/cache/clearCache.ts b/packages/cli/src/commands/cache/clearCache.ts
index e879cdb40..016eb4be2 100644
--- a/packages/cli/src/commands/cache/clearCache.ts
+++ b/packages/cli/src/commands/cache/clearCache.ts
@@ -10,7 +10,7 @@ export interface ClearCacheOptions {
   concurrency: number;
 }
 
-export async function clearCache(options: ClearCacheOptions) {
+export async function clearCache(options: ClearCacheOptions): Promise<void> {
   const { logger, cwd } = options;
 
   const config = await getConfig(cwd);
diff --git a/packages/cli/src/commands/cache/index.ts b/packages/cli/src/commands/cache/index.ts
index 77e13e2de..8ab5a8698 100644
--- a/packages/cli/src/commands/cache/index.ts
+++ b/packages/cli/src/commands/cache/index.ts
@@ -2,7 +2,7 @@ import { Command } from "commander";
 import { cacheAction } from "./action.js";
 import { addOptions } from "../addOptions.js";
 
-const command = new Command("cache");
+const command: Command = new Command("cache");
 
 addOptions("cache", command);
 addOptions("logger", command);
diff --git a/packages/cli/src/commands/cache/pruneCache.ts b/packages/cli/src/commands/cache/pruneCache.ts
index c96188767..c22ed7812 100644
--- a/packages/cli/src/commands/cache/pruneCache.ts
+++ b/packages/cli/src/commands/cache/pruneCache.ts
@@ -11,7 +11,7 @@ export interface PruneCacheOptions {
   pruneDays: number;
 }
 
-export async function pruneCache(options: PruneCacheOptions) {
+export async function pruneCache(options: PruneCacheOptions): Promise<void> {
   const { logger, cwd, pruneDays } = options;
 
   const config = await getConfig(cwd);
diff --git a/packages/cli/src/commands/cache/runners/ClearCacheRunner.ts b/packages/cli/src/commands/cache/runners/ClearCacheRunner.ts
index ff5c25c1e..453d0468d 100644
--- a/packages/cli/src/commands/cache/runners/ClearCacheRunner.ts
+++ b/packages/cli/src/commands/cache/runners/ClearCacheRunner.ts
@@ -4,7 +4,7 @@ import path from "path";
 import { rm, stat, unlink } from "fs/promises";
 
 export class ClearCacheRunner implements TargetRunner {
-  async shouldRun() {
+  async shouldRun(): Promise<boolean> {
     return true;
   }
   async run(runOptions: TargetRunnerOptions): Promise<void> {
diff --git a/packages/cli/src/commands/cache/runners/PruneCacheRunner.ts b/packages/cli/src/commands/cache/runners/PruneCacheRunner.ts
index 8b4df0a1a..4d9a5c4d2 100644
--- a/packages/cli/src/commands/cache/runners/PruneCacheRunner.ts
+++ b/packages/cli/src/commands/cache/runners/PruneCacheRunner.ts
@@ -6,7 +6,7 @@ import { rm, stat, unlink } from "fs/promises";
 const MS_IN_A_DAY = 1000 * 60 * 60 * 24;
 
 export class PruneCacheRunner implements TargetRunner {
-  async shouldRun() {
+  async shouldRun(): Promise<boolean> {
     return true;
   }
   async run(runOptions: TargetRunnerOptions): Promise<void> {
diff --git a/packages/cli/src/commands/exec/action.ts b/packages/cli/src/commands/exec/action.ts
index 0a90002a6..169633e77 100644
--- a/packages/cli/src/commands/exec/action.ts
+++ b/packages/cli/src/commands/exec/action.ts
@@ -18,7 +18,7 @@ interface ExecRemoteOptions extends ExecOptions {
   tasks: string[];
 }
 
-export async function execAction(options: ExecOptions, command: Command) {
+export async function execAction(options: ExecOptions, command: Command): Promise<void> {
   const cwd = options.cwd ?? process.cwd();
   const config = await getConfig(cwd);
   const logger = createLogger();
diff --git a/packages/cli/src/commands/exec/executeInProcess.ts b/packages/cli/src/commands/exec/executeInProcess.ts
index c2821ec60..7514e756b 100644
--- a/packages/cli/src/commands/exec/executeInProcess.ts
+++ b/packages/cli/src/commands/exec/executeInProcess.ts
@@ -80,7 +80,7 @@ function parsePackageInfoFromArgs(root: string, cwd: string | undefined, package
   };
 }
 
-export async function executeInProcess({ cwd, args, nodeArg, logger }: ExecuteInProcessOptions) {
+export async function executeInProcess({ cwd, args, nodeArg, logger }: ExecuteInProcessOptions): Promise<void> {
   const root = getWorkspaceManagerRoot(process.cwd())!;
   const config = await getConfig(root);
   const { pipeline } = config;
diff --git a/packages/cli/src/commands/exec/executeRemotely.ts b/packages/cli/src/commands/exec/executeRemotely.ts
index a4a33dc6b..11fdeef01 100644
--- a/packages/cli/src/commands/exec/executeRemotely.ts
+++ b/packages/cli/src/commands/exec/executeRemotely.ts
@@ -93,7 +93,7 @@ async function executeOnServer(args: string[], client: LageClient, logger: Logge
   }
 }
 
-export async function executeRemotely(options: ExecRemotelyOptions, command: Command) {
+export async function executeRemotely(options: ExecRemotelyOptions, command: Command): Promise<void> {
   // launch a 'lage-server.js' process, detached if it is not already running
   // send the command to the server process
   const { server, tasks, nodeArg } = options;
diff --git a/packages/cli/src/commands/exec/expandTargetDefinition.ts b/packages/cli/src/commands/exec/expandTargetDefinition.ts
index 18371b070..4cf4ed636 100644
--- a/packages/cli/src/commands/exec/expandTargetDefinition.ts
+++ b/packages/cli/src/commands/exec/expandTargetDefinition.ts
@@ -1,6 +1,12 @@
 import { type PipelineDefinition } from "@lage-run/config";
+import { type TargetConfig } from "@lage-run/target-graph";
 
-export function expandTargetDefinition(packageName: string | undefined, task: string, pipeline: PipelineDefinition, outputs: string[]) {
+export function expandTargetDefinition(
+  packageName: string | undefined,
+  task: string,
+  pipeline: PipelineDefinition,
+  outputs: string[]
+): TargetConfig {
   const id = packageName ? `${packageName}#${task}` : task;
   const emptyDefinition = {
     cache: false,
diff --git a/packages/cli/src/commands/exec/index.ts b/packages/cli/src/commands/exec/index.ts
index 2fc03c143..d89358643 100644
--- a/packages/cli/src/commands/exec/index.ts
+++ b/packages/cli/src/commands/exec/index.ts
@@ -2,7 +2,7 @@ import { Command } from "commander";
 import { execAction } from "./action.js";
 import { addOptions } from "../addOptions.js";
 
-const command = new Command("exec");
+const command: Command = new Command("exec");
 addOptions("pool", command);
 addOptions("runner", command);
 addOptions("server", command);
diff --git a/packages/cli/src/commands/exec/simulateFileAccess.ts b/packages/cli/src/commands/exec/simulateFileAccess.ts
index 0d69e38b5..07e86cb00 100644
--- a/packages/cli/src/commands/exec/simulateFileAccess.ts
+++ b/packages/cli/src/commands/exec/simulateFileAccess.ts
@@ -2,7 +2,7 @@ import type { Logger } from "@lage-run/logger";
 import path from "path";
 import fs from "fs";
 
-export async function simulateFileAccess(logger: Logger, root: string, inputs: string[], outputs: string[]) {
+export async function simulateFileAccess(logger: Logger, root: string, inputs: string[], outputs: string[]): Promise<void> {
   logger.silly("Now probing and touching inputs and outputs");
 
   // Helper to get all directory parts up to root
diff --git a/packages/cli/src/commands/info/action.ts b/packages/cli/src/commands/info/action.ts
index c089697e0..d91b8c46c 100644
--- a/packages/cli/src/commands/info/action.ts
+++ b/packages/cli/src/commands/info/action.ts
@@ -94,7 +94,7 @@ interface PackageTask {
  *   ...
  * ]
  */
-export async function infoAction(options: InfoActionOptions, command: Command) {
+export async function infoAction(options: InfoActionOptions, command: Command): Promise<void> {
   const cwd = process.cwd();
   const config = await getConfig(cwd);
   const logger = createLogger();
diff --git a/packages/cli/src/commands/info/index.ts b/packages/cli/src/commands/info/index.ts
index 0453ca6f6..3f46dd311 100644
--- a/packages/cli/src/commands/info/index.ts
+++ b/packages/cli/src/commands/info/index.ts
@@ -2,7 +2,7 @@ import { Command } from "commander";
 import { infoAction } from "./action.js";
 import { addOptions } from "../addOptions.js";
 
-const command = new Command("info");
+const command: Command = new Command("info");
 addOptions("server", command);
 addOptions("runner", command);
 addOptions("logger", command);
diff --git a/packages/cli/src/commands/init/action.ts b/packages/cli/src/commands/init/action.ts
index a56744b01..7cdf9c4e3 100644
--- a/packages/cli/src/commands/init/action.ts
+++ b/packages/cli/src/commands/init/action.ts
@@ -6,7 +6,7 @@ import execa from "execa";
 
 type WorkspaceManager = "rush" | "pnpm" | "yarn" | "npm";
 
-export async function initAction() {
+export async function initAction(): Promise<void> {
   const cwd = process.cwd();
 
   const config = await readConfigFile(cwd);
diff --git a/packages/cli/src/commands/init/index.ts b/packages/cli/src/commands/init/index.ts
index df653b672..35f1b7a15 100644
--- a/packages/cli/src/commands/init/index.ts
+++ b/packages/cli/src/commands/init/index.ts
@@ -1,7 +1,7 @@
 import { Command } from "commander";
 import { initAction } from "./action.js";
 
-const initCommand = new Command("init");
+const initCommand: Command = new Command("init");
 
 initCommand.description("Install lage in a workspace and create a config file").action(initAction);
 
diff --git a/packages/cli/src/commands/initializeReporters.ts b/packages/cli/src/commands/initializeReporters.ts
index f103e3dac..40ad3d94d 100644
--- a/packages/cli/src/commands/initializeReporters.ts
+++ b/packages/cli/src/commands/initializeReporters.ts
@@ -1,5 +1,5 @@
 import { createReporter } from "./createReporter.js";
-import type { Logger } from "@lage-run/logger";
+import type { LogStructuredData, Logger, Reporter } from "@lage-run/logger";
 import {
   type BuiltInReporterName,
   type ReporterInitOptions,
@@ -8,7 +8,11 @@ import {
   logBuiltInReporterNames,
 } from "../types/ReporterInitOptions.js";
 
-export async function initializeReporters(logger: Logger, options: ReporterInitOptions, customReporters: Record<string, string> = {}) {
+export async function initializeReporters(
+  logger: Logger,
+  options: ReporterInitOptions,
+  customReporters: Record<string, string> = {}
+): Promise<Reporter<LogStructuredData>[]> {
   const customReporterNames = Object.keys(customReporters);
 
   // Mapping from lowercase reporter name to original name
diff --git a/packages/cli/src/commands/isRunningFromCI.ts b/packages/cli/src/commands/isRunningFromCI.ts
index b2ec496b7..dd86cb254 100644
--- a/packages/cli/src/commands/isRunningFromCI.ts
+++ b/packages/cli/src/commands/isRunningFromCI.ts
@@ -1 +1 @@
-export const isRunningFromCI = process.env.NODE_ENV !== "test" && (!!process.env.CI || !!process.env.TF_BUILD);
+export const isRunningFromCI: boolean = process.env.NODE_ENV !== "test" && (!!process.env.CI || !!process.env.TF_BUILD);
diff --git a/packages/cli/src/commands/launchServerInBackground.ts b/packages/cli/src/commands/launchServerInBackground.ts
index ea170f807..c8c078832 100644
--- a/packages/cli/src/commands/launchServerInBackground.ts
+++ b/packages/cli/src/commands/launchServerInBackground.ts
@@ -25,7 +25,7 @@ export async function launchServerInBackground({
   timeout,
   args,
   nodeArg,
-}: launchServerInBackgroundOptions) {
+}: launchServerInBackgroundOptions): Promise<void> {
   const lockfilePath = path.join(root, `node_modules/.cache/lage/.lage-server-${host}-${port}.pid`);
 
   logger.info(`Starting server on http://${host}:${port}`);
diff --git a/packages/cli/src/commands/options.ts b/packages/cli/src/commands/options.ts
index 1f839024c..e693ebc85 100644
--- a/packages/cli/src/commands/options.ts
+++ b/packages/cli/src/commands/options.ts
@@ -3,7 +3,20 @@ import { logBuiltInReporterNames } from "../types/ReporterInitOptions.js";
 
 const isCI = process.env.CI || process.env.TF_BUILD;
 
-const options = {
+interface Options {
+  // Groupings of options
+  logger: { [key: string]: Option };
+  pool: { [key: string]: Option };
+  runner: { [key: string]: Option };
+  run: { [key: string]: Option };
+  server: { [key: string]: Option };
+  filter: { [key: string]: Option };
+  affected: { [key: string]: Option };
+  cache: { [key: string]: Option };
+  info: { [key: string]: Option };
+}
+
+const options: Options = {
   logger: {
     reporter: new Option("--reporter <reporter...>", `log reporter (built-in choices: ${logBuiltInReporterNames.join(", ")})`),
     grouped: new Option("--grouped", "groups the logs").default(false),
@@ -75,7 +88,7 @@ const options = {
   },
 } as const;
 
-const optionsWithEnv = addEnvOptions(options);
+const optionsWithEnv: Options = addEnvOptions(options);
 
 function addEnvOptions(opts: typeof options) {
   for (const key in opts) {
diff --git a/packages/cli/src/commands/parseServerOption.ts b/packages/cli/src/commands/parseServerOption.ts
index 939ed4e18..275efe45d 100644
--- a/packages/cli/src/commands/parseServerOption.ts
+++ b/packages/cli/src/commands/parseServerOption.ts
@@ -1,4 +1,7 @@
-export function parseServerOption(server: boolean | string | undefined) {
+export function parseServerOption(server: boolean | string | undefined): {
+  host: string;
+  port: number;
+} {
   const isBooleanAndTrue = typeof server === "boolean" && server;
   const isEmptyServer = typeof server === "undefined" || server === false;
   const serverString = isBooleanAndTrue ? "localhost:5332" : isEmptyServer ? "localhost:5332" : server;
diff --git a/packages/cli/src/commands/run/action.ts b/packages/cli/src/commands/run/action.ts
index be8770867..f94226c89 100644
--- a/packages/cli/src/commands/run/action.ts
+++ b/packages/cli/src/commands/run/action.ts
@@ -23,7 +23,7 @@ interface RunOptions extends ReporterInitOptions {
   allowNoTargetRuns: boolean;
 }
 
-export async function action(options: RunOptions, command: Command) {
+export async function action(options: RunOptions, command: Command): Promise<void> {
   if (options.watch) {
     return watchAction(options, command);
   } else {
diff --git a/packages/cli/src/commands/run/createTargetGraph.ts b/packages/cli/src/commands/run/createTargetGraph.ts
index 7056315aa..ebfbcef67 100644
--- a/packages/cli/src/commands/run/createTargetGraph.ts
+++ b/packages/cli/src/commands/run/createTargetGraph.ts
@@ -1,5 +1,5 @@
 import type { Logger } from "@lage-run/logger";
-import { WorkspaceTargetGraphBuilder } from "@lage-run/target-graph";
+import { type TargetGraph, WorkspaceTargetGraphBuilder } from "@lage-run/target-graph";
 import type { PackageInfos } from "workspace-tools";
 import { getBranchChanges, getDefaultRemoteBranch, getStagedChanges, getUnstagedChanges, getUntrackedChanges } from "workspace-tools";
 import { getFilteredPackages } from "../../filter/getFilteredPackages.js";
@@ -38,7 +38,7 @@ function getChangedFiles(since: string, cwd: string) {
   return changes;
 }
 
-export async function createTargetGraph(options: CreateTargetGraphOptions) {
+export async function createTargetGraph(options: CreateTargetGraphOptions): Promise<TargetGraph> {
   const {
     logger,
     root,
diff --git a/packages/cli/src/commands/run/filterArgsForTasks.ts b/packages/cli/src/commands/run/filterArgsForTasks.ts
index 740746319..578976a7d 100644
--- a/packages/cli/src/commands/run/filterArgsForTasks.ts
+++ b/packages/cli/src/commands/run/filterArgsForTasks.ts
@@ -1,4 +1,7 @@
-export function filterArgsForTasks(args: string[]) {
+export function filterArgsForTasks(args: string[]): {
+  tasks: string[];
+  taskArgs: string[];
+} {
   const optionsPosition = args.findIndex((arg) => arg.startsWith("-"));
   return {
     tasks: args.slice(0, optionsPosition === -1 ? undefined : optionsPosition),
diff --git a/packages/cli/src/commands/run/filterPipelineDefinitions.ts b/packages/cli/src/commands/run/filterPipelineDefinitions.ts
index cde3a1905..59984c1f1 100644
--- a/packages/cli/src/commands/run/filterPipelineDefinitions.ts
+++ b/packages/cli/src/commands/run/filterPipelineDefinitions.ts
@@ -1,7 +1,7 @@
 import type { Target } from "@lage-run/target-graph";
 import type { PipelineDefinition } from "@lage-run/config";
 
-export function filterPipelineDefinitions(targets: IterableIterator<Target>, pipeline: PipelineDefinition) {
+export function filterPipelineDefinitions(targets: IterableIterator<Target>, pipeline: PipelineDefinition): PipelineDefinition {
   const tasksSet = new Set<string>();
 
   for (const target of targets) {
diff --git a/packages/cli/src/commands/run/index.ts b/packages/cli/src/commands/run/index.ts
index 2ae333c96..1a0465145 100644
--- a/packages/cli/src/commands/run/index.ts
+++ b/packages/cli/src/commands/run/index.ts
@@ -2,7 +2,7 @@ import { Command } from "commander";
 import { action } from "./action.js";
 import { addOptions } from "../addOptions.js";
 
-const command = new Command("run");
+const command: Command = new Command("run");
 
 addOptions("filter", command);
 addOptions("logger", command);
diff --git a/packages/cli/src/commands/run/runAction.ts b/packages/cli/src/commands/run/runAction.ts
index 03a656374..a02a92ed8 100644
--- a/packages/cli/src/commands/run/runAction.ts
+++ b/packages/cli/src/commands/run/runAction.ts
@@ -31,7 +31,7 @@ interface RunOptions extends ReporterInitOptions, FilterOptions {
   allowNoTargetRuns: boolean;
 }
 
-export async function runAction(options: RunOptions, command: Command) {
+export async function runAction(options: RunOptions, command: Command): Promise<void> {
   const cwd = process.cwd();
   const config = await getConfig(cwd);
 
diff --git a/packages/cli/src/commands/run/watchAction.ts b/packages/cli/src/commands/run/watchAction.ts
index f164889fb..534932586 100644
--- a/packages/cli/src/commands/run/watchAction.ts
+++ b/packages/cli/src/commands/run/watchAction.ts
@@ -30,7 +30,7 @@ interface RunOptions extends ReporterInitOptions, FilterOptions {
   allowNoTargetRuns: boolean;
 }
 
-export async function watchAction(options: RunOptions, command: Command) {
+export async function watchAction(options: RunOptions, command: Command): Promise<void> {
   const cwd = process.cwd();
   const config = await getConfig(cwd);
   const concurrency = getConcurrency(options.concurrency, config.concurrency);
diff --git a/packages/cli/src/commands/server/MemoryStream.ts b/packages/cli/src/commands/server/MemoryStream.ts
index f45d7b651..33083c344 100644
--- a/packages/cli/src/commands/server/MemoryStream.ts
+++ b/packages/cli/src/commands/server/MemoryStream.ts
@@ -8,8 +8,8 @@ export class MemoryStream extends Writable {
     this.chunks = [];
   }
 
-  _write(chunk: any, encoding: BufferEncoding) {
-    this.chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding));
+  _write(chunk: unknown, encoding: BufferEncoding): void {
+    this.chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk as any, encoding));
   }
 
   getData(): Buffer {
diff --git a/packages/cli/src/commands/server/action.ts b/packages/cli/src/commands/server/action.ts
index 7a04776b6..51d5deff3 100644
--- a/packages/cli/src/commands/server/action.ts
+++ b/packages/cli/src/commands/server/action.ts
@@ -14,7 +14,7 @@ interface WorkerOptions extends ReporterInitOptions {
   tasks: string[];
 }
 
-export async function serverAction(options: WorkerOptions) {
+export async function serverAction(options: WorkerOptions): Promise<void> {
   const { server = "localhost:5332", timeout = 1, tasks } = options;
 
   const { host, port } = parseServerOption(server);
diff --git a/packages/cli/src/commands/server/getOutputFiles.ts b/packages/cli/src/commands/server/getOutputFiles.ts
index edf3cb3c8..f0c9d77c4 100644
--- a/packages/cli/src/commands/server/getOutputFiles.ts
+++ b/packages/cli/src/commands/server/getOutputFiles.ts
@@ -5,7 +5,7 @@ import type { Target } from "@lage-run/target-graph";
 
 import path from "path";
 
-export function getOutputFiles(root: string, target: Target, outputGlob: CacheOptions["outputGlob"], packageTree: PackageTree) {
+export function getOutputFiles(root: string, target: Target, outputGlob: CacheOptions["outputGlob"], packageTree: PackageTree): string[] {
   const patterns = target.outputs ?? outputGlob ?? ["**/*"];
 
   const sourceControlledFiles = new Set(packageTree.getPackageFiles(target.packageName ?? "", patterns));
diff --git a/packages/cli/src/commands/server/index.ts b/packages/cli/src/commands/server/index.ts
index b275f7a4a..fb72645e3 100644
--- a/packages/cli/src/commands/server/index.ts
+++ b/packages/cli/src/commands/server/index.ts
@@ -2,7 +2,7 @@ import { Command } from "commander";
 import { serverAction } from "./action.js";
 import { addOptions } from "../addOptions.js";
 
-const command = new Command("server");
+const command: Command = new Command("server");
 
 command.action(serverAction);
 addOptions("server", command);
diff --git a/packages/cli/src/commands/targetHashFilePath.ts b/packages/cli/src/commands/targetHashFilePath.ts
index cb21b3376..4786a3503 100644
--- a/packages/cli/src/commands/targetHashFilePath.ts
+++ b/packages/cli/src/commands/targetHashFilePath.ts
@@ -1,9 +1,9 @@
 import path from "path";
 
-export function getHashFilePath(target: { task: string }) {
+export function getHashFilePath(target: { task: string }): string {
   return path.join(`node_modules/.lage/hash_${target.task}`);
 }
 
-export function getGlobalInputHashFilePath(target: { task: string }) {
+export function getGlobalInputHashFilePath(target: { task: string }): string {
   return path.join(`node_modules/.lage/global_inputs_hash_${target.task}`);
 }
diff --git a/packages/cli/src/filter/getFilteredPackages.ts b/packages/cli/src/filter/getFilteredPackages.ts
index e8f2cd681..605899cf0 100644
--- a/packages/cli/src/filter/getFilteredPackages.ts
+++ b/packages/cli/src/filter/getFilteredPackages.ts
@@ -14,7 +14,7 @@ export function getFilteredPackages(options: {
   repoWideChanges: string[];
   includeDependents: boolean;
   includeDependencies: boolean;
-}) {
+}): string[] {
   const { scope, since, sinceIgnoreGlobs, repoWideChanges, includeDependents, includeDependencies, logger, packageInfos, root } = options;
 
   // If scoped is defined, get scoped packages
@@ -78,7 +78,7 @@ export function filterPackages(options: {
   includeDependencies: boolean;
   scopedPackages: string[] | undefined;
   changedPackages: string[] | undefined;
-}) {
+}): string[] {
   const { scopedPackages, changedPackages, packageInfos, includeDependents, includeDependencies, logger } = options;
 
   let filtered: string[] = [];
diff --git a/packages/cli/src/filter/hasRepoChanged.ts b/packages/cli/src/filter/hasRepoChanged.ts
index abfcad38e..711435863 100644
--- a/packages/cli/src/filter/hasRepoChanged.ts
+++ b/packages/cli/src/filter/hasRepoChanged.ts
@@ -2,7 +2,7 @@ import { getBranchChanges } from "workspace-tools";
 import * as fg from "fast-glob";
 import type { Logger } from "@lage-run/logger";
 
-export function hasRepoChanged(since: string, root: string, environmentGlob: string[], logger: Logger) {
+export function hasRepoChanged(since: string, root: string, environmentGlob: string[], logger: Logger): boolean {
   try {
     const changedFiles = getBranchChanges(since, root);
     const envFiles = fg.sync(environmentGlob, { cwd: root });
diff --git a/packages/cli/src/getBinPaths.ts b/packages/cli/src/getBinPaths.ts
index d6afe7b08..100034d09 100644
--- a/packages/cli/src/getBinPaths.ts
+++ b/packages/cli/src/getBinPaths.ts
@@ -14,7 +14,10 @@ function findUp(name: string, dir: string) {
   return undefined;
 }
 
-export function getBinPaths() {
+export function getBinPaths(): {
+  lage: string;
+  "lage-server": string;
+} {
   const bins = os.platform() === "win32" ? ["lage.cmd", "lage-server.cmd"] : ["lage", "lage-server"];
   const binPaths = bins.map((bin) => findUp("node_modules/.bin/" + bin, __dirname));
 
@@ -25,7 +28,10 @@ export function getBinPaths() {
   return { lage: binPaths[0]!, "lage-server": binPaths[1]! };
 }
 
-export function getBinScripts() {
+export function getBinScripts(): {
+  lage: string;
+  "lage-server": string;
+} {
   const thisPackageJsonPath = findUp("package.json", __dirname);
 
   if (!thisPackageJsonPath) {
diff --git a/packages/cli/src/showHelp.ts b/packages/cli/src/showHelp.ts
index a7fba311b..1a5b9db13 100644
--- a/packages/cli/src/showHelp.ts
+++ b/packages/cli/src/showHelp.ts
@@ -1,6 +1,6 @@
 /* eslint-disable no-console */
 
-export function showHelp(msg: string) {
+export function showHelp(msg: string): void {
   console.error(msg);
 
   console.log(`
diff --git a/packages/cli/src/types/ReporterInitOptions.ts b/packages/cli/src/types/ReporterInitOptions.ts
index 73b8f8a9d..b563dac7d 100644
--- a/packages/cli/src/types/ReporterInitOptions.ts
+++ b/packages/cli/src/types/ReporterInitOptions.ts
@@ -32,10 +32,12 @@ const shouldListBuiltInReporters: Record<BuiltInReporterName, boolean> = {
 };
 
 /** All the built-in reporter names */
-export const builtInReporterNames = Object.keys(shouldListBuiltInReporters);
+export const builtInReporterNames: string[] = Object.keys(shouldListBuiltInReporters);
 
 /** Built-in reporter names that should be listed in doc output */
-export const logBuiltInReporterNames = builtInReporterNames.filter((name) => shouldListBuiltInReporters[name as BuiltInReporterName]);
+export const logBuiltInReporterNames: string[] = builtInReporterNames.filter(
+  (name) => shouldListBuiltInReporters[name as BuiltInReporterName]
+);
 
 export interface ReporterInitOptions {
   reporter: ReporterName[] | ReporterName | undefined;
diff --git a/packages/cli/src/types/errors.ts b/packages/cli/src/types/errors.ts
index ddaaf0bc6..472409ee0 100644
--- a/packages/cli/src/types/errors.ts
+++ b/packages/cli/src/types/errors.ts
@@ -1 +1 @@
-export const NoTargetFoundError = new Error("No target found");
+export const NoTargetFoundError: Error = new Error("No target found");
diff --git a/packages/config/src/getMaxWorkersPerTask.ts b/packages/config/src/getMaxWorkersPerTask.ts
index d350bd4fd..737fc91c0 100644
--- a/packages/config/src/getMaxWorkersPerTask.ts
+++ b/packages/config/src/getMaxWorkersPerTask.ts
@@ -1,6 +1,6 @@
 import type { ConfigOptions } from "./types/ConfigOptions.js";
 
-export function getMaxWorkersPerTask(pipelineConfig: ConfigOptions["pipeline"], concurrency: number) {
+export function getMaxWorkersPerTask(pipelineConfig: ConfigOptions["pipeline"], concurrency: number): Map<string, number> {
   const maxWorkersPerTask = new Map<string, number>();
 
   let generalPoolCount = 0;
@@ -58,7 +58,7 @@ export function getMaxWorkersPerTask(pipelineConfig: ConfigOptions["pipeline"],
   return maxWorkersPerTask;
 }
 
-export function getMaxWorkersPerTaskFromOptions(maxWorkersPerTask: string[]) {
+export function getMaxWorkersPerTaskFromOptions(maxWorkersPerTask: string[]): Map<string, number> {
   return new Map([
     ...maxWorkersPerTask.map((setting) => {
       const [task, maxWorkers] = setting.split(/[=:]/);
diff --git a/packages/e2e-tests/src/killDetachedProcess.ts b/packages/e2e-tests/src/killDetachedProcess.ts
index 857afd6e6..9dc636bdc 100644
--- a/packages/e2e-tests/src/killDetachedProcess.ts
+++ b/packages/e2e-tests/src/killDetachedProcess.ts
@@ -1,6 +1,6 @@
 import { execSync } from "child_process";
 
-export function killDetachedProcess(pid: number | string) {
+export function killDetachedProcess(pid: number | string): void {
   const pidNumber = typeof pid === "string" ? parseInt(pid) : pid;
   try {
     if (process.platform !== "win32") {
diff --git a/packages/e2e-tests/src/mock/monorepo.ts b/packages/e2e-tests/src/mock/monorepo.ts
index 057f177de..ca2f48aa1 100644
--- a/packages/e2e-tests/src/mock/monorepo.ts
+++ b/packages/e2e-tests/src/mock/monorepo.ts
@@ -6,15 +6,15 @@ import * as execa from "execa";
 import { glob } from "@lage-run/globby";
 
 export class Monorepo {
-  static tmpdir = os.tmpdir();
+  static tmpdir: string = os.tmpdir();
 
   root: string;
   nodeModulesPath: string;
   yarnPath: string;
 
-  static externalPackageJsonGlobs = ["node_modules/glob-hasher/package.json", "node_modules/glob-hasher-*/package.json"];
+  static externalPackageJsonGlobs: string[] = ["node_modules/glob-hasher/package.json", "node_modules/glob-hasher-*/package.json"];
 
-  static externalPackageJsons = glob(Monorepo.externalPackageJsonGlobs, {
+  static externalPackageJsons: string[] = glob(Monorepo.externalPackageJsonGlobs, {
     cwd: path.join(__dirname, "..", "..", "..", ".."),
     gitignore: false,
   })!.map((f) => path.resolve(path.join(__dirname, "..", "..", "..", ".."), f));
@@ -25,7 +25,7 @@ export class Monorepo {
     this.yarnPath = path.join(this.root, ".yarn", "yarn.js");
   }
 
-  init() {
+  init(): void {
     const options = { cwd: this.root };
     execa.sync("git", ["init"], options);
     execa.sync("git", ["config", "user.email", "you@example.com"], options);
@@ -34,7 +34,7 @@ export class Monorepo {
     this.generateRepoFiles();
   }
 
-  install() {
+  install(): void {
     for (const packagePath of Monorepo.externalPackageJsons.map((p) => path.dirname(p))) {
       const name = JSON.parse(fs.readFileSync(path.join(packagePath, "package.json"), "utf-8")).name;
       fs.cpSync(packagePath, path.join(this.root, "node_modules", name), { recursive: true });
@@ -44,7 +44,7 @@ export class Monorepo {
     execa.sync(`"${process.execPath}"`, [`"${this.yarnPath}"`, "install", "--no-immutable"], { cwd: this.root, shell: true });
   }
 
-  generateRepoFiles() {
+  generateRepoFiles(): void {
     this.commitFiles({
       ".yarnrc.yml": `yarnPath: "${this.yarnPath.replace(/\\/g, "/")}"\ncacheFolder: "${this.root.replace(
         /\\/g,
@@ -84,13 +84,13 @@ export class Monorepo {
     });
   }
 
-  setLageConfig(contents: string) {
+  setLageConfig(contents: string): void {
     this.commitFiles({
       "lage.config.js": contents,
     });
   }
 
-  addPackage(name: string, internalDeps: string[] = [], scripts?: { [script: string]: string }) {
+  addPackage(name: string, internalDeps: string[] = [], scripts?: { [script: string]: string }): void {
     return this.commitFiles({
       [`packages/${name}/build.js`]: `console.log('building ${name}');`,
       [`packages/${name}/test.js`]: `console.log('testing ${name}');`,
@@ -114,15 +114,15 @@ export class Monorepo {
     });
   }
 
-  clone(origin: string) {
+  clone(origin: string): execa.ExecaSyncReturnValue {
     return execa.sync("git", ["clone", origin], { cwd: this.root });
   }
 
-  push(origin: string, branch: string) {
+  push(origin: string, branch: string): execa.ExecaSyncReturnValue {
     return execa.sync("git", ["push", origin, branch], { cwd: this.root });
   }
 
-  commitFiles(files: { [name: string]: string | Record<string, unknown> }, options: { executable?: boolean } = {}) {
+  commitFiles(files: { [name: string]: string | Record<string, unknown> }, options: { executable?: boolean } = {}): void {
     for (const [file, contents] of Object.entries(files)) {
       let out = "";
       if (typeof contents !== "string") {
@@ -151,14 +151,14 @@ export class Monorepo {
     execa.sync("git", ["commit", "-m", "commit files"], { cwd: this.root });
   }
 
-  run(command: string, args?: string[], silent?: boolean, options?: Partial<execa.SyncOptions>) {
+  run(command: string, args?: string[], silent?: boolean, options?: Partial<execa.SyncOptions>): execa.ExecaSyncReturnValue {
     return execa.sync(process.execPath, [this.yarnPath, ...(silent === true ? ["--silent"] : []), command, ...(args || [])], {
       cwd: this.root,
       ...options,
     });
   }
 
-  runServer(tasks: string[]) {
+  runServer(tasks: string[]): execa.ExecaChildProcess<string> {
     const cp = execa.default(process.execPath, [path.join(this.root, "node_modules/lage/dist/lage-server.js"), "--tasks", ...tasks], {
       cwd: this.root,
       detached: true,
@@ -172,7 +172,7 @@ export class Monorepo {
     return cp;
   }
 
-  async cleanup() {
+  async cleanup(): Promise<void> {
     const maxRetries = 5;
     let attempts = 0;
 
diff --git a/packages/e2e-tests/src/parseNdJson.ts b/packages/e2e-tests/src/parseNdJson.ts
index d51a2e628..47e9420b2 100644
--- a/packages/e2e-tests/src/parseNdJson.ts
+++ b/packages/e2e-tests/src/parseNdJson.ts
@@ -1,6 +1,6 @@
 import type { TargetStatus } from "@lage-run/scheduler-types";
 
-export function parseNdJson(ndjson: string) {
+export function parseNdJson(ndjson: string): any[] {
   const entries = ndjson.substr(ndjson.indexOf("{"));
   return entries
     .split("\n")
@@ -20,6 +20,12 @@ export function parseNdJson(ndjson: string) {
     .filter((entry) => Object.keys(entry).length > 0);
 }
 
-export function filterEntry(data: any, pkg: string, task: string, status: TargetStatus) {
+export function filterEntry(
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  data: any,
+  pkg: string,
+  task: string,
+  status: TargetStatus
+): boolean {
   return data?.target?.packageName === pkg && data?.target?.task === task && data.status === status;
 }
diff --git a/packages/format-hrtime/src/formatDuration.ts b/packages/format-hrtime/src/formatDuration.ts
index 99df72c9c..7cd3e48cf 100644
--- a/packages/format-hrtime/src/formatDuration.ts
+++ b/packages/format-hrtime/src/formatDuration.ts
@@ -1,4 +1,4 @@
-export function formatDuration(seconds: string) {
+export function formatDuration(seconds: string): string {
   const raw = parseFloat(seconds);
   if (raw > 60) {
     const minutes = Math.floor(raw / 60);
@@ -10,7 +10,7 @@ export function formatDuration(seconds: string) {
   }
 }
 
-export function hrToSeconds(hrtime: [number, number]) {
+export function hrToSeconds(hrtime: [number, number]): string {
   const raw = hrtime[0] + hrtime[1] / 1e9;
   return raw.toFixed(2);
 }
diff --git a/packages/globby/package.json b/packages/globby/package.json
index 4a83dfc46..6da3263a4 100644
--- a/packages/globby/package.json
+++ b/packages/globby/package.json
@@ -12,7 +12,7 @@
     "dts-bundle-generator": "^9.5.1",
     "esbuild": "^0.25.0",
     "globby": "^14.0.2",
-    "typescript": "~5.0.3"
+    "typescript": "~5.9.3"
   },
   "exports": {
     ".": {
diff --git a/packages/globby/src/index.mts b/packages/globby/src/index.mts
index 4e152ca67..571349eea 100644
--- a/packages/globby/src/index.mts
+++ b/packages/globby/src/index.mts
@@ -6,7 +6,7 @@ function cacheKey(patterns: string[], options: Options = {}) {
   return JSON.stringify({ patterns, options });
 }
 
-export async function globAsync(patterns: string[], options?: Options) {
+export async function globAsync(patterns: string[], options?: Options): Promise<string[]> {
   const key = cacheKey(patterns, options);
   if (!cache.has(key)) {
     cache.set(key, await globby(patterns, options));
@@ -14,7 +14,7 @@ export async function globAsync(patterns: string[], options?: Options) {
   return cache.get(key) || [];
 }
 
-export function glob(patterns: string[], options?: Options) {
+export function glob(patterns: string[], options?: Options): string[] {
   const key = cacheKey(patterns, options);
   if (!cache.has(key)) {
     cache.set(key, globbySync(patterns, options));
diff --git a/packages/globby/tsconfig.json b/packages/globby/tsconfig.json
index 820d66a8d..a5ed253bf 100644
--- a/packages/globby/tsconfig.json
+++ b/packages/globby/tsconfig.json
@@ -3,9 +3,10 @@
   "compilerOptions": {
     "outDir": "./lib",
     "emitDeclarationOnly": true,
-    "module": "Node16"
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "lib": ["ES2020"]
   },
-  "files": [],
   "include": ["src/index.mts"],
   "exclude": ["lib/**/*.mts"]
 }
diff --git a/packages/hasher/src/FileHasher.ts b/packages/hasher/src/FileHasher.ts
index 065f849e8..15c7e4e0e 100644
--- a/packages/hasher/src/FileHasher.ts
+++ b/packages/hasher/src/FileHasher.ts
@@ -27,9 +27,9 @@ export class FileHasher {
     this.#manifestFile = path.join(cacheDirectory, "file_hashes.manifest");
   }
 
-  async getHashesFromGit() {
+  private getHashesFromGit(): void {
     const { root } = this.options;
-    const fileHashes = await getPackageDeps(root);
+    const fileHashes = getPackageDeps(root);
     const files = [...fileHashes.keys()];
     const fileStats = stat(files, { cwd: root }) ?? {};
 
@@ -45,12 +45,15 @@ export class FileHasher {
     this.writeManifest();
   }
 
-  async readManifest() {
+  public async readManifest(): Promise<void> {
     return new Promise<void>((resolve, reject) => {
       if (!fs.existsSync(this.#manifestFile)) {
-        this.getHashesFromGit()
-          .then(() => resolve())
-          .catch(reject);
+        try {
+          this.getHashesFromGit();
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
         return;
       }
 
@@ -79,7 +82,7 @@ export class FileHasher {
     });
   }
 
-  writeManifest() {
+  public writeManifest(): void {
     fs.mkdirSync(path.dirname(this.#manifestFile), { recursive: true });
     const outputLines = Object.entries(this.#store).map(([relativePath, info]) => {
       return `${relativePath}\0${info.mtime.toString()}\0${info.size.toString()}\0${info.hash}`;
@@ -88,7 +91,7 @@ export class FileHasher {
     fs.writeFileSync(this.#manifestFile, outputLines.join("\n"), "utf-8");
   }
 
-  hash(files: string[]) {
+  public hash(files: string[]): Record<string, string> {
     const hashes: Record<string, string> = {};
 
     const updatedFiles: string[] = [];
diff --git a/packages/hasher/src/PackageTree.ts b/packages/hasher/src/PackageTree.ts
index f5208b95e..2dc719931 100644
--- a/packages/hasher/src/PackageTree.ts
+++ b/packages/hasher/src/PackageTree.ts
@@ -31,14 +31,14 @@ export class PackageTree {
 
   constructor(private options: PackageTreeOptions) {}
 
-  reset() {
+  reset(): void {
     // reset the internal state
     this.#tree = { children: {}, isPackage: true };
     this.#packageFiles = {};
     this.#memoizedPackageFiles = {};
   }
 
-  async initialize() {
+  async initialize(): Promise<void> {
     const { root, includeUntracked, packageInfos } = this.options;
 
     this.reset();
@@ -77,7 +77,7 @@ export class PackageTree {
     }
   }
 
-  addToPackageTree(filePaths: string[]) {
+  addToPackageTree(filePaths: string[]): void {
     // key: path/to/package (packageRoot), value: array of a tuple of [file, hash]
     const packageFiles = this.#packageFiles;
 
@@ -108,7 +108,7 @@ export class PackageTree {
     }
   }
 
-  getPackageFiles(packageName: string, patterns: string[]) {
+  getPackageFiles(packageName: string, patterns: string[]): string[] {
     const { root, packageInfos } = this.options;
     const packagePath = path.relative(root, path.dirname(packageInfos[packageName].packageJsonPath)).replace(/\\/g, "/");
 
diff --git a/packages/hasher/src/TargetHasher.ts b/packages/hasher/src/TargetHasher.ts
index b697bccd8..74d4929b6 100644
--- a/packages/hasher/src/TargetHasher.ts
+++ b/packages/hasher/src/TargetHasher.ts
@@ -73,7 +73,7 @@ export class TargetHasher {
     dependents: new Map(),
   };
 
-  getPackageInfos(workspacePackages: WorkspaceInfos) {
+  getPackageInfos(workspacePackages: WorkspaceInfos): PackageInfos {
     const { root } = this.options;
     const packageInfos: PackageInfos = {};
 
@@ -114,13 +114,13 @@ export class TargetHasher {
     }
   }
 
-  ensureInitialized() {
+  ensureInitialized(): void {
     if (!this.initializedPromise) {
       throw new Error("TargetHasher is not initialized");
     }
   }
 
-  async initialize() {
+  async initialize(): Promise<void> {
     const { environmentGlob, root } = this.options;
 
     if (this.initializedPromise) {
@@ -228,7 +228,7 @@ export class TargetHasher {
     return hashString;
   }
 
-  writeTargetHashesManifest() {
+  writeTargetHashesManifest(): void {
     for (const [id, { fileHashes, globalFileHashes }] of Object.entries(this.targetHashesLog)) {
       const targetHashesManifestPath = path.join(this.targetHashesDirectory, `${id}.json`);
       if (!fs.existsSync(path.dirname(targetHashesManifestPath))) {
@@ -238,7 +238,7 @@ export class TargetHasher {
     }
   }
 
-  async getEnvironmentGlobHashes(root: string, target: Target) {
+  async getEnvironmentGlobHashes(root: string, target: Target): Promise<Record<string, string>> {
     const globalFileHashes = target.environmentGlob
       ? this.fileHasher.hash(await globAsync(target.environmentGlob ?? [], { cwd: root }))
       : (this.globalInputsHash ?? {});
@@ -246,7 +246,7 @@ export class TargetHasher {
     return globalFileHashes;
   }
 
-  async cleanup() {
+  async cleanup(): Promise<void> {
     this.writeTargetHashesManifest();
     await this.fileHasher.writeManifest();
   }
diff --git a/packages/hasher/src/__tests__/resolveDependenciesHelper.ts b/packages/hasher/src/__tests__/resolveDependenciesHelper.ts
index 54c61a57a..f3cddfa97 100644
--- a/packages/hasher/src/__tests__/resolveDependenciesHelper.ts
+++ b/packages/hasher/src/__tests__/resolveDependenciesHelper.ts
@@ -4,7 +4,7 @@ const fixturesPath = path.join(__dirname, "..", "__fixtures__");
 
 import { getYarnWorkspaces, getPnpmWorkspaces, getRushWorkspaces } from "workspace-tools";
 
-export async function filterDependenciesInYarnFixture(fixture: string, filterFunction: any) {
+export async function filterDependenciesInYarnFixture(fixture: string, filterFunction: any): Promise<any> {
   const monorepo = new Monorepo("monorepo");
   await monorepo.init(path.join(fixturesPath, fixture));
   const packageRoot = monorepo.root;
@@ -18,7 +18,7 @@ export async function filterDependenciesInYarnFixture(fixture: string, filterFun
   return filteredDependencies;
 }
 
-export async function filterDependenciesInPnpmFixture(fixture: string, filterFunction: any) {
+export async function filterDependenciesInPnpmFixture(fixture: string, filterFunction: any): Promise<any> {
   const monorepo = new Monorepo("monorepo");
   await monorepo.init(path.join(fixturesPath, fixture));
   const packageRoot = monorepo.root;
@@ -32,7 +32,7 @@ export async function filterDependenciesInPnpmFixture(fixture: string, filterFun
   return filteredDependencies;
 }
 
-export async function filterDependenciesInRushFixture(fixture: string, filterFunction: any) {
+export async function filterDependenciesInRushFixture(fixture: string, filterFunction: any): Promise<any> {
   const monorepo = new Monorepo("monorepo");
   await monorepo.init(path.join(fixturesPath, fixture));
   const packageRoot = monorepo.root;
diff --git a/packages/hasher/src/expandInputPatterns.ts b/packages/hasher/src/expandInputPatterns.ts
index 775938956..82843dac2 100644
--- a/packages/hasher/src/expandInputPatterns.ts
+++ b/packages/hasher/src/expandInputPatterns.ts
@@ -1,7 +1,7 @@
 import { type Target } from "@lage-run/target-graph";
 import { type DependencyMap } from "workspace-tools";
 
-export function expandInputPatterns(patterns: string[], target: Target, dependencyMap: DependencyMap) {
+export function expandInputPatterns(patterns: string[], target: Target, dependencyMap: DependencyMap): Record<string, string[]> {
   const expandedPatterns: Record<string, string[]> = {};
 
   for (const pattern of patterns) {
diff --git a/packages/hasher/src/getInputFiles.ts b/packages/hasher/src/getInputFiles.ts
index 9fe9c0971..257d0a6d6 100644
--- a/packages/hasher/src/getInputFiles.ts
+++ b/packages/hasher/src/getInputFiles.ts
@@ -3,7 +3,7 @@ import { type DependencyMap } from "workspace-tools";
 import { type PackageTree } from "./PackageTree.js";
 import { expandInputPatterns } from "./expandInputPatterns.js";
 
-export function getInputFiles(target: Target, dependencyMap: DependencyMap, packageTree: PackageTree) {
+export function getInputFiles(target: Target, dependencyMap: DependencyMap, packageTree: PackageTree): string[] {
   const inputs = target.inputs ?? ["**/*"];
 
   const packagePatterns = expandInputPatterns(inputs, target, dependencyMap);
diff --git a/packages/logger/src/Logger.ts b/packages/logger/src/Logger.ts
index 7657c7a3f..1ad0f10e3 100644
--- a/packages/logger/src/Logger.ts
+++ b/packages/logger/src/Logger.ts
@@ -6,7 +6,7 @@ import { createInterface } from "readline";
 export class Logger<TLogStructuredData extends LogStructuredData = LogStructuredData> {
   reporters: Reporter[] = [];
 
-  log(level: LogLevel, msg: string, data?: TLogStructuredData) {
+  log(level: LogLevel, msg: string, data?: TLogStructuredData): void {
     const entry = {
       timestamp: Date.now(),
       level,
@@ -19,27 +19,27 @@ export class Logger<TLogStructuredData extends LogStructuredData = LogStructured
     }
   }
 
-  info(msg: string, data?: TLogStructuredData) {
+  info(msg: string, data?: TLogStructuredData): void {
     this.log(LogLevel.info, msg, data);
   }
 
-  warn(msg: string, data?: TLogStructuredData) {
+  warn(msg: string, data?: TLogStructuredData): void {
     this.log(LogLevel.warn, msg, data);
   }
 
-  error(msg: string, data?: TLogStructuredData) {
+  error(msg: string, data?: TLogStructuredData): void {
     this.log(LogLevel.error, msg, data);
   }
 
-  verbose(msg: string, data?: TLogStructuredData) {
+  verbose(msg: string, data?: TLogStructuredData): void {
     this.log(LogLevel.verbose, msg, data);
   }
 
-  silly(msg: string, data?: TLogStructuredData) {
+  silly(msg: string, data?: TLogStructuredData): void {
     this.log(LogLevel.silly, msg, data);
   }
 
-  stream(level: LogLevel, input: NodeJS.ReadableStream, data?: TLogStructuredData) {
+  stream(level: LogLevel, input: NodeJS.ReadableStream, data?: TLogStructuredData): () => void {
     const readline = createInterface({
       input,
       crlfDelay: Infinity,
@@ -52,13 +52,13 @@ export class Logger<TLogStructuredData extends LogStructuredData = LogStructured
 
     readline.on("line", lineLogger);
 
-    return () => {
+    return (): void => {
       readline.off("line", lineLogger);
       readline.close();
     };
   }
 
-  addReporter(reporter: Reporter) {
+  addReporter(reporter: Reporter): void {
     this.reporters.push(reporter);
   }
 }
diff --git a/packages/logger/src/index.ts b/packages/logger/src/index.ts
index 55e587043..5c76b78df 100644
--- a/packages/logger/src/index.ts
+++ b/packages/logger/src/index.ts
@@ -1,7 +1,7 @@
 import type { LogStructuredData } from "./interfaces/LogStructuredData.js";
 import { Logger } from "./Logger.js";
 
-export default function createLogger<TLogStructuredData extends LogStructuredData = LogStructuredData>() {
+export default function createLogger<TLogStructuredData extends LogStructuredData = LogStructuredData>(): Logger<TLogStructuredData> {
   return new Logger<TLogStructuredData>();
 }
 
diff --git a/packages/monorepo-fixture/src/monorepo.ts b/packages/monorepo-fixture/src/monorepo.ts
index cb46d93f8..33f9a7b81 100644
--- a/packages/monorepo-fixture/src/monorepo.ts
+++ b/packages/monorepo-fixture/src/monorepo.ts
@@ -1,26 +1,25 @@
 import * as os from "os";
-import * as fs from "fs/promises";
-import { existsSync, mkdtempSync } from "fs";
+import * as fs from "fs";
 import * as path from "path";
 import execa from "execa";
 
 export class Monorepo {
-  static tmpdir = os.tmpdir();
+  static tmpdir: string = os.tmpdir();
 
   root: string;
 
   lagePath: string;
 
-  get nodeModulesPath() {
+  get nodeModulesPath(): string {
     return path.join(this.root, "node_modules");
   }
 
   constructor(private name: string) {
-    this.root = mkdtempSync(path.join(Monorepo.tmpdir, `monorepo-fixture-${name}-`));
+    this.root = fs.mkdtempSync(path.join(Monorepo.tmpdir, `monorepo-fixture-${name}-`));
     this.lagePath = path.join(this.nodeModulesPath, "@lage-run");
   }
 
-  async init(fixturePath?: string) {
+  async init(fixturePath?: string): Promise<void> {
     const options = { cwd: this.root };
     const cwd = this.root;
     await execa("git", ["init"], options);
@@ -29,8 +28,8 @@ export class Monorepo {
     await execa("git", ["config", "commit.gpgsign", "false"], options);
 
     if (fixturePath) {
-      await fs.mkdir(this.root, { recursive: true });
-      await fs.cp(fixturePath, this.root, { recursive: true });
+      fs.mkdirSync(this.root, { recursive: true });
+      fs.cpSync(fixturePath, this.root, { recursive: true });
 
       execa.sync("git", ["add", "."], { cwd });
       execa.sync("git", ["commit", "-m", "test"], { cwd });
@@ -39,26 +38,27 @@ export class Monorepo {
     }
   }
 
-  async install() {
-    if (!existsSync(this.nodeModulesPath)) {
-      await fs.mkdir(this.nodeModulesPath, { recursive: true });
+  async install(): Promise<void> {
+    if (!fs.existsSync(this.nodeModulesPath)) {
+      fs.mkdirSync(this.nodeModulesPath, { recursive: true });
     }
 
     // pretends to perform a npm install of lage
-    if (!existsSync(this.lagePath)) {
-      await fs.symlink(path.join(__dirname, "..", ".."), this.lagePath, "junction");
+    if (!fs.existsSync(this.lagePath)) {
+      fs.symlinkSync(path.join(__dirname, "..", ".."), this.lagePath, "junction");
     }
 
     const lagePackagePath = path.join(__dirname, "..", "..", "..");
-    const lagePackages = (await fs.readdir(lagePackagePath, { withFileTypes: true }))
+    const lagePackages = fs
+      .readdirSync(lagePackagePath, { withFileTypes: true })
       .filter((dirent) => dirent.isDirectory)
       .map((dirent) => dirent.name);
 
     // pretends to perform a npm install of lage
-    if (!existsSync(this.lagePath)) {
-      await fs.mkdir(this.lagePath, { recursive: true });
+    if (!fs.existsSync(this.lagePath)) {
+      fs.mkdirSync(this.lagePath, { recursive: true });
       for (const lagePackage of lagePackages) {
-        await fs.symlink(path.join(lagePackagePath, lagePackage), path.join(this.lagePath, lagePackage), "junction");
+        fs.symlinkSync(path.join(lagePackagePath, lagePackage), path.join(this.lagePath, lagePackage), "junction");
       }
     }
   }
@@ -66,19 +66,19 @@ export class Monorepo {
   /**
    * Simulates a "yarn" call by linking internal packages and generates a yarn.lock file
    */
-  async linkPackages() {
-    const pkgs = await fs.readdir(path.join(this.root, "packages"));
+  async linkPackages(): Promise<void> {
+    const pkgs = fs.readdirSync(path.join(this.root, "packages"));
 
-    if (!existsSync(this.nodeModulesPath)) {
-      await fs.mkdir(this.nodeModulesPath, { recursive: true });
+    if (!fs.existsSync(this.nodeModulesPath)) {
+      fs.mkdirSync(this.nodeModulesPath, { recursive: true });
     }
 
     let yarnYaml = `# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.\n# yarn lockfile v1\n`;
 
     for (const pkg of pkgs) {
-      await fs.symlink(path.join(this.root, "packages", pkg), path.join(this.nodeModulesPath, pkg), "junction");
+      fs.symlinkSync(path.join(this.root, "packages", pkg), path.join(this.nodeModulesPath, pkg), "junction");
 
-      const pkgJson = JSON.parse(await fs.readFile(path.join(this.root, "packages", pkg, "package.json"), "utf-8"));
+      const pkgJson = JSON.parse(fs.readFileSync(path.join(this.root, "packages", pkg, "package.json"), "utf-8"));
       const deps = pkgJson.dependencies;
 
       yarnYaml += `"${pkg}@^${pkgJson.version}":\n  version "${pkgJson.version}"\n`;
@@ -94,7 +94,7 @@ export class Monorepo {
     await this.commitFiles({ "yarn.lock": yarnYaml });
   }
 
-  async generateRepoFiles() {
+  async generateRepoFiles(): Promise<void> {
     const lagePath = path.join(this.nodeModulesPath, "lage/lib/cli");
 
     await this.commitFiles({
@@ -127,13 +127,13 @@ export class Monorepo {
     });
   }
 
-  async setLageConfig(contents: string) {
+  async setLageConfig(contents: string): Promise<void> {
     await this.commitFiles({
       "lage.config.js": contents,
     });
   }
 
-  async addPackage(name: string, internalDeps: string[] = [], scripts?: { [script: string]: string }) {
+  async addPackage(name: string, internalDeps: string[] = [], scripts?: { [script: string]: string }): Promise<void> {
     return await this.commitFiles({
       [`packages/${name}/build.js`]: `console.log('building ${name}');`,
       [`packages/${name}/test.js`]: `console.log('building ${name}');`,
@@ -156,15 +156,15 @@ export class Monorepo {
     });
   }
 
-  clone(origin: string) {
+  clone(origin: string): execa.ExecaChildProcess<string> {
     return execa("git", ["clone", origin], { cwd: this.root });
   }
 
-  push(origin: string, branch: string) {
+  push(origin: string, branch: string): execa.ExecaChildProcess<string> {
     return execa("git", ["push", origin, branch], { cwd: this.root });
   }
 
-  async writeFiles(files: { [file: string]: string | object }, options: { executable?: boolean } = {}) {
+  writeFiles(files: { [file: string]: string | object }, options: { executable?: boolean } = {}): void {
     for (const [file, contents] of Object.entries(files)) {
       let out = "";
       if (typeof contents !== "string") {
@@ -175,32 +175,32 @@ export class Monorepo {
 
       const fullPath = path.isAbsolute(file) ? file : path.join(this.root, file);
 
-      if (!existsSync(path.dirname(fullPath))) {
-        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+      if (!fs.existsSync(path.dirname(fullPath))) {
+        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
       }
 
-      await fs.writeFile(fullPath, out);
+      fs.writeFileSync(fullPath, out);
 
       if (options.executable) {
-        await fs.chmod(path.join(this.root, file), 0o755);
+        fs.chmodSync(path.join(this.root, file), 0o755);
       }
     }
   }
 
-  async readFiles(files: string[]) {
+  async readFiles(files: string[]): Promise<Record<string, string>> {
     const contents: Record<string, string> = {};
     for (const file of files) {
       const fullPath = path.isAbsolute(file) ? file : path.join(this.root, file);
-      if (!existsSync(fullPath)) {
+      if (!fs.existsSync(fullPath)) {
         throw new Error(`File ${fullPath} does not exist`);
       }
-      contents[file] = await fs.readFile(fullPath, "utf-8");
+      contents[file] = fs.readFileSync(fullPath, "utf-8");
     }
 
     return contents;
   }
 
-  async commitFiles(files: { [name: string]: string | object }, options: { executable?: boolean } = {}) {
+  async commitFiles(files: { [name: string]: string | object }, options: { executable?: boolean } = {}): Promise<void> {
     await this.writeFiles(files, options);
     await execa("git", ["add", "--", ...Object.keys(files)], {
       cwd: this.root,
@@ -208,20 +208,20 @@ export class Monorepo {
     await execa("git", ["commit", "-m", "commit files"], { cwd: this.root });
   }
 
-  run(command: string, args?: string[], silent?: boolean) {
+  run(command: string, args?: string[], silent?: boolean): execa.ExecaChildProcess<string> {
     return execa("yarn", [...(silent === true ? ["--silent"] : []), command, ...(args || [])], {
       cwd: this.root,
       shell: true,
     });
   }
 
-  async cleanup() {
+  async cleanup(): Promise<void> {
     const maxRetries = 5;
     let attempts = 0;
 
     while (attempts < maxRetries) {
       try {
-        await fs.rm(this.root, { recursive: true });
+        fs.rmdirSync(this.root, { recursive: true });
         break;
       } catch (error) {
         attempts++;
diff --git a/packages/reporters/src/AdoReporter.ts b/packages/reporters/src/AdoReporter.ts
index 4ea575ff6..14a5c84d7 100644
--- a/packages/reporters/src/AdoReporter.ts
+++ b/packages/reporters/src/AdoReporter.ts
@@ -1,6 +1,6 @@
 import { formatDuration, hrToSeconds } from "@lage-run/format-hrtime";
 import { isTargetStatusLogEntry } from "./isTargetStatusLogEntry.js";
-import { LogLevel } from "@lage-run/logger";
+import { LogLevel, type LogStructuredData } from "@lage-run/logger";
 import chalk from "chalk";
 import type { Reporter, LogEntry } from "@lage-run/logger";
 import type { SchedulerRunSummary, TargetStatus } from "@lage-run/scheduler-types";
@@ -52,13 +52,13 @@ export class AdoReporter implements Reporter {
   logStream: Writable = process.stdout;
 
   private logEntries = new Map<string, LogEntry[]>();
-  readonly groupedEntries = new Map<string, LogEntry[]>();
+  readonly groupedEntries: Map<string, LogEntry<LogStructuredData>[]> = new Map<string, LogEntry[]>();
 
   constructor(private options: { logLevel?: LogLevel; grouped?: boolean }) {
     options.logLevel = options.logLevel || LogLevel.info;
   }
 
-  log(entry: LogEntry<any>) {
+  log(entry: LogEntry<any>): boolean | void {
     if (entry.data && entry.data.target && entry.data.target.hidden) {
       return;
     }
@@ -159,7 +159,7 @@ export class AdoReporter implements Reporter {
     }
   }
 
-  summarize(schedulerRunSummary: SchedulerRunSummary) {
+  summarize(schedulerRunSummary: SchedulerRunSummary): void {
     const { targetRuns, targetRunByStatus, duration } = schedulerRunSummary;
     const { failed, aborted, skipped, success, pending } = targetRunByStatus;
 
diff --git a/packages/reporters/src/BasicReporter.ts b/packages/reporters/src/BasicReporter.ts
index 18f8d392d..98c5108cd 100644
--- a/packages/reporters/src/BasicReporter.ts
+++ b/packages/reporters/src/BasicReporter.ts
@@ -57,7 +57,8 @@ export class BasicReporter implements Reporter {
   private updateTimer: NodeJS.Timeout | undefined;
   private startTimer: () => void;
 
-  constructor({ concurrency = 0, version = "0.0.0", frequency = 500 } = {}) {
+  constructor(params: { concurrency?: number; version?: string; frequency?: number } = {}) {
+    const { concurrency = 0, version = "0.0.0", frequency = 500 } = params;
     print(`${fancy("lage")} - Version ${version} - ${concurrency} Workers`);
 
     this.startTimer = () => {
@@ -70,7 +71,7 @@ export class BasicReporter implements Reporter {
     process.on("exit", () => process.stdout.write(terminal.showCursor));
   }
 
-  log(entry: LogEntry) {
+  log(entry: LogEntry): void {
     const data = entry.data;
     if (!data?.target || data.target.hidden) return;
 
@@ -91,7 +92,7 @@ export class BasicReporter implements Reporter {
     }
   }
 
-  summarize(schedulerRunSummary: SchedulerRunSummary) {
+  summarize(schedulerRunSummary: SchedulerRunSummary): void {
     clearInterval(this.updateTimer);
     process.stdout.write(terminal.clearLine);
 
diff --git a/packages/reporters/src/ChromeTraceEventsReporter.ts b/packages/reporters/src/ChromeTraceEventsReporter.ts
index 5dc6e1531..fcbf89b42 100644
--- a/packages/reporters/src/ChromeTraceEventsReporter.ts
+++ b/packages/reporters/src/ChromeTraceEventsReporter.ts
@@ -51,11 +51,11 @@ export class ChromeTraceEventsReporter implements Reporter {
     this.outputFile = options.outputFile ?? getTimeBasedFilename("profile");
   }
 
-  log() {
+  log(): void {
     // pass
   }
 
-  summarize(schedulerRunSummary: SchedulerRunSummary) {
+  summarize(schedulerRunSummary: SchedulerRunSummary): void {
     const { targetRuns, startTime } = schedulerRunSummary;
 
     // categorize events
diff --git a/packages/reporters/src/JsonReporter.ts b/packages/reporters/src/JsonReporter.ts
index 74b912157..4b5c4da06 100644
--- a/packages/reporters/src/JsonReporter.ts
+++ b/packages/reporters/src/JsonReporter.ts
@@ -10,7 +10,7 @@ import type { TargetMessageEntry, TargetStatusEntry } from "./types/TargetLogEnt
 export class JsonReporter implements Reporter {
   constructor(private options: { logLevel: LogLevel; indented: boolean }) {}
 
-  log(entry: LogEntry<TargetStatusEntry | TargetMessageEntry>) {
+  log(entry: LogEntry<TargetStatusEntry | TargetMessageEntry>): void {
     if (entry.data && entry.data.target && entry.data.target.hidden) {
       return;
     }
@@ -20,7 +20,7 @@ export class JsonReporter implements Reporter {
     }
   }
 
-  summarize(schedulerRunSummary: SchedulerRunSummary) {
+  summarize(schedulerRunSummary: SchedulerRunSummary): void {
     const { duration, targetRuns, targetRunByStatus } = schedulerRunSummary;
 
     const summary: Record<string, unknown> = {
diff --git a/packages/reporters/src/LogReporter.ts b/packages/reporters/src/LogReporter.ts
index ce8a8ae8c..3eb751e98 100644
--- a/packages/reporters/src/LogReporter.ts
+++ b/packages/reporters/src/LogReporter.ts
@@ -1,6 +1,6 @@
 import { formatDuration, hrtimeDiff, hrToSeconds } from "@lage-run/format-hrtime";
 import { isTargetStatusLogEntry } from "./isTargetStatusLogEntry.js";
-import { LogLevel } from "@lage-run/logger";
+import { LogLevel, type LogStructuredData } from "@lage-run/logger";
 import ansiRegex from "ansi-regex";
 import chalk from "chalk";
 import type { Chalk } from "chalk";
@@ -79,13 +79,13 @@ function normalize(prefixOrMessage: string, message?: string) {
 export class LogReporter implements Reporter {
   logStream: Writable = process.stdout;
   private logEntries = new Map<string, LogEntry[]>();
-  readonly groupedEntries = new Map<string, LogEntry[]>();
+  readonly groupedEntries: Map<string, LogEntry<LogStructuredData>[]> = new Map<string, LogEntry[]>();
 
   constructor(private options: { logLevel?: LogLevel; grouped?: boolean }) {
     options.logLevel = options.logLevel || LogLevel.info;
   }
 
-  log(entry: LogEntry<any>) {
+  log(entry: LogEntry<any>): void {
     // if "hidden", do not even attempt to record or report the entry
     if (entry?.data?.target?.hidden) {
       return;
@@ -190,11 +190,11 @@ export class LogReporter implements Reporter {
     }
   }
 
-  hr() {
+  hr(): void {
     this.print("┈".repeat(80));
   }
 
-  summarize(schedulerRunSummary: SchedulerRunSummary) {
+  summarize(schedulerRunSummary: SchedulerRunSummary): void {
     const { targetRuns, targetRunByStatus, duration } = schedulerRunSummary;
     const { failed, aborted, skipped, success, pending } = targetRunByStatus;
 
@@ -281,7 +281,7 @@ export class LogReporter implements Reporter {
     this.print(`Took a total of ${formatDuration(hrToSeconds(duration))} to complete. ${allCacheHitText}`);
   }
 
-  resetLogEntries() {
+  resetLogEntries(): void {
     this.logEntries.clear();
   }
 }
diff --git a/packages/reporters/src/ProgressReporter.ts b/packages/reporters/src/ProgressReporter.ts
index 4a0ac6fe0..128b8d630 100644
--- a/packages/reporters/src/ProgressReporter.ts
+++ b/packages/reporters/src/ProgressReporter.ts
@@ -1,9 +1,7 @@
 import EventEmitter from "events";
-import { type LogEntry, LogLevel, type Reporter } from "@lage-run/logger";
+import { type LogEntry, LogLevel, type Reporter, type LogStructuredData } from "@lage-run/logger";
 import type { SchedulerRunSummary, TargetStatus } from "@lage-run/scheduler-types";
 
-// @ts-expect-error -- this package has CJS via the exports map, but old TS might not recognize it?
-// (it works fine with the actual transpiling via SWC)
 import { TaskReporter, type TaskReporterTask } from "@ms-cloudpack/task-reporter";
 import type { Target } from "@lage-run/target-graph";
 import { gradient } from "./gradient.js";
@@ -35,7 +33,7 @@ export class ProgressReporter implements Reporter {
   startTime: [number, number] = [0, 0];
 
   logEvent: EventEmitter = new EventEmitter();
-  logEntries = new Map<string, LogEntry[]>();
+  logEntries: Map<string, LogEntry<LogStructuredData>[]> = new Map<string, LogEntry[]>();
 
   taskReporter: TaskReporter;
   tasks: Map<string, TaskReporterTask> = new Map();
@@ -46,7 +44,7 @@ export class ProgressReporter implements Reporter {
     this.print(`${fancy("lage")} - Version ${options.version} - ${options.concurrency} Workers`);
   }
 
-  createTaskReporter() {
+  createTaskReporter(): TaskReporter {
     return new TaskReporter({
       productName: "lage",
       version: this.options.version,
@@ -66,7 +64,7 @@ export class ProgressReporter implements Reporter {
     });
   }
 
-  log(entry: LogEntry<any>) {
+  log(entry: LogEntry<any>): void {
     // save the logs for errors
     if (entry.data?.target?.id) {
       if (!this.logEntries.has(entry.data.target.id)) {
@@ -121,11 +119,11 @@ export class ProgressReporter implements Reporter {
     this.logStream.write(message + "\n");
   }
 
-  hr() {
+  hr(): void {
     this.print("┈".repeat(80));
   }
 
-  summarize(schedulerRunSummary: SchedulerRunSummary) {
+  summarize(schedulerRunSummary: SchedulerRunSummary): void {
     const { targetRuns, targetRunByStatus, duration } = schedulerRunSummary;
     const { failed, aborted, skipped, success, pending, running, queued } = targetRunByStatus;
 
diff --git a/packages/reporters/src/VerboseFileLogReporter.ts b/packages/reporters/src/VerboseFileLogReporter.ts
index 09ea2adcf..2ce5cd482 100644
--- a/packages/reporters/src/VerboseFileLogReporter.ts
+++ b/packages/reporters/src/VerboseFileLogReporter.ts
@@ -29,11 +29,11 @@ export class VerboseFileLogReporter implements Reporter {
     this.fileStream = logFile ? fs.createWriteStream(logFile) : new Writable({ write() {} });
   }
 
-  cleanup() {
+  cleanup(): void {
     this.fileStream?.end();
   }
 
-  log(entry: LogEntry<any>) {
+  log(entry: LogEntry<any>): void {
     // if "hidden", do not even attempt to record or report the entry
     if (entry?.data?.target?.hidden) {
       return;
@@ -102,7 +102,7 @@ export class VerboseFileLogReporter implements Reporter {
     }
   }
 
-  summarize() {
+  summarize(): void {
     // No summary needed for VerboseFileLogReporter
   }
 }
diff --git a/packages/reporters/src/formatBytes.ts b/packages/reporters/src/formatBytes.ts
index 12aab0121..ce7c0a86e 100644
--- a/packages/reporters/src/formatBytes.ts
+++ b/packages/reporters/src/formatBytes.ts
@@ -1,3 +1,3 @@
-export function formatBytes(bytes: number) {
+export function formatBytes(bytes: number): string {
   return `${(bytes / 1024 / 1024).toFixed(2)} MB`;
 }
diff --git a/packages/reporters/src/slowestTargetRuns.ts b/packages/reporters/src/slowestTargetRuns.ts
index 76db420d8..41bb850f3 100644
--- a/packages/reporters/src/slowestTargetRuns.ts
+++ b/packages/reporters/src/slowestTargetRuns.ts
@@ -1,7 +1,7 @@
 import { hrtimeDiff, hrToSeconds } from "@lage-run/format-hrtime";
 import type { TargetRun } from "@lage-run/scheduler-types";
 
-export function slowestTargetRuns(targetRuns: TargetRun[]) {
+export function slowestTargetRuns(targetRuns: TargetRun[]): TargetRun<unknown>[] {
   return targetRuns
     .sort((a, b) => parseFloat(hrToSeconds(hrtimeDiff(a.duration, b.duration))))
     .filter((run) => run.status !== "skipped" && !run.target.hidden);
diff --git a/packages/rpc/src/createClient.ts b/packages/rpc/src/createClient.ts
index fb4854920..19e6f921a 100644
--- a/packages/rpc/src/createClient.ts
+++ b/packages/rpc/src/createClient.ts
@@ -1,4 +1,4 @@
-import { createPromiseClient } from "@connectrpc/connect";
+import { createPromiseClient, type PromiseClient } from "@connectrpc/connect";
 import { createGrpcTransport } from "@connectrpc/connect-node";
 import { LageService } from "./gen/lage/v1/lage_connect.js";
 
@@ -9,7 +9,7 @@ export interface CreateClientOptions {
 
 export type LageClient = ReturnType<typeof createClient>;
 
-export function createClient({ baseUrl, httpVersion }: CreateClientOptions) {
+export function createClient({ baseUrl, httpVersion }: CreateClientOptions): PromiseClient<typeof LageService> {
   const transport = createGrpcTransport({
     httpVersion,
     baseUrl,
diff --git a/packages/rpc/src/createRoutes.ts b/packages/rpc/src/createRoutes.ts
index 0afec6890..2313a693e 100644
--- a/packages/rpc/src/createRoutes.ts
+++ b/packages/rpc/src/createRoutes.ts
@@ -3,7 +3,7 @@ import { LageService } from "./gen/lage/v1/lage_connect.js";
 import { type ILageService } from "./types/ILageService.js";
 
 export function createRoutes(serviceImpl: ILageService) {
-  return (router: ConnectRouter) => {
+  return (router: ConnectRouter): void => {
     router.service(LageService, serviceImpl);
   };
 }
diff --git a/packages/rpc/src/createServer.ts b/packages/rpc/src/createServer.ts
index 662d532ec..c97c9ea07 100644
--- a/packages/rpc/src/createServer.ts
+++ b/packages/rpc/src/createServer.ts
@@ -3,10 +3,17 @@ import { fastifyConnectPlugin } from "@connectrpc/connect-fastify";
 import { createRoutes } from "./createRoutes.js";
 import type { ILageService } from "./types/ILageService.js";
 
-export async function createServer(lageService: ILageService, abortController: AbortController) {
+import type { FastifyInstance, FastifyBaseLogger, FastifyTypeProviderDefault } from "fastify";
+import type { Http2Server, Http2ServerRequest, Http2ServerResponse } from "http2";
+
+export async function createServer(
+  lageService: ILageService,
+  abortController: AbortController
+): Promise<FastifyInstance<Http2Server, Http2ServerRequest, Http2ServerResponse, FastifyBaseLogger, FastifyTypeProviderDefault>> {
   const server = fastify({
     http2: true,
   });
+
   await server.register(fastifyConnectPlugin, {
     routes: createRoutes(lageService),
     shutdownSignal: abortController.signal,
diff --git a/packages/rpc/src/gen/lage/v1/lage_connect.ts b/packages/rpc/src/gen/lage/v1/lage_connect.ts
index 9d8ebc53b..3953559f4 100644
--- a/packages/rpc/src/gen/lage/v1/lage_connect.ts
+++ b/packages/rpc/src/gen/lage/v1/lage_connect.ts
@@ -9,7 +9,31 @@ import { MethodKind } from "@bufbuild/protobuf";
 /**
  * @generated from service connectrpc.lage.v1.LageService
  */
-export const LageService = {
+export const LageService: {
+  readonly typeName: "connectrpc.lage.v1.LageService";
+  readonly methods: {
+    /**
+     * @generated from rpc connectrpc.lage.v1.LageService.RunTarget
+     */
+    readonly runTarget: {
+      readonly name: "RunTarget";
+      readonly I: typeof RunTargetRequest;
+      readonly O: typeof RunTargetResponse;
+      readonly kind: MethodKind.Unary;
+    };
+    /**
+     * a ping function to check if the server is up
+     *
+     * @generated from rpc connectrpc.lage.v1.LageService.Ping
+     */
+    readonly ping: {
+      readonly name: "Ping";
+      readonly I: typeof PingRequest;
+      readonly O: typeof PingResponse;
+      readonly kind: MethodKind.Unary;
+    };
+  };
+} = {
   typeName: "connectrpc.lage.v1.LageService",
   methods: {
     /**
diff --git a/packages/runners/src/NoOpRunner.ts b/packages/runners/src/NoOpRunner.ts
index 0b871d4fe..59b023b02 100644
--- a/packages/runners/src/NoOpRunner.ts
+++ b/packages/runners/src/NoOpRunner.ts
@@ -1,11 +1,11 @@
 import type { TargetRunner } from "./types/TargetRunner.js";
 
 export class NoOpRunner implements TargetRunner {
-  async shouldRun() {
+  async shouldRun(): Promise<boolean> {
     return true;
   }
 
-  async run() {
+  async run(): Promise<void> {
     // pass
   }
 }
diff --git a/packages/runners/src/NpmScriptRunner.ts b/packages/runners/src/NpmScriptRunner.ts
index 02102ab19..f20868c97 100644
--- a/packages/runners/src/NpmScriptRunner.ts
+++ b/packages/runners/src/NpmScriptRunner.ts
@@ -46,7 +46,7 @@ export class NpmScriptRunner implements TargetRunner {
     return !!packageJson.scripts?.[task];
   }
 
-  async shouldRun(target: Target) {
+  async shouldRun(target: Target): Promise<boolean> {
     // By convention, do not run anything if there is no script for this task defined in package.json (counts as "success")
     const hasNpmScript = await this.hasNpmScript(target);
 
diff --git a/packages/runners/src/WorkerRunner.ts b/packages/runners/src/WorkerRunner.ts
index 83b16917f..1700728b2 100644
--- a/packages/runners/src/WorkerRunner.ts
+++ b/packages/runners/src/WorkerRunner.ts
@@ -75,7 +75,7 @@ export class WorkerRunner implements TargetRunner {
     return await runFn({ target, weight, taskArgs, abortSignal });
   }
 
-  async getScriptModule(target: Target) {
+  async getScriptModule(target: Target): Promise<any> {
     const scriptFile = target.options?.worker ?? target.options?.script;
 
     if (!scriptFile) {
diff --git a/packages/scheduler/src/SimpleScheduler.ts b/packages/scheduler/src/SimpleScheduler.ts
index a0d2715e2..956ee2aef 100644
--- a/packages/scheduler/src/SimpleScheduler.ts
+++ b/packages/scheduler/src/SimpleScheduler.ts
@@ -1,7 +1,7 @@
 import { AggregatedPool } from "@lage-run/worker-threads-pool";
 import { formatBytes } from "./formatBytes.js";
 import { categorizeTargetRuns } from "./categorizeTargetRuns.js";
-import { getStartTargetId, sortTargetsByPriority } from "@lage-run/target-graph";
+import { type Target, getStartTargetId, sortTargetsByPriority } from "@lage-run/target-graph";
 import { WrappedTarget } from "./WrappedTarget.js";
 import { TargetRunnerPicker } from "@lage-run/runners";
 
@@ -77,7 +77,7 @@ export class SimpleScheduler implements TargetScheduler<WorkerResult> {
     this.runnerPicker = new TargetRunnerPicker(options.workerData.runners);
   }
 
-  getTargetsByPriority() {
+  getTargetsByPriority(): Target[] {
     return sortTargetsByPriority([...this.targetRuns.values()].map((run) => run.target));
   }
 
@@ -183,7 +183,7 @@ export class SimpleScheduler implements TargetScheduler<WorkerResult> {
    * Used by consumers of the scheduler to notify that the inputs to the target has changed
    * @param targetId
    */
-  markTargetAndDependentsPending(targetId: string) {
+  markTargetAndDependentsPending(targetId: string): void {
     const queue = [targetId];
     while (queue.length > 0) {
       const current = queue.shift()!;
@@ -203,7 +203,7 @@ export class SimpleScheduler implements TargetScheduler<WorkerResult> {
     }
   }
 
-  getReadyTargets() {
+  getReadyTargets(): WrappedTarget[] {
     const readyTargets: Set<WrappedTarget> = new Set();
 
     for (const target of this.getTargetsByPriority()) {
@@ -233,7 +233,7 @@ export class SimpleScheduler implements TargetScheduler<WorkerResult> {
     return [...readyTargets];
   }
 
-  isAllDone() {
+  isAllDone(): boolean {
     for (const t of this.targetRuns.values()) {
       if (t.status !== "skipped" && t.status !== "success" && t.target.id !== getStartTargetId()) {
         return false;
@@ -243,7 +243,7 @@ export class SimpleScheduler implements TargetScheduler<WorkerResult> {
     return true;
   }
 
-  async scheduleReadyTargets() {
+  async scheduleReadyTargets(): Promise<void> {
     if (this.isAllDone() || this.abortSignal.aborted) {
       return Promise.resolve();
     }
@@ -260,7 +260,7 @@ export class SimpleScheduler implements TargetScheduler<WorkerResult> {
     await Promise.all(promises);
   }
 
-  logProgress() {
+  logProgress(): void {
     const targetRunByStatus = categorizeTargetRuns(this.targetRuns.values());
     const total = [...this.targetRuns.values()].filter((t) => !t.target.hidden).length;
 
@@ -323,7 +323,7 @@ export class SimpleScheduler implements TargetScheduler<WorkerResult> {
     await this.scheduleReadyTargets();
   }
 
-  async cleanup() {
+  async cleanup(): Promise<void> {
     this.options.logger.silly(`Max Worker Memory Usage: ${formatBytes(this.pool.stats().maxWorkerMemoryUsage)}`);
     await this.pool.close();
   }
@@ -331,8 +331,7 @@ export class SimpleScheduler implements TargetScheduler<WorkerResult> {
   /**
    * Abort the scheduler using the abort controller.
    */
-  abort() {
+  abort(): void {
     this.abortController.abort();
   }
 }
-encodeURI;
diff --git a/packages/scheduler/src/WrappedTarget.ts b/packages/scheduler/src/WrappedTarget.ts
index 15bf53977..c66337e98 100644
--- a/packages/scheduler/src/WrappedTarget.ts
+++ b/packages/scheduler/src/WrappedTarget.ts
@@ -50,15 +50,15 @@ export class WrappedTarget implements TargetRun<WorkerResult> {
   target: Target;
   threadId = 0;
 
-  get result() {
+  get result(): WorkerResult | undefined {
     return this.#result;
   }
 
-  get status() {
+  get status(): TargetStatus {
     return this.#status;
   }
 
-  get abortController() {
+  get abortController(): AbortController {
     return this.options.abortController;
   }
 
@@ -66,11 +66,11 @@ export class WrappedTarget implements TargetRun<WorkerResult> {
     this.options.abortController = abortController;
   }
 
-  get successful() {
+  get successful(): boolean {
     return this.#status === "skipped" || this.#status === "success";
   }
 
-  get waiting() {
+  get waiting(): boolean {
     return this.#status === "pending" || this.#status === "queued";
   }
 
@@ -84,18 +84,18 @@ export class WrappedTarget implements TargetRun<WorkerResult> {
     this.options.logger.info("", { target: this.target, status: this.status });
   }
 
-  onQueued() {
+  onQueued(): void {
     this.#status = "queued";
     this.queueTime = process.hrtime();
     this.options.logger.info("", { target: this.target, status: "queued" });
   }
 
-  onAbort() {
+  onAbort(): void {
     this.#status = "aborted";
     this.options.logger.info("", { target: this.target, status: "aborted", threadId: this.threadId });
   }
 
-  onStart(threadId: number) {
+  onStart(threadId: number): void {
     if (this.status !== "running") {
       this.threadId = threadId;
       this.#status = "running";
@@ -104,7 +104,7 @@ export class WrappedTarget implements TargetRun<WorkerResult> {
     }
   }
 
-  onComplete() {
+  onComplete(): void {
     this.#status = "success";
     this.options.logger.info("", {
       target: this.target,
@@ -114,7 +114,7 @@ export class WrappedTarget implements TargetRun<WorkerResult> {
     });
   }
 
-  onFail() {
+  onFail(): void {
     this.#status = "failed";
     this.options.logger.info("", {
       target: this.target,
@@ -128,7 +128,7 @@ export class WrappedTarget implements TargetRun<WorkerResult> {
     }
   }
 
-  onSkipped(hash?: string | undefined) {
+  onSkipped(hash?: string | undefined): void {
     this.#status = "skipped";
 
     if (hash) {
@@ -142,7 +142,7 @@ export class WrappedTarget implements TargetRun<WorkerResult> {
     }
   }
 
-  async run() {
+  async run(): Promise<WorkerResult | undefined> {
     const { target, logger, shouldCache, abortController, root } = this.options;
 
     const abortSignal = abortController.signal;
@@ -283,7 +283,10 @@ export class WrappedTarget implements TargetRun<WorkerResult> {
    *
    * @returns
    */
-  toJSON() {
+  toJSON(): {
+    target: string;
+    status: TargetStatus;
+  } {
     return {
       target: this.target.id,
       status: this.status,
@@ -293,7 +296,7 @@ export class WrappedTarget implements TargetRun<WorkerResult> {
   /**
    * Reset the state of this wrapped target.
    */
-  reset() {
+  reset(): void {
     this.#result = undefined;
     this.#status = "pending";
   }
diff --git a/packages/scheduler/src/bufferTransform.ts b/packages/scheduler/src/bufferTransform.ts
index 4a62fa7a7..50697f75a 100644
--- a/packages/scheduler/src/bufferTransform.ts
+++ b/packages/scheduler/src/bufferTransform.ts
@@ -1,6 +1,9 @@
 import { Transform } from "stream";
 
-export function bufferTransform() {
+export function bufferTransform(): {
+  readonly buffer: string;
+  transform: Transform;
+} {
   const chunks: string[] = [];
 
   return {
diff --git a/packages/scheduler/src/cache/createCacheProvider.ts b/packages/scheduler/src/cache/createCacheProvider.ts
index fb00cfa16..3b653598b 100644
--- a/packages/scheduler/src/cache/createCacheProvider.ts
+++ b/packages/scheduler/src/cache/createCacheProvider.ts
@@ -11,7 +11,9 @@ interface CreateCacheOptions {
   cliArgs: string[];
 }
 
-export async function createCache(options: CreateCacheOptions) {
+export async function createCache(options: CreateCacheOptions): Promise<{
+  cacheProvider: RemoteFallbackCacheProvider;
+}> {
   const { cacheOptions, logger, root, skipLocalCache } = options;
 
   const hasRemoteCacheConfig =
diff --git a/packages/scheduler/src/cache/isRunningFromCI.ts b/packages/scheduler/src/cache/isRunningFromCI.ts
index b2ec496b7..dd86cb254 100644
--- a/packages/scheduler/src/cache/isRunningFromCI.ts
+++ b/packages/scheduler/src/cache/isRunningFromCI.ts
@@ -1 +1 @@
-export const isRunningFromCI = process.env.NODE_ENV !== "test" && (!!process.env.CI || !!process.env.TF_BUILD);
+export const isRunningFromCI: boolean = process.env.NODE_ENV !== "test" && (!!process.env.CI || !!process.env.TF_BUILD);
diff --git a/packages/scheduler/src/formatBytes.ts b/packages/scheduler/src/formatBytes.ts
index 12aab0121..ce7c0a86e 100644
--- a/packages/scheduler/src/formatBytes.ts
+++ b/packages/scheduler/src/formatBytes.ts
@@ -1,3 +1,3 @@
-export function formatBytes(bytes: number) {
+export function formatBytes(bytes: number): string {
   return `${(bytes / 1024 / 1024).toFixed(2)} MB`;
 }
diff --git a/packages/scheduler/src/getLageOutputCacheLocation.ts b/packages/scheduler/src/getLageOutputCacheLocation.ts
index 7ea3889ac..9ab8bcc54 100644
--- a/packages/scheduler/src/getLageOutputCacheLocation.ts
+++ b/packages/scheduler/src/getLageOutputCacheLocation.ts
@@ -1,7 +1,7 @@
 import { getLogsCacheDirectory } from "@lage-run/cache";
 import path from "path";
 
-export function getLageOutputCacheLocation(root: string, hash: string) {
+export function getLageOutputCacheLocation(root: string, hash: string): string {
   const outputPath = getLogsCacheDirectory(root, hash);
   return path.join(outputPath, hash + ".log");
 }
diff --git a/packages/scheduler/tests/SimpleScheduler.watchmode.test.ts b/packages/scheduler/tests/SimpleScheduler.watchmode.test.ts
index 2b12a4a98..2ab9286a4 100644
--- a/packages/scheduler/tests/SimpleScheduler.watchmode.test.ts
+++ b/packages/scheduler/tests/SimpleScheduler.watchmode.test.ts
@@ -3,7 +3,7 @@ import { Logger } from "@lage-run/logger";
 import { SimpleScheduler } from "../src/SimpleScheduler";
 import { InProcPool } from "./fixtures/pools";
 import { getTargetId, Target, TargetGraphBuilder } from "@lage-run/target-graph";
-import { TargetRunner } from "@lage-run/scheduler-types";
+import { TargetRunner } from "@lage-run/runners";
 
 import fs from "fs";
 import path from "path";
diff --git a/packages/scheduler/tests/fixtures/pools.ts b/packages/scheduler/tests/fixtures/pools.ts
index 0e7f793b1..b12de9909 100644
--- a/packages/scheduler/tests/fixtures/pools.ts
+++ b/packages/scheduler/tests/fixtures/pools.ts
@@ -1,19 +1,20 @@
-import { TargetRunner } from "@lage-run/scheduler-types";
+import { TargetRunner } from "@lage-run/runners";
 import { Target } from "@lage-run/target-graph";
 import { Pool } from "@lage-run/worker-threads-pool";
+import { PoolStats } from "@lage-run/worker-threads-pool";
 
 export class InProcPool implements Pool {
   constructor(private runner: TargetRunner) {}
-  exec({ target }: { target: Target }) {
+  exec({ target }: { target: Target }): Promise<unknown> {
     return this.runner.run({ target, weight: 1 });
   }
-  stats() {
+  stats(): PoolStats {
     return {
       workerRestarts: 0,
       maxWorkerMemoryUsage: 0,
     };
   }
-  close() {
+  close(): Promise<unknown> {
     return Promise.resolve();
   }
 }
@@ -24,7 +25,7 @@ export class SingleSchedulePool implements Pool {
     private runner: TargetRunner,
     private concurrency: number
   ) {}
-  exec({ target }: { target: Target }) {
+  exec({ target }: { target: Target }): Promise<unknown> {
     if (this.concurrency > this.count) {
       this.count++;
       return this.runner.run({ target, weight: 1 });
@@ -32,13 +33,13 @@ export class SingleSchedulePool implements Pool {
 
     return Promise.reject(new Error("Pool is full"));
   }
-  stats() {
+  stats(): PoolStats {
     return {
       workerRestarts: 0,
       maxWorkerMemoryUsage: 0,
     };
   }
-  close() {
+  close(): Promise<unknown> {
     return Promise.resolve();
   }
 }
diff --git a/packages/scheduler/tests/waitFor.ts b/packages/scheduler/tests/waitFor.ts
index a148098f0..df31b2716 100644
--- a/packages/scheduler/tests/waitFor.ts
+++ b/packages/scheduler/tests/waitFor.ts
@@ -1,10 +1,10 @@
-export function waitFor(condition: () => boolean, maxWait: number = 5000) {
+export function waitFor(condition: () => boolean, maxWait: number = 5000): Promise<void> {
   let retries = 0;
   let timeout = 100;
   let maxRetries = maxWait / timeout;
 
   return new Promise<void>((resolve, reject) => {
-    const loop = (timer) => {
+    const loop = (timer: NodeJS.Timeout) => {
       clearTimeout(timer);
 
       retries++;
@@ -18,6 +18,6 @@ export function waitFor(condition: () => boolean, maxWait: number = 5000) {
       }
     };
 
-    const timer = setTimeout(() => loop(timer), timeout);
+    const timer: NodeJS.Timeout = setTimeout(() => loop(timer), timeout);
   });
 }
diff --git a/packages/target-graph/src/TargetFactory.ts b/packages/target-graph/src/TargetFactory.ts
index e8359d119..817000064 100644
--- a/packages/target-graph/src/TargetFactory.ts
+++ b/packages/target-graph/src/TargetFactory.ts
@@ -12,7 +12,7 @@ export interface TargetFactoryOptions {
 }
 
 export class TargetFactory {
-  packageScripts = new Set<string>();
+  packageScripts: Set<string> = new Set<string>();
 
   constructor(private options: TargetFactoryOptions) {
     const { packageInfos } = options;
@@ -23,7 +23,7 @@ export class TargetFactory {
     }
   }
 
-  getTargetType(task: string, config: TargetConfig) {
+  getTargetType(task: string, config: TargetConfig): string {
     if (!config.type) {
       if (this.packageScripts.has(task)) {
         return "npmScript";
diff --git a/packages/target-graph/src/TargetGraphBuilder.ts b/packages/target-graph/src/TargetGraphBuilder.ts
index 58caefbf9..0df2c8b0f 100644
--- a/packages/target-graph/src/TargetGraphBuilder.ts
+++ b/packages/target-graph/src/TargetGraphBuilder.ts
@@ -3,6 +3,7 @@ import { prioritize } from "./prioritize.js";
 import { detectCycles } from "./detectCycles.js";
 
 import type { Target } from "./types/Target.js";
+import type { TargetGraph } from "./types/TargetGraph.js";
 
 /**
  * Target graph builder
@@ -62,13 +63,13 @@ export class TargetGraphBuilder {
     } as Target);
   }
 
-  addTarget(target: Target) {
+  addTarget(target: Target): Target {
     this.targets.set(target.id, target);
     this.addDependency(getStartTargetId(), target.id);
     return target;
   }
 
-  addDependency(dependency: string, dependent: string) {
+  addDependency(dependency: string, dependent: string): void {
     if (this.targets.has(dependent)) {
       const target = this.targets.get(dependent)!;
 
@@ -89,7 +90,7 @@ export class TargetGraphBuilder {
   /**
    * Builds a target graph for given tasks and packages
    */
-  build() {
+  build(): TargetGraph {
     // Ensure we do not have cycles in the subgraph
     const cycleInfo = detectCycles(this.targets);
     if (cycleInfo.hasCycle) {
@@ -104,7 +105,7 @@ export class TargetGraphBuilder {
     };
   }
 
-  subgraph(entriesTargetIds: string[]) {
+  subgraph(entriesTargetIds: string[]): TargetGraph {
     const subgraphBuilder = new TargetGraphBuilder();
     const visited: Set<string> = new Set();
     const queue: string[] = [];
diff --git a/packages/target-graph/src/WorkspaceTargetGraphBuilder.ts b/packages/target-graph/src/WorkspaceTargetGraphBuilder.ts
index c74a053c4..7c00c9c9a 100644
--- a/packages/target-graph/src/WorkspaceTargetGraphBuilder.ts
+++ b/packages/target-graph/src/WorkspaceTargetGraphBuilder.ts
@@ -8,12 +8,15 @@ import type { DependencyMap } from "workspace-tools/lib/graph/createDependencyMa
 import type { PackageInfos } from "workspace-tools";
 import type { Target } from "./types/Target.js";
 import type { TargetConfig } from "./types/TargetConfig.js";
+import type { TargetGraph } from "./types/TargetGraph.js";
 import { TargetGraphBuilder } from "./TargetGraphBuilder.js";
 import { TargetFactory } from "./TargetFactory.js";
 import pLimit from "p-limit";
+import * as mergicianModule from "mergician";
 
-//eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-require-imports -- mergician is a dual-mode library with CJS and ESM export but a single .d.ts file. Without type="module" on this packge.json typescript gets confused. See: https://github.com/microsoft/TypeScript/issues/50466
-const { mergician } = require("mergician");
+// mergician is a dual-mode library with CJS and ESM export but a single .d.ts file.
+// Without type="module" on this packge.json typescript gets confused. See: https://github.com/microsoft/TypeScript/issues/50466
+const mergician = mergicianModule.mergician || (mergicianModule as unknown as { default: typeof mergicianModule }).default.mergician;
 
 const DEFAULT_STAGED_TARGET_THRESHOLD = 50;
 /**
@@ -74,7 +77,7 @@ export class WorkspaceTargetGraphBuilder {
    * @param id
    * @param targetDefinition
    */
-  async addTargetConfig(id: string, config: TargetConfig = {}, changedFiles?: string[]) {
+  public async addTargetConfig(id: string, config: TargetConfig = {}, changedFiles?: string[]): Promise<void> {
     // Generates a target definition from the target config
     if (id.startsWith("//") || id.startsWith("#")) {
       const targetConfig = this.determineFinalTargetConfig(id, config);
@@ -103,7 +106,8 @@ export class WorkspaceTargetGraphBuilder {
     }
   }
 
-  deepCloneTargetConfig = mergician({
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  private deepCloneTargetConfig: Function = mergician({
     appendArrays: true,
     onCircular: () => {
       throw new Error(`Circular object reference detected in TargetConfig`);
@@ -116,7 +120,7 @@ export class WorkspaceTargetGraphBuilder {
    * @param config The TargetConfig settings that will be merged if this target has already been seen before
    * @returns The merged TargetConfig object.
    */
-  determineFinalTargetConfig(targetId: string, config: TargetConfig): TargetConfig {
+  private determineFinalTargetConfig(targetId: string, config: TargetConfig): TargetConfig {
     let finalConfig = config;
     if (this.enableTargetConfigMerging && this.targetConfigMap.has(targetId)) {
       const existingConfig = this.targetConfigMap.get(targetId)!;
@@ -132,7 +136,7 @@ export class WorkspaceTargetGraphBuilder {
    * @param parentTarget
    * @param config
    */
-  processStagedConfig(parentTarget: Target, config: TargetConfig, changedFiles?: string[]) {
+  private processStagedConfig(parentTarget: Target, config: TargetConfig, changedFiles?: string[]): void {
     if (typeof config.stagedTarget === "undefined") {
       return;
     }
@@ -176,7 +180,7 @@ export class WorkspaceTargetGraphBuilder {
     }
   }
 
-  shouldRun(config: TargetConfig, target: Target) {
+  public shouldRun(config: TargetConfig, target: Target): boolean | Promise<boolean> {
     if (typeof config.shouldRun === "function") {
       return config.shouldRun(target);
     }
@@ -197,7 +201,11 @@ export class WorkspaceTargetGraphBuilder {
    * @param scope
    * @param priorities the set of global priorities for the workspace.
    */
-  async build(tasks: string[], scope?: string[], priorities?: { package?: string; task: string; priority: number }[]) {
+  public async build(
+    tasks: string[],
+    scope?: string[],
+    priorities?: { package?: string; task: string; priority: number }[]
+  ): Promise<TargetGraph> {
     // Expands the dependency specs from the target definitions
     const fullDependencies = expandDepSpecs(this.graphBuilder.targets, this.dependencyMap);
 
diff --git a/packages/target-graph/src/detectCycles.ts b/packages/target-graph/src/detectCycles.ts
index 23cdc1648..9cdba390a 100644
--- a/packages/target-graph/src/detectCycles.ts
+++ b/packages/target-graph/src/detectCycles.ts
@@ -4,7 +4,10 @@ import type { Target } from "./types/Target.js";
  * Checks for any cycles in the dependency graph, returning `{ hasCycle: false }` if no cycles were detected.
  * Otherwise it returns the chain of nodes where the cycle was detected.
  */
-export function detectCycles(targets: Map<string, Target>) {
+export function detectCycles(targets: Map<string, Target>): {
+  hasCycle: boolean;
+  cycle?: string[];
+} {
   /**
    *  A map to keep track of the visited and visiting nodes.
    * <node, true> entry means it is currently being visited.
diff --git a/packages/target-graph/src/expandDepSpecs.ts b/packages/target-graph/src/expandDepSpecs.ts
index f4861d06d..2992832c5 100644
--- a/packages/target-graph/src/expandDepSpecs.ts
+++ b/packages/target-graph/src/expandDepSpecs.ts
@@ -5,7 +5,7 @@ import { getPackageAndTask, getStartTargetId, getTargetId } from "./targetId.js"
 /**
  * Expands the dependency graph by adding all transitive dependencies of the given targets.
  */
-export function expandDepSpecs(targets: Map<string, Target>, dependencyMap: DependencyMap) {
+export function expandDepSpecs(targets: Map<string, Target>, dependencyMap: DependencyMap): [string, string][] {
   const dependencies: [string, string][] = [];
 
   /**
diff --git a/packages/target-graph/src/prioritize.ts b/packages/target-graph/src/prioritize.ts
index 09c546f0a..9ccd8465e 100644
--- a/packages/target-graph/src/prioritize.ts
+++ b/packages/target-graph/src/prioritize.ts
@@ -52,7 +52,7 @@ function reverseTopoSort(targets: Map<string, Target>, nodesWithNoDependencies:
 /**
  * Priorities for a target is actually the MAX of all the priorities of the targets that depend on it plus the current priority.
  */
-export function prioritize(targets: Map<string, Target>) {
+export function prioritize(targets: Map<string, Target>): void {
   const nodeCumulativePriorities = new Map<string, number>();
 
   const nodesWithNoDependencies = getNodesWithNoDependencies(targets);
diff --git a/packages/target-graph/src/sortTargetsByPriority.ts b/packages/target-graph/src/sortTargetsByPriority.ts
index 6f08ffc4d..961c7f2f6 100644
--- a/packages/target-graph/src/sortTargetsByPriority.ts
+++ b/packages/target-graph/src/sortTargetsByPriority.ts
@@ -1,6 +1,6 @@
 import type { Target } from "./types/Target.js";
 
-export function sortTargetsByPriority(targets: Target[]) {
+export function sortTargetsByPriority(targets: Target[]): Target[] {
   return targets.sort((a, b) => {
     return (b.priority ?? 0) - (a.priority ?? 0);
   });
diff --git a/packages/target-graph/src/targetId.ts b/packages/target-graph/src/targetId.ts
index e6dc67547..fafac2d70 100644
--- a/packages/target-graph/src/targetId.ts
+++ b/packages/target-graph/src/targetId.ts
@@ -1,11 +1,7 @@
 /**
  * Generates a unique target id in this format: `<package-name>#<task-name>` or `//#<task-name>`
- *
- * @param pkgName
- * @param task
- * @returns
  */
-export function getTargetId(pkgName: string | undefined, task: string) {
+export function getTargetId(pkgName: string | undefined, task: string): string {
   return `${typeof pkgName === "string" ? pkgName : ""}#${task}`;
 }
 
@@ -15,10 +11,11 @@ export function getTargetId(pkgName: string | undefined, task: string) {
  * If the packageName is //, that means that the task is meant to be run at the repo root level.
  *
  * @internal
- * @param targetId
- * @returns
  */
-export function getPackageAndTask(targetId: string) {
+export function getPackageAndTask(targetId: string): {
+  packageName?: string;
+  task: string;
+} {
   if (targetId.startsWith("Δ")) {
     return { packageName: undefined, task: targetId.slice(1) };
   } else if (targetId.includes("#")) {
@@ -36,10 +33,10 @@ export function getPackageAndTask(targetId: string) {
 }
 
 const START_TARGET_ID = "__start";
-export function getStartTargetId() {
+export function getStartTargetId(): string {
   return START_TARGET_ID;
 }
 
-export function getStagedTargetId(task: string) {
+export function getStagedTargetId(task: string): string {
   return `Δ${task}`;
 }
diff --git a/packages/worker-threads-pool/src/AggregatedPool.ts b/packages/worker-threads-pool/src/AggregatedPool.ts
index 97190ccc9..93b096721 100644
--- a/packages/worker-threads-pool/src/AggregatedPool.ts
+++ b/packages/worker-threads-pool/src/AggregatedPool.ts
@@ -72,7 +72,10 @@ export class AggregatedPool extends EventEmitter implements Pool {
     });
   }
 
-  stats() {
+  stats(): {
+    maxWorkerMemoryUsage: number;
+    workerRestarts: number;
+  } {
     const stats = [...this.groupedPools.values(), this.defaultPool].reduce(
       (acc, pool) => {
         if (pool) {
@@ -88,14 +91,14 @@ export class AggregatedPool extends EventEmitter implements Pool {
     return stats;
   }
 
-  async exec(
+  async exec<T>(
     data: Record<string, unknown>,
     weight: number,
     setup?: (worker: IWorker, stdout: Readable, stderr: Readable) => void,
     cleanup?: (args: any) => void,
     abortSignal?: AbortSignal,
     priority?: number
-  ): Promise<unknown> {
+  ): Promise<T | void> {
     const group = this.options.groupBy(data);
     const pool = this.groupedPools.get(group) ?? this.defaultPool;
 
diff --git a/packages/worker-threads-pool/src/TaskInfo.ts b/packages/worker-threads-pool/src/TaskInfo.ts
index e013817d4..0bc73e907 100644
--- a/packages/worker-threads-pool/src/TaskInfo.ts
+++ b/packages/worker-threads-pool/src/TaskInfo.ts
@@ -23,19 +23,19 @@ export class TaskInfo extends AsyncResource {
     }
   }
 
-  get id() {
+  get id(): string {
     return this.options.id;
   }
 
-  get weight() {
+  get weight(): number {
     return this.options.weight;
   }
 
-  get abortSignal() {
+  get abortSignal(): AbortSignal | undefined {
     return this.options.abortSignal;
   }
 
-  done(err: Error, results: unknown) {
+  done(err: Error, results: unknown): void {
     const { cleanup, worker, resolve, reject } = this.options;
 
     if (cleanup) {
diff --git a/packages/worker-threads-pool/src/ThreadWorker.ts b/packages/worker-threads-pool/src/ThreadWorker.ts
index 7431d2e58..6adc6401f 100644
--- a/packages/worker-threads-pool/src/ThreadWorker.ts
+++ b/packages/worker-threads-pool/src/ThreadWorker.ts
@@ -9,7 +9,7 @@ import crypto from "crypto";
 import v8 from "v8";
 import type { IWorker } from "./types/WorkerQueue.js";
 import type { QueueItem } from "./types/WorkerQueue.js";
-import type { WorkerOptions as ThreadWorkerOptions } from "worker_threads";
+import type { ResourceLimits, WorkerOptions as ThreadWorkerOptions } from "worker_threads";
 
 export interface WorkerOptions {
   workerOptions?: ThreadWorkerOptions;
@@ -225,7 +225,7 @@ export class ThreadWorker extends EventEmitter implements IWorker {
     }
   }
 
-  start(work: QueueItem, abortSignal?: AbortSignal) {
+  start(work: QueueItem, abortSignal?: AbortSignal): void {
     this.status = "busy";
 
     const { task, resolve, reject, cleanup, setup } = work;
@@ -249,44 +249,44 @@ export class ThreadWorker extends EventEmitter implements IWorker {
     this.#worker.postMessage({ type: "start", task: { ...task, weight: work.weight }, id });
   }
 
-  get weight() {
+  get weight(): number {
     return this.#taskInfo?.weight ?? 1;
   }
 
-  get stdout() {
+  get stdout(): Readable {
     return this.#stdoutInfo.stream;
   }
 
-  get stderr() {
+  get stderr(): Readable {
     return this.#stderrInfo.stream;
   }
 
-  get resourceLimits() {
+  get resourceLimits(): ResourceLimits | undefined {
     return this.#worker.resourceLimits;
   }
 
-  get threadId() {
+  get threadId(): number {
     return this.#worker.threadId;
   }
 
-  terminate() {
+  terminate(): void {
     this.#worker.removeAllListeners();
     void this.#worker.terminate();
     this.#worker.unref();
   }
 
-  restart() {
+  restart(): void {
     this.restarts++;
     this.status = "busy";
     void this.#worker.terminate();
     this.#createNewWorker();
   }
 
-  checkMemoryUsage() {
+  checkMemoryUsage(): void {
     this.#worker.postMessage({ type: "check-memory-usage" });
   }
 
-  postMessage(value: any, transferList?: readonly TransferListItem[] | undefined): void {
+  postMessage(value: unknown, transferList?: readonly TransferListItem[] | undefined): void {
     this.#worker.postMessage(value, transferList);
   }
 }
diff --git a/packages/worker-threads-pool/src/WorkerPool.ts b/packages/worker-threads-pool/src/WorkerPool.ts
index fc46faa47..58055eb49 100644
--- a/packages/worker-threads-pool/src/WorkerPool.ts
+++ b/packages/worker-threads-pool/src/WorkerPool.ts
@@ -48,26 +48,29 @@ export class WorkerPool extends EventEmitter implements Pool {
     });
   }
 
-  isIdle() {
+  isIdle(): boolean {
     return this.workers.every((w) => w.status === "free");
   }
 
-  get workerRestarts() {
+  get workerRestarts(): number {
     return this.workers.reduce((acc, worker) => acc + worker.restarts, 0);
   }
 
-  get maxWorkerMemoryUsage() {
+  get maxWorkerMemoryUsage(): number {
     return this.workers.reduce((acc, worker) => Math.max(acc, worker.maxWorkerMemoryUsage), 0);
   }
 
-  stats() {
+  stats(): {
+    maxWorkerMemoryUsage: number;
+    workerRestarts: number;
+  } {
     return {
       maxWorkerMemoryUsage: this.maxWorkerMemoryUsage,
       workerRestarts: this.workerRestarts,
     };
   }
 
-  createInitialWorkers() {
+  createInitialWorkers(): void {
     if (this.workers.length === 0) {
       for (let i = 0; i < this.minWorkers; i++) {
         this.addNewWorker();
@@ -75,7 +78,7 @@ export class WorkerPool extends EventEmitter implements Pool {
     }
   }
 
-  addNewWorker() {
+  addNewWorker(): ThreadWorker | undefined {
     if (this.workers.length < this.maxWorkers) {
       const { script, workerOptions } = this.options;
       const worker = new ThreadWorker(script, { workerOptions, workerIdleMemoryLimit: this.options.workerIdleMemoryLimit });
@@ -89,14 +92,14 @@ export class WorkerPool extends EventEmitter implements Pool {
     }
   }
 
-  exec(
+  exec<T>(
     task: Record<string, unknown>,
     weight: number,
     setup?: (worker: IWorker, stdout: Readable, stderr: Readable) => void,
     cleanup?: (worker: IWorker) => void,
     abortSignal?: AbortSignal,
     priority?: number
-  ) {
+  ): Promise<T | void> {
     if (abortSignal?.aborted) {
       return Promise.resolve();
     }
@@ -104,13 +107,13 @@ export class WorkerPool extends EventEmitter implements Pool {
     // cull the weight of the task to be [1, maxWorkers]
     weight = Math.min(Math.max(1, weight), this.maxWorkers);
 
-    return new Promise((resolve, reject) => {
+    return new Promise<any>((resolve, reject) => {
       this.queue.push({ task: { ...task, weight }, weight, resolve, reject, cleanup, setup, priority });
       this._exec(abortSignal);
     });
   }
 
-  _exec(abortSignal?: AbortSignal) {
+  _exec(abortSignal?: AbortSignal): void {
     // find work that will fit the availability of workers
     const workIndex = pickTaskFromQueue(this.queue, this.availability);
 
@@ -135,7 +138,7 @@ export class WorkerPool extends EventEmitter implements Pool {
     }
   }
 
-  async close() {
+  async close(): Promise<void> {
     await Promise.all(this.workers.map((worker) => worker.terminate()));
   }
 }
diff --git a/packages/worker-threads-pool/src/index.ts b/packages/worker-threads-pool/src/index.ts
index 81928737c..098308de4 100644
--- a/packages/worker-threads-pool/src/index.ts
+++ b/packages/worker-threads-pool/src/index.ts
@@ -1,4 +1,4 @@
 export { registerWorker } from "./registerWorker.js";
 export { WorkerPool } from "./WorkerPool.js";
 export { AggregatedPool } from "./AggregatedPool.js";
-export type { Pool } from "./types/Pool.js";
+export type { Pool, PoolStats } from "./types/Pool.js";
diff --git a/packages/worker-threads-pool/src/pickTaskFromQueue.ts b/packages/worker-threads-pool/src/pickTaskFromQueue.ts
index e4999c4f6..a453f1918 100644
--- a/packages/worker-threads-pool/src/pickTaskFromQueue.ts
+++ b/packages/worker-threads-pool/src/pickTaskFromQueue.ts
@@ -21,7 +21,7 @@ function isBetterCandidateThanCurrent(current: QueueItem | undefined, candidate:
  * There are no eligible tasks when the queue is empty, there is no availability, there are no tasks with a weight lower than the availability, or the tasks with the highest priority have a weight higher than the availability.
  * @returns the index of the task to run or -1 if no eligible task is available.
  */
-export function pickTaskFromQueue(queue: QueueItem[], availability: number) {
+export function pickTaskFromQueue(queue: QueueItem[], availability: number): number {
   let maxPrioritySeenSoFar: undefined | number = undefined;
   let bestCandidateTask: undefined | { queueItem: QueueItem; index: number } = undefined;
   for (let i = 0; i < queue.length; i++) {
diff --git a/packages/worker-threads-pool/src/registerWorker.ts b/packages/worker-threads-pool/src/registerWorker.ts
index ecb68d7ca..4a3dfc60c 100644
--- a/packages/worker-threads-pool/src/registerWorker.ts
+++ b/packages/worker-threads-pool/src/registerWorker.ts
@@ -3,7 +3,7 @@ import { endMarker, startMarker } from "./stdioStreamMarkers.js";
 
 import type { MessagePort } from "worker_threads";
 
-export function registerWorker(fn: (data: any, abortSignal?: AbortSignal) => Promise<any> | any) {
+export function registerWorker(fn: (data: any, abortSignal?: AbortSignal) => Promise<any> | any): void {
   parentPort?.on("message", async (message) => {
     let abortController: AbortController | undefined;
 
diff --git a/packages/worker-threads-pool/src/stdioStreamMarkers.ts b/packages/worker-threads-pool/src/stdioStreamMarkers.ts
index 8c7b7af2d..d847d1a5a 100644
--- a/packages/worker-threads-pool/src/stdioStreamMarkers.ts
+++ b/packages/worker-threads-pool/src/stdioStreamMarkers.ts
@@ -1,10 +1,10 @@
 export const START_MARKER_PREFIX = "## WORKER:START:";
 export const END_MARKER_PREFIX = "## WORKER:END:";
 
-export function startMarker(id: string) {
+export function startMarker(id: string): string {
   return `${START_MARKER_PREFIX}${id}`;
 }
 
-export function endMarker(id: string) {
+export function endMarker(id: string): string {
   return `${END_MARKER_PREFIX}${id}`;
 }
diff --git a/scripts/config/eslintrc.js b/scripts/config/eslintrc.js
index 1eee2db1e..7964d7ca4 100644
--- a/scripts/config/eslintrc.js
+++ b/scripts/config/eslintrc.js
@@ -14,6 +14,7 @@ module.exports = {
     "no-console": "error",
     "file-extension-in-import-ts/file-extension-in-import-ts": "error",
     "@typescript-eslint/no-floating-promises": "error",
+    "@typescript-eslint/explicit-module-boundary-types": "error",
   },
   parserOptions: {
     project: "./tsconfig.json",
diff --git a/scripts/config/tsconfig.base.json b/scripts/config/tsconfig.base.json
index 6f068fe2d..da4796630 100644
--- a/scripts/config/tsconfig.base.json
+++ b/scripts/config/tsconfig.base.json
@@ -2,8 +2,9 @@
   "compilerOptions": {
     "target": "ES2020",
     "module": "CommonJS",
-    "moduleResolution": "Node16",
+    "moduleResolution": "Node",
     "declaration": true,
+    "isolatedModules": true,
     "lib": ["ES2020"],
     "allowJs": true,
     "strict": true,
diff --git a/scripts/package.json b/scripts/package.json
index 852455bbc..7fd31d678 100644
--- a/scripts/package.json
+++ b/scripts/package.json
@@ -14,7 +14,7 @@
     "eslint": "^8.20.0",
     "eslint-plugin-file-extension-in-import-ts": "^1.0.1",
     "jest": "^30.0.0",
-    "typescript": "~5.0.3",
+    "typescript": "~5.9.3",
     "workspace-tools": "0.40.4"
   }
 }
diff --git a/yarn.lock b/yarn.lock
index e1fd0f2ad..62895d670 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1657,7 +1657,7 @@ __metadata:
     dts-bundle-generator: "npm:^9.5.1"
     esbuild: "npm:^0.25.0"
     globby: "npm:^14.0.2"
-    typescript: "npm:~5.0.3"
+    typescript: "npm:~5.9.3"
   languageName: unknown
   linkType: soft
 
@@ -1696,7 +1696,7 @@ __metadata:
     prettier: "npm:^3.0.0"
     syncpack: "npm:^13.0.0"
     ts-node: "npm:^10.9.1"
-    typescript: "npm:~5.0.3"
+    typescript: "npm:~5.9.3"
   languageName: unknown
   linkType: soft
 
@@ -1731,7 +1731,7 @@ __metadata:
     eslint: "npm:^8.20.0"
     eslint-plugin-file-extension-in-import-ts: "npm:^1.0.1"
     jest: "npm:^30.0.0"
-    typescript: "npm:~5.0.3"
+    typescript: "npm:~5.9.3"
     workspace-tools: "npm:0.40.4"
   bin:
     monorepo-scripts: bin/monorepo-scripts.js
@@ -8155,13 +8155,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"typescript@npm:~5.0.3":
-  version: 5.0.4
-  resolution: "typescript@npm:5.0.4"
+"typescript@npm:~5.9.3":
+  version: 5.9.3
+  resolution: "typescript@npm:5.9.3"
   bin:
     tsc: bin/tsc
     tsserver: bin/tsserver
-  checksum: 10c0/2f5bd1cead194905957cb34e220b1d6ff1662399adef8ec1864f74620922d860ee35b6e50eafb3b636ea6fd437195e454e1146cb630a4236b5095ed7617395c2
+  checksum: 10c0/6bd7552ce39f97e711db5aa048f6f9995b53f1c52f7d8667c1abdc1700c68a76a308f579cd309ce6b53646deb4e9a1be7c813a93baaf0a28ccd536a30270e1c5
   languageName: node
   linkType: hard
 
@@ -8175,13 +8175,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"typescript@patch:typescript@npm%3A~5.0.3#optional!builtin<compat/typescript>":
-  version: 5.0.4
-  resolution: "typescript@patch:typescript@npm%3A5.0.4#optional!builtin<compat/typescript>::version=5.0.4&hash=b5f058"
+"typescript@patch:typescript@npm%3A~5.9.3#optional!builtin<compat/typescript>":
+  version: 5.9.3
+  resolution: "typescript@patch:typescript@npm%3A5.9.3#optional!builtin<compat/typescript>::version=5.9.3&hash=5786d5"
   bin:
     tsc: bin/tsc
     tsserver: bin/tsserver
-  checksum: 10c0/c3f7b80577bddf6fab202a7925131ac733bfc414aec298c2404afcddc7a6f242cfa8395cf2d48192265052e11a7577c27f6e5fac8d8fe6a6602023c83d6b3292
+  checksum: 10c0/ad09fdf7a756814dce65bc60c1657b40d44451346858eea230e10f2e95a289d9183b6e32e5c11e95acc0ccc214b4f36289dcad4bf1886b0adb84d711d336a430
   languageName: node
   linkType: hard