diff --git a/greenwood.config.js b/greenwood.config.js
index 332980001..525eeee88 100644
--- a/greenwood.config.js
+++ b/greenwood.config.js
@@ -6,10 +6,9 @@ import { greenwoodPluginPolyfills } from '@greenwood/plugin-polyfills';
 import { greenwoodPluginPostCss } from '@greenwood/plugin-postcss';
 import { greenwoodPluginRendererPuppeteer } from '@greenwood/plugin-renderer-puppeteer';
 import rollupPluginAnalyzer from 'rollup-plugin-analyzer';
-import { fileURLToPath, URL } from 'url';
 
 export default {
-  workspace: fileURLToPath(new URL('./www', import.meta.url)),
+  workspace: new URL('./www/', import.meta.url),
   prerender: true,
   optimization: 'inline',
   staticRouter: true,
@@ -20,6 +19,8 @@ export default {
     greenwoodPluginPostCss(),
     greenwoodPluginImportJson(),
     greenwoodPluginImportCss(),
+    greenwoodPluginIncludeHTML(),
+    greenwoodPluginRendererPuppeteer(),
     {
       type: 'rollup',
       name: 'rollup-plugin-analyzer',
@@ -33,9 +34,7 @@ export default {
           })
         ];
       }
-    },
-    greenwoodPluginIncludeHTML(),
-    greenwoodPluginRendererPuppeteer()
+    }
   ],
   markdown: {
     plugins: [
diff --git a/packages/cli/src/commands/build.js b/packages/cli/src/commands/build.js
index e5ce43348..b8b9e142a 100644
--- a/packages/cli/src/commands/build.js
+++ b/packages/cli/src/commands/build.js
@@ -1,6 +1,7 @@
 import { bundleCompilation } from '../lifecycles/bundle.js';
+import { checkResourceExists } from '../lib/resource-utils.js';
 import { copyAssets } from '../lifecycles/copy.js';
-import fs from 'fs';
+import fs from 'fs/promises';
 import { preRenderCompilationWorker, preRenderCompilationCustom, staticRenderCompilation } from '../lifecycles/prerender.js';
 import { ServerInterface } from '../lib/server-interface.js';
 
@@ -11,12 +12,14 @@ const runProductionBuild = async (compilation) => {
     try {
       const { prerender } = compilation.config;
       const outputDir = compilation.context.outputDir;
-      const prerenderPlugin = (compilation.config.plugins.filter(plugin => plugin.type === 'renderer') || []).length === 1
-        ? compilation.config.plugins.filter(plugin => plugin.type === 'renderer')[0].provider(compilation)
+      const prerenderPlugin = compilation.config.plugins.find(plugin => plugin.type === 'renderer')
+        ? compilation.config.plugins.find(plugin => plugin.type === 'renderer').provider(compilation)
         : {};
 
-      if (!fs.existsSync(outputDir)) {
-        fs.mkdirSync(outputDir);
+      if (!await checkResourceExists(outputDir)) {
+        await fs.mkdir(outputDir, {
+          recursive: true
+        });
       }
 
       if (prerender || prerenderPlugin.prerender) {
diff --git a/packages/cli/src/commands/eject.js b/packages/cli/src/commands/eject.js
index e93792ff7..886b74e2a 100644
--- a/packages/cli/src/commands/eject.js
+++ b/packages/cli/src/commands/eject.js
@@ -1,21 +1,19 @@
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath, URL } from 'url';
+import fs from 'fs/promises';
 
 const ejectConfiguration = async (compilation) => {
   return new Promise(async (resolve, reject) => {
     try {
-      const configFilePath = fileURLToPath(new URL('../config', import.meta.url));
-      const configFiles = fs.readdirSync(configFilePath);
+      const configFileDirUrl = new URL('../config/', import.meta.url);
+      const configFiles = await fs.readdir(configFileDirUrl);
       
-      configFiles.forEach((configFile) => {
-        const from = path.join(configFilePath, configFile);
-        const to = `${compilation.context.projectDirectory}/${configFile}`;
+      for (const file of configFiles) {
+        const from = new URL(`./${file}`, configFileDirUrl);
+        const to = new URL(`./${file}`, compilation.context.projectDirectory);
 
-        fs.copyFileSync(from, to);
+        await fs.copyFile(from, to);
         
-        console.log(`Ejected ${configFile} successfully.`);
-      });
+        console.log(`Ejected ${file} successfully.`);
+      }
 
       console.debug('all configuration files ejected.');
 
diff --git a/packages/cli/src/config/rollup.config.js b/packages/cli/src/config/rollup.config.js
index 0fec32a25..2e6e34f97 100644
--- a/packages/cli/src/config/rollup.config.js
+++ b/packages/cli/src/config/rollup.config.js
@@ -1,5 +1,5 @@
-import fs from 'fs';
-import path from 'path';
+import fs from 'fs/promises';
+import { checkResourceExists, normalizePathnameForWindows, resolveForRelativeUrl } from '../lib/resource-utils.js';
 
 function greenwoodResourceLoader (compilation) {
   const resourcePlugins = compilation.config.plugins.filter((plugin) => {
@@ -10,43 +10,42 @@ function greenwoodResourceLoader (compilation) {
 
   return {
     name: 'greenwood-resource-loader',
-    resolveId(id) {
-      const { userWorkspace } = compilation.context;
+    async resolveId(id) {
+      const normalizedId = id.replace(/\?type=(.*)/, '');
+      const { projectDirectory, userWorkspace } = compilation.context;
 
-      if ((id.indexOf('./') === 0 || id.indexOf('/') === 0) && fs.existsSync(path.join(userWorkspace, id))) {
-        return path.join(userWorkspace, id.replace(/\?type=(.*)/, ''));
-      }
+      if (id.startsWith('.') || id.startsWith('/')) {
+        const prefix = id.startsWith('/') ? '.' : '';
+        const contextUrl = id.indexOf('/node_modules/') >= 0 ? projectDirectory : userWorkspace;
+        const userWorkspaceUrl = await resolveForRelativeUrl(new URL(`${prefix}${normalizedId}`, contextUrl), contextUrl);
 
-      return null;
+        if (await checkResourceExists(userWorkspaceUrl)) {
+          return normalizePathnameForWindows(userWorkspaceUrl);
+        }
+      }
     },
     async load(id) {
-      const importAsIdAsUrl = id.replace(/\?type=(.*)/, '');
-      const extension = path.extname(importAsIdAsUrl);
+      const pathname = id.indexOf('?') >= 0 ? id.slice(0, id.indexOf('?')) : id;
+      const extension = pathname.split('.').pop();
 
-      if (extension !== '.js') {
-        const originalUrl = `${id}?type=${extension.replace('.', '')}`;
-        let contents;
+      if (extension !== '' && extension !== 'js') {
+        const url = new URL(`file://${pathname}?type=${extension}`);
+        const request = new Request(url.href);
+        let response = new Response('');
 
         for (const plugin of resourcePlugins) {
-          const headers = {
-            request: {
-              originalUrl
-            },
-            response: {
-              'content-type': plugin.contentType
-            }
-          };
-
-          contents = await plugin.shouldServe(importAsIdAsUrl)
-            ? (await plugin.serve(importAsIdAsUrl)).body
-            : contents;
+          if (plugin.shouldServe && await plugin.shouldServe(url, request)) {
+            response = await plugin.serve(url, request);
+          }
+        }
 
-          if (await plugin.shouldIntercept(importAsIdAsUrl, contents, headers)) {
-            contents = (await plugin.intercept(importAsIdAsUrl, contents, headers)).body;
+        for (const plugin of resourcePlugins) {
+          if (plugin.shouldIntercept && await plugin.shouldIntercept(url, request, response.clone())) {
+            response = await plugin.intercept(url, request, response.clone());
           }
         }
 
-        return contents;
+        return await response.text();
       }
     }
   };
@@ -55,15 +54,14 @@ function greenwoodResourceLoader (compilation) {
 function greenwoodSyncPageResourceBundlesPlugin(compilation) {
   return {
     name: 'greenwood-sync-page-resource-bundles-plugin',
-    writeBundle(outputOptions, bundles) {
+    async writeBundle(outputOptions, bundles) {
       const { outputDir } = compilation.context;
 
       for (const resource of compilation.resources.values()) {
-        const resourceKey = resource.sourcePathURL.pathname;
+        const resourceKey = normalizePathnameForWindows(resource.sourcePathURL);
 
         for (const bundle in bundles) {
           let facadeModuleId = (bundles[bundle].facadeModuleId || '').replace(/\\/g, '/');
-
           /*
            * this is an odd issue related to symlinking in our Greenwood monorepo when building the website
            * and managing packages that we create as "virtual" modules, like for the mpa router
@@ -82,25 +80,27 @@ function greenwoodSyncPageResourceBundlesPlugin(compilation) {
            * pathToMatch (before): /node_modules/@greenwood/cli/src/lib/router.js
            * pathToMatch (after): /cli/src/lib/router.js
            */
-          if (facadeModuleId && resourceKey.indexOf('/node_modules/@greenwood/cli') > 0 && facadeModuleId.indexOf('/packages/cli') > 0 && fs.existsSync(facadeModuleId)) {
-            facadeModuleId = facadeModuleId.replace('/packages/cli', '/node_modules/@greenwood/cli');
+          if (resourceKey?.indexOf('/node_modules/@greenwood/cli') > 0 && facadeModuleId?.indexOf('/packages/cli') > 0) {
+            if (await checkResourceExists(new URL(`file://${facadeModuleId}`))) {
+              facadeModuleId = facadeModuleId.replace('/packages/cli', '/node_modules/@greenwood/cli');
+            }
           }
 
           if (resourceKey === facadeModuleId) {
             const { fileName } = bundles[bundle];
             const { rawAttributes, contents } = resource;
             const noop = rawAttributes && rawAttributes.indexOf('data-gwd-opt="none"') >= 0 || compilation.config.optimization === 'none';
-            const outputPath = path.join(outputDir, fileName);
+            const outputPath = new URL(`./${fileName}`, outputDir);
 
-            compilation.resources.set(resourceKey, {
-              ...compilation.resources.get(resourceKey),
+            compilation.resources.set(resource.sourcePathURL.pathname, {
+              ...compilation.resources.get(resource.sourcePathURL.pathname),
               optimizedFileName: fileName,
-              optimizedFileContents: fs.readFileSync(outputPath, 'utf-8'),
+              optimizedFileContents: await fs.readFile(outputPath, 'utf-8'),
               contents: contents.replace(/\.\//g, '/')
             });
 
             if (noop) {
-              fs.writeFileSync(outputPath, contents);
+              await fs.writeFile(outputPath, contents);
             }
           }
         }
@@ -113,7 +113,7 @@ const getRollupConfig = async (compilation) => {
   const { outputDir } = compilation.context;
   const input = [...compilation.resources.values()]
     .filter(resource => resource.type === 'script')
-    .map(resource => resource.sourcePathURL.pathname);
+    .map(resource => normalizePathnameForWindows(resource.sourcePathURL));
   const customRollupPlugins = compilation.config.plugins.filter(plugin => {
     return plugin.type === 'rollup';
   }).map(plugin => {
@@ -124,7 +124,7 @@ const getRollupConfig = async (compilation) => {
     preserveEntrySignatures: 'strict', // https://github.com/ProjectEvergreen/greenwood/pull/990
     input,
     output: { 
-      dir: outputDir,
+      dir: normalizePathnameForWindows(outputDir),
       entryFileNames: '[name].[hash].js',
       chunkFileNames: '[name].[hash].js',
       sourcemap: true
diff --git a/packages/cli/src/index.js b/packages/cli/src/index.js
index f398ed2e7..566b68ac2 100755
--- a/packages/cli/src/index.js
+++ b/packages/cli/src/index.js
@@ -6,11 +6,11 @@
 process.setMaxListeners(0);
 
 import { generateCompilation } from './lifecycles/compile.js';
-import fs from 'fs';
+import fs from 'fs/promises';
 import program from 'commander';
 import { URL } from 'url';
 
-const greenwoodPackageJson = JSON.parse(await fs.promises.readFile(new URL('../package.json', import.meta.url), 'utf-8'));
+const greenwoodPackageJson = JSON.parse(await fs.readFile(new URL('../package.json', import.meta.url), 'utf-8'));
 let cmdOption = {};
 let command = '';
 
diff --git a/packages/cli/src/lib/node-modules-utils.js b/packages/cli/src/lib/node-modules-utils.js
index 393d03c9f..2a45af8ad 100644
--- a/packages/cli/src/lib/node-modules-utils.js
+++ b/packages/cli/src/lib/node-modules-utils.js
@@ -1,6 +1,8 @@
+// TODO convert this to use / return URLs
+// https://github.com/ProjectEvergreen/greenwood/issues/953
 import { createRequire } from 'module'; // https://stackoverflow.com/a/62499498/417806
-import fs from 'fs';
-import path from 'path';
+import { checkResourceExists } from '../lib/resource-utils.js';
+import fs from 'fs/promises';
 
 // defer to NodeJS to find where on disk a package is located using import.meta.resolve
 // and return the root absolute location
@@ -35,14 +37,14 @@ async function getNodeModulesLocationForPackage(packageName) {
       const nodeModulesPackageRoot = `${locations[location]}/${packageName}`;
       const packageJsonLocation = `${nodeModulesPackageRoot}/package.json`;
 
-      if (fs.existsSync(packageJsonLocation)) {
+      if (await checkResourceExists(new URL(`file://${packageJsonLocation}`))) {
         nodeModulesUrl = nodeModulesPackageRoot;
       }
     }
 
     if (!nodeModulesUrl) {
       console.debug(`Unable to look up ${packageName} using NodeJS require.resolve.  Falling back to process.cwd()`);
-      nodeModulesUrl = path.join(process.cwd(), 'node_modules', packageName); // force / for consistency and path matching);
+      nodeModulesUrl = new URL(`./node_modules/${packageName}`, `file://${process.cwd()}`).pathname;
     }
   }
 
@@ -62,7 +64,21 @@ function getPackageNameFromUrl(url) {
   return packageName;
 }
 
+async function getPackageJson({ userWorkspace, projectDirectory }) {
+  const monorepoPackageJsonUrl = new URL('./package.json', userWorkspace);
+  const topLevelPackageJsonUrl = new URL('./package.json', projectDirectory);
+  const hasMonorepoPackageJson = await checkResourceExists(monorepoPackageJsonUrl);
+  const hasTopLevelPackageJson = await checkResourceExists(topLevelPackageJsonUrl);
+
+  return hasMonorepoPackageJson // handle monorepos first
+    ? JSON.parse(await fs.readFile(monorepoPackageJsonUrl, 'utf-8'))
+    : hasTopLevelPackageJson
+      ? JSON.parse(await fs.readFile(topLevelPackageJsonUrl, 'utf-8'))
+      : {};
+}
+
 export {
   getNodeModulesLocationForPackage,
+  getPackageJson,
   getPackageNameFromUrl
 };
\ No newline at end of file
diff --git a/packages/cli/src/lib/resource-interface.js b/packages/cli/src/lib/resource-interface.js
index adb07900d..bee66b637 100644
--- a/packages/cli/src/lib/resource-interface.js
+++ b/packages/cli/src/lib/resource-interface.js
@@ -1,96 +1,8 @@
-import fs from 'fs';
-import path from 'path';
-
 class ResourceInterface {
   constructor(compilation, options = {}) {
     this.compilation = compilation;
     this.options = options;
     this.extensions = [];
-    this.contentType = ''; // https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types
-  }
-
-  // get rid of things like query string parameters
-  // that will break when trying to use with fs
-  getBareUrlPath(url) {
-    return url.replace(/\?(.*)/, '');
-  }
-
-  // turn relative paths into relatively absolute based on a known root directory
-  // e.g. "../styles/theme.css" -> `${userWorkspace}/styles/theme.css`
-  resolveRelativeUrl(root, url) {
-    if (fs.existsSync(path.join(root, url))) {
-      return url;
-    }
-
-    let reducedUrl;
-
-    url.split('/')
-      .filter((segment) => segment !== '')
-      .reduce((acc, segment) => {
-        const reducedPath = url.replace(`${acc}/${segment}`, '');
-
-        if (path.extname(reducedPath) !== '' && fs.existsSync(path.join(root, reducedPath))) {
-          reducedUrl = reducedPath;
-        }
-        return `${acc}/${segment}`;
-      }, '');
-
-    return reducedUrl;
-  }
-
-  // test if this plugin should change a relative URL from the browser to an absolute path on disk 
-  // like for node_modules/ resolution. not commonly needed by most resource plugins
-  // return true | false
-  // eslint-disable-next-line no-unused-vars
-  async shouldResolve(url) {
-    return Promise.resolve(false);
-  }
-
-  // return an absolute path
-  async resolve(url) {
-    return Promise.resolve(url);
-  }
-
-  // test if this plugin should be used to process a given url / header combo the browser and retu
-  // ex: `<script type="module" src="index.ts">`
-  // return true | false
-  // eslint-disable-next-line no-unused-vars
-  async shouldServe(url, headers) {
-    return Promise.resolve(this.extensions.indexOf(path.extname(url)) >= 0);
-  }
-
-  // return the new body and / or contentType, e.g. convert file.foo -> file.js
-  // eslint-disable-next-line no-unused-vars
-  async serve(url, headers) {
-    return Promise.resolve({});
-  }
-
-  // test if this plugin should return a new body for an already resolved resource
-  // useful for modifying code on the fly without needing to read the file from disk
-  // return true | false
-  // eslint-disable-next-line no-unused-vars
-  async shouldIntercept(url, body, headers) {
-    return Promise.resolve(false);
-  }
-
-  // return the new body
-  // eslint-disable-next-line no-unused-vars
-  async intercept(url, body, headers) {
-    return Promise.resolve({ body });
-  }
-
-  // test if this plugin should manipulate any files prior to any final optmizations happening 
-  // ex: add a "banner" to all .js files with a timestamp of the build, or minifying files
-  // return true | false
-  // eslint-disable-next-line no-unused-vars
-  async shouldOptimize(url, body, headers) {
-    return Promise.resolve(false);
-  }
-
-  // return the new body
-  // eslint-disable-next-line no-unused-vars
-  async optimize (url, body, headers) {
-    return Promise.resolve(body);
   }
 }
 
diff --git a/packages/cli/src/lib/resource-utils.js b/packages/cli/src/lib/resource-utils.js
index 506f3b0ba..7feb3091f 100644
--- a/packages/cli/src/lib/resource-utils.js
+++ b/packages/cli/src/lib/resource-utils.js
@@ -1,38 +1,24 @@
-import fs from 'fs';
+import fs from 'fs/promises';
 import { hashString } from '../lib/hashing-utils.js';
-import path from 'path';
-import { pathToFileURL } from 'url';
 
-function modelResource(context, type, src = undefined, contents = undefined, optimizationAttr = undefined, rawAttributes = undefined) {
+async function modelResource(context, type, src = undefined, contents = undefined, optimizationAttr = undefined, rawAttributes = undefined) {
   const { projectDirectory, scratchDir, userWorkspace } = context;
   const extension = type === 'script' ? 'js' : 'css';
-  const windowsDriveRegex = /\/[a-zA-Z]{1}:\//;
   let sourcePathURL;
 
   if (src) {
-    sourcePathURL = src.indexOf('/node_modules') === 0
-      ? pathToFileURL(path.join(projectDirectory, src)) // TODO (good first issue) get "real" location of node modules
-      : pathToFileURL(path.join(userWorkspace, src.replace(/\.\.\//g, '').replace('./', '')));
+    sourcePathURL = src.startsWith('/node_modules')
+      ? new URL(`.${src}`, projectDirectory)
+      : src.startsWith('/')
+        ? new URL(`.${src}`, userWorkspace)
+        : new URL(`./${src.replace(/\.\.\//g, '').replace('./', '')}`, userWorkspace);
 
-    contents = fs.readFileSync(sourcePathURL, 'utf-8');
+    contents = await fs.readFile(sourcePathURL, 'utf-8');
   } else {
     const scratchFileName = hashString(contents);
 
-    sourcePathURL = pathToFileURL(path.join(scratchDir, `${scratchFileName}.${extension}`));
-    fs.writeFileSync(sourcePathURL, contents);
-  }
-
-  // TODO (good first issue) handle for Windows adding extra / in front of drive letter for whatever reason :(
-  // e.g. turn /C:/... -> C:/...
-  // and also URL is readonly in NodeJS??
-  if (windowsDriveRegex.test(sourcePathURL.pathname)) {
-    const driveMatch = sourcePathURL.pathname.match(windowsDriveRegex)[0];
-
-    sourcePathURL = {
-      ...sourcePathURL,
-      pathname: sourcePathURL.pathname.replace(driveMatch, driveMatch.replace('/', '')),
-      href: sourcePathURL.href.replace(driveMatch, driveMatch.replace('/', ''))
-    };
+    sourcePathURL = new URL(`./${scratchFileName}.${extension}`, scratchDir);
+    await fs.writeFile(sourcePathURL, contents);
   }
 
   return {
@@ -47,4 +33,82 @@ function modelResource(context, type, src = undefined, contents = undefined, opt
   };
 }
 
-export { modelResource };
\ No newline at end of file
+function mergeResponse(destination, source) {
+  const headers = destination.headers || new Headers();
+
+  source.headers.forEach((value, key) => {
+    // TODO better way to handle Response automatically setting content-type
+    // https://github.com/ProjectEvergreen/greenwood/issues/1049
+    const isDefaultHeader = key.toLowerCase() === 'content-type' && value === 'text/plain;charset=UTF-8';
+
+    if (!isDefaultHeader) {
+      headers.set(key, value);
+    }
+  });
+
+  // TODO handle merging in state (aborted, type, status, etc)
+  // https://github.com/ProjectEvergreen/greenwood/issues/1048
+  return new Response(source.body, {
+    headers
+  });
+}
+
+// On Windows, a URL with a drive letter like C:/ thinks it is a protocol and so prepends a /, e.g. /C:/
+// This is fine with never fs methods that Greenwood uses, but tools like Rollupand PostCSS will need this handled manually
+// https://github.com/rollup/rollup/issues/3779
+function normalizePathnameForWindows(url) {
+  const windowsDriveRegex = /\/[a-zA-Z]{1}:\//;
+  const { pathname = '' } = url;
+
+  if (windowsDriveRegex.test(pathname)) {
+    const driveMatch = pathname.match(windowsDriveRegex)[0];
+
+    return pathname.replace(driveMatch, driveMatch.replace('/', ''));
+  }
+
+  return pathname;
+}
+
+async function checkResourceExists(url) {
+  try {
+    await fs.access(url);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+// turn relative paths into relatively absolute based on a known root directory
+// * deep link route - /blog/releases/some-post
+// * and a nested path in the template - ../../styles/theme.css
+// so will get resolved as `${rootUrl}/styles/theme.css`
+async function resolveForRelativeUrl(url, rootUrl) {
+  const search = url.search || '';
+  let reducedUrl;
+
+  if (await checkResourceExists(new URL(`.${url.pathname}`, rootUrl))) {
+    return new URL(`.${url.pathname}${search}`, rootUrl);
+  }
+
+  const segments = url.pathname.split('/').filter(segment => segment !== '');
+  segments.shift();
+
+  for (let i = 0, l = segments.length - 1; i < l; i += 1) {
+    const nextSegments = segments.slice(i);
+    const urlToCheck = new URL(`./${nextSegments.join('/')}`, rootUrl);
+
+    if (await checkResourceExists(urlToCheck)) {
+      reducedUrl = new URL(`${urlToCheck}${search}`);
+    }
+  }
+
+  return reducedUrl;
+}
+
+export {
+  checkResourceExists,
+  mergeResponse,
+  modelResource,
+  normalizePathnameForWindows,
+  resolveForRelativeUrl
+};
\ No newline at end of file
diff --git a/packages/cli/src/lib/ssr-route-worker.js b/packages/cli/src/lib/ssr-route-worker.js
index 129fecc45..e43c380d6 100644
--- a/packages/cli/src/lib/ssr-route-worker.js
+++ b/packages/cli/src/lib/ssr-route-worker.js
@@ -1,9 +1,8 @@
 // https://github.com/nodejs/modules/issues/307#issuecomment-858729422
-import { pathToFileURL } from 'url';
 import { parentPort } from 'worker_threads';
 import { renderToString, renderFromHTML } from 'wc-compiler';
 
-async function executeRouteModule({ modulePath, compilation, route, label, id, prerender, htmlContents, scripts }) {
+async function executeRouteModule({ moduleUrl, compilation, route, label, id, prerender, htmlContents, scripts }) {
   const parsedCompilation = JSON.parse(compilation);
   const data = {
     template: null,
@@ -18,11 +17,11 @@ async function executeRouteModule({ modulePath, compilation, route, label, id, p
 
     data.html = html;
   } else {
-    const module = await import(pathToFileURL(modulePath)).then(module => module);
+    const module = await import(moduleUrl).then(module => module);
     const { getTemplate = null, getBody = null, getFrontmatter = null } = module;
 
     if (module.default) {
-      const { html } = await renderToString(pathToFileURL(modulePath));
+      const { html } = await renderToString(new URL(moduleUrl));
 
       data.body = html;
     } else {
diff --git a/packages/cli/src/lifecycles/bundle.js b/packages/cli/src/lifecycles/bundle.js
index 39d4de559..bc58cf0dd 100644
--- a/packages/cli/src/lifecycles/bundle.js
+++ b/packages/cli/src/lifecycles/bundle.js
@@ -1,6 +1,8 @@
-import fs from 'fs';
+/* eslint-disable max-depth */
+import fs from 'fs/promises';
 import { getRollupConfig } from '../config/rollup.config.js';
 import { hashString } from '../lib/hashing-utils.js';
+import { checkResourceExists, mergeResponse } from '../lib/resource-utils.js';
 import path from 'path';
 import { rollup } from 'rollup';
 
@@ -13,44 +15,47 @@ async function cleanUpResources(compilation) {
     const optAttr = ['inline', 'static'].indexOf(optimizationAttr) >= 0;
 
     if (optimizedFileName && (!src || (optAttr || optConfig))) {
-      fs.unlinkSync(path.join(outputDir, optimizedFileName));
+      await fs.unlink(new URL(`./${optimizedFileName}`, outputDir));
     }
   }
 }
 
-async function optimizeStaticPages(compilation, optimizeResources) {
+async function optimizeStaticPages(compilation, plugins) {
   const { scratchDir, outputDir } = compilation.context;
 
   return Promise.all(compilation.graph
     .filter(page => !page.isSSR || (page.isSSR && page.data.static) || (page.isSSR && compilation.config.prerender))
     .map(async (page) => {
       const { route, outputPath } = page;
-      const html = await fs.promises.readFile(path.join(scratchDir, outputPath), 'utf-8');
-
-      if (route !== '/404/' && !fs.existsSync(path.join(outputDir, route))) {
-        fs.mkdirSync(path.join(outputDir, route), {
+      const outputDirUrl = new URL(`.${route}`, outputDir);
+      const url = new URL(`http://localhost:${compilation.config.port}${route}`);
+      const contents = await fs.readFile(new URL(`./${outputPath}`, scratchDir), 'utf-8');
+      const headers = new Headers({ 'Content-Type': 'text/html' });
+      let response = new Response(contents, { headers });
+
+      if (!await checkResourceExists(outputDirUrl)) {
+        await fs.mkdir(outputDirUrl, {
           recursive: true
         });
       }
 
-      let htmlOptimized = await optimizeResources.reduce(async (htmlPromise, resource) => {
-        const contents = await htmlPromise;
-        const shouldOptimize = await resource.shouldOptimize(outputPath, contents);
+      for (const plugin of plugins) {
+        if (plugin.shouldOptimize && await plugin.shouldOptimize(url, response.clone())) {
+          const currentResponse = await plugin.optimize(url, response.clone());
 
-        return shouldOptimize
-          ? resource.optimize(outputPath, contents)
-          : Promise.resolve(contents);
-      }, Promise.resolve(html));
+          response = mergeResponse(response.clone(), currentResponse.clone());
+        }
+      }
 
       // clean up optimization markers
-      htmlOptimized = htmlOptimized.replace(/data-gwd-opt=".*[a-z]"/g, '');
+      const body = (await response.text()).replace(/data-gwd-opt=".*[a-z]"/g, '');
 
-      await fs.promises.writeFile(path.join(outputDir, outputPath), htmlOptimized);
+      await fs.writeFile(new URL(`./${outputPath}`, outputDir), body);
     })
   );
 }
 
-async function bundleStyleResources(compilation, optimizationPlugins) {
+async function bundleStyleResources(compilation, resourcePlugins) {
   const { outputDir } = compilation.context;
 
   for (const resource of compilation.resources.values()) {
@@ -74,10 +79,16 @@ async function bundleStyleResources(compilation, optimizationPlugins) {
         optimizedFileName = `${hashString(contents)}.css`;
       }
 
-      const outputPathRoot = path.join(outputDir, path.dirname(optimizedFileName));
+      const outputPathRoot = new URL(`./${optimizedFileName}`, outputDir)
+        .pathname
+        .split('/')
+        .slice(0, -1)
+        .join('/')
+        .concat('/');
+      const outputPathRootUrl = new URL(`file://${outputPathRoot}`);
 
-      if (!fs.existsSync(outputPathRoot)) {
-        fs.mkdirSync(outputPathRoot, {
+      if (!await checkResourceExists(outputPathRootUrl)) {
+        await fs.mkdir(new URL(`file://${outputPathRoot}`), {
           recursive: true
         });
       }
@@ -85,22 +96,38 @@ async function bundleStyleResources(compilation, optimizationPlugins) {
       if (compilation.config.optimization === 'none' || optimizationAttr === 'none') {
         optimizedFileContents = contents;
       } else {
-        const url = resource.sourcePathURL.pathname;
-        let optimizedStyles = await fs.promises.readFile(url, 'utf-8');
-
-        for (const plugin of optimizationPlugins) {
-          optimizedStyles = await plugin.shouldIntercept(url, optimizedStyles)
-            ? (await plugin.intercept(url, optimizedStyles)).body
-            : optimizedStyles;
-        }
-
-        for (const plugin of optimizationPlugins) {
-          optimizedStyles = await plugin.shouldOptimize(url, optimizedStyles)
-            ? await plugin.optimize(url, optimizedStyles)
-            : optimizedStyles;
-        }
-
-        optimizedFileContents = optimizedStyles;
+        const url = resource.sourcePathURL;
+        const contentType = 'text/css';
+        const headers = new Headers({ 'Content-Type': contentType });
+        const request = new Request(url, { headers });
+        const initResponse = new Response(contents, { headers });
+
+        let response = await resourcePlugins.reduce(async (responsePromise, plugin) => {
+          const intermediateResponse = await responsePromise;
+          const shouldIntercept = plugin.shouldIntercept && await plugin.shouldIntercept(url, request, intermediateResponse.clone());
+
+          if (shouldIntercept) {
+            const currentResponse = await plugin.intercept(url, request, intermediateResponse.clone());
+            const mergedResponse = mergeResponse(intermediateResponse.clone(), currentResponse.clone());
+
+            if (mergedResponse.headers.get('Content-Type').indexOf(contentType) >= 0) {
+              return Promise.resolve(mergedResponse.clone());
+            }
+          }
+
+          return Promise.resolve(responsePromise);
+        }, Promise.resolve(initResponse));
+
+        response = await resourcePlugins.reduce(async (responsePromise, plugin) => {
+          const intermediateResponse = await responsePromise;
+          const shouldOptimize = plugin.shouldOptimize && await plugin.shouldOptimize(url, intermediateResponse.clone());
+
+          return shouldOptimize
+            ? Promise.resolve(await plugin.optimize(url, intermediateResponse.clone()))
+            : Promise.resolve(responsePromise);
+        }, Promise.resolve(response.clone()));
+
+        optimizedFileContents = await response.text();
       }
 
       compilation.resources.set(resourceKey, {
@@ -109,7 +136,7 @@ async function bundleStyleResources(compilation, optimizationPlugins) {
         optimizedFileContents
       });
 
-      await fs.promises.writeFile(path.join(outputDir, optimizedFileName), optimizedFileContents);
+      await fs.writeFile(new URL(`./${optimizedFileName}`, outputDir), optimizedFileContents);
     }
   }
 }
@@ -147,12 +174,12 @@ const bundleCompilation = async (compilation) => {
 
       await Promise.all([
         await bundleScriptResources(compilation),
-        await bundleStyleResources(compilation, optimizeResourcePlugins.filter(plugin => plugin.contentType.includes('text/css')))
+        await bundleStyleResources(compilation, optimizeResourcePlugins)
       ]);
 
       console.info('optimizing static pages....');
 
-      await optimizeStaticPages(compilation, optimizeResourcePlugins.filter(plugin => plugin.contentType.includes('text/html')));
+      await optimizeStaticPages(compilation, optimizeResourcePlugins);
       await cleanUpResources(compilation);
 
       resolve();
diff --git a/packages/cli/src/lifecycles/config.js b/packages/cli/src/lifecycles/config.js
index 1e4fbdaf8..52ed7f272 100644
--- a/packages/cli/src/lifecycles/config.js
+++ b/packages/cli/src/lifecycles/config.js
@@ -1,23 +1,23 @@
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath, pathToFileURL, URL } from 'url';
+import fs from 'fs/promises';
+import { checkResourceExists } from '../lib/resource-utils.js';
 
-// get and "tag" all plugins provided / maintained by the @greenwood/cli
-// and include as the default set, with all user plugins getting appended
-const greenwoodPluginsBasePath = fileURLToPath(new URL('../plugins', import.meta.url));
+const cwd = new URL(`file://${process.cwd()}/`);
+const greenwoodPluginsDirectoryUrl = new URL('../plugins/', import.meta.url);
 const PLUGINS_FLATTENED_DEPTH = 2;
 
+// get and "tag" all plugins provided / maintained by the @greenwood/cli
+// and include as the default set, with all user plugins getting appended
 const greenwoodPlugins = (await Promise.all([
-  path.join(greenwoodPluginsBasePath, 'copy'),
-  path.join(greenwoodPluginsBasePath, 'renderer'),
-  path.join(greenwoodPluginsBasePath, 'resource'),
-  path.join(greenwoodPluginsBasePath, 'server')
-].map(async (pluginDirectory) => {
-  const files = await fs.promises.readdir(pluginDirectory);
+  new URL('./copy/', greenwoodPluginsDirectoryUrl),
+  new URL('./renderer/', greenwoodPluginsDirectoryUrl),
+  new URL('./resource/', greenwoodPluginsDirectoryUrl),
+  new URL('./server/', greenwoodPluginsDirectoryUrl)
+].map(async (pluginDirectoryUrl) => {
+  const files = await fs.readdir(pluginDirectoryUrl);
 
   return await Promise.all(files.map(async(file) => {
-    const importPaTh = pathToFileURL(`${pluginDirectory}${path.sep}${file}`);
-    const pluginImport = await import(importPaTh);
+    const importUrl = new URL(`./${file}`, pluginDirectoryUrl);
+    const pluginImport = await import(importUrl);
     const plugin = pluginImport[Object.keys(pluginImport)[0]];
 
     return Array.isArray(plugin)
@@ -34,7 +34,7 @@ const greenwoodPlugins = (await Promise.all([
 const optimizations = ['default', 'none', 'static', 'inline'];
 const pluginTypes = ['copy', 'context', 'resource', 'rollup', 'server', 'source', 'renderer'];
 const defaultConfig = {
-  workspace: path.join(process.cwd(), 'src'),
+  workspace: new URL('./src/', cwd),
   devServer: {
     hud: true,
     port: 1984,
@@ -55,34 +55,35 @@ const readAndMergeConfig = async() => {
   return new Promise(async (resolve, reject) => {
     try {
       // deep clone of default config
+      const configUrl = new URL('./greenwood.config.js', cwd);
       let customConfig = Object.assign({}, defaultConfig);
+      let hasConfigFile;
+      let isSPA;
 
-      if (fs.existsSync(path.join(process.cwd(), 'greenwood.config.js'))) {
-        const userCfgFile = (await import(pathToFileURL(path.join(process.cwd(), 'greenwood.config.js')))).default;
+      // check for greenwood.config.js
+      if (await checkResourceExists(configUrl)) {
+        hasConfigFile = true;
+      }
+
+      // check for SPA
+      if (await checkResourceExists(new URL('./index.html', customConfig.workspace))) {
+        isSPA = true;
+      }
+
+      if (hasConfigFile) {
+        const userCfgFile = (await import(configUrl)).default;
         const { workspace, devServer, markdown, optimization, plugins, port, prerender, staticRouter, pagesDirectory, templatesDirectory, interpolateFrontmatter } = userCfgFile;
 
         // workspace validation
         if (workspace) {
-          if (typeof workspace !== 'string') {
-            reject('Error: greenwood.config.js workspace path must be a string');
-          }
-
-          if (!path.isAbsolute(workspace)) {
-            // prepend relative path with current directory
-            customConfig.workspace = path.join(process.cwd(), workspace);
+          if (!(workspace instanceof URL)) {
+            reject('Error: greenwood.config.js workspace must be an instance of URL');
           }
 
-          if (path.isAbsolute(workspace)) {
-            // use the users provided path
+          if (await checkResourceExists(workspace)) {
             customConfig.workspace = workspace;
-          }
-
-          if (!fs.existsSync(customConfig.workspace)) {
-            reject('Error: greenwood.config.js workspace doesn\'t exist! \n' +
-              'common issues to check might be: \n' +
-              '- typo in your workspace directory name, or in greenwood.config.js \n' +
-              '- if using relative paths, make sure your workspace is in the same cwd as _greenwood.config.js_ \n' +
-              '- consider using an absolute path, e.g. new URL(\'/your/relative/path/\', import.meta.url)');
+          } else {
+            reject('Error: greenwood.config.js workspace doesn\'t exist! Please double check your configuration.');
           }
         }
 
@@ -205,7 +206,7 @@ const readAndMergeConfig = async() => {
         }
 
         // SPA should _not_ prerender unless if user has specified prerender should be true
-        if (prerender === undefined && fs.existsSync(path.join(customConfig.workspace, 'index.html'))) {
+        if (prerender === undefined && isSPA) {
           customConfig.prerender = false;
         }
 
@@ -218,7 +219,7 @@ const readAndMergeConfig = async() => {
         }
       } else {
         // SPA should _not_ prerender unless if user has specified prerender should be true
-        if (fs.existsSync(path.join(customConfig.workspace, 'index.html'))) {
+        if (isSPA) {
           customConfig.prerender = false;
         }
       }
diff --git a/packages/cli/src/lifecycles/context.js b/packages/cli/src/lifecycles/context.js
index d52a3ccee..1318c343c 100644
--- a/packages/cli/src/lifecycles/context.js
+++ b/packages/cli/src/lifecycles/context.js
@@ -1,20 +1,20 @@
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath, URL } from 'url';
+import fs from 'fs/promises';
+import { checkResourceExists } from '../lib/resource-utils.js';
 
 const initContext = async({ config }) => {
-  const scratchDir = path.join(process.cwd(), './.greenwood');
-  const outputDir = path.join(process.cwd(), './public');
-  const dataDir = fileURLToPath(new URL('../data', import.meta.url));
 
   return new Promise(async (resolve, reject) => {
     try {
-      const projectDirectory = process.cwd();
-      const userWorkspace = path.join(config.workspace);
-      const apisDir = path.join(userWorkspace, 'api/');
-      const pagesDir = path.join(userWorkspace, `${config.pagesDirectory}/`);
-      const userTemplatesDir = path.join(userWorkspace, `${config.templatesDirectory}/`);
+      const { workspace, pagesDirectory, templatesDirectory } = config;
 
+      const projectDirectory = new URL(`file://${process.cwd()}/`);
+      const scratchDir = new URL('./.greenwood/', projectDirectory);
+      const outputDir = new URL('./public/', projectDirectory);
+      const dataDir = new URL('../data/', import.meta.url);
+      const userWorkspace = workspace;
+      const apisDir = new URL('./api/', userWorkspace);
+      const pagesDir = new URL(`./${pagesDirectory}/`, userWorkspace);
+      const userTemplatesDir = new URL(`./${templatesDirectory}/`, userWorkspace);
       const context = {
         dataDir,
         outputDir,
@@ -26,8 +26,8 @@ const initContext = async({ config }) => {
         projectDirectory
       };
 
-      if (!fs.existsSync(scratchDir)) {
-        fs.mkdirSync(scratchDir, {
+      if (!await checkResourceExists(scratchDir)) {
+        await fs.mkdir(scratchDir, {
           recursive: true
         });
       }
diff --git a/packages/cli/src/lifecycles/copy.js b/packages/cli/src/lifecycles/copy.js
index 4000bf52a..8964354b3 100644
--- a/packages/cli/src/lifecycles/copy.js
+++ b/packages/cli/src/lifecycles/copy.js
@@ -1,22 +1,22 @@
 import fs from 'fs';
-import path from 'path';
+import { checkResourceExists } from '../lib/resource-utils.js';
 
 async function rreaddir (dir, allFiles = []) {
-  const files = (await fs.promises.readdir(dir)).map(f => path.join(dir, f));
+  const files = (await fs.promises.readdir(dir)).map(f => new URL(`./${f}`, dir));
 
   allFiles.push(...files);
 
   await Promise.all(files.map(async f => (
-    await fs.promises.stat(f)).isDirectory() && rreaddir(f, allFiles
+    await fs.promises.stat(f)).isDirectory() && await rreaddir(new URL(`file://${f.pathname}/`), allFiles
   )));
 
   return allFiles;
 }
 
 // https://stackoverflow.com/a/30405105/417806
-async function copyFile(source, target) {
+async function copyFile(source, target, projectDirectory) {
   try {
-    console.info(`copying file... ${source.replace(`${process.cwd()}/`, '')}`);
+    console.info(`copying file... ${source.pathname.replace(projectDirectory.pathname, '')}`);
     const rd = fs.createReadStream(source);
     const wr = fs.createWriteStream(target);
 
@@ -33,67 +33,53 @@ async function copyFile(source, target) {
   }
 }
 
-async function copyDirectory(from, to) {
-  return new Promise(async(resolve, reject) => {
-    try {
-      console.info(`copying directory... ${from.replace(`${process.cwd()}/`, '')}`);
-      const files = await rreaddir(from);
+async function copyDirectory(fromUrl, toUrl, projectDirectory) {
+  try {
+    console.info(`copying directory... ${fromUrl.pathname.replace(projectDirectory.pathname, '')}`);
+    const files = await rreaddir(fromUrl);
+
+    if (files.length > 0) {
+      if (!await checkResourceExists(toUrl)) {
+        await fs.promises.mkdir(toUrl, {
+          recursive: true
+        });
+      }
+
+      for (const fileUrl of files) {
+        const targetUrl = new URL(`file://${fileUrl.pathname.replace(fromUrl.pathname, toUrl.pathname)}`);
+        const isDirectory = (await fs.promises.stat(fileUrl)).isDirectory();
 
-      if (files.length > 0) {
-        if (!fs.existsSync(to)) {
-          fs.mkdirSync(to, {
+        if (isDirectory && !await checkResourceExists(targetUrl)) {
+          await fs.promises.mkdir(targetUrl, {
             recursive: true
           });
+        } else if (!isDirectory) {
+          await copyFile(fileUrl, targetUrl, projectDirectory);
         }
-        await Promise.all(files.filter((asset) => {
-          const target = asset.replace(from, to);
-          const isDirectory = path.extname(target) === '';
-
-          if (isDirectory && !fs.existsSync(target)) {
-            fs.mkdirSync(target);
-          } else if (!isDirectory) {
-            return asset;
-          }
-        }).map((asset) => {
-          const target = asset.replace(from, to);
-
-          return copyFile(asset, target);
-        }));
       }
-      resolve();
-    } catch (e) {
-      reject(e);
     }
-  });
+  } catch (e) {
+    console.error('ERROR', e);
+  }
 }
 
-const copyAssets = (compilation) => {
-
-  return new Promise(async (resolve, reject) => {
-    try {
-      const copyPlugins = compilation.config.plugins.filter(plugin => plugin.type === 'copy');
+const copyAssets = async (compilation) => {
+  const copyPlugins = compilation.config.plugins.filter(plugin => plugin.type === 'copy');
+  const { projectDirectory } = compilation.context;
 
-      for (const plugin of copyPlugins) {
-        const locations = await plugin.provider(compilation);
+  for (const plugin of copyPlugins) {
+    const locations = await plugin.provider(compilation);
 
-        for (const location of locations) {
-          const { from, to } = location;
+    for (const location of locations) {
+      const { from, to } = location;
 
-          if (path.extname(from) === '') {
-            // copy directory
-            await copyDirectory(from, to);
-          } else {
-            // copy file
-            await copyFile(from, to);
-          }
-        }
+      if (from.pathname.endsWith('/')) {
+        await copyDirectory(from, to, projectDirectory);
+      } else {
+        await copyFile(from, to, projectDirectory);
       }
-
-      resolve();
-    } catch (err) {
-      reject(err);
     }
-  });
+  }
 };
 
 export { copyAssets };
\ No newline at end of file
diff --git a/packages/cli/src/lifecycles/graph.js b/packages/cli/src/lifecycles/graph.js
index 2f6381668..0064ec3b1 100644
--- a/packages/cli/src/lifecycles/graph.js
+++ b/packages/cli/src/lifecycles/graph.js
@@ -1,8 +1,7 @@
 /* eslint-disable complexity, max-depth */
-import fs from 'fs';
+import fs from 'fs/promises';
 import fm from 'front-matter';
-import { modelResource } from '../lib/resource-utils.js';
-import path from 'path';
+import { checkResourceExists, modelResource } from '../lib/resource-utils.js';
 import toc from 'markdown-toc';
 import { Worker } from 'worker_threads';
 
@@ -11,7 +10,7 @@ const generateGraph = async (compilation) => {
   return new Promise(async (resolve, reject) => {
     try {
       const { context } = compilation;
-      const { pagesDir, userWorkspace } = context;
+      const { pagesDir, projectDirectory, userWorkspace, scratchDir } = context;
       let graph = [{
         outputPath: 'index.html',
         filename: 'index.html',
@@ -24,23 +23,23 @@ const generateGraph = async (compilation) => {
       }];
 
       const walkDirectoryForPages = async function(directory, pages = []) {
-        const files = fs.readdirSync(directory);
+        const files = await fs.readdir(directory);
 
         for (const filename of files) {
-          const fullPath = path.normalize(`${directory}${path.sep}${filename}`);
-          
-          if (fs.statSync(fullPath).isDirectory()) {
-            pages = await walkDirectoryForPages(fullPath, pages);
+          const filenameUrl = new URL(`./${filename}`, directory);
+          const filenameUrlAsDir = new URL(`./${filename}/`, directory);
+          const isDirectory = await checkResourceExists(filenameUrlAsDir) && (await fs.stat(filenameUrlAsDir)).isDirectory();
+
+          if (isDirectory) {
+            pages = await walkDirectoryForPages(filenameUrlAsDir, pages);
           } else {
-            const extension = path.extname(filename);
+            const extension = `.${filenameUrl.pathname.split('.').pop()}`; 
             const isStatic = extension === '.md' || extension === '.html';
             const isDynamic = extension === '.js';
-            const relativePagePath = fullPath.substring(pagesDir.length - 1, fullPath.length);
-            const relativeWorkspacePath = directory.replace(process.cwd(), '').replace(path.sep, '');
-            let route = relativePagePath
-              .replace(extension, '')
-              .replace(/\\/g, '/');
-            let id = filename.split(path.sep)[filename.split(path.sep).length - 1].replace(extension, '');
+            const relativePagePath = filenameUrl.pathname.replace(pagesDir.pathname, '/');
+            const relativeWorkspacePath = directory.pathname.replace(projectDirectory.pathname, '');
+            let route = relativePagePath.replace(extension, '');
+            let id = filename.split('/')[filename.split('/').length - 1].replace(extension, '');
             let template = 'page';
             let title = null;
             let imports = [];
@@ -55,7 +54,7 @@ const generateGraph = async (compilation) => {
              * - pages/blog/index.{html,md,js} -> /blog/
              * - pages/blog/some-post.{html,md,js} -> /blog/some-post/
              */
-            if (relativePagePath.lastIndexOf(path.sep) > 0) {
+            if (relativePagePath.lastIndexOf('/') > 0) {
               // https://github.com/ProjectEvergreen/greenwood/issues/455
               route = id === 'index' || route.replace('/index', '') === `/${id}`
                 ? route.replace('index', '')
@@ -67,17 +66,14 @@ const generateGraph = async (compilation) => {
             }
 
             if (isStatic) {
-              const fileContents = fs.readFileSync(fullPath, 'utf8');
+              const fileContents = await fs.readFile(filenameUrl, 'utf8');
               const { attributes } = fm(fileContents);
               
               template = attributes.template || 'page';
               title = attributes.title || title;
               id = attributes.label || id;
               imports = attributes.imports || [];
-              
-              filePath = route === '/' || relativePagePath.lastIndexOf(path.sep) === 0
-                ? `${relativeWorkspacePath}${filename}`
-                : `${relativeWorkspacePath}${path.sep}${filename}`,
+              filePath = `${relativeWorkspacePath}${filename}`;
 
               // prune "reserved" attributes that are supported by Greenwood
               // https://www.greenwoodjs.io/docs/front-matter
@@ -127,13 +123,13 @@ const generateGraph = async (compilation) => {
               await new Promise((resolve, reject) => {
                 const worker = new Worker(routeWorkerUrl);
 
-                worker.on('message', (result) => {
+                worker.on('message', async (result) => {
                   if (result.frontmatter) {
-                    const resources = (result.frontmatter.imports || []).map((resource) => {
-                      const type = path.extname(resource) === '.js' ? 'script' : 'link';
+                    const resources = await Promise.all((result.frontmatter.imports || []).map(async (resource) => {
+                      const type = resource.split('.').pop() === 'js' ? 'script' : 'link';
 
-                      return modelResource(compilation.context, type, resource);
-                    });
+                      return await modelResource(compilation.context, type, resource);
+                    }));
 
                     result.frontmatter.imports = resources;
                     ssrFrontmatter = result.frontmatter;
@@ -148,7 +144,7 @@ const generateGraph = async (compilation) => {
                 });
 
                 worker.postMessage({
-                  modulePath: fullPath,
+                  moduleUrl: filenameUrl.href,
                   compilation: JSON.stringify(compilation),
                   route
                 });
@@ -214,16 +210,17 @@ const generateGraph = async (compilation) => {
       };
 
       console.debug('building from local sources...');
-      if (fs.existsSync(path.join(userWorkspace, 'index.html'))) { // SPA
+      // test for SPA
+      if (await checkResourceExists(new URL('./index.html', userWorkspace))) {
         graph = [{
           ...graph[0],
-          path: `${userWorkspace}${path.sep}index.html`,
+          path: `${userWorkspace.pathname}index.html`,
           isSPA: true
         }];
       } else {
         const oldGraph = graph[0];
-        
-        graph = fs.existsSync(pagesDir) ? await walkDirectoryForPages(pagesDir) : graph;
+
+        graph = await checkResourceExists(pagesDir) ? await walkDirectoryForPages(pagesDir) : graph;
 
         const has404Page = graph.filter(page => page.route === '/404/').length === 1;
 
@@ -269,7 +266,7 @@ const generateGraph = async (compilation) => {
               path: null,
               data: {},
               imports: [],
-              outputPath: path.join(node.route, 'index.html'),
+              outputPath: `${node.route}index.html`,
               ...node,
               external: true
             });
@@ -279,11 +276,11 @@ const generateGraph = async (compilation) => {
 
       compilation.graph = graph;
 
-      if (!fs.existsSync(context.scratchDir)) {
-        await fs.promises.mkdir(context.scratchDir);
+      if (!await checkResourceExists(scratchDir)) {
+        await fs.mkdir(scratchDir);
       }
 
-      await fs.promises.writeFile(`${context.scratchDir}/graph.json`, JSON.stringify(compilation.graph));
+      await fs.writeFile(new URL('./graph.json', scratchDir), JSON.stringify(compilation.graph));
 
       resolve(compilation);
     } catch (err) {
diff --git a/packages/cli/src/lifecycles/prerender.js b/packages/cli/src/lifecycles/prerender.js
index 65437e773..0fa273b2a 100644
--- a/packages/cli/src/lifecycles/prerender.js
+++ b/packages/cli/src/lifecycles/prerender.js
@@ -1,17 +1,16 @@
-import fs from 'fs';
+import fs from 'fs/promises';
 import htmlparser from 'node-html-parser';
-import { modelResource } from '../lib/resource-utils.js';
+import { checkResourceExists, modelResource } from '../lib/resource-utils.js';
 import os from 'os';
-import path from 'path';
 import { WorkerPool } from '../lib/threadpool.js';
 
 function isLocalLink(url = '') {
   return url !== '' && (url.indexOf('http') !== 0 && url.indexOf('//') !== 0);
 }
 
-function createOutputDirectory(route, outputPathDir) {
-  if (route !== '/404/' && !fs.existsSync(outputPathDir)) {
-    fs.mkdirSync(outputPathDir, {
+async function createOutputDirectory(route, outputDir) {
+  if (route !== '/404/' && !await checkResourceExists(outputDir)) {
+    await fs.mkdir(outputDir, {
       recursive: true
     });
   }
@@ -22,7 +21,7 @@ function createOutputDirectory(route, outputPathDir) {
 // or could this be done sooner (like in appTemplate building in html resource plugin)?
 // Or do we need to ensure userland code / plugins have gone first
 // before we can curate the final list of <script> / <style> / <link> tags to bundle
-function trackResourcesForRoute(html, compilation, route) {
+async function trackResourcesForRoute(html, compilation, route) {
   const { context } = compilation;
   const root = htmlparser.parse(html, {
     script: true,
@@ -30,36 +29,36 @@ function trackResourcesForRoute(html, compilation, route) {
   });
 
   // intentionally support <script> tags from the <head> or <body>
-  const scripts = root.querySelectorAll('script')
+  const scripts = await Promise.all(root.querySelectorAll('script')
     .filter(script => (
       isLocalLink(script.getAttribute('src')) || script.rawText)
       && script.rawAttrs.indexOf('importmap') < 0)
-    .map(script => {
+    .map(async(script) => {
       const src = script.getAttribute('src');
       const optimizationAttr = script.getAttribute('data-gwd-opt');
       const { rawAttrs } = script;
 
       if (src) {
         // <script src="...."></script>
-        return modelResource(context, 'script', src, null, optimizationAttr, rawAttrs);
+        return await modelResource(context, 'script', src, null, optimizationAttr, rawAttrs);
       } else if (script.rawText) {
         // <script>...</script>
-        return modelResource(context, 'script', null, script.rawText, optimizationAttr, rawAttrs);
+        return await modelResource(context, 'script', null, script.rawText, optimizationAttr, rawAttrs);
       }
-    });
+    }));
 
-  const styles = root.querySelectorAll('style')
+  const styles = await Promise.all(root.querySelectorAll('style')
     .filter(style => !(/\$/).test(style.rawText) && !(/<!-- Shady DOM styles for -->/).test(style.rawText)) // filter out Shady DOM <style> tags that happen when using puppeteer
-    .map(style => modelResource(context, 'style', null, style.rawText, null, style.getAttribute('data-gwd-opt')));
+    .map(async(style) => await modelResource(context, 'style', null, style.rawText, null, style.getAttribute('data-gwd-opt'))));
 
-  const links = root.querySelectorAll('head link')
+  const links = await Promise.all(root.querySelectorAll('head link')
     .filter(link => {
       // <link rel="stylesheet" href="..."></link>
       return link.getAttribute('rel') === 'stylesheet'
         && link.getAttribute('href') && isLocalLink(link.getAttribute('href'));
-    }).map(link => {
+    }).map(async(link) => {
       return modelResource(context, 'link', link.getAttribute('href'), null, link.getAttribute('data-gwd-opt'), link.rawAttrs);
-    });
+    }));
 
   const resources = [
     ...scripts,
@@ -72,66 +71,74 @@ function trackResourcesForRoute(html, compilation, route) {
   return resources;
 }
 
-async function interceptPage(compilation, contents, route) {
-  const headers = {
-    request: { 'accept': 'text/html', 'content-type': 'text/html' },
-    response: { 'content-type': 'text/html' }
-  };
-  const interceptResources = compilation.config.plugins.filter((plugin) => {
-    return plugin.type === 'resource' && plugin.name !== 'plugin-node-modules:resource';
-  }).map((plugin) => {
-    return plugin.provider(compilation);
-  }).filter((provider) => {
-    return provider.shouldIntercept && provider.intercept;
+async function servePage(url, request, plugins) {
+  let response = new Response('');
+
+  for (const plugin of plugins) {
+    if (plugin.shouldServe && await plugin.shouldServe(url, request)) {
+      response = await plugin.serve(url, request);
+      break;
+    }
+  }
+
+  return response;
+}
+
+async function interceptPage(url, request, plugins, body) {
+  let response = new Response(body, {
+    headers: new Headers({ 'Content-Type': 'text/html' })
   });
 
-  const htmlIntercepted = await interceptResources.reduce(async (htmlPromise, resource) => {
-    const html = (await htmlPromise).body;
-    const shouldIntercept = await resource.shouldIntercept(route, html, headers);
+  for (const plugin of plugins) {
+    if (plugin.shouldIntercept && await plugin.shouldIntercept(url, request, response)) {
+      response = await plugin.intercept(url, request, response);
+    }
+  }
 
-    return shouldIntercept
-      ? resource.intercept(route, html, headers)
-      : htmlPromise;
-  }, Promise.resolve({ body: contents }));
+  return response;
+}
 
-  return htmlIntercepted;
+function getPluginInstances (compilation) {
+  return [...compilation.config.plugins]
+    .filter(plugin => plugin.type === 'resource' && plugin.name !== 'plugin-node-modules:resource')
+    .map((plugin) => {
+      return plugin.provider(compilation);
+    });
 }
 
 async function preRenderCompilationWorker(compilation, workerPrerender) {
   const pages = compilation.graph.filter(page => !page.isSSR || (page.isSSR && page.data.static) || (page.isSSR && compilation.config.prerender));
   const { scratchDir } = compilation.context;
+  const plugins = getPluginInstances(compilation);
 
   console.info('pages to generate', `\n ${pages.map(page => page.route).join('\n ')}`);
 
   const pool = new WorkerPool(os.cpus().length, workerPrerender.workerUrl);
 
   for (const page of pages) {
-    const { outputPath, route } = page;
-    const outputPathDir = path.join(scratchDir, route);
-    const htmlResource = compilation.config.plugins.filter((plugin) => {
-      return plugin.name === 'plugin-standard-html';
-    }).map((plugin) => {
-      return plugin.provider(compilation);
-    })[0];
-    let html;
+    const { route, outputPath } = page;
+    const outputDirUrl = new URL(`./${route}/`, scratchDir);
+    const outputPathUrl = new URL(`./${outputPath}`, scratchDir);
+    const url = new URL(`http://localhost:${compilation.config.port}${route}`);
+    const request = new Request(url);
 
-    html = (await htmlResource.serve(route)).body;
-    html = (await interceptPage(compilation, html, route)).body;
+    let body = await (await servePage(url, request, plugins)).text();
+    body = await (await interceptPage(url, request, plugins, body)).text();
 
-    createOutputDirectory(route, outputPathDir);
+    await createOutputDirectory(route, outputDirUrl);
 
-    const resources = trackResourcesForRoute(html, compilation, route);
+    const resources = await trackResourcesForRoute(body, compilation, route);
     const scripts = resources
       .filter(resource => resource.type === 'script')
       .map(resource => resource.sourcePathURL.href);
 
-    html = await new Promise((resolve, reject) => {
+    body = await new Promise((resolve, reject) => {
       pool.runTask({
         modulePath: null,
         compilation: JSON.stringify(compilation),
         route,
         prerender: true,
-        htmlContents: html,
+        htmlContents: body,
         scripts: JSON.stringify(scripts)
       }, (err, result) => {
         if (err) {
@@ -142,7 +149,7 @@ async function preRenderCompilationWorker(compilation, workerPrerender) {
       });
     });
 
-    await fs.promises.writeFile(path.join(scratchDir, outputPath), html);
+    await fs.writeFile(outputPathUrl, body);
 
     console.info('generated page...', route);
   }
@@ -154,25 +161,23 @@ async function preRenderCompilationCustom(compilation, customPrerender) {
 
   console.info('pages to generate', `\n ${compilation.graph.map(page => page.route).join('\n ')}`);
 
-  await renderer(compilation, async (page, contents) => {
-    const { outputPath, route } = page;
-    const outputPathDir = path.join(scratchDir, route);
+  await renderer(compilation, async (page, body) => {
+    const { route, outputPath } = page;
+    const outputDirUrl = new URL(`./${route}`, scratchDir);
+    const outputPathUrl = new URL(`./${outputPath}`, scratchDir);
 
     // clean up special Greenwood dev only assets that would come through if prerendering with a headless browser
-    contents = contents.replace(/<script src="(.*lit\/polyfill-support.js)"><\/script>/, '');
-    contents = contents.replace(/<script type="importmap-shim">.*?<\/script>/s, '');
-    contents = contents.replace(/<script defer="" src="(.*es-module-shims.js)"><\/script>/, '');
-    contents = contents.replace(/type="module-shim"/g, 'type="module"');
-
-    contents = (await interceptPage(compilation, contents, route)).body;
+    body = body.replace(/<script src="(.*lit\/polyfill-support.js)"><\/script>/, '');
+    body = body.replace(/<script type="importmap-shim">.*?<\/script>/s, '');
+    body = body.replace(/<script defer="" src="(.*es-module-shims.js)"><\/script>/, '');
+    body = body.replace(/type="module-shim"/g, 'type="module"');
 
     // clean this up here to avoid sending webcomponents-bundle to rollup
-    contents = contents.replace(/<script src="(.*webcomponents-bundle.js)"><\/script>/, '');
-
-    trackResourcesForRoute(contents, compilation, route);
-    createOutputDirectory(route, outputPathDir);
+    body = body.replace(/<script src="(.*webcomponents-bundle.js)"><\/script>/, '');
 
-    await fs.promises.writeFile(path.join(scratchDir, outputPath), contents);
+    await trackResourcesForRoute(body, compilation, route);
+    await createOutputDirectory(route, outputDirUrl);
+    await fs.writeFile(outputPathUrl, body);
 
     console.info('generated page...', route);
   });
@@ -181,24 +186,23 @@ async function preRenderCompilationCustom(compilation, customPrerender) {
 async function staticRenderCompilation(compilation) {
   const { scratchDir } = compilation.context;
   const pages = compilation.graph.filter(page => !page.isSSR || page.isSSR && page.data.static);
-  const htmlResource = compilation.config.plugins.filter((plugin) => {
-    return plugin.name === 'plugin-standard-html';
-  }).map((plugin) => {
-    return plugin.provider(compilation);
-  })[0];
+  const plugins = getPluginInstances(compilation);
 
   console.info('pages to generate', `\n ${pages.map(page => page.route).join('\n ')}`);
   
   await Promise.all(pages.map(async (page) => {
     const { route, outputPath } = page;
-    const outputPathDir = path.join(scratchDir, route);
-    let html = (await htmlResource.serve(route)).body;
-    html = (await interceptPage(compilation, html, route)).body;
+    const outputDirUrl = new URL(`.${route}`, scratchDir);
+    const outputPathUrl = new URL(`./${outputPath}`, scratchDir);
+    const url = new URL(`http://localhost:${compilation.config.port}${route}`);
+    const request = new Request(url);
 
-    trackResourcesForRoute(html, compilation, route);
-    createOutputDirectory(route, outputPathDir);
+    let body = await (await servePage(url, request, plugins)).text();
+    body = await (await interceptPage(url, request, plugins, body)).text();
 
-    await fs.promises.writeFile(path.join(scratchDir, outputPath), html);
+    await trackResourcesForRoute(body, compilation, route);
+    await createOutputDirectory(route, outputDirUrl);
+    await fs.writeFile(outputPathUrl, body);
 
     console.info('generated page...', route);
 
diff --git a/packages/cli/src/lifecycles/serve.js b/packages/cli/src/lifecycles/serve.js
index 6f83544e9..3fbfef60d 100644
--- a/packages/cli/src/lifecycles/serve.js
+++ b/packages/cli/src/lifecycles/serve.js
@@ -1,13 +1,14 @@
-import fs from 'fs';
+import fs from 'fs/promises';
 import { hashString } from '../lib/hashing-utils.js';
-import path from 'path';
 import Koa from 'koa';
+import { mergeResponse } from '../lib/resource-utils.js';
+import { Readable } from 'stream';
 import { ResourceInterface } from '../lib/resource-interface.js';
 
 async function getDevServer(compilation) {
   const app = new Koa();
   const compilationCopy = Object.assign({}, compilation);
-  const resources = [
+  const resourcePlugins = [
     // Greenwood default standard resource and import plugins
     ...compilation.config.plugins.filter((plugin) => {
       return plugin.type === 'resource' && plugin.isGreenwoodDefaultPlugin;
@@ -29,96 +30,88 @@ async function getDevServer(compilation) {
     })
   ];
 
-  // resolve urls to paths first
+  // resolve urls to `file://` paths if applicable, otherwise default is `http://`
   app.use(async (ctx, next) => {
-    ctx.url = await resources.reduce(async (responsePromise, resource) => {
-      const response = await responsePromise;
-      const resourceShouldResolveUrl = await resource.shouldResolve(response);
-      
-      return resourceShouldResolveUrl
-        ? resource.resolve(response)
-        : Promise.resolve(response);
-    }, Promise.resolve(ctx.url));
-
-    // bit of a hack to get these two bugs to play well together
-    // https://github.com/ProjectEvergreen/greenwood/issues/598
-    // https://github.com/ProjectEvergreen/greenwood/issues/604
-    ctx.request.headers.originalUrl = ctx.originalUrl;
+    try {
+      const url = new URL(`http://localhost:${compilation.config.port}${ctx.url}`);
+      const initRequest = new Request(url, {
+        method: ctx.request.method,
+        headers: new Headers(ctx.request.header)
+      });
+      const request = await resourcePlugins.reduce(async (requestPromise, plugin) => {
+        const intermediateRequest = await requestPromise;
+        return plugin.shouldResolve && await plugin.shouldResolve(url, intermediateRequest.clone())
+          ? Promise.resolve(await plugin.resolve(url, intermediateRequest.clone()))
+          : Promise.resolve(await requestPromise);
+      }, Promise.resolve(initRequest));
+
+      ctx.url = request.url;
+    } catch (e) {
+      ctx.status = 500;
+      console.error(e);
+    }
 
     await next();
   });
 
-  // then handle serving urls
+  // handle creating responses from urls
   app.use(async (ctx, next) => {
-    const responseAccumulator = {
-      body: ctx.body,
-      contentType: ctx.response.contentType
-    };
-    
-    const reducedResponse = await resources.reduce(async (responsePromise, resource) => {
-      const response = await responsePromise;
-      const { url } = ctx;
-      const { headers } = ctx.response;
-      const shouldServe = await resource.shouldServe(url, {
-        request: ctx.headers,
-        response: headers
-      });
-
-      if (shouldServe) {
-        const resolvedResource = await resource.serve(url, {
-          request: ctx.headers,
-          response: headers
-        });
-        
-        return Promise.resolve({
-          ...response,
-          ...resolvedResource
-        });
-      } else {
-        return Promise.resolve(response);
+    try {
+      const url = new URL(ctx.url);
+      const { method, header } = ctx.request;
+      const { status } = ctx.response;
+      const request = new Request(url.href, { method, headers: new Headers(header) });
+      let response = new Response(null, { status });
+
+      for (const plugin of resourcePlugins) {
+        if (plugin.shouldServe && await plugin.shouldServe(url, request)) {
+          response = await plugin.serve(url, request);
+          break;
+        }
       }
-    }, Promise.resolve(responseAccumulator));
 
-    ctx.set('Content-Type', reducedResponse.contentType);
-    ctx.body = reducedResponse.body;
+      ctx.body = response.body ? Readable.from(response.body) : '';
+      ctx.type = response.headers.get('Content-Type');
+      ctx.status = response.status;
+    } catch (e) {
+      ctx.status = 500;
+      console.error(e);
+    }
 
     await next();
   });
 
-  // allow intercepting of urls (response)
+  // allow intercepting of responses for URLs
   app.use(async (ctx, next) => {
-    const responseAccumulator = {
-      body: ctx.body,
-      contentType: ctx.response.headers['content-type']
-    };
-
-    const reducedResponse = await resources.reduce(async (responsePromise, resource) => {
-      const response = await responsePromise;
-      const { url } = ctx;
-      const { headers } = ctx.response;
-      const shouldIntercept = await resource.shouldIntercept(url, response.body, {
-        request: ctx.headers,
-        response: headers
+    try {
+      const url = new URL(ctx.url);
+      const request = new Request(url, {
+        method: ctx.request.method,
+        headers: new Headers(ctx.request.header)
       });
+      const initResponse = new Response(ctx.body, {
+        status: ctx.response.status,
+        headers: new Headers(ctx.response.header)
+      });
+      const response = await resourcePlugins.reduce(async (responsePromise, plugin) => {
+        const intermediateResponse = await responsePromise;
+        if (plugin.shouldIntercept && await plugin.shouldIntercept(url, request, intermediateResponse.clone())) {
+          const current = await plugin.intercept(url, request, await intermediateResponse.clone());
+          const merged = mergeResponse(intermediateResponse.clone(), current);
+
+          return Promise.resolve(merged);
+        } else {
+          return Promise.resolve(await responsePromise);
+        }
+      }, Promise.resolve(initResponse.clone()));
 
-      if (shouldIntercept) {
-        const interceptedResponse = await resource.intercept(url, response.body, {
-          request: ctx.headers,
-          response: headers
-        });
-        
-        return Promise.resolve({
-          ...response,
-          ...interceptedResponse
-        });
-      } else {
-        return Promise.resolve(response);
-      }
-    }, Promise.resolve(responseAccumulator));
-
-    ctx.set('Content-Type', reducedResponse.contentType);
-    ctx.body = reducedResponse.body;
-
+      ctx.body = response.body ? Readable.from(response.body) : '';
+      ctx.set('Content-Type', response.headers.get('Content-Type'));
+    } catch (e) {
+      ctx.status = 500;
+      console.error(e);
+    }
+  
     await next();
   });
 
@@ -126,16 +119,16 @@ async function getDevServer(compilation) {
   // https://stackoverflow.com/questions/43659756/chrome-ignores-the-etag-header-and-just-uses-the-in-memory-cache-disk-cache
   app.use(async (ctx) => {
     const body = ctx.response.body;
-    const { url } = ctx;
+    const url = new URL(ctx.url);
 
     // don't interfere with external requests or API calls, binary files, or JSON
     // and only run in development
-    if (process.env.__GWD_COMMAND__ === 'develop' && path.extname(url) !== '' && url.indexOf('http') !== 0) { // eslint-disable-line no-underscore-dangle
+    if (process.env.__GWD_COMMAND__ === 'develop' && url.protocol === 'file:') { // eslint-disable-line no-underscore-dangle
       if (!body || Buffer.isBuffer(body)) {
         // console.warn(`no body for => ${ctx.url}`);
       } else {
         const inm = ctx.headers['if-none-match'];
-        const etagHash = path.extname(ctx.request.headers.originalUrl) === '.json'
+        const etagHash = url.pathname.split('.').pop() === 'json'
           ? hashString(JSON.stringify(body))
           : hashString(body);
 
@@ -149,99 +142,95 @@ async function getDevServer(compilation) {
         }
       }
     }
-
   });
 
-  return Promise.resolve(app);
+  return app;
 }
 
 async function getStaticServer(compilation, composable) {
   const app = new Koa();
-  const standardResources = compilation.config.plugins.filter((plugin) => {
-    // html is intentionally omitted
-    return plugin.isGreenwoodDefaultPlugin
-      && plugin.type === 'resource'
-      && ((plugin.name.indexOf('plugin-standard') >= 0 // allow standard web resources
-      && plugin.name.indexOf('plugin-standard-html') < 0) // but _not_ our markdown / HTML plugin
-      || plugin.name.indexOf('plugin-source-maps') >= 0); // and source maps
-  }).map((plugin) => {
-    return plugin.provider(compilation);
+  const { outputDir } = compilation.context;
+  const standardResourcePlugins = compilation.config.plugins.filter((plugin) => {
+    return plugin.type === 'resource'
+      && plugin.isGreenwoodDefaultPlugin
+      && plugin.name !== 'plugin-standard-html';
   });
 
   app.use(async (ctx, next) => {
-    const { outputDir, userWorkspace } = compilation.context;
-    const url = ctx.request.url.replace(/\?(.*)/, ''); // get rid of things like query string parameters
-
-    // only handle static output routes, eg. public/about.html
-    if (url.endsWith('/') || url.endsWith('.html')) {
-      const barePath = fs.existsSync(path.join(userWorkspace, 'index.html')) // SPA
-        ? 'index.html'
-        : url.endsWith('/')
-          ? path.join(url, 'index.html')
-          : url;
-
-      if (fs.existsSync(path.join(outputDir, barePath))) {
-        const contents = await fs.promises.readFile(path.join(outputDir, barePath), 'utf-8');
-
-        ctx.set('content-type', 'text/html');
-        ctx.body = contents;
+    try {
+      const url = new URL(`http://localhost:8080${ctx.url}`);
+      const matchingRoute = compilation.graph.find(page => page.route === url.pathname);
+
+      if ((matchingRoute && !matchingRoute.isSSR) || url.pathname.split('.').pop() === 'html') {
+        const pathname = matchingRoute ? matchingRoute.outputPath : url.pathname;
+        const body = await fs.readFile(new URL(`./${pathname}`, outputDir), 'utf-8');
+
+        ctx.set('Content-Type', 'text/html');
+        ctx.body = body;
       }
+    } catch (e) {
+      ctx.status = 500;
+      console.error(e);
     }
 
     await next();
   });
 
   app.use(async (ctx, next) => {
-    const url = ctx.request.url;
+    try {
+      const url = new URL(`http://localhost:8080${ctx.url}`);
+      const request = new Request(url, {
+        method: ctx.request.method,
+        headers: ctx.request.header
+      });
 
-    if (compilation.config.devServer.proxy) {
-      const proxyPlugin = compilation.config.plugins.filter((plugin) => {
-        return plugin.name === 'plugin-dev-proxy';
-      }).map((plugin) => {
-        return plugin.provider(compilation);
-      })[0];
+      if (compilation.config.devServer.proxy) {
+        const proxyPlugin = standardResourcePlugins
+          .find((plugin) => plugin.name === 'plugin-dev-proxy')
+          .provider(compilation);
+
+        if (await proxyPlugin.shouldServe(url, request)) {
+          const response = await proxyPlugin.serve(url, request);
 
-      if (url !== '/' && await proxyPlugin.shouldServe(url)) {
-        ctx.body = (await proxyPlugin.serve(url)).body;
+          ctx.body = Readable.from(response.body);
+          ctx.set('Content-Type', response.headers.get('Content-Type'));
+        }
       }
+    } catch (e) {
+      ctx.status = 500;
+      console.error(e);
     }
 
     await next();
   });
 
   app.use(async (ctx, next) => {
-    const responseAccumulator = {
-      body: ctx.body,
-      contentType: ctx.response.header['content-type']
-    };
-
-    const reducedResponse = await standardResources.reduce(async (responsePromise, resource) => {
-      const response = await responsePromise;
-      const url = ctx.url.replace(/\?(.*)/, '');
-      const { headers } = ctx.response;
-      const outputPathUrl = path.join(compilation.context.outputDir, url);
-      const shouldServe = await resource.shouldServe(outputPathUrl, {
-        request: ctx.headers,
-        response: headers
+    try {
+      const url = new URL(`.${ctx.url}`, outputDir.href);
+      const resourcePlugins = standardResourcePlugins.map((plugin) => {
+        return plugin.provider(compilation);
       });
 
-      if (shouldServe) {
-        const resolvedResource = await resource.serve(outputPathUrl, {
-          request: ctx.headers,
-          response: headers
-        });
-
-        return Promise.resolve({
-          ...response,
-          ...resolvedResource
-        });
-      } else {
-        return Promise.resolve(response);
+      const request = new Request(url.href);
+      const initResponse = new Response(ctx.body, {
+        status: ctx.response.status,
+        headers: new Headers(ctx.response.header)
+      });
+      const response = await resourcePlugins.reduce(async (responsePromise, plugin) => {
+        return plugin.shouldServe && await plugin.shouldServe(url, request)
+          ? Promise.resolve(await plugin.serve(url, request))
+          : responsePromise;
+      }, Promise.resolve(initResponse));
+
+      if (response.ok) {
+        ctx.body = Readable.from(response.body);
+        ctx.type = response.headers.get('Content-Type');
+        ctx.status = response.status;
       }
-    }, Promise.resolve(responseAccumulator));
-
-    ctx.set('content-type', reducedResponse.contentType);
-    ctx.body = reducedResponse.body;
+    } catch (e) {
+      ctx.status = 500;
+      console.error(e);
+    }
 
     if (composable) {
       await next();
@@ -253,81 +242,46 @@ async function getStaticServer(compilation, composable) {
 
 async function getHybridServer(compilation) {
   const app = await getStaticServer(compilation, true);
-  const apiResource = compilation.config.plugins.filter((plugin) => {
-    return plugin.isGreenwoodDefaultPlugin
-      && plugin.type === 'resource'
-      && plugin.name.indexOf('plugin-api-routes') === 0;
-  }).map((plugin) => {
-    return plugin.provider(compilation);
-  })[0];
+  const resourcePlugins = compilation.config.plugins.filter((plugin) => {
+    return plugin.type === 'resource';
+  });
 
   app.use(async (ctx) => {
-    const url = ctx.request.url.replace(/\?(.*)/, ''); // get rid of things like query string parameters
-    const isApiRoute = await apiResource.shouldServe(url);
-    const matchingRoute = compilation.graph.filter((node) => {
-      return node.route === url;
-    })[0] || { data: {} };
-
-    if (matchingRoute.isSSR && !matchingRoute.data.static) {
-      // TODO would be nice to pull these plugins once instead of one every request
-      const headers = {
-        request: { 'accept': 'text/html', 'content-type': 'text/html' },
-        response: { 'content-type': 'text/html' }
-      };
-      const standardHtmlResource = compilation.config.plugins.filter((plugin) => {
-        return plugin.isGreenwoodDefaultPlugin
-          && plugin.type === 'resource'
-          && plugin.name.indexOf('plugin-standard-html') === 0;
-      }).map((plugin) => {
-        return plugin.provider(compilation);
-      })[0];
-      let body;
-
-      const interceptResources = compilation.config.plugins.filter((plugin) => {
-        return plugin.type === 'resource' && !plugin.isGreenwoodDefaultPlugin;
-      }).map((plugin) => {
-        return plugin.provider(compilation);
-      }).filter((provider) => {
-        return provider.shouldIntercept && provider.intercept;
+    try {
+      const url = new URL(`http://localhost:8080${ctx.url}`);
+      const isApiRoute = url.pathname.startsWith('/api');
+      const matchingRoute = compilation.graph.find((node) => node.route === url.pathname) || { data: {} };
+      const request = new Request(url.href, {
+        method: ctx.request.method,
+        headers: ctx.request.header
       });
 
-      body = (await standardHtmlResource.serve(url)).body;
-      body = (await interceptResources.reduce(async (htmlPromise, resource) => {
-        const html = (await htmlPromise).body;
-        const shouldIntercept = await resource.shouldIntercept(url, html, headers);
-
-        return shouldIntercept
-          ? resource.intercept(url, html, headers)
-          : htmlPromise;
-      }, Promise.resolve({ url, body }))).body;
-
-      const optimizeResources = compilation.config.plugins.filter((plugin) => {
-        return plugin.type === 'resource';
-      }).map((plugin) => {
-        return plugin.provider(compilation);
-      }).filter((provider) => {
-        return provider.shouldOptimize && provider.optimize;
-      });
-
-      body = await optimizeResources.reduce(async (htmlPromise, resource) => {
-        const html = await htmlPromise;
-        const shouldOptimize = await resource.shouldOptimize(url, html, headers);
-
-        return shouldOptimize
-          ? resource.optimize(url, html, headers)
-          : Promise.resolve(html);
-      }, Promise.resolve(body));
-
-      ctx.status = 200;
-      ctx.set('content-type', 'text/html');
-      ctx.body = body;
-    } else if (isApiRoute) {
-      // TODO just use response
-      const { body, resp } = await apiResource.serve(ctx.request.url);
-
-      ctx.status = 200;
-      ctx.set('content-type', resp.headers.get('content-type'));
-      ctx.body = body;
+      if (matchingRoute.isSSR && !matchingRoute.data.static) {
+        const standardHtmlResource = resourcePlugins.find((plugin) => {
+          return plugin.isGreenwoodDefaultPlugin
+            && plugin.name.indexOf('plugin-standard-html') === 0;
+        }).provider(compilation);
+        let response = await standardHtmlResource.serve(url, request);
+
+        response = await standardHtmlResource.optimize(url, response);
+
+        ctx.body = Readable.from(response.body);
+        ctx.set('Content-Type', 'text/html');
+        ctx.status = 200;
+      } else if (isApiRoute) {
+        const apiResource = resourcePlugins.find((plugin) => {
+          return plugin.isGreenwoodDefaultPlugin
+            && plugin.name === 'plugin-api-routes';
+        }).provider(compilation);
+        const response = await apiResource.serve(url, request);
+
+        ctx.status = 200;
+        ctx.set('Content-Type', response.headers.get('Content-Type'));
+        ctx.body = Readable.from(response.body);
+      }
+    } catch (e) {
+      ctx.status = 500;
+      console.error(e);
     }
   });
 
diff --git a/packages/cli/src/loader.js b/packages/cli/src/loader.js
index dc1f1c1e1..73827a132 100644
--- a/packages/cli/src/loader.js
+++ b/packages/cli/src/loader.js
@@ -1,23 +1,54 @@
-import path from 'path';
+import fs from 'fs/promises';
 import { readAndMergeConfig as initConfig } from './lifecycles/config.js';
-import { URL, fileURLToPath } from 'url';
 
 const config = await initConfig();
-const plugins = config.plugins.filter(plugin => plugin.type === 'resource' && !plugin.isGreenwoodDefaultPlugin).map(plugin => plugin.provider({
+const resourcePlugins = config.plugins.filter(plugin => plugin.type === 'resource' && !plugin.isGreenwoodDefaultPlugin).map(plugin => plugin.provider({
   context: {
-    projectDirectory: process.cwd()
+    projectDirectory: new URL(`file://${process.cwd()}`)
   }
 }));
 
-function getCustomLoaderPlugins(url, body, headers) {
-  return plugins.filter(plugin => plugin.extensions.includes(path.extname(url)) && (plugin.shouldServe(url, body, headers) || plugin.shouldIntercept(url, body, headers)));
+async function getCustomLoaderResponse(url, body = '', checkOnly = false) {
+  const headers = new Headers({
+    'Content-Type': 'text/javascript'
+  });
+  const request = new Request(url.href, { headers });
+  const initResponse = new Response(body, { headers });
+  let response = initResponse.clone();
+  let shouldHandle = false;
+
+  for (const plugin of resourcePlugins) {
+    if (plugin.shouldServe && await plugin.shouldServe(url, request)) {
+      shouldHandle = true;
+  
+      if (!checkOnly) {
+        response = await plugin.serve(url, request);
+      }
+    }
+  }
+
+  for (const plugin of resourcePlugins) {
+    if (plugin.shouldIntercept && await plugin.shouldIntercept(url, request, response.clone())) {
+      shouldHandle = true;
+
+      if (!checkOnly) {
+        response = await plugin.intercept(url, request, response.clone());
+      }
+    }
+  }
+
+  return {
+    shouldHandle,
+    response
+  };
 }
 
 // https://nodejs.org/docs/latest-v18.x/api/esm.html#resolvespecifier-context-nextresolve
-export function resolve(specifier, context, defaultResolve) {
+export async function resolve(specifier, context, defaultResolve) {
   const { baseURL } = context;
+  const { shouldHandle } = await getCustomLoaderResponse(new URL(specifier), null, true);
 
-  if (getCustomLoaderPlugins(specifier).length > 0) {
+  if (shouldHandle) {
     return {
       url: new URL(specifier, baseURL).href,
       shortCircuit: true
@@ -29,35 +60,20 @@ export function resolve(specifier, context, defaultResolve) {
 
 // https://nodejs.org/docs/latest-v18.x/api/esm.html#loadurl-context-nextload
 export async function load(source, context, defaultLoad) {
-  const resourcePlugins = getCustomLoaderPlugins(source);
-  const extension = path.extname(source).replace('.', '');
+  const extension = source.split('.').pop();
+  const url = new URL('', `${source}?type=${extension}`);
+  const { shouldHandle } = await getCustomLoaderResponse(url, null, true);
 
-  if (resourcePlugins.length) {
-    const headers = {
-      request: {
-        originalUrl: `${source}?type=${extension}`,
-        accept: ''
-      }
-    };
-    let contents = '';
-
-    for (const plugin of resourcePlugins) {
-      if (await plugin.shouldServe(source, headers)) {
-        contents = (await plugin.serve(source, headers)).body || contents;
-      }
-    }
-
-    for (const plugin of resourcePlugins) {
-      if (await plugin.shouldIntercept(fileURLToPath(source), contents, headers)) {
-        contents = (await plugin.intercept(fileURLToPath(source), contents, headers)).body || contents;
-      }
-    }
+  if (shouldHandle) {
+    const contents = await fs.readFile(new URL(source), 'utf-8');
+    const { response } = await getCustomLoaderResponse(url, contents);
+    const body = await response.text();
 
-    // TODO better way to handle remove export default?
-    // https://github.com/ProjectEvergreen/greenwood/issues/948
+    // TODO better way to handle remove export default?  leverage import assertions instead
+    // https://github.com/ProjectEvergreen/greenwood/issues/923
     return {
       format: extension === 'json' ? 'json' : 'module',
-      source: extension === 'json' ? JSON.parse(contents.replace('export default ', '')) : contents,
+      source: extension === 'json' ? JSON.stringify(JSON.parse(contents.replace('export default ', ''))) : body,
       shortCircuit: true
     };
   }
diff --git a/packages/cli/src/plugins/copy/plugin-copy-assets.js b/packages/cli/src/plugins/copy/plugin-copy-assets.js
index 802bf03b3..6fb781d02 100644
--- a/packages/cli/src/plugins/copy/plugin-copy-assets.js
+++ b/packages/cli/src/plugins/copy/plugin-copy-assets.js
@@ -1,18 +1,17 @@
-import fs from 'fs';
-import path from 'path';
+import { checkResourceExists } from '../../lib/resource-utils.js';
 
 const greenwoodPluginCopyAssets = [{
   type: 'copy',
   name: 'plugin-copy-assets',
-  provider: (compilation) => {
-    const { context } = compilation;
-    const fromAssetsDir = path.join(context.userWorkspace, 'assets');
+  provider: async (compilation) => {
+    const { outputDir, userWorkspace } = compilation.context;
+    const fromAssetsDirUrl = new URL('./assets/', userWorkspace);
     const assets = [];
 
-    if (fs.existsSync(fromAssetsDir)) {
+    if (await checkResourceExists(fromAssetsDirUrl)) {
       assets.push({
-        from: fromAssetsDir,
-        to: path.join(context.outputDir, 'assets')
+        from: fromAssetsDirUrl,
+        to: new URL('./assets/', outputDir)
       });
     }
 
diff --git a/packages/cli/src/plugins/copy/plugin-copy-favicon.js b/packages/cli/src/plugins/copy/plugin-copy-favicon.js
index ad66a1e4f..ba554d055 100644
--- a/packages/cli/src/plugins/copy/plugin-copy-favicon.js
+++ b/packages/cli/src/plugins/copy/plugin-copy-favicon.js
@@ -1,19 +1,18 @@
-import fs from 'fs';
-import path from 'path';
+import { checkResourceExists } from '../../lib/resource-utils.js';
 
 const greenwoodPluginCopyFavicon = [{
   type: 'copy',
   name: 'plugin-copy-favicon',
-  provider: (compilation) => {
+  provider: async (compilation) => {
     const fileName = 'favicon.ico';
-    const { context } = compilation;
-    const robotsPath = path.join(context.userWorkspace, fileName);
+    const { outputDir, userWorkspace } = compilation.context;
+    const faviconPathUrl = new URL(`./${fileName}`, userWorkspace);
     const assets = [];
 
-    if (fs.existsSync(robotsPath)) {
+    if (await checkResourceExists(faviconPathUrl)) {
       assets.push({
-        from: robotsPath,
-        to: path.join(context.outputDir, fileName)
+        from: faviconPathUrl,
+        to: new URL(`./${fileName}`, outputDir)
       });
     }
 
diff --git a/packages/cli/src/plugins/copy/plugin-copy-graph-json.js b/packages/cli/src/plugins/copy/plugin-copy-graph-json.js
index 50f9df92a..2753c4a88 100644
--- a/packages/cli/src/plugins/copy/plugin-copy-graph-json.js
+++ b/packages/cli/src/plugins/copy/plugin-copy-graph-json.js
@@ -1,14 +1,12 @@
-import path from 'path';
-
 const greenwoodPluginCopyGraphJson = [{
   type: 'copy',
   name: 'plugin-copy-graph-json',
   provider: (compilation) => {
-    const { context } = compilation;
+    const { scratchDir, outputDir } = compilation.context;
 
     return [{
-      from: path.join(context.scratchDir, 'graph.json'),
-      to: path.join(context.outputDir, 'graph.json')
+      from: new URL('./graph.json', scratchDir),
+      to: new URL('./graph.json', outputDir)
     }];
   }
 }];
diff --git a/packages/cli/src/plugins/copy/plugin-copy-robots.js b/packages/cli/src/plugins/copy/plugin-copy-robots.js
index 51e9acc0b..5e2fe03d2 100644
--- a/packages/cli/src/plugins/copy/plugin-copy-robots.js
+++ b/packages/cli/src/plugins/copy/plugin-copy-robots.js
@@ -1,19 +1,18 @@
-import fs from 'fs';
-import path from 'path';
+import { checkResourceExists } from '../../lib/resource-utils.js';
 
 const greenwoodPluginCopyRobots = [{
   type: 'copy',
   name: 'plugin-copy-robots',
-  provider: (compilation) => {
+  provider: async (compilation) => {
     const fileName = 'robots.txt';
-    const { context } = compilation;
-    const robotsPath = path.join(context.userWorkspace, fileName);
+    const { outputDir, userWorkspace } = compilation.context;
+    const robotsPathUrl = new URL(`./${fileName}`, userWorkspace);
     const assets = [];
 
-    if (fs.existsSync(robotsPath)) {
+    if (await checkResourceExists(robotsPathUrl)) {
       assets.push({
-        from: robotsPath,
-        to: path.join(context.outputDir, fileName)
+        from: robotsPathUrl,
+        to: new URL(`./${fileName}`, outputDir)
       });
     }
 
diff --git a/packages/cli/src/plugins/resource/plugin-api-routes.js b/packages/cli/src/plugins/resource/plugin-api-routes.js
index cd4f1c85c..da39f3e30 100644
--- a/packages/cli/src/plugins/resource/plugin-api-routes.js
+++ b/packages/cli/src/plugins/resource/plugin-api-routes.js
@@ -3,7 +3,7 @@
  * Manages routing to API routes.
  *
  */
-import fs from 'fs';
+import { checkResourceExists } from '../../lib/resource-utils.js';
 import { ResourceInterface } from '../../lib/resource-interface.js';
 
 class ApiRoutesResource extends ResourceInterface {
@@ -12,16 +12,16 @@ class ApiRoutesResource extends ResourceInterface {
   }
 
   async shouldServe(url) {
-    // TODO Could this existance check be derived from the graph instead?
-    // https://github.com/ProjectEvergreen/greenwood/issues/946
-    return url.startsWith('/api') && fs.existsSync(this.compilation.context.apisDir, url);
+    const { protocol, pathname } = url;
+    const apiPathUrl = new URL(`.${pathname.replace('/api', '')}.js`, this.compilation.context.apisDir);
+
+    if (protocol.startsWith('http') && pathname.startsWith('/api') && await checkResourceExists(apiPathUrl)) {
+      return true;
+    }
   }
 
-  async serve(url) {
-    // TODO we assume host here, but eventually we will be getting a Request
-    // https://github.com/ProjectEvergreen/greenwood/issues/948
-    const host = `https://localhost:${this.compilation.config.port}`;
-    let href = new URL(`${this.getBareUrlPath(url).replace('/api/', '')}.js`, `file://${this.compilation.context.apisDir}`).href;
+  async serve(url, request) {
+    let href = new URL(`./${url.pathname.replace('/api/', '')}.js`, `file://${this.compilation.context.apisDir.pathname}`).href;
 
     // https://github.com/nodejs/modules/issues/307#issuecomment-1165387383
     if (process.env.__GWD_COMMAND__ === 'develop') { // eslint-disable-line no-underscore-dangle
@@ -29,18 +29,11 @@ class ApiRoutesResource extends ResourceInterface {
     }
 
     const { handler } = await import(href);
-    // TODO we need to pass in headers here
-    // https://github.com/ProjectEvergreen/greenwood/issues/948
-    const req = new Request(new URL(`${host}${url}`));
-    const resp = await handler(req);
-    const contents = resp.headers.get('content-type').indexOf('application/json') >= 0
-      ? await resp.json()
-      : await resp.text();
-
-    return {
-      body: contents,
-      resp
-    };
+    const req = new Request(new URL(`${request.url.origin}${url}`), {
+      ...request
+    });
+
+    return await handler(req);
   }
 }
 
diff --git a/packages/cli/src/plugins/resource/plugin-dev-proxy.js b/packages/cli/src/plugins/resource/plugin-dev-proxy.js
index 20dd4c2bd..b45a40873 100644
--- a/packages/cli/src/plugins/resource/plugin-dev-proxy.js
+++ b/packages/cli/src/plugins/resource/plugin-dev-proxy.js
@@ -13,27 +13,26 @@ class DevProxyResource extends ResourceInterface {
   async shouldServe(url) {
     const proxies = this.compilation.config.devServer.proxy || {};
     const hasMatches = Object.entries(proxies).reduce((acc, entry) => {
-      return acc || url.indexOf(entry[0]) >= 0;
+      return acc || url.pathname.indexOf(entry[0]) >= 0;
     }, false);
 
-    return hasMatches;
+    return url.protocol.startsWith('http:') && hasMatches;
   }
 
-  async serve(url) {
-    const baseUrl = url.replace(this.compilation.context.userWorkspace, '');
+  async serve(url, request) {
+    const { pathname } = url;
     const proxies = this.compilation.config.devServer.proxy;
     const proxyBaseUrl = Object.entries(proxies).reduce((acc, entry) => {
-      return url.indexOf(entry[0]) >= 0
-        ? `${entry[1]}${baseUrl}`
+      return pathname.indexOf(entry[0]) >= 0
+        ? `${entry[1]}${pathname}`
         : acc;
-    }, baseUrl);
-
-    const response = await fetch(proxyBaseUrl)
-      .then(res => res.json());
-
-    return Promise.resolve({
-      body: response
+    }, pathname);
+    const requestProxied = new Request(`${proxyBaseUrl}${url.search}`, {
+      method: request.method,
+      headers: request.header
     });
+
+    return await fetch(requestProxied);
   }
 }
 
diff --git a/packages/cli/src/plugins/resource/plugin-node-modules.js b/packages/cli/src/plugins/resource/plugin-node-modules.js
index b56616a8f..cc3d673c8 100644
--- a/packages/cli/src/plugins/resource/plugin-node-modules.js
+++ b/packages/cli/src/plugins/resource/plugin-node-modules.js
@@ -3,11 +3,12 @@
  * Detects and fully resolves requests to node_modules and handles creating an importMap.
  *
  */
-import fs from 'fs';
-import path from 'path';
+import { checkResourceExists } from '../../lib/resource-utils.js';
+import fs from 'fs/promises';
 import { nodeResolve } from '@rollup/plugin-node-resolve';
 import replace from '@rollup/plugin-replace';
-import { getNodeModulesLocationForPackage, getPackageNameFromUrl } from '../../lib/node-modules-utils.js';
+import { getNodeModulesLocationForPackage, getPackageJson, getPackageNameFromUrl } from '../../lib/node-modules-utils.js';
+import { resolveForRelativeUrl } from '../../lib/resource-utils.js';
 import { ResourceInterface } from '../../lib/resource-interface.js';
 import { walkPackageJson } from '../../lib/walker-package-ranger.js';
 
@@ -16,110 +17,92 @@ let importMap;
 class NodeModulesResource extends ResourceInterface {
   constructor(compilation, options) {
     super(compilation, options);
-    this.extensions = ['*'];
+    this.extensions = ['js', 'mjs'];
+    this.contentType = 'text/javascript';
   }
 
   async shouldResolve(url) {
-    return Promise.resolve(url.indexOf('node_modules/') >= 0);
+    return url.pathname.indexOf('/node_modules/') === 0;
   }
 
+  // TODO convert node modules util to URL
+  // https://github.com/ProjectEvergreen/greenwood/issues/953v
   async resolve(url) {
-    const bareUrl = this.getBareUrlPath(url);
     const { projectDirectory } = this.compilation.context;
-    const packageName = getPackageNameFromUrl(bareUrl);
+    const { pathname } = url;
+    const packageName = getPackageNameFromUrl(pathname);
     const absoluteNodeModulesLocation = await getNodeModulesLocationForPackage(packageName);
-    const packagePathPieces = bareUrl.split('node_modules/')[1].split('/'); // double split to handle node_modules within nested paths
-    let absoluteNodeModulesUrl;
-
-    if (absoluteNodeModulesLocation) {
-      absoluteNodeModulesUrl = `${absoluteNodeModulesLocation}${packagePathPieces.join('/').replace(packageName, '')}`;
-    } else {
-      const isAbsoluteNodeModulesFile = fs.existsSync(path.join(projectDirectory, bareUrl));
-      
-      absoluteNodeModulesUrl = isAbsoluteNodeModulesFile
-        ? path.join(projectDirectory, bareUrl)
-        : this.resolveRelativeUrl(projectDirectory, bareUrl)
-          ? path.join(projectDirectory, this.resolveRelativeUrl(projectDirectory, bareUrl))
-          : bareUrl;
-    }
+    const packagePathPieces = pathname.split('node_modules/')[1].split('/'); // double split to handle node_modules within nested paths
+    // use node modules resolution logic first, else hope for the best from the root of the project
+    const absoluteNodeModulesPathname = absoluteNodeModulesLocation
+      ? `${absoluteNodeModulesLocation}${packagePathPieces.join('/').replace(packageName, '')}`
+      : (await resolveForRelativeUrl(url, projectDirectory)).pathname;
 
-    return Promise.resolve(absoluteNodeModulesUrl);
+    return new Request(`file://${absoluteNodeModulesPathname}`);
   }
 
   async shouldServe(url) {
-    return Promise.resolve(path.extname(url) === '.mjs' 
-      || (path.extname(url) === '' && fs.existsSync(`${url}.js`))
-      || (path.extname(url) === '.js' && (/node_modules/).test(url)));
+    const { href, pathname, protocol } = url;
+    const extension = pathname.split('.').pop();
+    const existsAsJs = protocol === 'file:' && await checkResourceExists(new URL(`${href}.js`));
+
+    return extension === 'mjs'
+      || extension === '' && existsAsJs
+      || extension === 'js' && url.pathname.startsWith('/node_modules/');
   }
 
   async serve(url) {
-    return new Promise(async(resolve, reject) => {
-      try {
-        const fullUrl = path.extname(url) === ''
-          ? `${url}.js`
-          : url;
-        const body = await fs.promises.readFile(fullUrl, 'utf-8');
-
-        resolve({
-          body,
-          contentType: 'text/javascript'
-        });
-      } catch (e) {
-        reject(e);
-      }
+    const pathname = url.pathname;
+    const urlExtended = pathname.split('.').pop() === ''
+      ? new URL(`file://${pathname}.js`)
+      : url;
+    const body = await fs.readFile(urlExtended, 'utf-8');
+
+    return new Response(body, {
+      headers: new Headers({
+        'Content-Type': this.contentType
+      })
     });
   }
 
-  async shouldIntercept(url, body, headers) {
-    return Promise.resolve(headers.response['content-type'] === 'text/html');
+  async shouldIntercept(url, request, response) {
+    return response.headers.get('Content-Type').indexOf('text/html') >= 0;
   }
 
-  async intercept(url, body) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const { userWorkspace } = this.compilation.context;
-        let newContents = body;
-        const hasHead = body.match(/\<head>(.*)<\/head>/s);
+  async intercept(url, request, response) {
+    const { context } = this.compilation;
+    let body = await response.text();
+    const hasHead = body.match(/\<head>(.*)<\/head>/s);
 
-        if (hasHead && hasHead.length > 0) {
-          const contents = hasHead[0].replace(/type="module"/g, 'type="module-shim"');
+    if (hasHead && hasHead.length > 0) {
+      const contents = hasHead[0].replace(/type="module"/g, 'type="module-shim"');
 
-          newContents = newContents.replace(/\<head>(.*)<\/head>/s, contents.replace(/\$/g, '$$$')); // https://github.com/ProjectEvergreen/greenwood/issues/656);
-        }
+      body = body.replace(/\<head>(.*)<\/head>/s, contents.replace(/\$/g, '$$$')); // https://github.com/ProjectEvergreen/greenwood/issues/656);
+    }
 
-        const userPackageJson = fs.existsSync(`${userWorkspace}/package.json`)
-          ? JSON.parse(fs.readFileSync(path.join(userWorkspace, 'package.json'), 'utf-8')) // its a monorepo?
-          : fs.existsSync(`${process.cwd()}/package.json`)
-            ? JSON.parse(fs.readFileSync(path.join(process.cwd(), 'package.json'), 'utf-8'))
-            : {};
-        
-        // if there are dependencies and we haven't generated the importMap already
-        // walk the project's package.json for all its direct dependencies
-        // for each entry found in dependencies, find its entry point
-        // then walk its entry point (e.g. index.js) for imports / exports to add to the importMap
-        // and then walk its package.json for transitive dependencies and all those import / exports
-        importMap = !importMap && Object.keys(userPackageJson.dependencies || []).length > 0
-          ? await walkPackageJson(userPackageJson)
-          : importMap || {};
-
-        // apply import map and shim for users
-        newContents = newContents.replace('<head>', `
-          <head>
-            <script defer src="/node_modules/es-module-shims/dist/es-module-shims.js"></script>
-            <script type="importmap-shim">
-              {
-                "imports": ${JSON.stringify(importMap, null, 1)}
-              }
-            </script>
-        `);
-
-        resolve({
-          body: newContents
-        });
-      } catch (e) {
-        reject(e);
-      }
-    });
+    const userPackageJson = await getPackageJson(context);
+    
+    // if there are dependencies and we haven't generated the importMap already
+    // walk the project's package.json for all its direct dependencies
+    // for each entry found in dependencies, find its entry point
+    // then walk its entry point (e.g. index.js) for imports / exports to add to the importMap
+    // and then walk its package.json for transitive dependencies and all those import / exports
+    importMap = !importMap && Object.keys(userPackageJson.dependencies || []).length > 0
+      ? await walkPackageJson(userPackageJson)
+      : importMap || {};
+
+    // apply import map and shim for users
+    body = body.replace('<head>', `
+      <head>
+        <script defer src="/node_modules/es-module-shims/dist/es-module-shims.js"></script>
+        <script type="importmap-shim">
+          {
+            "imports": ${JSON.stringify(importMap, null, 1)}
+          }
+        </script>
+    `);
+
+    return new Response(body);
   }
 }
 
diff --git a/packages/cli/src/plugins/resource/plugin-source-maps.js b/packages/cli/src/plugins/resource/plugin-source-maps.js
index eb01ec38a..320915bdd 100644
--- a/packages/cli/src/plugins/resource/plugin-source-maps.js
+++ b/packages/cli/src/plugins/resource/plugin-source-maps.js
@@ -3,32 +3,28 @@
  * Detects and fully resolve requests to source map (.map) files.
  *
  */
-import fs from 'fs';
-import path from 'path';
+import { checkResourceExists } from '../../lib/resource-utils.js';
+import fs from 'fs/promises';
 import { ResourceInterface } from '../../lib/resource-interface.js';
 
 class SourceMapsResource extends ResourceInterface {
   constructor(compilation, options) {
     super(compilation, options);
-    this.extensions = ['.map'];
+    this.extensions = ['map'];
+    this.contentType = 'application/json';
   }
 
   async shouldServe(url) {
-    return Promise.resolve(path.extname(url) === this.extensions[0] && fs.existsSync(url));
+    return url.pathname.split('.').pop() === this.extensions[0] && await checkResourceExists(url);
   }
 
   async serve(url) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const sourceMap = fs.readFileSync(url, 'utf-8');
-        
-        resolve({
-          body: sourceMap,
-          contentType: 'application/json'
-        });
-      } catch (e) {
-        reject(e);
-      }
+    const body = await fs.readFile(url, 'utf-8');
+
+    return new Response(body, {
+      headers: new Headers({
+        'Content-Type': this.contentType
+      })
     });
   }
 }
diff --git a/packages/cli/src/plugins/resource/plugin-standard-css.js b/packages/cli/src/plugins/resource/plugin-standard-css.js
index cbb05d2ac..22b3801f4 100644
--- a/packages/cli/src/plugins/resource/plugin-standard-css.js
+++ b/packages/cli/src/plugins/resource/plugin-standard-css.js
@@ -6,7 +6,6 @@
  */
 import fs from 'fs';
 import { parse, walk } from 'css-tree';
-import path from 'path';
 import { ResourceInterface } from '../../lib/resource-interface.js';
 
 function bundleCss(body, url, projectDirectory) {
@@ -25,10 +24,10 @@ function bundleCss(body, url, projectDirectory) {
         const { value } = node;
 
         if (value.indexOf('.') === 0 || value.indexOf('/node_modules') === 0) {
-          const location = value.indexOf('/node_modules') === 0
-            ? path.join(projectDirectory, value)
-            : path.resolve(path.dirname(url), value);
-          const importContents = fs.readFileSync(location, 'utf-8');
+          const resolvedUrl = value.startsWith('/node_modules')
+            ? new URL(`.${value}`, projectDirectory)
+            : new URL(value, url);
+          const importContents = fs.readFileSync(resolvedUrl, 'utf-8');
 
           optimizedCss += bundleCss(importContents, url, projectDirectory);
         } else {
@@ -206,39 +205,38 @@ function bundleCss(body, url, projectDirectory) {
 class StandardCssResource extends ResourceInterface {
   constructor(compilation, options) {
     super(compilation, options);
-    this.extensions = ['.css'];
+    this.extensions = ['css'];
     this.contentType = 'text/css';
   }
 
+  async shouldServe(url) {
+    return url.protocol === 'file:' && this.extensions.indexOf(url.pathname.split('.').pop()) >= 0;
+  }
+
   async serve(url) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const css = await fs.promises.readFile(url, 'utf-8');
-
-        resolve({
-          body: css,
-          contentType: this.contentType
-        });
-      } catch (e) {
-        reject(e);
+    const body = await fs.promises.readFile(url, 'utf-8');
+
+    return new Response(body, {
+      headers: {
+        'Content-Type': this.contentType
       }
     });
   }
 
-  async shouldOptimize(url) {
-    const isValidCss = path.extname(url) === this.extensions[0] && this.compilation.config.optimization !== 'none';
+  async shouldOptimize(url, response) {
+    const { protocol, pathname } = url;
+    const isValidCss = pathname.split('.').pop() === this.extensions[0]
+      && protocol === 'file:'
+      && response.headers.get('Content-Type').indexOf(this.contentType) >= 0;
 
-    return Promise.resolve(isValidCss);
+    return this.compilation.config.optimization !== 'none' && isValidCss;
   }
 
-  async optimize(url, body) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        resolve(bundleCss(body, url, this.compilation.context.projectDirectory));
-      } catch (e) {
-        reject(e);
-      }
-    });
+  async optimize(url, response) {
+    const body = await response.text();
+    const optimizedBody = bundleCss(body, url, this.compilation.context.projectDirectory);
+
+    return new Response(optimizedBody);
   }
 }
 
diff --git a/packages/cli/src/plugins/resource/plugin-standard-font.js b/packages/cli/src/plugins/resource/plugin-standard-font.js
index e19e06e7d..ab6b71e3e 100644
--- a/packages/cli/src/plugins/resource/plugin-standard-font.js
+++ b/packages/cli/src/plugins/resource/plugin-standard-font.js
@@ -4,8 +4,7 @@
  * This is a Greenwood default plugin.
  *
  */
-import fs from 'fs';
-import path from 'path';
+import fs from 'fs/promises';
 import { ResourceInterface } from '../../lib/resource-interface.js';
 
 class StandardFontResource extends ResourceInterface {
@@ -13,23 +12,22 @@ class StandardFontResource extends ResourceInterface {
     super(compilation, options);
 
     // https://developer.mozilla.org/en-US/docs/Learn/CSS/Styling_text/Web_fonts
-    this.extensions = ['.woff2', '.woff', '.ttf', '.eot'];
+    this.extensions = ['woff2', 'woff', 'ttf', 'eot'];
+  }
+
+  async shouldServe(url) {
+    return this.extensions.indexOf(url.pathname.split('.').pop()) >= 0;
   }
 
   async serve(url) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const ext = path.extname(url).replace('.', '');
-        const contentType = ext === 'eot' ? 'application/vnd.ms-fontobject' : ext;
-        const body = await fs.promises.readFile(url);
+    const extension = url.pathname.split('.').pop();
+    const contentType = extension === 'eot' ? 'application/vnd.ms-fontobject' : extension;
+    const body = await fs.readFile(url);
 
-        resolve({
-          body,
-          contentType
-        });
-      } catch (e) {
-        reject(e);
-      }
+    return new Response(body, {
+      headers: new Headers({
+        'Content-Type': contentType
+      })
     });
   }
 }
diff --git a/packages/cli/src/plugins/resource/plugin-standard-html.js b/packages/cli/src/plugins/resource/plugin-standard-html.js
index d4bfe7d31..43eff82c3 100644
--- a/packages/cli/src/plugins/resource/plugin-standard-html.js
+++ b/packages/cli/src/plugins/resource/plugin-standard-html.js
@@ -5,8 +5,10 @@
  * This is a Greenwood default plugin.
  *
  */
+import { checkResourceExists } from '../../lib/resource-utils.js';
 import frontmatter from 'front-matter';
-import fs from 'fs';
+import fs from 'fs/promises';
+import { getPackageJson } from '../../lib/node-modules-utils.js';
 import htmlparser from 'node-html-parser';
 import path from 'path';
 import rehypeStringify from 'rehype-stringify';
@@ -16,57 +18,72 @@ import remarkParse from 'remark-parse';
 import remarkRehype from 'remark-rehype';
 import { ResourceInterface } from '../../lib/resource-interface.js';
 import unified from 'unified';
-import { fileURLToPath } from 'url';
 import { Worker } from 'worker_threads';
 
-function getCustomPageTemplates(contextPlugins, templateName) {
-  return contextPlugins
+async function getCustomPageTemplatesFromPlugins(contextPlugins, templateName) {
+  const customTemplateLocations = [];
+  const templateDir = contextPlugins
     .map(plugin => plugin.templates)
-    .flat()
-    .filter((templateDir) => {
-      return templateName && fs.existsSync(path.join(templateDir, `${templateName}.html`));
-    });
+    .flat();
+
+  for (const templateDirUrl of templateDir) {
+    if (templateName) {
+      const templateUrl = new URL(`./${templateName}.html`, templateDirUrl);
+
+      if (await checkResourceExists(templateUrl)) {
+        customTemplateLocations.push(templateUrl);
+      }
+    }
+  }
+
+  return customTemplateLocations;
 }
 
-const getPageTemplate = (fullPath, templatesDir, template, contextPlugins = [], pagesDir) => {
-  const customPluginDefaultPageTemplates = getCustomPageTemplates(contextPlugins, 'page');
-  const customPluginPageTemplates = getCustomPageTemplates(contextPlugins, template);
-  const is404Page = path.basename(fullPath).indexOf('404') === 0 && path.extname(fullPath) === '.html';
+const getPageTemplate = async (filePath, { userTemplatesDir, pagesDir, projectDirectory }, template, contextPlugins = []) => {
+  const customPluginDefaultPageTemplates = await getCustomPageTemplatesFromPlugins(contextPlugins, 'page');
+  const customPluginPageTemplates = await getCustomPageTemplatesFromPlugins(contextPlugins, template);
+  const extension = filePath.split('.').pop();
+  const is404Page = filePath.startsWith('404') && extension === 'html';
+  const hasCustomTemplate = await checkResourceExists(new URL(`./${template}.html`, userTemplatesDir));
+  const hasPageTemplate = await checkResourceExists(new URL('./page.html', userTemplatesDir));
+  const hasCustom404Page = await checkResourceExists(new URL('./404.html', pagesDir));
+  const isHtmlPage = extension === 'html' && await checkResourceExists(new URL(`./${filePath}`, projectDirectory));
   let contents;
 
-  if (template && customPluginPageTemplates.length > 0 || fs.existsSync(`${templatesDir}/${template}.html`)) {
+  if (template && (customPluginPageTemplates.length > 0 || hasCustomTemplate)) {
     // use a custom template, usually from markdown frontmatter
     contents = customPluginPageTemplates.length > 0
-      ? fs.readFileSync(`${customPluginPageTemplates[0]}/${template}.html`, 'utf-8')
-      : fs.readFileSync(`${templatesDir}/${template}.html`, 'utf-8');
-  } else if (path.extname(fullPath) === '.html' && fs.existsSync(fullPath)) {
+      ? await fs.readFile(new URL(`./${template}.html`, customPluginPageTemplates[0]), 'utf-8')
+      : await fs.readFile(new URL(`./${template}.html`, userTemplatesDir), 'utf-8');
+  } else if (isHtmlPage) {
     // if the page is already HTML, use that as the template, NOT accounting for 404 pages
-    contents = fs.readFileSync(fullPath, 'utf-8');
-  } else if (customPluginDefaultPageTemplates.length > 0 || (!is404Page && fs.existsSync(`${templatesDir}/page.html`))) {
+    contents = await fs.readFile(new URL(`./${filePath}`, projectDirectory), 'utf-8');
+  } else if (customPluginDefaultPageTemplates.length > 0 || (!is404Page && hasPageTemplate)) {
     // else look for default page template from the user
     // and 404 pages should be their own "top level" template
     contents = customPluginDefaultPageTemplates.length > 0
-      ? fs.readFileSync(`${customPluginDefaultPageTemplates[0]}/page.html`, 'utf-8')
-      : fs.readFileSync(`${templatesDir}/page.html`, 'utf-8');
-  } else if (is404Page && !fs.existsSync(path.join(pagesDir, '404.html'))) {
-    contents = fs.readFileSync(fileURLToPath(new URL('../../templates/404.html', import.meta.url)), 'utf-8');
+      ? await fs.readFile(new URL('./page.html', customPluginDefaultPageTemplates[0]), 'utf-8')
+      : await fs.readFile(new URL('./page.html', userTemplatesDir), 'utf-8');
+  } else if (is404Page && !hasCustom404Page) {
+    contents = await fs.readFile(new URL('../../templates/404.html', import.meta.url), 'utf-8');
   } else {
     // fallback to using Greenwood's stock page template
-    contents = fs.readFileSync(fileURLToPath(new URL('../../templates/page.html', import.meta.url)), 'utf-8');
+    contents = await fs.readFile(new URL('../../templates/page.html', import.meta.url), 'utf-8');
   }
 
   return contents;
 };
 
-const getAppTemplate = (pageTemplateContents, templatesDir, customImports = [], contextPlugins, enableHud, frontmatterTitle) => {
-  const userAppTemplatePath = `${templatesDir}app.html`;
-  const customAppTemplates = getCustomPageTemplates(contextPlugins, 'app');
+const getAppTemplate = async (pageTemplateContents, templatesDir, customImports = [], contextPlugins, enableHud, frontmatterTitle) => {
+  const userAppTemplateUrl = new URL('./app.html', templatesDir);
+  const customAppTemplatesFromPlugins = await getCustomPageTemplatesFromPlugins(contextPlugins, 'app');
+  const hasCustomUserAppTemplate = await checkResourceExists(userAppTemplateUrl);
+  let appTemplateContents = customAppTemplatesFromPlugins.length > 0
+    ? await fs.readFile(new URL('./app.html', customAppTemplatesFromPlugins[0]))
+    : hasCustomUserAppTemplate
+      ? await fs.readFile(userAppTemplateUrl, 'utf-8')
+      : await fs.readFile(new URL('../../templates/app.html', import.meta.url), 'utf-8');
   let mergedTemplateContents = '';
-  let appTemplateContents = customAppTemplates.length > 0
-    ? fs.readFileSync(`${customAppTemplates[0]}/app.html`, 'utf-8')
-    : fs.existsSync(userAppTemplatePath)
-      ? fs.readFileSync(userAppTemplatePath, 'utf-8')
-      : fs.readFileSync(fileURLToPath(new URL('../../templates/app.html', import.meta.url)), 'utf-8');
 
   const pageRoot = htmlparser.parse(pageTemplateContents, {
     script: true,
@@ -169,16 +186,11 @@ const getAppTemplate = (pageTemplateContents, templatesDir, customImports = [],
   return mergedTemplateContents;
 };
 
-const getUserScripts = (contents, context) => {
+const getUserScripts = async (contents, context) => {
   // https://lit.dev/docs/tools/requirements/#polyfills
   if (process.env.__GWD_COMMAND__ === 'build') { // eslint-disable-line no-underscore-dangle
-    const { projectDirectory, userWorkspace } = context;
-    const dependencies = fs.existsSync(path.join(userWorkspace, 'package.json')) // handle monorepos first
-      ? JSON.parse(fs.readFileSync(path.join(userWorkspace, 'package.json'), 'utf-8')).dependencies
-      : fs.existsSync(path.join(projectDirectory, 'package.json'))
-        ? JSON.parse(fs.readFileSync(path.join(projectDirectory, 'package.json'), 'utf-8')).dependencies
-        : {};
-
+    const userPackageJson = await getPackageJson(context);
+    const dependencies = userPackageJson?.dependencies || {};
     const litPolyfill = dependencies && dependencies.lit
       ? '<script src="/node_modules/lit/polyfill-support.js"></script>\n'
       : '';
@@ -199,290 +211,271 @@ class StandardHtmlResource extends ResourceInterface {
     this.contentType = 'text/html';
   }
 
-  getRelativeUserworkspaceUrl(url) {
-    return path.normalize(url.replace(this.compilation.context.userWorkspace, ''));
-  }
-
-  async shouldServe(url, headers) {
-    const relativeUrl = this.getRelativeUserworkspaceUrl(url).replace(/\\/g, '/'); // and handle for windows
-    const isClientSideRoute = this.compilation.graph[0].isSPA && path.extname(url) === '' && (headers.request.accept || '').indexOf(this.contentType) >= 0;
-    const hasMatchingRoute = this.compilation.graph.filter((node) => {
-      return node.route === relativeUrl;
-    }).length === 1;
+  async shouldServe(url) {
+    const { protocol, pathname } = url;
+    const hasMatchingPageRoute = this.compilation.graph.find(node => node.route === pathname);
 
-    return Promise.resolve(hasMatchingRoute || isClientSideRoute);
+    return protocol.startsWith('http') && (hasMatchingPageRoute || this.compilation.graph[0].isSPA);
   }
 
   async serve(url) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const config = Object.assign({}, this.compilation.config);
-        const { pagesDir, userTemplatesDir } = this.compilation.context;
-        const { interpolateFrontmatter } = this.compilation.config;
-        const relativeUrl = this.getRelativeUserworkspaceUrl(url).replace(/\\/g, '/'); // and handle for windows;
-        const isClientSideRoute = this.compilation.graph[0].isSPA;
-        const matchingRoute = isClientSideRoute
-          ? this.compilation.graph[0]
-          : this.compilation.graph.filter((node) => {
-            return node.route === relativeUrl;
-          })[0];
-        const fullPath = !matchingRoute.external ? matchingRoute.path : '';
-        const isMarkdownContent = path.extname(fullPath) === '.md';
-
-        let customImports = [];
-        let body = '';
-        let title = null;
-        let template = null;
-        let frontMatter = {};
-        let ssrBody;
-        let ssrTemplate;
-        let ssrFrontmatter;
-        let processedMarkdown = null;
-
-        if (matchingRoute.external) {
-          template = matchingRoute.template || template;
+    const { config } = this.compilation;
+    const { pagesDir, userTemplatesDir, userWorkspace } = this.compilation.context;
+    const { interpolateFrontmatter } = config;
+    const { pathname } = url;
+    const isSpaRoute = this.compilation.graph.find(node => node.isSPA);
+    const matchingRoute = this.compilation.graph.find((node) => node.route === pathname) || {};
+    const filePath = !matchingRoute.external ? matchingRoute.path : '';
+    const isMarkdownContent = (matchingRoute?.filename || '').split('.').pop() === 'md';
+
+    let customImports = [];
+    let body = '';
+    let title = null;
+    let template = null;
+    let frontMatter = {};
+    let ssrBody;
+    let ssrTemplate;
+    let ssrFrontmatter;
+    let processedMarkdown = null;
+
+    if (matchingRoute.external) {
+      template = matchingRoute.template || template;
+    }
+
+    if (isMarkdownContent) {
+      const markdownContents = await fs.readFile(filePath, 'utf-8');
+      const rehypePlugins = [];
+      const remarkPlugins = [];
+
+      for (const plugin of config.markdown.plugins) {
+        if (plugin.indexOf('rehype-') >= 0) {
+          rehypePlugins.push((await import(plugin)).default);
         }
 
-        if (isMarkdownContent) {
-          const markdownContents = await fs.promises.readFile(fullPath, 'utf-8');
-          const rehypePlugins = [];
-          const remarkPlugins = [];
+        if (plugin.indexOf('remark-') >= 0) {
+          remarkPlugins.push((await import(plugin)).default);
+        }
+      }
 
-          for (const plugin of config.markdown.plugins) {
-            if (plugin.indexOf('rehype-') >= 0) {
-              rehypePlugins.push((await import(plugin)).default);
-            }
+      const settings = config.markdown.settings || {};
+      const fm = frontmatter(markdownContents);
+
+      processedMarkdown = await unified()
+        .use(remarkParse, settings) // parse markdown into AST
+        .use(remarkFrontmatter) // extract frontmatter from AST
+        .use(remarkPlugins) // apply userland remark plugins
+        .use(remarkRehype, { allowDangerousHtml: true }) // convert from markdown to HTML AST
+        .use(rehypeRaw) // support mixed HTML in markdown
+        .use(rehypePlugins) // apply userland rehype plugins
+        .use(rehypeStringify) // convert AST to HTML string
+        .process(markdownContents);
+
+      // configure via frontmatter
+      if (fm.attributes) {
+        frontMatter = fm.attributes;
+
+        if (frontMatter.title) {
+          title = frontMatter.title;
+        }
 
-            if (plugin.indexOf('remark-') >= 0) {
-              remarkPlugins.push((await import(plugin)).default);
-            }
+        if (frontMatter.template) {
+          template = frontMatter.template;
+        }
+
+        if (frontMatter.imports) {
+          customImports = frontMatter.imports;
+        }
+      }
+    }
+
+    if (matchingRoute.isSSR) {
+      const routeModuleLocationUrl = new URL(`./${matchingRoute.filename}`, pagesDir);
+      const routeWorkerUrl = this.compilation.config.plugins.find(plugin => plugin.type === 'renderer').provider().workerUrl;
+
+      await new Promise((resolve, reject) => {
+        const worker = new Worker(routeWorkerUrl);
+
+        worker.on('message', (result) => {
+          if (result.template) {
+            ssrTemplate = result.template;
           }
+          if (result.body) {
+            ssrBody = result.body;
+          }
+          if (result.frontmatter) {
+            ssrFrontmatter = result.frontmatter;
 
-          const settings = config.markdown.settings || {};
-          const fm = frontmatter(markdownContents);
-
-          processedMarkdown = await unified()
-            .use(remarkParse, settings) // parse markdown into AST
-            .use(remarkFrontmatter) // extract frontmatter from AST
-            .use(remarkPlugins) // apply userland remark plugins
-            .use(remarkRehype, { allowDangerousHtml: true }) // convert from markdown to HTML AST
-            .use(rehypeRaw) // support mixed HTML in markdown
-            .use(rehypePlugins) // apply userland rehype plugins
-            .use(rehypeStringify) // convert AST to HTML string
-            .process(markdownContents);
-
-          // configure via frontmatter
-          if (fm.attributes) {
-            frontMatter = fm.attributes;
-
-            if (frontMatter.title) {
-              title = frontMatter.title;
+            if (ssrFrontmatter.title) {
+              title = ssrFrontmatter.title;
+              frontMatter.title = ssrFrontmatter.title;
             }
 
-            if (frontMatter.template) {
-              template = frontMatter.template;
+            if (ssrFrontmatter.template) {
+              template = ssrFrontmatter.template;
             }
 
-            if (frontMatter.imports) {
-              customImports = frontMatter.imports;
+            if (ssrFrontmatter.imports) {
+              customImports = customImports.concat(ssrFrontmatter.imports);
             }
           }
-        }
-
-        if (matchingRoute.isSSR) {
-          const routeModuleLocation = path.join(pagesDir, matchingRoute.filename);
-          const routeWorkerUrl = this.compilation.config.plugins.filter(plugin => plugin.type === 'renderer')[0].provider().workerUrl;
-
-          await new Promise((resolve, reject) => {
-            const worker = new Worker(routeWorkerUrl);
-
-            worker.on('message', (result) => {
-              if (result.template) {
-                ssrTemplate = result.template;
-              }
-              if (result.body) {
-                ssrBody = result.body;
-              }
-              if (result.frontmatter) {
-                ssrFrontmatter = result.frontmatter;
-
-                if (ssrFrontmatter.title) {
-                  title = ssrFrontmatter.title;
-                  frontMatter.title = ssrFrontmatter.title;
-                }
-
-                if (ssrFrontmatter.template) {
-                  template = ssrFrontmatter.template;
-                }
-
-                if (ssrFrontmatter.imports) {
-                  customImports = customImports.concat(ssrFrontmatter.imports);
-                }
-              }
-              resolve();
-            });
-            worker.on('error', reject);
-            worker.on('exit', (code) => {
-              if (code !== 0) {
-                reject(new Error(`Worker stopped with exit code ${code}`));
-              }
-            });
-
-            worker.postMessage({
-              modulePath: routeModuleLocation,
-              compilation: JSON.stringify(this.compilation),
-              route: fullPath
-            });
-          });
-        }
-
-        // get context plugins
-        const contextPlugins = this.compilation.config.plugins.filter((plugin) => {
-          return plugin.type === 'context';
-        }).map((plugin) => {
-          return plugin.provider(this.compilation);
+          resolve();
+        });
+        worker.on('error', reject);
+        worker.on('exit', (code) => {
+          if (code !== 0) {
+            reject(new Error(`Worker stopped with exit code ${code}`));
+          }
         });
 
-        if (isClientSideRoute) {
-          body = fs.readFileSync(fullPath, 'utf-8');
-        } else {
-          body = ssrTemplate ? ssrTemplate : getPageTemplate(fullPath, userTemplatesDir, template, contextPlugins, pagesDir);
-        }
+        worker.postMessage({
+          moduleUrl: routeModuleLocationUrl.href,
+          compilation: JSON.stringify(this.compilation),
+          route: matchingRoute.path
+        });
+      });
+    }
 
-        body = getAppTemplate(body, userTemplatesDir, customImports, contextPlugins, config.devServer.hud, title);
-        body = getUserScripts(body, this.compilation.context);
+    // get context plugins
+    const contextPlugins = this.compilation.config.plugins.filter((plugin) => {
+      return plugin.type === 'context';
+    }).map((plugin) => {
+      return plugin.provider(this.compilation);
+    });
 
-        if (processedMarkdown) {
-          const wrappedCustomElementRegex = /<p><[a-zA-Z]*-[a-zA-Z](.*)>(.*)<\/[a-zA-Z]*-[a-zA-Z](.*)><\/p>/g;
-          const ceTest = wrappedCustomElementRegex.test(processedMarkdown.contents);
+    if (isSpaRoute) {
+      body = await fs.readFile(new URL(`./${isSpaRoute.filename}`, userWorkspace), 'utf-8');
+    } else {
+      body = ssrTemplate ? ssrTemplate : await getPageTemplate(filePath, this.compilation.context, template, contextPlugins);
+    }
 
-          if (ceTest) {
-            const ceMatches = processedMarkdown.contents.match(wrappedCustomElementRegex);
+    body = await getAppTemplate(body, userTemplatesDir, customImports, contextPlugins, config.devServer.hud, title);
+    body = await getUserScripts(body, this.compilation.context);
 
-            ceMatches.forEach((match) => {
-              const stripWrappingTags = match
-                .replace('<p>', '')
-                .replace('</p>', '');
+    if (processedMarkdown) {
+      const wrappedCustomElementRegex = /<p><[a-zA-Z]*-[a-zA-Z](.*)>(.*)<\/[a-zA-Z]*-[a-zA-Z](.*)><\/p>/g;
+      const ceTest = wrappedCustomElementRegex.test(processedMarkdown.contents);
 
-              processedMarkdown.contents = processedMarkdown.contents.replace(match, stripWrappingTags);
-            });
-          }
+      if (ceTest) {
+        const ceMatches = processedMarkdown.contents.match(wrappedCustomElementRegex);
 
-          body = body.replace(/\<content-outlet>(.*)<\/content-outlet>/s, processedMarkdown.contents);
-        } else if (matchingRoute.external) {
-          body = body.replace(/\<content-outlet>(.*)<\/content-outlet>/s, matchingRoute.body);
-        } else if (ssrBody) {
-          body = body.replace(/\<content-outlet>(.*)<\/content-outlet>/s, ssrBody);
-        }
+        ceMatches.forEach((match) => {
+          const stripWrappingTags = match
+            .replace('<p>', '')
+            .replace('</p>', '');
 
-        if (interpolateFrontmatter) {
-          for (const fm in frontMatter) {
-            const interpolatedFrontmatter = '\\$\\{globalThis.page.' + fm + '\\}';
+          processedMarkdown.contents = processedMarkdown.contents.replace(match, stripWrappingTags);
+        });
+      }
 
-            body = body.replace(new RegExp(interpolatedFrontmatter, 'g'), frontMatter[fm]);
-          }
-        }
+      body = body.replace(/\<content-outlet>(.*)<\/content-outlet>/s, processedMarkdown.contents);
+    } else if (matchingRoute.external) {
+      body = body.replace(/\<content-outlet>(.*)<\/content-outlet>/s, matchingRoute.body);
+    } else if (ssrBody) {
+      body = body.replace(/\<content-outlet>(.*)<\/content-outlet>/s, ssrBody);
+    }
 
-        // give the user something to see so they know it works, if they have no content
-        if (body.indexOf('<content-outlet></content-outlet>') > 0) {
-          body = body.replace('<content-outlet></content-outlet>', `
-            <h1>Welcome to Greenwood!</h1>
-          `);
-        }
+    if (interpolateFrontmatter) {
+      for (const fm in frontMatter) {
+        const interpolatedFrontmatter = '\\$\\{globalThis.page.' + fm + '\\}';
 
-        resolve({
-          body,
-          contentType: this.contentType
-        });
-      } catch (e) {
-        reject(e);
+        body = body.replace(new RegExp(interpolatedFrontmatter, 'g'), frontMatter[fm]);
       }
+    }
+
+    // give the user something to see so they know it works, if they have no content
+    if (body.indexOf('<content-outlet></content-outlet>') > 0) {
+      body = body.replace('<content-outlet></content-outlet>', `
+        <h1>Welcome to Greenwood!</h1>
+      `);
+    }
+
+    return new Response(body, {
+      headers: new Headers({
+        'Content-Type': this.contentType
+      })
     });
   }
 
-  async shouldOptimize(url = '', body, headers = {}) {
-    return Promise.resolve(path.extname(url) === '.html' || (headers.request && headers.request['content-type'].indexOf('text/html') >= 0));
+  async shouldOptimize(url, response) {
+    return response.headers.get('Content-Type').indexOf(this.contentType) >= 0;
   }
 
-  async optimize(url, body) {
+  async optimize(url, response) {
     const { optimization } = this.compilation.config;
-    const pageResources = this.compilation.graph.find(page => page.outputPath === url || page.route === url).imports;
-
-    return new Promise((resolve, reject) => {
-      try {
-        for (const pageResource of pageResources) {
-          const keyedResource = this.compilation.resources.get(pageResource.sourcePathURL.pathname);
-          const { contents, src, type, optimizationAttr, optimizedFileContents, optimizedFileName, rawAttributes } = keyedResource;
-
-          if (src) {
-            if (type === 'script') {
-              if (!optimizationAttr && optimization === 'default') {
-                const optimizedFilePath = `/${optimizedFileName}`;
-
-                body = body.replace(src, optimizedFilePath);
-                body = body.replace('<head>', `
-                  <head>
-                  <link rel="modulepreload" href="${optimizedFilePath}" as="script">
-                `);
-              } else if (optimizationAttr === 'inline' || optimization === 'inline') {
-                const isModule = rawAttributes.indexOf('type="module') >= 0 ? ' type="module"' : '';
-
-                body = body.replace(`<script ${rawAttributes}></script>`, `
-                  <script ${isModule}>
-                    ${optimizedFileContents.replace(/\.\//g, '/').replace(/\$/g, '$$$')}
-                  </script>
-                `);
-              } else if (optimizationAttr === 'static' || optimization === 'static') {
-                body = body.replace(`<script ${rawAttributes}></script>`, '');
-              }
-            } else if (type === 'link') {
-              if (!optimizationAttr && (optimization !== 'none' && optimization !== 'inline')) {
-                const optimizedFilePath = `/${optimizedFileName}`;
-
-                body = body.replace(src, optimizedFilePath);
-                body = body.replace('<head>', `
-                  <head>
-                  <link rel="preload" href="${optimizedFilePath}" as="style" crossorigin="anonymous"></link>
-                `);
-              } else if (optimizationAttr === 'inline' || optimization === 'inline') {
-                // https://github.com/ProjectEvergreen/greenwood/issues/810
-                // when pre-rendering, puppeteer normalizes everything to <link .../>
-                // but if not using pre-rendering, then it could come out as <link ...></link>
-                // not great, but best we can do for now until #742
-                body = body.replace(`<link ${rawAttributes}>`, `
-                  <style>
-                    ${optimizedFileContents}
-                  </style>
-                `).replace(`<link ${rawAttributes}/>`, `
-                  <style>
-                    ${optimizedFileContents}
-                  </style>
-                `);
-              }
-            }
+    const { pathname } = url;
+    const pageResources = this.compilation.graph.find(page => page.outputPath === pathname || page.route === pathname).imports;
+    let body = await response.text();
+
+    for (const pageResource of pageResources) {
+      const keyedResource = this.compilation.resources.get(pageResource.sourcePathURL.pathname);
+      const { contents, src, type, optimizationAttr, optimizedFileContents, optimizedFileName, rawAttributes } = keyedResource;
+
+      if (src) {
+        if (type === 'script') {
+          if (!optimizationAttr && optimization === 'default') {
+            const optimizedFilePath = `/${optimizedFileName}`;
+
+            body = body.replace(src, optimizedFilePath);
+            body = body.replace('<head>', `
+              <head>
+              <link rel="modulepreload" href="${optimizedFilePath}" as="script">
+            `);
+          } else if (optimizationAttr === 'inline' || optimization === 'inline') {
+            const isModule = rawAttributes.indexOf('type="module') >= 0 ? ' type="module"' : '';
+
+            body = body.replace(`<script ${rawAttributes}></script>`, `
+              <script ${isModule}>
+                ${optimizedFileContents.replace(/\.\//g, '/').replace(/\$/g, '$$$')}
+              </script>
+            `);
+          } else if (optimizationAttr === 'static' || optimization === 'static') {
+            body = body.replace(`<script ${rawAttributes}></script>`, '');
+          }
+        } else if (type === 'link') {
+          if (!optimizationAttr && (optimization !== 'none' && optimization !== 'inline')) {
+            const optimizedFilePath = `/${optimizedFileName}`;
+
+            body = body.replace(src, optimizedFilePath);
+            body = body.replace('<head>', `
+              <head>
+              <link rel="preload" href="${optimizedFilePath}" as="style" crossorigin="anonymous"></link>
+            `);
+          } else if (optimizationAttr === 'inline' || optimization === 'inline') {
+            // https://github.com/ProjectEvergreen/greenwood/issues/810
+            // when pre-rendering, puppeteer normalizes everything to <link .../>
+            // but if not using pre-rendering, then it could come out as <link ...></link>
+            // not great, but best we can do for now until #742
+            body = body.replace(`<link ${rawAttributes}>`, `
+              <style>
+                ${optimizedFileContents}
+              </style>
+            `).replace(`<link ${rawAttributes}/>`, `
+              <style>
+                ${optimizedFileContents}
+              </style>
+            `);
+          }
+        }
+      } else {
+        if (type === 'script') {
+          if (optimizationAttr === 'static' || optimization === 'static') {
+            body = body.replace(`<script ${rawAttributes}>${contents.replace(/\.\//g, '/').replace(/\$/g, '$$$')}</script>`, '');
+          } else if (optimizationAttr === 'none') {
+            body = body.replace(contents, contents.replace(/\.\//g, '/').replace(/\$/g, '$$$'));
           } else {
-            if (type === 'script') {
-              if (optimizationAttr === 'static' || optimization === 'static') {
-                body = body.replace(`<script ${rawAttributes}>${contents.replace(/\.\//g, '/').replace(/\$/g, '$$$')}</script>`, '');
-              } else if (optimizationAttr === 'none') {
-                body = body.replace(contents, contents.replace(/\.\//g, '/').replace(/\$/g, '$$$'));
-              } else {
-                body = body.replace(contents, optimizedFileContents.replace(/\.\//g, '/').replace(/\$/g, '$$$'));
-              }
-            } else if (type === 'style') {
-              body = body.replace(contents, optimizedFileContents);
-            }
+            body = body.replace(contents, optimizedFileContents.replace(/\.\//g, '/').replace(/\$/g, '$$$'));
           }
+        } else if (type === 'style') {
+          body = body.replace(contents, optimizedFileContents);
         }
+      }
+    }
 
-        // TODO clean up lit-polyfill as part of https://github.com/ProjectEvergreen/greenwood/issues/728
-        body = body.replace(/<script src="(.*lit\/polyfill-support.js)"><\/script>/, '');
+    // TODO clean up lit-polyfill
+    // https://github.com/ProjectEvergreen/greenwood/issues/728
+    body = body.replace(/<script src="(.*lit\/polyfill-support.js)"><\/script>/, '');
 
-        resolve(body);
-      } catch (e) {
-        reject(e);
-      }
-    });
+    return new Response(body);
   }
 }
 
diff --git a/packages/cli/src/plugins/resource/plugin-standard-image.js b/packages/cli/src/plugins/resource/plugin-standard-image.js
index 0e39e64d1..b67ae63a7 100644
--- a/packages/cli/src/plugins/resource/plugin-standard-image.js
+++ b/packages/cli/src/plugins/resource/plugin-standard-image.js
@@ -4,8 +4,7 @@
  * This is a Greenwood default plugin.
  *
  */
-import fs from 'fs';
-import path from 'path';
+import fs from 'fs/promises';
 import { ResourceInterface } from '../../lib/resource-interface.js';
 
 class StandardFontResource extends ResourceInterface {
@@ -13,39 +12,25 @@ class StandardFontResource extends ResourceInterface {
     super(compilation, options);
 
     // https://developer.mozilla.org/en-US/docs/Web/Media/Formats/Image_types
-    this.extensions = ['.avif', '.webp', '.jpg', '.jpeg', '.png', '.gif', '.svg', '.ico'];
+    this.extensions = ['avif', 'webp', 'jpg', 'jpeg', 'png', 'gif', 'svg', 'ico'];
   }
 
-  async serve(url) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        let body = '';
-        let contentType = '';
-        const ext = path.extname(url);
-        const type = ext === '.svg'
-          ? `${ext.replace('.', '')}+xml`
-          : ext.replace('.', '');
-
-        if (['.avif', '.webp', '.jpg', '.jpeg', '.png', '.gif', '.svg'].includes(ext)) {
-          contentType = `image/${type}`;
-
-          if (ext === '.svg') {
-            body = await fs.promises.readFile(url, 'utf-8');
-          } else {
-            body = await fs.promises.readFile(url); 
-          }
-        } else if (['.ico'].includes(ext)) {
-          contentType = 'image/x-icon';
-          body = await fs.promises.readFile(url);
-        }
+  async shouldServe(url) {
+    return url.protocol === 'file:' && this.extensions.indexOf(url.pathname.split('.').pop()) >= 0;
+  }
 
-        resolve({
-          body,
-          contentType
-        });
-      } catch (e) {
-        reject(e);
-      }
+  async serve(url) {
+    const extension = url.pathname.split('.').pop();
+    const type = extension === 'svg' ? `${extension}+xml` : extension;
+    const body = await fs.readFile(url);
+    const contentType = extension === 'ico'
+      ? 'x-icon'
+      : type;
+
+    return new Response(body, {
+      headers: new Headers({
+        'Content-Type': `image/${contentType}`
+      })
     });
   }
 }
diff --git a/packages/cli/src/plugins/resource/plugin-standard-javascript.js b/packages/cli/src/plugins/resource/plugin-standard-javascript.js
index a8ebce6b3..987ac8b37 100644
--- a/packages/cli/src/plugins/resource/plugin-standard-javascript.js
+++ b/packages/cli/src/plugins/resource/plugin-standard-javascript.js
@@ -4,28 +4,27 @@
  * This is a Greenwood default plugin.
  *
  */
-import fs from 'fs';
+import fs from 'fs/promises';
 import { ResourceInterface } from '../../lib/resource-interface.js';
 import terser from '@rollup/plugin-terser';
 
 class StandardJavaScriptResource extends ResourceInterface {
   constructor(compilation, options) {
     super(compilation, options);
-    this.extensions = ['.js'];
+    this.extensions = ['js'];
     this.contentType = 'text/javascript';
   }
 
+  async shouldServe(url) {
+    return url.protocol === 'file:' && this.extensions.includes(url.pathname.split('.').pop());
+  }
+
   async serve(url) {
-    return new Promise(async(resolve, reject) => {
-      try {
-        const body = await fs.promises.readFile(url, 'utf-8');
-    
-        resolve({
-          body,
-          contentType: this.contentType
-        });
-      } catch (e) {
-        reject(e);
+    const body = await fs.readFile(url, 'utf-8');
+
+    return new Response(body, {
+      headers: {
+        'Content-Type': this.contentType
       }
     });
   }
diff --git a/packages/cli/src/plugins/resource/plugin-standard-json.js b/packages/cli/src/plugins/resource/plugin-standard-json.js
index 529cf4993..0192910b1 100644
--- a/packages/cli/src/plugins/resource/plugin-standard-json.js
+++ b/packages/cli/src/plugins/resource/plugin-standard-json.js
@@ -4,40 +4,38 @@
  * This is a Greenwood default plugin.
  *
  */
-import fs from 'fs';
-import path from 'path';
+import { checkResourceExists } from '../../lib/resource-utils.js';
+import fs from 'fs/promises';
 import { ResourceInterface } from '../../lib/resource-interface.js';
 
 class StandardJsonResource extends ResourceInterface {
   constructor(compilation, options) {
     super(compilation, options);
-    this.extensions = ['.json'];
+    this.extensions = ['json'];
     this.contentType = 'application/json';
   }
 
   async shouldServe(url) {
-    return Promise.resolve(
-      url.indexOf('graph.json') >= 0 ||
-      path.extname(url) === '.json' && fs.existsSync(url)
-    );
+    const { protocol, pathname } = url;
+    const isJson = pathname.split('.').pop() === this.extensions[0];
+    const isGraphJson = pathname === '/graph.json';
+    const isWorkspaceFile = protocol === 'file:' && await checkResourceExists(url);
+
+    return isJson && (isWorkspaceFile || isGraphJson);
   }
 
   async serve(url) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const { scratchDir } = this.compilation.context;
-        const filePath = url.indexOf('graph.json') >= 0
-          ? `${scratchDir}/graph.json`
-          : url;
-        const contents = await fs.promises.readFile(filePath, 'utf-8');
+    const { pathname } = url;
+    const { scratchDir } = this.compilation.context;
+    const finalUrl = pathname.startsWith('/graph.json')
+      ? new URL('./graph.json', scratchDir)
+      : url;
+    const contents = await fs.readFile(finalUrl, 'utf-8');
 
-        resolve({
-          body: JSON.parse(contents),
-          contentType: this.contentType
-        });
-      } catch (e) {
-        reject(e);
-      }
+    return new Response(contents, {
+      headers: new Headers({
+        'Content-Type': this.contentType
+      })
     });
   }
 }
diff --git a/packages/cli/src/plugins/resource/plugin-static-router.js b/packages/cli/src/plugins/resource/plugin-static-router.js
index 060a2c1bd..f68e320a1 100644
--- a/packages/cli/src/plugins/resource/plugin-static-router.js
+++ b/packages/cli/src/plugins/resource/plugin-static-router.js
@@ -5,128 +5,113 @@
  * This is a Greenwood default plugin.
  *
  */
-import fs from 'fs';
-import path from 'path';
+import { checkResourceExists } from '../../lib/resource-utils.js';
+import fs from 'fs/promises';
 import { ResourceInterface } from '../../lib/resource-interface.js';
-import { fileURLToPath, URL } from 'url';
 
 class StaticRouterResource extends ResourceInterface {
   constructor(compilation, options) {
     super(compilation, options);
-    this.extensions = ['.html'];
+    this.extensions = ['html'];
     this.contentType = 'text/html';
     this.libPath = '@greenwood/router/router.js';
   }
 
   async shouldResolve(url) {
-    return Promise.resolve(url.indexOf(this.libPath) >= 0);
+    return url.pathname.indexOf(this.libPath) >= 0;
   }
 
   async resolve() {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const routerUrl = fileURLToPath(new URL('../../lib/router.js', import.meta.url));
-
-        resolve(routerUrl);
-      } catch (e) {
-        reject(e);
-      }
-    });
+    const routerUrl = new URL('../../lib/router.js', import.meta.url);
+    
+    return new Request(`file://${routerUrl.pathname}`);
   }
 
-  async shouldIntercept(url, body, headers = { request: {} }) {
-    const contentType = headers.request['content-type'];
+  async shouldIntercept(url, request, response) {
+    const { pathname, protocol } = url;
+    const contentType = response.headers.get('Content-Type') || '';
 
-    return Promise.resolve(process.env.__GWD_COMMAND__ === 'build' // eslint-disable-line no-underscore-dangle
+    return process.env.__GWD_COMMAND__ === 'build' // eslint-disable-line no-underscore-dangle
       && this.compilation.config.staticRouter
-      && url !== '404.html'
-      && (path.extname(url) === '.html' || (contentType && contentType.indexOf('text/html') >= 0)));
+      && !pathname.startsWith('/404')
+      && (protocol === 'http:' && contentType.indexOf(this.contentType) >= 0);
   }
 
-  async intercept(url, body) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        body = body.replace('</head>', `
-          <script type="module" src="/node_modules/@greenwood/cli/src/lib/router.js"></script>\n
-          </head>
-        `);
-
-        resolve({ body });
-      } catch (e) {
-        reject(e);
-      }
-    });
-  }
+  async intercept(url, request, response) {
+    let body = await response.text();
 
-  async shouldOptimize(url, body, headers = { request: {} }) {
-    const contentType = headers.request['content-type'];
+    body = body.replace('</head>', `
+      <script type="module" src="/node_modules/@greenwood/cli/src/lib/router.js"></script>\n
+      </head>
+    `);
 
-    return Promise.resolve(this.compilation.config.staticRouter
-      && url !== '404.html'
-      && (path.extname(url) === '.html' || (contentType && contentType.indexOf('text/html') >= 0)));
+    return new Response(body);
   }
 
-  async optimize(url, body) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        let currentTemplate;
-        const isStaticRoute = this.compilation.graph.filter(page => page.outputPath === url && url !== '/404/' && !page.isSSR).length === 1;
-        const { outputDir } = this.compilation.context;
-        const bodyContents = body.match(/<body>(.*)<\/body>/s)[0].replace('<body>', '').replace('</body>', '');
-        const outputBundlePath = path.join(`${outputDir}/_routes${url}`);
-
-        const routeTags = this.compilation.graph
-          .filter(page => !page.isSSR)
-          .filter(page => page.route !== '/404/')
-          .map((page) => {
-            const template = page.filename && path.extname(page.filename) === '.html'
-              ? page.route
-              : page.template;
-            const key = page.route === '/'
-              ? ''
-              : page.route.slice(0, page.route.lastIndexOf('/'));
-
-            if (url === page.outputPath) {
-              currentTemplate = template;
-            }
-            return `
-              <greenwood-route data-route="${page.route}" data-template="${template}" data-key="/_routes${key}/index.html"></greenwood-route>
-            `;
-          });
-
-        if (isStaticRoute) {
-          if (!fs.existsSync(path.dirname(outputBundlePath))) {
-            fs.mkdirSync(path.dirname(outputBundlePath), {
-              recursive: true
-            });
-          }
-
-          await fs.promises.writeFile(outputBundlePath, bodyContents);
-        }
+  async shouldOptimize(url, response) {
+    return this.compilation.config.staticRouter
+      && !url.pathname.startsWith('/404')
+      && response.headers.get('Content-Type').indexOf(this.contentType) >= 0;
+  }
 
-        body = body.replace('</head>', `
-          <script>
-            window.__greenwood = window.__greenwood || {};
-            window.__greenwood.currentTemplate = "${currentTemplate}";
-          </script>
-          </head>
-        `.replace(/\n/g, '').replace(/ /g, ''))
-          .replace(/<body>(.*)<\/body>/s, `
-            <body>\n
-
-              <router-outlet>
-                ${bodyContents.replace(/\$/g, '$$$')}\n
-              </router-outlet>
-
-              ${routeTags.join('\n')}
-            </body>
-          `);
-
-        resolve(body);
-      } catch (e) {
-        reject(e);
+  async optimize(url, response) {
+    let body = await response.text();
+    const { pathname } = url;
+    const isStaticRoute = this.compilation.graph.find(page => page.route === pathname && !page.isSSR);
+    const { outputDir } = this.compilation.context;
+    const partial = body.match(/<body>(.*)<\/body>/s)[0].replace('<body>', '').replace('</body>', '');
+    const outputPartialDirUrl = new URL(`./_routes${url.pathname}`, outputDir);
+    const outputPartialDirPathUrl = new URL(`file://${outputPartialDirUrl.pathname.split('/').slice(0, -1).join('/').concat('/')}`);
+    let currentTemplate;
+
+    const routeTags = this.compilation.graph
+      .filter(page => !page.isSSR)
+      .filter(page => page.route !== '/404/')
+      .map((page) => {
+        const template = page.filename && page.filename.split('.').pop() === this.extensions[0]
+          ? page.route
+          : page.template;
+        const key = page.route === '/'
+          ? ''
+          : page.route.slice(0, page.route.lastIndexOf('/'));
+
+        if (pathname === page.route) {
+          currentTemplate = template;
+        }
+        return `
+          <greenwood-route data-route="${page.route}" data-template="${template}" data-key="/_routes${key}/index.html"></greenwood-route>
+        `;
+      });
+
+    if (isStaticRoute) {
+      if (!await checkResourceExists(outputPartialDirPathUrl)) {
+        await fs.mkdir(outputPartialDirPathUrl, {
+          recursive: true
+        });
       }
-    });
+
+      await fs.writeFile(new URL('./index.html', outputPartialDirUrl), partial);
+    }
+
+    body = body.replace('</head>', `
+      <script>
+        window.__greenwood = window.__greenwood || {};
+        window.__greenwood.currentTemplate = "${currentTemplate}";
+      </script>
+      </head>
+    `.replace(/\n/g, '').replace(/ /g, ''))
+      .replace(/<body>(.*)<\/body>/s, `
+        <body>\n
+
+          <router-outlet>
+            ${partial.replace(/\$/g, '$$$')}\n
+          </router-outlet>
+
+          ${routeTags.join('\n')}
+        </body>
+      `);
+
+    return new Response(body);
   }
 }
 
diff --git a/packages/cli/src/plugins/resource/plugin-user-workspace.js b/packages/cli/src/plugins/resource/plugin-user-workspace.js
index 2c308d725..cb67c6041 100644
--- a/packages/cli/src/plugins/resource/plugin-user-workspace.js
+++ b/packages/cli/src/plugins/resource/plugin-user-workspace.js
@@ -4,42 +4,29 @@
  * This sets the default value for requests in Greenwood.
  *
  */
-import fs from 'fs';
-import path from 'path';
+import { resolveForRelativeUrl } from '../../lib/resource-utils.js';
 import { ResourceInterface } from '../../lib/resource-interface.js';
 
 class UserWorkspaceResource extends ResourceInterface {
   constructor(compilation, options) {
     super(compilation, options);
-    this.extensions = ['*'];
   }
 
-  async shouldResolve(url = '/') {
+  async shouldResolve(url) {
     const { userWorkspace } = this.compilation.context;
-    const bareUrl = this.getBareUrlPath(url);
-    const isAbsoluteWorkspaceFile = fs.existsSync(path.join(userWorkspace, bareUrl));
-    const workspaceUrl = isAbsoluteWorkspaceFile
-      ? isAbsoluteWorkspaceFile || bareUrl === '/'
-      : url.indexOf('node_modules') < 0 && this.resolveRelativeUrl(userWorkspace, bareUrl);
+    const extension = url.pathname.split('.').pop();
+    const hasExtension = extension !== '' && !extension.startsWith('/');
 
-    return Promise.resolve(workspaceUrl);
+    return hasExtension
+      && !url.pathname.startsWith('/node_modules')
+      && await resolveForRelativeUrl(url, userWorkspace);
   }
 
-  async resolve(url = '/') {
+  async resolve(url) {
     const { userWorkspace } = this.compilation.context;
+    const workspaceUrl = await resolveForRelativeUrl(url, userWorkspace);
 
-    return new Promise(async (resolve, reject) => {
-      try {
-        const bareUrl = this.getBareUrlPath(url);
-        const workspaceUrl = fs.existsSync(path.join(userWorkspace, bareUrl))
-          ? path.join(userWorkspace, bareUrl)
-          : path.join(userWorkspace, this.resolveRelativeUrl(userWorkspace, bareUrl));
-        
-        resolve(workspaceUrl);
-      } catch (e) {
-        reject(e);
-      }
-    });
+    return new Request(workspaceUrl);
   }
 }
 
diff --git a/packages/cli/src/plugins/server/plugin-livereload.js b/packages/cli/src/plugins/server/plugin-livereload.js
index 82deca0b1..8b974179c 100644
--- a/packages/cli/src/plugins/server/plugin-livereload.js
+++ b/packages/cli/src/plugins/server/plugin-livereload.js
@@ -1,8 +1,7 @@
-import fs from 'fs';
+import fs from 'fs/promises';
 import livereload from 'livereload';
 import { ResourceInterface } from '../../lib/resource-interface.js';
 import { ServerInterface } from '../../lib/server-interface.js';
-import { fileURLToPath, pathToFileURL } from 'url';
 
 class LiveReloadServer extends ServerInterface {
   constructor(compilation, options = {}) {
@@ -11,23 +10,17 @@ class LiveReloadServer extends ServerInterface {
 
   async start() {
     const { userWorkspace } = this.compilation.context;
-    const standardPluginsPath = fileURLToPath(new URL('../resource', import.meta.url));
-    const standardPluginsNames = fs.readdirSync(standardPluginsPath)
+    const standardPluginsDirectoryPath = new URL('../resource/', import.meta.url);
+    const standardPluginsNames = (await fs.readdir(standardPluginsDirectoryPath))
       .filter(filename => filename.indexOf('plugin-standard') === 0);
     const standardPluginsExtensions = (await Promise.all(standardPluginsNames.map(async (filename) => {
-      const pluginImport = await import(pathToFileURL(`${standardPluginsPath}/${filename}`));
+      const pluginImport = await import(new URL(`./${filename}`, standardPluginsDirectoryPath));
       const plugin = pluginImport[Object.keys(pluginImport)[0]];
       
       return plugin;
     })))
-      .map((plugin) => {
-        // assume that if it is an array, the second item is a rollup plugin
-        const instance = plugin.length
-          ? plugin[0].provider(this.compilation)
-          : plugin.provider(this.compilation);
-
-        return instance.extensions.flat();
-      })
+      .filter(plugin => plugin.type === 'resource')
+      .map((plugin) => plugin.provider(this.compilation).extensions.flat())
       .flat();
     const customPluginsExtensions = this.compilation.config.plugins
       .filter((plugin) => plugin.type === 'resource')
@@ -49,7 +42,7 @@ class LiveReloadServer extends ServerInterface {
       applyCSSLive: false // https://github.com/napcs/node-livereload/issues/33#issuecomment-693707006
     });
 
-    liveReloadServer.watch(userWorkspace, () => {
+    liveReloadServer.watch(userWorkspace.pathname, () => {
       console.info(`Now watching directory "${userWorkspace}" for changes.`);
       return Promise.resolve(true);
     });
@@ -58,25 +51,21 @@ class LiveReloadServer extends ServerInterface {
 
 class LiveReloadResource extends ResourceInterface {
   
-  async shouldIntercept(url, body, headers) {
-    const { accept } = headers.request;
+  async shouldIntercept(url, request, response) {
+    const contentType = response.headers.get('Content-Type');
 
-    return Promise.resolve(accept && accept.indexOf('text/html') >= 0 && process.env.__GWD_COMMAND__ === 'develop'); // eslint-disable-line no-underscore-dangle
+    return contentType.indexOf('text/html') >= 0 && process.env.__GWD_COMMAND__ === 'develop'; // eslint-disable-line no-underscore-dangle
   }
 
-  async intercept(url, body) {
-    return new Promise((resolve, reject) => {
-      try {
-        const contents = body.replace('</head>', `
-            <script src="http://localhost:35729/livereload.js?snipver=1"></script>
-          </head>
-        `);
+  async intercept(url, request, response) {
+    let body = await response.text();
+    
+    body = body.replace('</head>', `
+        <script src="http://localhost:35729/livereload.js?snipver=1"></script>
+      </head>
+    `);
 
-        resolve({ body: contents });
-      } catch (e) {
-        reject(e);
-      }
-    });
+    return new Response(body);
   }
 }
 
diff --git a/packages/cli/test/cases/build.config.error-workspace-absolute/greenwood.config.js b/packages/cli/test/cases/build.config.error-workspace-absolute/greenwood.config.js
index 3c0eb5fe5..fd2a060f4 100644
--- a/packages/cli/test/cases/build.config.error-workspace-absolute/greenwood.config.js
+++ b/packages/cli/test/cases/build.config.error-workspace-absolute/greenwood.config.js
@@ -1,5 +1,3 @@
-import { fileURLToPath, URL } from 'url';
-
 export default {
-  workspace: fileURLToPath(new URL('./noop', import.meta.url))
+  workspace: new URL('./noop', import.meta.url)
 };
\ No newline at end of file
diff --git a/packages/cli/test/cases/build.config.error-workspace/build.config.error-workspace.spec.js b/packages/cli/test/cases/build.config.error-workspace/build.config.error-workspace.spec.js
index 75c5a2e3c..82cd986a7 100644
--- a/packages/cli/test/cases/build.config.error-workspace/build.config.error-workspace.spec.js
+++ b/packages/cli/test/cases/build.config.error-workspace/build.config.error-workspace.spec.js
@@ -36,12 +36,12 @@ describe('Build Greenwood With: ', function() {
   });
 
   describe('Custom Configuration with a bad value for Workspace', function() {
-    it('should throw an error that workspace path must be a string', async function() {
+    it('should throw an error that workspace path must be a URL', async function() {
       try {
         await runner.setup(outputPath);
         await runner.runCommand(cliPath, 'build');
       } catch (err) {
-        expect(err).to.contain('greenwood.config.js workspace path must be a string');
+        expect(err).to.contain('Error: greenwood.config.js workspace must be an instance of URL');
       }
     });
   });
diff --git a/packages/cli/test/cases/build.config.workspace-custom/greenwood.config.js b/packages/cli/test/cases/build.config.workspace-custom/greenwood.config.js
index cef9426a0..5adb52a1e 100644
--- a/packages/cli/test/cases/build.config.workspace-custom/greenwood.config.js
+++ b/packages/cli/test/cases/build.config.workspace-custom/greenwood.config.js
@@ -1,5 +1,3 @@
-import { fileURLToPath, URL } from 'url';
-
 export default {
-  workspace: fileURLToPath(new URL('./www', import.meta.url))
+  workspace: new URL('./www/', import.meta.url)
 };
\ No newline at end of file
diff --git a/packages/cli/test/cases/build.default.ssr/build.default.ssr.spec.js b/packages/cli/test/cases/build.default.ssr/build.default.ssr.spec.js
index 155bf389d..58ac4a43e 100644
--- a/packages/cli/test/cases/build.default.ssr/build.default.ssr.spec.js
+++ b/packages/cli/test/cases/build.default.ssr/build.default.ssr.spec.js
@@ -86,7 +86,7 @@ describe('Build Greenwood With: ', function() {
     before(async function() {
       const graph = JSON.parse(await fs.promises.readFile(path.join(outputPath, 'public/graph.json'), 'utf-8'));
       
-      artistsPageGraphData = graph.filter(page => page.route === '/artists/')[0];
+      artistsPageGraphData = graph.find(page => page.route === '/artists/');
 
       return new Promise((resolve, reject) => {
         request.get(`${hostname}/artists/`, (err, res, body) => {
diff --git a/packages/cli/test/cases/build.plugins.context/theme-pack-context-plugin.js b/packages/cli/test/cases/build.plugins.context/theme-pack-context-plugin.js
index 5bac46467..56310dcbf 100644
--- a/packages/cli/test/cases/build.plugins.context/theme-pack-context-plugin.js
+++ b/packages/cli/test/cases/build.plugins.context/theme-pack-context-plugin.js
@@ -1,23 +1,20 @@
-import fs from 'fs';
+import fs from 'fs/promises';
 import os from 'os';
-import path from 'path';
 import { spawnSync } from 'child_process';
-import { fileURLToPath, URL } from 'url';
 
-const packageJson = JSON.parse(await fs.promises.readFile(new URL('./package.json', import.meta.url), 'utf-8'));
+const packageJson = JSON.parse(await fs.readFile(new URL('./package.json', import.meta.url), 'utf-8'));
 const myThemePackPlugin = () => [{
   type: 'context',
   name: 'my-theme-pack:context',
   provider: () => {
     const { name } = packageJson;
-    const baseDistDir = `node_modules/${name}/dist`;
     const command = os.platform() === 'win32' ? 'npm.cmd' : 'npm';
     const ls = spawnSync(command, ['ls', name]);
     
     const isInstalled = ls.stdout.toString().indexOf('(empty)') < 0;
     const templateLocation = isInstalled
-      ? fileURLToPath(new URL(`${baseDistDir}/layouts`, import.meta.url))
-      : path.join(process.cwd(), 'fixtures/layouts');
+      ? new URL(`./node_modules/${name}/dist/layouts/`, import.meta.url)
+      : new URL('./fixtures/layouts/', import.meta.url);
 
     return {
       templates: [
diff --git a/packages/cli/test/cases/build.plugins.copy/greenwood.config.js b/packages/cli/test/cases/build.plugins.copy/greenwood.config.js
index 26bc24c67..ac08ffe25 100644
--- a/packages/cli/test/cases/build.plugins.copy/greenwood.config.js
+++ b/packages/cli/test/cases/build.plugins.copy/greenwood.config.js
@@ -1,19 +1,14 @@
-import path from 'path';
-
 export default {
   plugins: [{
     type: 'copy',
     name: 'plugin-copy-prismjs',
     provider: (compilation) => {
       const { projectDirectory, outputDir } = compilation.context;
-      const prismThemeDir = 'node_modules/prismjs/themes';
-      const from = path.join(projectDirectory, prismThemeDir);
-      const to = path.join(outputDir, prismThemeDir);
+      const prismThemeDir = '/node_modules/prismjs/themes/';
+      const from = new URL(`.${prismThemeDir}`, projectDirectory);
+      const to = new URL(`.${prismThemeDir}`, outputDir);
 
-      return [{
-        from,
-        to
-      }];
+      return [{ from, to }];
     }
   }]
 };
\ No newline at end of file
diff --git a/packages/cli/test/cases/build.plugins.resource/greenwood.config.js b/packages/cli/test/cases/build.plugins.resource/greenwood.config.js
index 18265ec27..34dd63d20 100644
--- a/packages/cli/test/cases/build.plugins.resource/greenwood.config.js
+++ b/packages/cli/test/cases/build.plugins.resource/greenwood.config.js
@@ -1,28 +1,27 @@
-import fs from 'fs';
+import fs from 'fs/promises';
 import { ResourceInterface } from '../../../src/lib/resource-interface.js';
 
 class FooResource extends ResourceInterface {
   constructor(compilation, options) {
     super(compilation, options);
     
-    this.extensions = ['.foo'];
+    this.extensions = ['foo'];
     this.contentType = 'text/javascript';
   }
 
+  async shouldServe(url) {
+    return url.pathname.split('.').pop() === this.extensions[0];
+  }
+
   async serve(url) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        let body = await fs.promises.readFile(url, 'utf-8');
-        
-        body = body.replace(/interface (.*){(.*)}/s, '');
+    let body = await fs.readFile(url, 'utf-8');
+
+    body = body.replace(/interface (.*){(.*)}/s, '');
 
-        resolve({
-          body,
-          contentType: this.contentType
-        });
-      } catch (e) {
-        reject(e);
-      }
+    return new Response(body, {
+      headers: new Headers({
+        'Content-Type': this.contentType
+      })
     });
   }
 }
diff --git a/packages/cli/test/cases/develop.default/develop.default.spec.js b/packages/cli/test/cases/develop.default/develop.default.spec.js
index 5c1666f0b..b6bba33dc 100644
--- a/packages/cli/test/cases/develop.default/develop.default.spec.js
+++ b/packages/cli/test/cases/develop.default/develop.default.spec.js
@@ -47,6 +47,7 @@ import { fileURLToPath, URL } from 'url';
 
 const expect = chai.expect;
 
+// TODO good first issue, to abstract along with copy plugin
 async function rreaddir (dir, allFiles = []) {
   const files = (await fs.promises.readdir(dir)).map(f => path.join(dir, f));
 
@@ -640,7 +641,7 @@ describe('Develop Greenwood With: ', function() {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal('text/javascript');
+        expect(response.headers['content-type']).to.contain('text/javascript');
         done();
       });
 
@@ -674,7 +675,7 @@ describe('Develop Greenwood With: ', function() {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal('text/css');
+        expect(response.headers['content-type']).to.contain('text/css');
         done();
       });
 
@@ -710,7 +711,7 @@ describe('Develop Greenwood With: ', function() {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal(`image/${ext}`);
+        expect(response.headers['content-type']).to.contain(`image/${ext}`);
         done();
       });
 
@@ -744,7 +745,7 @@ describe('Develop Greenwood With: ', function() {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal('image/x-icon');
+        expect(response.headers['content-type']).to.contain('image/x-icon');
         done();
       });
 
@@ -778,7 +779,7 @@ describe('Develop Greenwood With: ', function() {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal('image/webp');
+        expect(response.headers['content-type']).to.contain('image/webp');
         done();
       });
 
@@ -812,7 +813,7 @@ describe('Develop Greenwood With: ', function() {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal('image/avif');
+        expect(response.headers['content-type']).to.contain('image/avif');
         done();
       });
 
@@ -847,7 +848,7 @@ describe('Develop Greenwood With: ', function() {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal(`image/${ext}+xml`);
+        expect(response.headers['content-type']).to.contain(`image/${ext}+xml`);
         done();
       });
 
@@ -882,7 +883,7 @@ describe('Develop Greenwood With: ', function() {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal(ext);
+        expect(response.headers['content-type']).to.contain(ext);
         done();
       });
 
@@ -984,7 +985,7 @@ describe('Develop Greenwood With: ', function() {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal('text/javascript');
+        expect(response.headers['content-type']).to.contain('text/javascript');
         done();
       });
 
@@ -1020,7 +1021,7 @@ describe('Develop Greenwood With: ', function() {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal('text/css');
+        expect(response.headers['content-type']).to.contain('text/css');
         done();
       });
 
@@ -1032,7 +1033,7 @@ describe('Develop Greenwood With: ', function() {
 
     // if things work correctly, this workspace file should never resolve to the equivalent node_modules file
     // https://github.com/ProjectEvergreen/greenwood/pull/687
-    describe('Develop command specific workspace resolution when matching node_modules', function() {
+    describe('Develop command specific workspace resolution when local file matches a file also in node_modules', function() {
       let response = {};
 
       before(async function() {
@@ -1056,7 +1057,7 @@ describe('Develop Greenwood With: ', function() {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal('text/javascript');
+        expect(response.headers['content-type']).to.contain('text/javascript');
         done();
       });
 
@@ -1091,7 +1092,7 @@ describe('Develop Greenwood With: ', function() {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal('text/javascript');
+        expect(response.headers['content-type']).to.contain('text/javascript');
         done();
       });
 
@@ -1127,7 +1128,7 @@ describe('Develop Greenwood With: ', function() {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal('text/javascript');
+        expect(response.headers['content-type']).to.contain('text/javascript');
         done();
       });
 
@@ -1167,7 +1168,12 @@ describe('Develop Greenwood With: ', function() {
       });
 
       it('should return the correct response body', function(done) {
-        expect(response.body).to.contain('Not Found');
+        expect(response.body).to.contain('');
+        done();
+      });
+
+      it('should return the correct status message body', function(done) {
+        expect(response.statusMessage).to.contain('Not Found');
         done();
       });
     });
@@ -1214,6 +1220,7 @@ describe('Develop Greenwood With: ', function() {
 
       before(async function() {
         response = await fetch(`${hostname}:${port}/api/greeting?name=${name}`);
+
         data = await response.json();
       });
 
diff --git a/packages/cli/test/cases/develop.default/src/api/greeting.js b/packages/cli/test/cases/develop.default/src/api/greeting.js
index f046e6243..09666902e 100644
--- a/packages/cli/test/cases/develop.default/src/api/greeting.js
+++ b/packages/cli/test/cases/develop.default/src/api/greeting.js
@@ -4,8 +4,8 @@ export async function handler(request) {
   const body = { message: `Hello ${name}!!!` };
 
   return new Response(JSON.stringify(body), {
-    headers: {
+    headers: new Headers({
       'Content-Type': 'application/json'
-    }
+    })
   });
 }
\ No newline at end of file
diff --git a/packages/cli/test/cases/develop.plugins.context/develop.plugins.context.spec.js b/packages/cli/test/cases/develop.plugins.context/develop.plugins.context.spec.js
index 2e7f330b9..5a2fa593b 100644
--- a/packages/cli/test/cases/develop.plugins.context/develop.plugins.context.spec.js
+++ b/packages/cli/test/cases/develop.plugins.context/develop.plugins.context.spec.js
@@ -141,7 +141,7 @@ describe('Develop Greenwood With: ', function() {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal('text/css');
+        expect(response.headers['content-type']).to.contain('text/css');
         done();
       });
 
@@ -179,7 +179,7 @@ describe('Develop Greenwood With: ', function() {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal('text/javascript');
+        expect(response.headers['content-type']).to.contain('text/javascript');
         done();
       });
 
diff --git a/packages/cli/test/cases/develop.plugins.context/greenwood.config.js b/packages/cli/test/cases/develop.plugins.context/greenwood.config.js
index b3b0cec5b..74c311257 100644
--- a/packages/cli/test/cases/develop.plugins.context/greenwood.config.js
+++ b/packages/cli/test/cases/develop.plugins.context/greenwood.config.js
@@ -1,24 +1,24 @@
 // shared from another test
-import fs from 'fs';
-import path from 'path';
+import fs from 'fs/promises';
 import { myThemePackPlugin } from '../build.plugins.context/theme-pack-context-plugin.js';
 import { ResourceInterface } from '@greenwood/cli/src/lib/resource-interface.js';
-import { URL } from 'url';
 
-const packageName = JSON.parse(await fs.promises.readFile(new URL('./package.json', import.meta.url), 'utf-8')).name;
+const packageName = JSON.parse(await fs.readFile(new URL('./package.json', import.meta.url), 'utf-8')).name;
 
 class MyThemePackDevelopmentResource extends ResourceInterface {
   constructor(compilation, options) {
     super(compilation, options);
-    this.extensions = ['*'];
   }
 
   async shouldResolve(url) {
-    return Promise.resolve(url.indexOf(`node_modules${path.sep}${packageName}`) >= 0);
+    return url.pathname.indexOf(`node_modules/${packageName}`) >= 0;
   }
 
   async resolve(url) {
-    return Promise.resolve(path.normalize(url).replace(`node_modules${path.sep}${packageName}${path.sep}dist`, 'fixtures'));
+    const themePackPathname = url.pathname.replace(`/node_modules/${packageName}/dist`, '/fixtures');
+    const themePackUrl = new URL(`.${themePackPathname}`, import.meta.url);
+
+    return new Request(themePackUrl);
   }
 }
 
diff --git a/packages/cli/test/cases/serve.default.api/serve.default.api.spec.js b/packages/cli/test/cases/serve.default.api/serve.default.api.spec.js
index 1e4fde3fd..da11977ed 100644
--- a/packages/cli/test/cases/serve.default.api/serve.default.api.spec.js
+++ b/packages/cli/test/cases/serve.default.api/serve.default.api.spec.js
@@ -83,7 +83,7 @@ describe('Serve Greenwood With: ', function() {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal('application/json; charset=utf-8');
+        expect(response.headers['content-type']).to.contain('application/json');
         done();
       });
 
diff --git a/packages/cli/test/cases/serve.default.api/src/api/greeting.js b/packages/cli/test/cases/serve.default.api/src/api/greeting.js
index f046e6243..09666902e 100644
--- a/packages/cli/test/cases/serve.default.api/src/api/greeting.js
+++ b/packages/cli/test/cases/serve.default.api/src/api/greeting.js
@@ -4,8 +4,8 @@ export async function handler(request) {
   const body = { message: `Hello ${name}!!!` };
 
   return new Response(JSON.stringify(body), {
-    headers: {
+    headers: new Headers({
       'Content-Type': 'application/json'
-    }
+    })
   });
 }
\ No newline at end of file
diff --git a/packages/cli/test/cases/serve.default/serve.default.spec.js b/packages/cli/test/cases/serve.default/serve.default.spec.js
index bd4a2bcf9..f66a7b872 100644
--- a/packages/cli/test/cases/serve.default/serve.default.spec.js
+++ b/packages/cli/test/cases/serve.default/serve.default.spec.js
@@ -226,7 +226,7 @@ describe('Serve Greenwood With: ', function() {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal(ext);
+        expect(response.headers['content-type']).to.equal(`font/${ext}`);
         done();
       });
 
diff --git a/packages/cli/test/cases/theme-pack/greenwood.config.js b/packages/cli/test/cases/theme-pack/greenwood.config.js
index ae0d3417d..1e8502c98 100644
--- a/packages/cli/test/cases/theme-pack/greenwood.config.js
+++ b/packages/cli/test/cases/theme-pack/greenwood.config.js
@@ -1,24 +1,23 @@
-import fs from 'fs';
-import path from 'path';
+import fs from 'fs/promises';
 import { myThemePack } from './my-theme-pack.js';
 import { ResourceInterface } from '@greenwood/cli/src/lib/resource-interface.js';
-import { URL } from 'url';
 
-const packageName = JSON.parse(await fs.promises.readFile(new URL('./package.json', import.meta.url), 'utf-8')).name;
+const packageName = JSON.parse(await fs.readFile(new URL('./package.json', import.meta.url), 'utf-8')).name;
 
 class MyThemePackDevelopmentResource extends ResourceInterface {
   constructor(compilation, options) {
     super(compilation, options);
-    this.extensions = ['*'];
   }
 
   async shouldResolve(url) {
     // eslint-disable-next-line no-underscore-dangle
-    return Promise.resolve(process.env.__GWD_COMMAND__ === 'develop' && url.indexOf(`node_modules${path.sep}${packageName}/`) >= 0);
+    return process.env.__GWD_COMMAND__ === 'develop' && url.pathname.startsWith(`/node_modules/${packageName}/`);
   }
 
   async resolve(url) {
-    return Promise.resolve(path.normalize(this.getBareUrlPath(url)).replace(`node_modules${path.sep}${packageName}${path.sep}dist`, 'src'));
+    const themePackUrl = url.pathname.replace(`/node_modules/${packageName}/dist`, 'src');
+
+    return new Request(`${this.compilation.context.projectDirectory}${themePackUrl}`); 
   }
 }
 
diff --git a/packages/cli/test/cases/theme-pack/my-theme-pack.js b/packages/cli/test/cases/theme-pack/my-theme-pack.js
index 168736103..745f70710 100644
--- a/packages/cli/test/cases/theme-pack/my-theme-pack.js
+++ b/packages/cli/test/cases/theme-pack/my-theme-pack.js
@@ -1,15 +1,13 @@
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath, URL } from 'url';
+import fs from 'fs/promises';
 
-const packageJson = JSON.parse(await fs.promises.readFile(new URL('./package.json', import.meta.url), 'utf-8'));
+const packageJson = JSON.parse(await fs.readFile(new URL('./package.json', import.meta.url), 'utf-8'));
 const myThemePack = (options = {}) => [{
   type: 'context',
   name: `${packageJson.name}:context`,
   provider: (compilation) => {
     const templateLocation = options.__isDevelopment // eslint-disable-line no-underscore-dangle
-      ? path.join(compilation.context.userWorkspace, 'layouts')
-      : fileURLToPath(new URL('./dist/layouts', import.meta.url));
+      ? new URL('./layouts/', compilation.context.userWorkspace)
+      : new URL('./dist/layouts/', import.meta.url);
 
     return {
       templates: [
diff --git a/packages/cli/test/cases/theme-pack/theme-pack.build.spec.js b/packages/cli/test/cases/theme-pack/theme-pack.build.spec.js
index 49c4ce574..123e307aa 100644
--- a/packages/cli/test/cases/theme-pack/theme-pack.build.spec.js
+++ b/packages/cli/test/cases/theme-pack/theme-pack.build.spec.js
@@ -131,13 +131,13 @@ describe('Build Greenwood With: ', function() {
         expect(await glob.promise(path.join(this.context.publicDir, '**/header.*.js'))).to.have.lengthOf(1);
       });
 
-      it('should have expected link tag in the head', function() {
-        const scriptTag = Array.from(dom.window.document.querySelectorAll('head script'))
-          .filter((linkTag) => {
-            return linkTag.getAttribute('src').indexOf('/header.') === 0;
+      it('should have expected script tag in the head', function() {
+        const scriptTags = Array.from(dom.window.document.querySelectorAll('head script'))
+          .filter((scriptTag) => {
+            return scriptTag.getAttribute('src').indexOf('/header.') === 0;
           });
 
-        expect(scriptTag.length).to.equal(1);
+        expect(scriptTags.length).to.equal(1);
       });
 
       it('should have expected <x-header> component', function() {
diff --git a/packages/cli/test/cases/theme-pack/theme-pack.develop.spec.js b/packages/cli/test/cases/theme-pack/theme-pack.develop.spec.js
index 1667cd584..3a6f14b2e 100644
--- a/packages/cli/test/cases/theme-pack/theme-pack.develop.spec.js
+++ b/packages/cli/test/cases/theme-pack/theme-pack.develop.spec.js
@@ -141,7 +141,7 @@ describe('Develop Greenwood With: ', function() {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal('text/css');
+        expect(response.headers['content-type']).to.contain('text/css');
         done();
       });
 
@@ -179,7 +179,7 @@ describe('Develop Greenwood With: ', function() {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal('text/javascript');
+        expect(response.headers['content-type']).to.contain('text/javascript');
         done();
       });
 
diff --git a/packages/plugin-babel/src/index.js b/packages/plugin-babel/src/index.js
index 364f9c051..56531c955 100644
--- a/packages/plugin-babel/src/index.js
+++ b/packages/plugin-babel/src/index.js
@@ -4,25 +4,24 @@
  *
  */
 import babel from '@babel/core';
-import fs from 'fs';
-import path from 'path';
+import { checkResourceExists } from '@greenwood/cli/src/lib/resource-utils.js';
 import { ResourceInterface } from '@greenwood/cli/src/lib/resource-interface.js';
 import rollupBabelPlugin from '@rollup/plugin-babel';
 
-async function getConfig (compilation, extendConfig = false) {
+async function getConfig(compilation, extendConfig = false) {
   const { projectDirectory } = compilation.context;
   const configFile = 'babel.config.mjs';
-  const defaultConfig = (await import(new URL(configFile, import.meta.url).pathname)).default;
-  const userConfig = fs.existsSync(path.join(projectDirectory, configFile))
+  const defaultConfig = (await import(new URL(`./${configFile}`, import.meta.url))).default;
+  const userConfig = await checkResourceExists(new URL(`./${configFile}`, projectDirectory))
     ? (await import(`${projectDirectory}/${configFile}`)).default
     : {};
-  let finalConfig = Object.assign({}, userConfig);
-  
+  const finalConfig = Object.assign({}, userConfig);
+
   if (extendConfig) {    
     finalConfig.presets = Array.isArray(userConfig.presets)
       ? [...defaultConfig.presets, ...userConfig.presets]
       : [...defaultConfig.presets];
-    
+
     finalConfig.plugins = Array.isArray(userConfig.plugins)
       ? [...defaultConfig.plugins, ...userConfig.plugins]
       : [...defaultConfig.plugins];
@@ -34,26 +33,21 @@ async function getConfig (compilation, extendConfig = false) {
 class BabelResource extends ResourceInterface {
   constructor(compilation, options) {
     super(compilation, options);
-    this.extensions = ['.js'];
+    this.extensions = ['js'];
     this.contentType = ['text/javascript'];
   }
 
   async shouldIntercept(url) {
-    return Promise.resolve(path.extname(url) === this.extensions[0] && url.indexOf('node_modules/') < 0);
+    return url.pathname.split('.').pop() === this.extensions[0] && !url.pathname.startsWith('/node_modules/');
   }
 
-  async intercept(url, body) {
-    return new Promise(async(resolve, reject) => {
-      try {
-        const config = await getConfig(this.compilation, this.options.extendConfig);
-        const result = await babel.transform(body, config);
-        
-        resolve({
-          body: result.code
-        });
-      } catch (e) {
-        reject(e);
-      }
+  async intercept(url, request, response) {
+    const config = await getConfig(this.compilation, this.options.extendConfig);
+    const body = await response.text();
+    const result = await babel.transform(body, config);
+    
+    return new Response(result.code, {
+      headers: response.headers
     });
   }
 }
diff --git a/packages/plugin-google-analytics/src/index.js b/packages/plugin-google-analytics/src/index.js
index 924a602f1..5e8b5d994 100644
--- a/packages/plugin-google-analytics/src/index.js
+++ b/packages/plugin-google-analytics/src/index.js
@@ -13,39 +13,36 @@ class GoogleAnalyticsResource extends ResourceInterface {
     this.contentType = 'text/html';
   }
 
-  async shouldIntercept(url, body, headers) {
-    return Promise.resolve((headers.request.accept || '').indexOf(this.contentType) >= 0);
+  async shouldIntercept(url, request, response) {    
+    return response.headers.get('Content-Type').indexOf(this.contentType) >= 0;
   }
 
-  async intercept(url, body) {
+  async intercept(url, request, response) {
     const { analyticsId, anonymous } = this.options;
     const trackAnon = typeof anonymous === 'boolean' ? anonymous : true;
-
-    return new Promise((resolve, reject) => {
-      try {
-        const newHtml = body.replace('</head>', `
-          <link rel="preconnect" href="https://www.google-analytics.com/">
-          <script async src="https://www.googletagmanager.com/gtag/js?id=${analyticsId}"></script>
-          <script data-gwd-opt="none">
-            var getOutboundLink = function(url) {
-              gtag('event', 'click', {
-                'event_category': 'outbound',
-                'event_label': url,
-                'transport_type': 'beacon'
-              });
-            }
-            window.dataLayer = window.dataLayer || [];
-            function gtag(){dataLayer.push(arguments);}
-            gtag('js', new Date());
-            gtag('config', '${analyticsId}', { 'anonymize_ip': ${trackAnon} });
-          </script>
-        </head>
-        `);
-
-        resolve({ body: newHtml });
-      } catch (e) {
-        reject(e);
-      }
+    let body = await response.text();
+
+    body = body.replace('</head>', `
+      <link rel="preconnect" href="https://www.google-analytics.com/">
+      <script async src="https://www.googletagmanager.com/gtag/js?id=${analyticsId}"></script>
+      <script data-gwd-opt="none">
+        var getOutboundLink = function(url) {
+          gtag('event', 'click', {
+            'event_category': 'outbound',
+            'event_label': url,
+            'transport_type': 'beacon'
+          });
+        }
+        window.dataLayer = window.dataLayer || [];
+        function gtag(){dataLayer.push(arguments);}
+        gtag('js', new Date());
+        gtag('config', '${analyticsId}', { 'anonymize_ip': ${trackAnon} });
+      </script>
+    </head>
+    `);
+
+    return new Response(body, {
+      headers: response.headers
     });
   }
 }
diff --git a/packages/plugin-google-analytics/test/cases/default/default.spec.js b/packages/plugin-google-analytics/test/cases/default/default.spec.js
index 6d191c76b..4db2a6af1 100644
--- a/packages/plugin-google-analytics/test/cases/default/default.spec.js
+++ b/packages/plugin-google-analytics/test/cases/default/default.spec.js
@@ -79,20 +79,20 @@ describe('Build Greenwood With: ', function() {
 
       it('should have the expected code with users analyticsId', function() {
         const expectedContent = `
-            var getOutboundLink = function(url) {
-              gtag('event', 'click', {
-                'event_category': 'outbound',
-                'event_label': url,
-                'transport_type': 'beacon'
-              });
-            }
-            window.dataLayer = window.dataLayer || [];
-            function gtag(){dataLayer.push(arguments);}
-            gtag('js', new Date());
-            gtag('config', '${mockAnalyticsId}', { 'anonymize_ip': true });
+          var getOutboundLink = function(url) {
+            gtag('event', 'click', {
+              'event_category': 'outbound',
+              'event_label': url,
+              'transport_type': 'beacon'
+            });
+          }
+          window.dataLayer = window.dataLayer || [];
+          function gtag(){dataLayer.push(arguments);}
+          gtag('js', new Date());
+          gtag('config', '${mockAnalyticsId}', { 'anonymize_ip': true });
         `;
 
-        expect(inlineScript[0].textContent).to.contain(expectedContent);
+        expect(inlineScript[0].textContent.trim().replace(/\n/g, '').replace(/ /g, '')).to.contain(expectedContent.trim().replace(/\n/g, '').replace(/ /g, ''));
       });
 
       it('should only have one external Google script tag', function() {
diff --git a/packages/plugin-google-analytics/test/cases/option-anonymous/option-anonymous.spec.js b/packages/plugin-google-analytics/test/cases/option-anonymous/option-anonymous.spec.js
index 057d6c390..b3035f1c3 100644
--- a/packages/plugin-google-analytics/test/cases/option-anonymous/option-anonymous.spec.js
+++ b/packages/plugin-google-analytics/test/cases/option-anonymous/option-anonymous.spec.js
@@ -15,7 +15,7 @@
  *   plugins: [{
  *     greenwoodPluginGoogleAnalytics({
  *       analyticsId: 'UA-123456-1',
- *       anonymouse: false
+ *       anonymous: false
  *     })
  *  }]
  *
@@ -81,7 +81,7 @@ describe('Build Greenwood With: ', function() {
             gtag('config', '${mockAnalyticsId}', { 'anonymize_ip': false });
         `;
 
-        expect(inlineScript[0].textContent).to.contain(expectedContent);
+        expect(inlineScript[0].textContent.trim().replace(/\n/g, '').replace(/ /g, '')).to.contain(expectedContent.trim().replace(/\n/g, '').replace(/ /g, ''));
       });
     });
 
diff --git a/packages/plugin-graphql/src/core/cache.js b/packages/plugin-graphql/src/core/cache.js
index b3f070149..52cd82845 100644
--- a/packages/plugin-graphql/src/core/cache.js
+++ b/packages/plugin-graphql/src/core/cache.js
@@ -1,5 +1,6 @@
 import ApolloCore from '@apollo/client/core/core.cjs.js';
-import fs from 'fs';
+import { checkResourceExists } from '@greenwood/cli/src/lib/resource-utils.js';
+import fs from 'fs/promises';
 import { gql } from 'apollo-server';
 import { getQueryHash } from './common.js';
 
@@ -28,14 +29,14 @@ const createCache = async (req, context) => {
         const cache = JSON.stringify(data);
         const queryHash = getQueryHash(query, variables);
         const hashFilename = `${queryHash}-cache.json`;
-        const cachePath = `${outputDir}/${hashFilename}`;
+        const cachePath = new URL(`./${hashFilename}`, outputDir);
 
-        if (!fs.existsSync(outputDir)) {
-          fs.mkdirSync(outputDir);
+        if (!await checkResourceExists(outputDir)) {
+          await fs.mkdir(outputDir);
         }
 
-        if (!fs.existsSync(cachePath)) {
-          fs.writeFileSync(cachePath, cache, 'utf8');
+        if (!await checkResourceExists(cachePath)) {
+          await fs.writeFile(cachePath, cache, 'utf-8');
         }
       }
       
diff --git a/packages/plugin-graphql/src/index.js b/packages/plugin-graphql/src/index.js
index bcf3c0f5a..0d2353bd5 100644
--- a/packages/plugin-graphql/src/index.js
+++ b/packages/plugin-graphql/src/index.js
@@ -1,7 +1,6 @@
-import fs from 'fs';
+import fs from 'fs/promises';
 import { graphqlServer } from './core/server.js';
 import { mergeImportMap } from '@greenwood/cli/src/lib/walker-package-ranger.js';
-import path from 'path';
 import { ResourceInterface } from '@greenwood/cli/src/lib/resource-interface.js';
 import { ServerInterface } from '@greenwood/cli/src/lib/server-interface.js';
 import rollupPluginAlias from '@rollup/plugin-alias';
@@ -19,63 +18,53 @@ const importMap = {
 class GraphQLResource extends ResourceInterface {
   constructor(compilation, options = {}) {
     super(compilation, options);
-    this.extensions = ['.gql'];
+    this.extensions = ['gql'];
     this.contentType = ['text/javascript', 'text/html'];
   }
 
+  async shouldServe(url) {
+    return url.protocol === 'file:' && this.extensions.indexOf(url.pathname.split('.').pop()) >= 0;
+  }
+
   async serve(url) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const js = await fs.promises.readFile(url, 'utf-8');
-        const body = `
-          export default \`${js}\`;
-        `;
+    const js = await fs.readFile(url, 'utf-8');
+    const body = `
+      export default \`${js}\`;
+    `;
 
-        resolve({
-          body,
-          contentType: this.contentType[0]
-        });
-      } catch (e) {
-        reject(e);
-      }
+    return new Response(body, {
+      headers: new Headers({
+        'Content-Type': this.contentType[0]
+      })
     });
   }
   
-  async shouldIntercept(url, body, headers) {
-    return Promise.resolve(headers.request.accept && headers.request.accept.indexOf(this.contentType[1]) >= 0);
+  async shouldIntercept(url, request, response) {
+    return response.headers.get('Content-Type').indexOf(this.contentType[1]) >= 0;
   }
 
-  async intercept(url, body) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const newBody = mergeImportMap(body, importMap);
+  async intercept(url, request, response) {
+    const body = await response.text();
+    const newBody = mergeImportMap(body, importMap);
 
-        resolve({ body: newBody });
-      } catch (e) {
-        reject(e);
-      }
-    });
+    return new Response(newBody);
   }
 
-  async shouldOptimize(url = '', body, headers = {}) {
-    return Promise.resolve(path.extname(url) === '.html' || (headers.request && headers.request['content-type'].indexOf('text/html') >= 0));
+  async shouldOptimize(url, response) {
+    return response.headers.get('Content-Type').indexOf(this.contentType[1]) >= 0;
   }
 
-  async optimize(url, body) {
-    return new Promise((resolve, reject) => {
-      try {
-        body = body.replace('<head>', `
-          <script data-state="apollo" data-gwd-opt="none">
-            window.__APOLLO_STATE__ = true;
-          </script>
-          <head>
-        `);
-    
-        resolve(body);
-      } catch (e) {
-        reject(e);
-      }
-    });
+  async optimize(url, response) {
+    let body = await response.text();
+
+    body = body.replace('<head>', `
+      <script data-state="apollo" data-gwd-opt="none">
+        window.__APOLLO_STATE__ = true;
+      </script>
+      <head>
+    `);
+
+    return new Response(body);
   }
 }
 
diff --git a/packages/plugin-graphql/src/schema/schema.js b/packages/plugin-graphql/src/schema/schema.js
index 15b95bc21..7f1dd0fad 100644
--- a/packages/plugin-graphql/src/schema/schema.js
+++ b/packages/plugin-graphql/src/schema/schema.js
@@ -1,15 +1,14 @@
+import { checkResourceExists } from '@greenwood/cli/src/lib/resource-utils.js';
 import { makeExecutableSchema } from 'apollo-server-express';
 import { configTypeDefs, configResolvers } from './config.js';
 import { graphTypeDefs, graphResolvers } from './graph.js';
-import fs from 'fs';
+import fs from 'fs/promises';
 import gql from 'graphql-tag';
-import path from 'path';
-import { pathToFileURL } from 'url';
 
 const createSchema = async (compilation) => {
   const { graph } = compilation;
   const uniqueCustomDataDefKeys = {};
-  const customSchemasPath = `${compilation.context.userWorkspace}/data/schema`;
+  const customSchemasUrl = new URL('./data/schema/', compilation.context.userWorkspace);
   const customUserResolvers = [];
   const customUserDefs = [];
   let customDataDefsString = '';
@@ -36,13 +35,13 @@ const createSchema = async (compilation) => {
       }
     `;
 
-    if (fs.existsSync(customSchemasPath)) {
+    if (await checkResourceExists(customSchemasUrl)) {
       console.log('custom schemas directory detected, scanning...');
-      const schemaPaths = (await fs.promises.readdir(customSchemasPath))
-        .filter(file => path.extname(file) === '.js');
+      const schemaPaths = (await fs.readdir(customSchemasUrl))
+        .filter(file => file.split('.').pop() === 'js');
 
       for (const schemaPath of schemaPaths) {
-        const { customTypeDefs, customResolvers } = await import(pathToFileURL(`${customSchemasPath}/${schemaPath}`));
+        const { customTypeDefs, customResolvers } = await import(new URL(`./${schemaPath}`, customSchemasUrl));
         
         customUserDefs.push(customTypeDefs);
         customUserResolvers.push(customResolvers);
diff --git a/packages/plugin-graphql/test/cases/develop.default/develop.default.spec.js b/packages/plugin-graphql/test/cases/develop.default/develop.default.spec.js
index 54efe5778..84b016e8b 100644
--- a/packages/plugin-graphql/test/cases/develop.default/develop.default.spec.js
+++ b/packages/plugin-graphql/test/cases/develop.default/develop.default.spec.js
@@ -134,7 +134,7 @@ describe('Develop Greenwood With: ', function() {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal('text/javascript');
+        expect(response.headers['content-type']).to.contain('text/javascript');
         done();
       });
 
@@ -170,7 +170,7 @@ describe('Develop Greenwood With: ', function() {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal('text/javascript');
+        expect(response.headers['content-type']).to.contain('text/javascript');
         done();
       });
 
diff --git a/packages/plugin-graphql/test/cases/qraphql-server/graphql-server.spec.js b/packages/plugin-graphql/test/cases/qraphql-server/graphql-server.spec.js
index d4389f8bf..b44c12069 100644
--- a/packages/plugin-graphql/test/cases/qraphql-server/graphql-server.spec.js
+++ b/packages/plugin-graphql/test/cases/qraphql-server/graphql-server.spec.js
@@ -130,7 +130,7 @@ describe('Develop Greenwood With: ', function() {
       });
 
       it('should return the expected query response', function(done) {
-        expect(response.body.data.config.workspace).to.equal(path.join(outputPath, 'src'));
+        expect(response.body.data.config.workspace).to.equal(new URL('./src/', import.meta.url).href);
         done();
       });
     });
diff --git a/packages/plugin-import-commonjs/src/index.js b/packages/plugin-import-commonjs/src/index.js
index d1506296f..51fcfe897 100644
--- a/packages/plugin-import-commonjs/src/index.js
+++ b/packages/plugin-import-commonjs/src/index.js
@@ -4,8 +4,7 @@
  *
  */
 import commonjs from '@rollup/plugin-commonjs';
-import fs from 'fs';
-import path from 'path';
+import fs from 'fs/promises';
 import { parse, init } from 'cjs-module-lexer';
 import { ResourceInterface } from '@greenwood/cli/src/lib/resource-interface.js';
 import rollupStream from '@rollup/stream';
@@ -13,12 +12,13 @@ import rollupStream from '@rollup/stream';
 // bit of a workaround for now, but maybe this could be supported by cjs-module-lexar natively?
 // https://github.com/guybedford/cjs-module-lexer/issues/35
 const testForCjsModule = async(url) => {
+  const { pathname } = url;
   let isCommonJs = false;
 
-  if (path.extname(url) === '.js' && (/node_modules/).test(url) && url.indexOf('es-module-shims.js') < 0) {
+  if (pathname.split('.').pop() === '.js' && pathname.startsWith('/node_modules/') && pathname.indexOf('es-module-shims.js') < 0) {
     try {
       await init();
-      const body = await fs.promises.readFile(url, 'utf-8');
+      const body = await fs.readFile(url, 'utf-8');
       await parse(body);
 
       isCommonJs = true;
@@ -26,7 +26,7 @@ const testForCjsModule = async(url) => {
       const { message } = e;
       const isProbablyLexarErrorSoIgnore = message.indexOf('Unexpected import statement in CJS module.') >= 0 
         || message.indexOf('Unexpected export statement in CJS module.') >= 0;
-      
+
       if (!isProbablyLexarErrorSoIgnore) {
         // we probably _shouldn't_ ignore this, so let's log it since we don't want to swallow all errors
         console.error(e);
@@ -34,7 +34,7 @@ const testForCjsModule = async(url) => {
     }
   }
 
-  return Promise.resolve(isCommonJs);
+  return isCommonJs;
 };
 
 class ImportCommonJsResource extends ResourceInterface {
@@ -43,23 +43,16 @@ class ImportCommonJsResource extends ResourceInterface {
   }
 
   async shouldIntercept(url) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const isCommonJs = await testForCjsModule(url);
-
-        return resolve(isCommonJs);
-      } catch (e) {
-        console.error(e);
-        reject(e);
-      }
-    });
+    return await testForCjsModule(url);
   }
 
   async intercept(url) {
+    const { pathname } = url;
+    
     return new Promise(async(resolve, reject) => {
       try {
         const options = {
-          input: url,
+          input: pathname,
           output: { format: 'esm' },
           plugins: [
             commonjs()
@@ -70,10 +63,10 @@ class ImportCommonJsResource extends ResourceInterface {
 
         stream.on('data', (data) => (bundle += data));
         stream.on('end', () => {
-          console.debug(`proccessed module "${url}" as a CommonJS module type.`);
-          resolve({
-            body: bundle
-          });
+          console.debug(`processed module "${pathname}" as a CommonJS module type.`);
+          resolve(new Response(bundle, {
+            headers: response.headers
+          }));
         });
       } catch (e) {
         reject(e);
diff --git a/packages/plugin-import-css/src/index.js b/packages/plugin-import-css/src/index.js
index 8c186cb58..333b25fda 100644
--- a/packages/plugin-import-css/src/index.js
+++ b/packages/plugin-import-css/src/index.js
@@ -3,61 +3,47 @@
  * Enables using JavaScript to import CSS files, using ESM syntax.
  *
  */
-import fs from 'fs';
-import path from 'path';
+import { checkResourceExists } from '@greenwood/cli/src/lib/resource-utils.js';
 import { ResourceInterface } from '@greenwood/cli/src/lib/resource-interface.js';
-import { pathToFileURL } from 'url';
 
 class ImportCssResource extends ResourceInterface {
   constructor(compilation, options) {
     super(compilation, options);
-    this.extensions = ['.css'];
+    this.extensions = ['css'];
     this.contentType = 'text/javascript';
   }
 
-  // TODO resolve as part of https://github.com/ProjectEvergreen/greenwood/issues/952
-  async shouldServe() {
-    return false;
-  }
-
   // https://github.com/ProjectEvergreen/greenwood/issues/700
   async shouldResolve(url) {
-    const isCssInDisguise = url.endsWith(this.extensions[0]) && fs.existsSync(`${url}.js`);
-
-    return Promise.resolve(isCssInDisguise);
+    return url.pathname.endsWith(`.${this.extensions[0]}`) && await checkResourceExists(url);
   }
 
   async resolve(url) {
-    return Promise.resolve(`${url}.js`);
+    return new Request(`file://${url.pathname}.js`);
   }
 
-  async shouldIntercept(url, body, headers = { request: {} }) {
-    const { originalUrl = '' } = headers.request;
-    const accept = headers.request.accept || '';
-    const isCssFile = path.extname(url) === this.extensions[0];
-    const notFromBrowser = accept.indexOf('text/css') < 0 && accept.indexOf('application/signed-exchange') < 0;
+  async shouldIntercept(url, request) {
+    const { pathname } = url;
+    const accepts = request.headers.get('accept') || '';
+    const isCssFile = pathname.split('.').pop() === this.extensions[0];
+    const notFromBrowser = accepts.indexOf('text/css') < 0 && accepts.indexOf('application/signed-exchange') < 0;
 
     // https://github.com/ProjectEvergreen/greenwood/issues/492
-    const isCssInJs = originalUrl.indexOf('?type=css') >= 0
+    const isCssInJs = url.searchParams.has('type') && url.searchParams.get('type') === this.extensions[0]
       || isCssFile && notFromBrowser
-      || isCssFile && notFromBrowser && url.indexOf('/node_modules/') >= 0;
+      || isCssFile && notFromBrowser && pathname.startsWith('/node_modules/');
 
-    return Promise.resolve(isCssInJs);
+    return isCssInJs;
   }
 
-  async intercept(url, body) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const finalBody = body || await fs.promises.readFile(pathToFileURL(url), 'utf-8');
-        const cssInJsBody = `const css = \`${finalBody.replace(/\r?\n|\r/g, ' ').replace(/\\/g, '\\\\')}\`;\nexport default css;`;
-        
-        resolve({
-          body: cssInJsBody,
-          contentType: this.contentType
-        });
-      } catch (e) {
-        reject(e);
-      }
+  async intercept(url, request, response) {
+    const body = await response.text();
+    const cssInJsBody = `const css = \`${body.replace(/\r?\n|\r/g, ' ').replace(/\\/g, '\\\\')}\`;\nexport default css;`;
+    
+    return new Response(cssInJsBody, {
+      headers: new Headers({
+        'Content-Type': this.contentType
+      })
     });
   }
 }
diff --git a/packages/plugin-import-css/test/cases/develop.default/develop.default.spec.js b/packages/plugin-import-css/test/cases/develop.default/develop.default.spec.js
index 601c872a3..035711775 100644
--- a/packages/plugin-import-css/test/cases/develop.default/develop.default.spec.js
+++ b/packages/plugin-import-css/test/cases/develop.default/develop.default.spec.js
@@ -89,7 +89,7 @@ describe('Develop Greenwood With: ', function() {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal('text/javascript');
+        expect(response.headers['content-type']).to.contain('text/javascript');
         done();
       });
 
@@ -132,7 +132,7 @@ describe('Develop Greenwood With: ', function() {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal('text/javascript');
+        expect(response.headers['content-type']).to.contain('text/javascript');
         done();
       });
 
diff --git a/packages/plugin-import-json/src/index.js b/packages/plugin-import-json/src/index.js
index 99f0d0642..ebfff8f5e 100644
--- a/packages/plugin-import-json/src/index.js
+++ b/packages/plugin-import-json/src/index.js
@@ -4,45 +4,29 @@
  * This is a Greenwood default plugin.
  *
  */
-import fs from 'fs';
 import { ResourceInterface } from '@greenwood/cli/src/lib/resource-interface.js';
 
 class ImportJsonResource extends ResourceInterface {
   constructor(compilation, options) {
     super(compilation, options);
-    this.extensions = ['.json'];
+    this.extensions = ['json'];
     this.contentType = 'text/javascript';
   }
 
-  // TODO resolve as part of https://github.com/ProjectEvergreen/greenwood/issues/952
-  async shouldServe() {
-    return false;
-  }
-
-  // TODO handle it from node_modules too, when without `?type=json`
-  async shouldIntercept(url, body, headers) {
-    const { originalUrl } = headers.request;
-    const type = this.extensions[0].replace('.', '');
+  async shouldIntercept(url) {
+    const { pathname } = url;
 
-    return Promise.resolve(originalUrl && originalUrl.indexOf(`?type=${type}`) >= 0);
+    return pathname.split('.').pop() === this.extensions[0] && (url.searchParams.has('type') && url.searchParams.get('type') === this.extensions[0]);
   }
 
-  async intercept(url, body = '') {
-    return new Promise(async (resolve, reject) => {
-      try {
-        // TODO better way to handle this?
-        // https://github.com/ProjectEvergreen/greenwood/issues/948
-        const raw = body === ''
-          ? await fs.promises.readFile(url, 'utf-8')
-          : body;
+  async intercept(url, request, response) {
+    const json = await response.json();
+    const body = `export default ${JSON.stringify(json)}`;
 
-        resolve({
-          body: `export default ${JSON.stringify(raw)}`,
-          contentType: this.contentType
-        });
-      } catch (e) {
-        reject(e);
-      }
+    return new Response(body, {
+      headers: new Headers({
+        'Content-Type': this.contentType
+      })
     });
   }
 }
diff --git a/packages/plugin-import-json/test/cases/develop.default/develop.default.spec.js b/packages/plugin-import-json/test/cases/develop.default/develop.default.spec.js
index 9bb03407c..26c24e787 100644
--- a/packages/plugin-import-json/test/cases/develop.default/develop.default.spec.js
+++ b/packages/plugin-import-json/test/cases/develop.default/develop.default.spec.js
@@ -13,8 +13,8 @@
  *
  * {
  *   plugins: [{
- *      ...greenwoodPluginImportJson()
- *  }]
+ *     greenwoodPluginImportJson()
+ *   }]
  * }
  *
  *
diff --git a/packages/plugin-import-json/test/cases/develop.default/src/main.json b/packages/plugin-import-json/test/cases/develop.default/src/main.json
index ba21e8844..ea0ea4f9a 100644
--- a/packages/plugin-import-json/test/cases/develop.default/src/main.json
+++ b/packages/plugin-import-json/test/cases/develop.default/src/main.json
@@ -1,4 +1 @@
-{
-  "status": 200,
-  "message": "got json"
-}
\ No newline at end of file
+{"status":200,"message":"got json"}
\ No newline at end of file
diff --git a/packages/plugin-include-html/src/index.js b/packages/plugin-include-html/src/index.js
index 031b9bec8..12682e661 100644
--- a/packages/plugin-include-html/src/index.js
+++ b/packages/plugin-include-html/src/index.js
@@ -1,7 +1,5 @@
-import fs from 'fs';
-import path from 'path';
+import fs from 'fs/promises';
 import { ResourceInterface } from '@greenwood/cli/src/lib/resource-interface.js';
-import { pathToFileURL } from 'url';
 
 class IncludeHtmlResource extends ResourceInterface {
   constructor(compilation, options) {
@@ -10,44 +8,42 @@ class IncludeHtmlResource extends ResourceInterface {
     this.contentType = 'text/html';
   }
 
-  async shouldIntercept(url, body, headers) {
-    return Promise.resolve(headers.response['content-type'] === this.contentType);
+  async shouldIntercept(url, request, response) {
+    return response.headers.get('Content-Type').indexOf(this.contentType) >= 0;
   }
 
-  async intercept(url, body) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const includeLinksRegexMatches = body.match(/<link (.*)>/g);
-        const includeCustomElementssRegexMatches = body.match(/<[a-zA-Z]*-[a-zA-Z](.*)>(.*)<\/[a-zA-Z]*-[a-zA-Z](.*)>/g);
-
-        if (includeLinksRegexMatches) {
-          includeLinksRegexMatches
-            .filter(link => link.indexOf('rel="html"') > 0)
-            .forEach((link) => {
-              const href = link.match(/href="(.*)"/)[1];
-              const includeContents = fs.readFileSync(path.join(this.compilation.context.userWorkspace, href), 'utf-8');
-
-              body = body.replace(link, includeContents);
-            });
-        }
-
-        if (includeCustomElementssRegexMatches) {
-          const customElementTags = includeCustomElementssRegexMatches.filter(customElementTag => customElementTag.indexOf('src=') > 0);
-
-          for (const tag of customElementTags) {
-            const src = tag.match(/src="(.*)"/)[1];
-            const filepath = path.join(this.compilation.context.userWorkspace, this.getBareUrlPath(src.replace(/\.\.\//g, '')));
-            const { getData, getTemplate } = await import(pathToFileURL(filepath));
-            const includeContents = await getTemplate(await getData());
-
-            body = body.replace(tag, includeContents);
-          }
-        }
-
-        resolve({ body });
-      } catch (e) {
-        reject(e);
+  async intercept(url, request, response) {
+    let body = await response.text();
+    const includeLinksRegexMatches = body.match(/<link (.*)>/g);
+    const includeCustomElementsRegexMatches = body.match(/<[a-zA-Z]*-[a-zA-Z](.*)>(.*)<\/[a-zA-Z]*-[a-zA-Z](.*)>/g);
+
+    if (includeLinksRegexMatches) {
+      const htmlIncludeLinks = includeLinksRegexMatches.filter(link => link.indexOf('rel="html"') > 0);
+
+      for (const link of htmlIncludeLinks) {
+        const href = link.match(/href="(.*)"/)[1];
+        const prefix = href.startsWith('/') ? '.' : '';
+        const includeContents = await fs.readFile(new URL(`${prefix}${href}`, this.compilation.context.userWorkspace), 'utf-8');
+
+        body = body.replace(link, includeContents);
+      }
+    }
+
+    if (includeCustomElementsRegexMatches) {
+      const customElementTags = includeCustomElementsRegexMatches.filter(customElementTag => customElementTag.indexOf('src=') > 0);
+
+      for (const tag of customElementTags) {
+        const src = tag.match(/src="(.*)"/)[1];
+        const srcUrl = new URL(`./${src.replace(/\.\.\//g, '')}`, this.compilation.context.userWorkspace);
+        const { getData, getTemplate } = await import(srcUrl);
+        const includeContents = await getTemplate(await getData());
+
+        body = body.replace(tag, includeContents);
       }
+    }
+
+    return new Response(body, {
+      headers: response.headers
     });
   }
 }
diff --git a/packages/plugin-include-html/test/cases/build.default-custom-element/src/components/footer.js b/packages/plugin-include-html/test/cases/build.default-custom-element/src/components/footer.js
index f2a883938..c62e8b7de 100644
--- a/packages/plugin-include-html/test/cases/build.default-custom-element/src/components/footer.js
+++ b/packages/plugin-include-html/test/cases/build.default-custom-element/src/components/footer.js
@@ -1,5 +1,4 @@
-import fs from 'fs';
-import { fileURLToPath, URL } from 'url';
+import fs from 'fs/promises';
 
 const getTemplate = async (data) => {
   return `
@@ -12,9 +11,8 @@ const getTemplate = async (data) => {
 };
 
 const getData = async () => {
-  const dataPath = fileURLToPath(new URL('../../package.json', import.meta.url));
-  const data = JSON.parse(await fs.promises.readFile(dataPath, 'utf-8'));
-
+  const dataUrl = new URL('../../package.json', import.meta.url);
+  const data = JSON.parse(await fs.readFile(dataUrl, 'utf-8'));
   const { version } = data;
 
   return { version };
diff --git a/packages/plugin-include-html/test/cases/build.default-link-tag/build.default.link-tag.spec.js b/packages/plugin-include-html/test/cases/build.default-link-tag/build.default.link-tag.spec.js
index b78b66b6f..68392a49b 100644
--- a/packages/plugin-include-html/test/cases/build.default-link-tag/build.default.link-tag.spec.js
+++ b/packages/plugin-include-html/test/cases/build.default-link-tag/build.default.link-tag.spec.js
@@ -36,7 +36,7 @@ import { fileURLToPath, URL } from 'url';
 const expect = chai.expect;
 
 describe('Build Greenwood With HTML Include Plugin: ', function() {
-  const LABEL = 'Using Custom Element feature';
+  const LABEL = 'Using Link Tag feature';
   const cliPath = path.join(process.cwd(), 'packages/cli/src/index.js');
   const outputPath = fileURLToPath(new URL('.', import.meta.url));
   let runner;
diff --git a/packages/plugin-polyfills/src/index.js b/packages/plugin-polyfills/src/index.js
index f45346093..e56252bd5 100644
--- a/packages/plugin-polyfills/src/index.js
+++ b/packages/plugin-polyfills/src/index.js
@@ -1,11 +1,11 @@
 import { getNodeModulesLocationForPackage } from '@greenwood/cli/src/lib/node-modules-utils.js';
-import path from 'path';
 import { ResourceInterface } from '@greenwood/cli/src/lib/resource-interface.js';
 
 class PolyfillsResource extends ResourceInterface {
   constructor(compilation, options = {}) {
     super(compilation, options);
 
+    this.contentType = 'text/html';
     this.options = {
       wc: true,
       dsd: false,
@@ -14,56 +14,57 @@ class PolyfillsResource extends ResourceInterface {
     };
   }
 
-  async shouldIntercept(url, body, headers = { request: {} }) {
-    return Promise.resolve(headers.request['content-type'] && headers.request['content-type'].indexOf('text/html') >= 0);
+  async shouldIntercept(url, request, response) {
+    const { protocol } = url;
+    const { wc, lit, dsd } = this.options;
+    const isEnabled = wc || lit || dsd;
+
+    return isEnabled
+      && protocol.startsWith('http')
+      && response.headers.get('Content-Type').indexOf(this.contentType) >= 0;
   }
 
-  async intercept(url, body) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        let newHtml = body;
+  async intercept(url, request, response) {
+    const { wc, lit, dsd } = this.options;
+    let body = await response.text();
 
-        // standard WC polyfill
-        if (this.options.wc) {
-          newHtml = newHtml.replace('<head>', `
-            <head>
-              <script src="/node_modules/@webcomponents/webcomponentsjs/webcomponents-loader.js"></script>
-          `);
-        }
+    // standard WC polyfill
+    if (wc) {
+      body = body.replace('<head>', `
+        <head>
+          <script src="/node_modules/@webcomponents/webcomponentsjs/webcomponents-loader.js"></script>
+      `);
+    }
 
-        // append Lit polyfill next to make sure it comes before WC polyfill
-        if (this.options.lit) {
-          newHtml = newHtml.replace('<head>', `
-            <head>
-              <script src="/node_modules/lit/polyfill-support.js"></script>
-          `);
-        }
+    // append Lit polyfill next to make sure it comes before WC polyfill
+    if (lit) {
+      body = body.replace('<head>', `
+        <head>
+          <script src="/node_modules/lit/polyfill-support.js"></script>
+      `);
+    }
 
-        // lastly, Declarative Shadow DOM polyfill
-        if (this.options.dsd) {
-          newHtml = newHtml.replace('</body>', `
-              <script>
-                if (!HTMLTemplateElement.prototype.hasOwnProperty('shadowRoot')) {
-                  (function attachShadowRoots(root) {
-                    root.querySelectorAll("template[shadowroot]").forEach(template => {
-                      const mode = template.getAttribute("shadowroot");
-                      const shadowRoot = template.parentNode.attachShadow({ mode });
-                      shadowRoot.appendChild(template.content);
-                      template.remove();
-                      attachShadowRoots(shadowRoot);
-                    });
-                  })(document);
-                }
-              </script>
-            </body>
-          `);
-        }
+    // lastly, Declarative Shadow DOM polyfill
+    if (dsd) {
+      body = body.replace('</body>', `
+          <script>
+            if (!HTMLTemplateElement.prototype.hasOwnProperty('shadowRoot')) {
+              (function attachShadowRoots(root) {
+                root.querySelectorAll("template[shadowroot]").forEach(template => {
+                  const mode = template.getAttribute("shadowroot");
+                  const shadowRoot = template.parentNode.attachShadow({ mode });
+                  shadowRoot.appendChild(template.content);
+                  template.remove();
+                  attachShadowRoots(shadowRoot);
+                });
+              })(document);
+            }
+          </script>
+        </body>
+      `);
+    }
 
-        resolve({ body: newHtml });
-      } catch (e) {
-        reject(e);
-      }
-    });
+    return new Response(body);
   }
 }
 
@@ -80,16 +81,17 @@ const greenwoodPluginPolyfills = (options = {}) => {
       const polyfillPackageName = '@webcomponents/webcomponentsjs';
       const polyfillNodeModulesLocation = await getNodeModulesLocationForPackage(polyfillPackageName);
       const litNodeModulesLocation = await getNodeModulesLocationForPackage('lit');
+
       const standardPolyfills = [{
-        from: path.join(polyfillNodeModulesLocation, 'webcomponents-loader.js'),
-        to: path.join(outputDir, 'webcomponents-loader.js')
+        from: new URL('./webcomponents-loader.js', new URL(`file://${polyfillNodeModulesLocation}/`)),
+        to: new URL('./webcomponents-loader.js', outputDir)
       }, {
-        from: path.join(polyfillNodeModulesLocation, 'bundles'),
-        to: path.join(outputDir, 'bundles')
+        from: new URL('./bundles/', new URL(`file://${polyfillNodeModulesLocation}/`)),
+        to: new URL('./bundles/', outputDir)
       }];
       const litPolyfills = [{
-        from: path.join(litNodeModulesLocation, 'polyfill-support.js'),
-        to: path.join(outputDir, 'polyfill-support.js')
+        from: new URL('./polyfill-support.js', new URL(`file://${litNodeModulesLocation}/`)),
+        to: new URL('./polyfill-support.js', outputDir)
       }];
 
       return [
diff --git a/packages/plugin-postcss/src/index.js b/packages/plugin-postcss/src/index.js
index 41bffa49e..fd01ce3f7 100644
--- a/packages/plugin-postcss/src/index.js
+++ b/packages/plugin-postcss/src/index.js
@@ -3,22 +3,21 @@
  * Enable using PostCSS process for CSS files.
  *
  */
-import fs from 'fs';
-import path from 'path';
+import { checkResourceExists, normalizePathnameForWindows } from '@greenwood/cli/src/lib/resource-utils.js';
 import postcss from 'postcss';
 import { ResourceInterface } from '@greenwood/cli/src/lib/resource-interface.js';
-import { pathToFileURL } from 'url';
 
 async function getConfig (compilation, extendConfig = false) {
   const { projectDirectory } = compilation.context;
   const configFile = 'postcss.config';
-  const defaultConfig = (await import(new URL(`${configFile}.js`, import.meta.url).pathname)).default;
-  const userConfig = fs.existsSync(path.join(projectDirectory, `${configFile}.mjs`))
-    ? (await import(pathToFileURL(path.join(projectDirectory, `${configFile}.mjs`)))).default
+  const defaultConfig = (await import(new URL(`./${configFile}.js`, import.meta.url))).default;
+  const userConfigUrl = new URL(`./${configFile}.mjs`, projectDirectory);
+  const userConfig = await checkResourceExists(userConfigUrl)
+    ? (await import(userConfigUrl)).default
     : {};
-  let finalConfig = Object.assign({}, userConfig);
+  const finalConfig = Object.assign({}, userConfig);
 
-  if (userConfig && extendConfig) {    
+  if (userConfig && extendConfig) {
     finalConfig.plugins = Array.isArray(userConfig.plugins)
       ? [...defaultConfig.plugins, ...userConfig.plugins]
       : [...defaultConfig.plugins];
@@ -30,38 +29,23 @@ async function getConfig (compilation, extendConfig = false) {
 class PostCssResource extends ResourceInterface {
   constructor(compilation, options) {
     super(compilation, options);
-    this.extensions = ['.css'];
+    this.extensions = ['css'];
     this.contentType = ['text/css'];
   }
 
-  async shouldServe() {
-    return false;
-  }
-
-  isCssFile(url) {
-    return path.extname(url) === '.css';
-  }
-
   async shouldIntercept(url) {
-    return Promise.resolve(this.isCssFile(url));
+    return url.protocol === 'file:' && url.pathname.split('.').pop() === this.extensions[0];
   }
 
-  async intercept(url, body) {
-    return new Promise(async(resolve, reject) => {
-      try {
-        const config = await getConfig(this.compilation, this.options.extendConfig);
-        const plugins = config.plugins || [];
-        const css = plugins.length > 0
-          ? (await postcss(plugins).process(body, { from: url })).css
-          : body;
-        
-        resolve({
-          body: css
-        });
-      } catch (e) {
-        reject(e);
-      }
-    });
+  async intercept(url, request, response) {
+    const config = await getConfig(this.compilation, this.options.extendConfig);
+    const plugins = config.plugins || [];
+    const body = await response.text();
+    const css = plugins.length > 0
+      ? (await postcss(plugins).process(body, { from: normalizePathnameForWindows(url) })).css
+      : body;
+
+    return new Response(css);
   }
 }
 
diff --git a/packages/plugin-renderer-lit/src/ssr-route-worker-lit.js b/packages/plugin-renderer-lit/src/ssr-route-worker-lit.js
index 24e042a91..4d96c71fa 100644
--- a/packages/plugin-renderer-lit/src/ssr-route-worker-lit.js
+++ b/packages/plugin-renderer-lit/src/ssr-route-worker-lit.js
@@ -3,7 +3,6 @@ import { render } from '@lit-labs/ssr/lib/render-with-global-dom-shim.js';
 import { Buffer } from 'buffer';
 import { html } from 'lit';
 import { unsafeHTML } from 'lit-html/directives/unsafe-html.js';
-import { pathToFileURL } from 'url';
 import { Readable } from 'stream';
 import { parentPort } from 'worker_threads';
 
@@ -21,7 +20,7 @@ async function getTemplateResultString(template) {
   return await streamToString(Readable.from(render(template)));
 }
 
-async function executeRouteModule({ modulePath, compilation, route, label, id, prerender, htmlContents, scripts }) {
+async function executeRouteModule({ moduleUrl, compilation, route, label, id, prerender, htmlContents, scripts }) {
   const parsedCompilation = JSON.parse(compilation);
   const parsedScripts = scripts ? JSON.parse(scripts) : [];
   const data = {
@@ -31,6 +30,7 @@ async function executeRouteModule({ modulePath, compilation, route, label, id, p
     html: null
   };
 
+  console.debug({ moduleUrl });
   // prerender static content
   if (prerender) {
     for (const script of parsedScripts) {
@@ -41,7 +41,7 @@ async function executeRouteModule({ modulePath, compilation, route, label, id, p
 
     data.html = await getTemplateResultString(templateResult);
   } else {
-    const module = await import(pathToFileURL(modulePath)).then(module => module);
+    const module = await import(moduleUrl).then(module => module);
     const { getTemplate = null, getBody = null, getFrontmatter = null } = module;
 
     if (module.default && module.tagName) {
diff --git a/packages/plugin-renderer-lit/test/cases/build.default/src/pages/artists.js b/packages/plugin-renderer-lit/test/cases/build.default/src/pages/artists.js
index 2bdf8c57f..5e2e8ab04 100644
--- a/packages/plugin-renderer-lit/test/cases/build.default/src/pages/artists.js
+++ b/packages/plugin-renderer-lit/test/cases/build.default/src/pages/artists.js
@@ -1,4 +1,4 @@
-import fs from 'fs';
+import fs from 'fs/promises';
 import { html } from 'lit';
 import { unsafeHTML } from 'lit-html/directives/unsafe-html.js';
 import '../components/greeting.js';
@@ -30,7 +30,7 @@ async function getTemplate(compilation, route) {
 }
 
 async function getBody() {
-  const artists = JSON.parse(await fs.promises.readFile(new URL('../../artists.json', import.meta.url), 'utf-8'));
+  const artists = JSON.parse(await fs.readFile(new URL('../../artists.json', import.meta.url), 'utf-8'));
 
   return html`
     <h1>Lit SSR response</h1>
diff --git a/packages/plugin-renderer-puppeteer/src/plugins/resource.js b/packages/plugin-renderer-puppeteer/src/plugins/resource.js
index d83b9020a..509f2faaf 100644
--- a/packages/plugin-renderer-puppeteer/src/plugins/resource.js
+++ b/packages/plugin-renderer-puppeteer/src/plugins/resource.js
@@ -1,4 +1,3 @@
-import path from 'path';
 import { ResourceInterface } from '@greenwood/cli/src/lib/resource-interface.js';
 
 class PuppeteerResource extends ResourceInterface {
@@ -9,19 +8,23 @@ class PuppeteerResource extends ResourceInterface {
     this.contentType = 'text/html';
   }
 
-  async shouldIntercept(url, body, headers = {}) {
-    const shouldIntercept = url.endsWith(path.sep) && headers.request && headers.request.accept.indexOf(this.contentType) >= 0;
-  
-    return process.env.__GWD_COMMAND__ === 'build' && shouldIntercept;// eslint-disable-line no-underscore-dangle
+  async shouldIntercept(url, request, response) {
+    const { protocol } = url;
+
+    return process.env.__GWD_COMMAND__ === 'build' // eslint-disable-line no-underscore-dangle
+      && protocol.startsWith('http')
+      && response.headers.get('Content-Type').indexOf(this.contentType) >= 0;
   }
 
-  async intercept(url, body) {
+  async intercept(url, request, response) {
+    let body = await response.text();
+
     body = body.replace('<head>', `
       <head>
         <script src="/node_modules/@webcomponents/webcomponentsjs/webcomponents-bundle.js"></script>
     `);
 
-    return Promise.resolve({ body });
+    return new Response(body);
   }
 }
 
diff --git a/packages/plugin-typescript/src/index.js b/packages/plugin-typescript/src/index.js
index 55d4d717d..027a642c7 100644
--- a/packages/plugin-typescript/src/index.js
+++ b/packages/plugin-typescript/src/index.js
@@ -3,8 +3,7 @@
  * Enables using JavaScript to import TypeScript files, using ESM syntax.
  *
  */
-import fs from 'fs';
-import path from 'path';
+import fs from 'fs/promises';
 import { ResourceInterface } from '@greenwood/cli/src/lib/resource-interface.js';
 import tsc from 'typescript';
 
@@ -15,9 +14,9 @@ const defaultCompilerOptions = {
   sourceMap: true
 };
 
-function getCompilerOptions (projectDirectory, extendConfig) {
+async function getCompilerOptions (projectDirectory, extendConfig) {
   const customOptions = extendConfig
-    ? JSON.parse(fs.readFileSync(path.join(projectDirectory, 'tsconfig.json'), 'utf-8'))
+    ? JSON.parse(await fs.readFile(new URL('./tsconfig.json', projectDirectory), 'utf-8'))
     : { compilerOptions: {} };
 
   return {
@@ -29,27 +28,28 @@ function getCompilerOptions (projectDirectory, extendConfig) {
 class TypeScriptResource extends ResourceInterface {
   constructor(compilation, options) {
     super(compilation, options);
-    this.extensions = ['.ts'];
+    this.extensions = ['ts'];
     this.contentType = 'text/javascript';
   }
 
-  async serve(url) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const { projectDirectory } = this.compilation.context;
-        const source = await fs.promises.readFile(url, 'utf-8');
-        const compilerOptions = getCompilerOptions(projectDirectory, this.options.extendConfig);
+  async shouldServe(url) {
+    const { pathname, protocol } = url;
+    const isTsFile = protocol === 'file:' && pathname.split('.').pop() === this.extensions[0];
+
+    return isTsFile || isTsFile && url.searchParams.has('type') && url.searchParams.get('type') === this.extensions[0];
+  }
 
-        // https://github.com/microsoft/TypeScript/wiki/Using-the-Compiler-API
-        const result = tsc.transpileModule(source, { compilerOptions });
+  async serve(url) {
+    const { projectDirectory } = this.compilation.context;
+    const source = await fs.readFile(url, 'utf-8');
+    const compilerOptions = await getCompilerOptions(projectDirectory, this.options.extendConfig);
+    // https://github.com/microsoft/TypeScript/wiki/Using-the-Compiler-API
+    const body = tsc.transpileModule(source, { compilerOptions }).outputText;
 
-        resolve({
-          body: result.outputText,
-          contentType: this.contentType
-        });
-      } catch (e) {
-        reject(e);
-      }
+    return new Response(body, {
+      headers: new Headers({
+        'Content-Type': this.contentType
+      })
     });
   }
 }
diff --git a/packages/plugin-typescript/test/cases/develop.default/develop.default.spec.js b/packages/plugin-typescript/test/cases/develop.default/develop.default.spec.js
index b99d5d05d..15f741133 100644
--- a/packages/plugin-typescript/test/cases/develop.default/develop.default.spec.js
+++ b/packages/plugin-typescript/test/cases/develop.default/develop.default.spec.js
@@ -82,7 +82,7 @@ describe('Develop Greenwood With: ', function() {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal('text/javascript');
+        expect(response.headers['content-type']).to.contain('text/javascript');
         done();
       });
 
diff --git a/test/smoke-test.js b/test/smoke-test.js
index 27a22fc04..ac7f8c83a 100644
--- a/test/smoke-test.js
+++ b/test/smoke-test.js
@@ -231,7 +231,7 @@ function serve(label) {
       });
 
       it('should return the correct content type', function(done) {
-        expect(response.headers['content-type']).to.equal('text/html');
+        expect(response.headers['content-type']).to.contain('text/html');
         done();
       });
 
diff --git a/www/pages/docs/api-routes.md b/www/pages/docs/api-routes.md
index 328dbd708..4e248c192 100644
--- a/www/pages/docs/api-routes.md
+++ b/www/pages/docs/api-routes.md
@@ -30,9 +30,9 @@ export async function handler(request) {
   const body = { message: `Hello ${name}!!!` };
 
   return new Response(JSON.stringify(body), {
-    headers: {
+    headers: new Headers({
       'Content-Type': 'application/json'
-    }
+    })
   });
 }
 ```
diff --git a/www/pages/docs/configuration.md b/www/pages/docs/configuration.md
index 0a095c42e..16d24c279 100644
--- a/www/pages/docs/configuration.md
+++ b/www/pages/docs/configuration.md
@@ -36,7 +36,7 @@ export default {
 
 ### Dev Server
 Configuration for Greenwood's development server is available using the `devServer` option.
-- `extensions`: Provide an array of to watch for changes and reload the live server with.  By default, Greenwood will already watch all "standard" web assets (HTML, CSS, JS, etc) it supports by default, as well as any extensions set by [resource plugins](/plugins/resource) you are using in your _greenwood.config.json_.
+- `extensions`: Provide an array of extensions to watch for changes and reload the live server with.  By default, Greenwood will already watch all "standard" web assets (HTML, CSS, JS, etc) it supports by default, as well as any extensions set by [resource plugins](/plugins/resource) you are using in your _greenwood.config.json_.
 - `hud`: The HUD option ([_head-up display_](https://en.wikipedia.org/wiki/Head-up_display)) is some additional HTML added to your site's page when Greenwood wants to help provide information to you in the browser.  For example, if your HTML is detected as malformed, which could break the parser.  Set this to `false` if you would like to turn it off.
 - `port`: Pick a different port when starting the dev server
 - `proxy`: A set of paths to match and re-route to other hosts.  Highest specificity should go at the end.
@@ -45,7 +45,7 @@ Configuration for Greenwood's development server is available using the `devServ
 ```js
 export default {
   devServer: {
-    extensions: ['.txt', '.rtf'],
+    extensions: ['txt', 'rtf'],
     port: 3000,
     proxy: {
       '/api': 'https://stage.myapp.com',
@@ -220,9 +220,7 @@ Path to where all your project files will be located.  Using an absolute path is
 Setting the workspace path to be the _www/_ folder in the current directory from where Greenwood is being run.
 
 ```js
-import { fileURLToPath, URL } from 'url';
-
 export default {
-  workspace: fileURLToPath(new URL('./www', import.meta.url))
+  workspace: new URL('./www', import.meta.url)
 };
 ```
\ No newline at end of file
diff --git a/www/pages/guides/theme-packs.md b/www/pages/guides/theme-packs.md
index fab5c7099..b6e3da683 100644
--- a/www/pages/guides/theme-packs.md
+++ b/www/pages/guides/theme-packs.md
@@ -55,8 +55,6 @@ _package.json_
 
 _my-theme-pack.js_
 ```js
-import { fileURLToPath } from 'url';
-
 const myThemePack = () => [{
   type: 'context',
   name: 'my-theme-pack:context',
@@ -65,7 +63,7 @@ const myThemePack = () => [{
       templates: [
         // import.meta.url will be located at _node_modules/your-package/_
         // when your plugin is run in a user's project
-        fileURLToPath(new URL('./dist/layouts', import.meta.url))
+        new URL('./dist/layouts', import.meta.url)
       ]
     };
   }
@@ -124,17 +122,14 @@ The main consideration needed for development is that your files won't be in _no
 So using our current example, our final _my-theme-pack.js_ would look like this:
 <!-- eslint-disable no-underscore-dangle -->
 ```js
-import path from 'path';
-import { fileURLToPath, URL } from 'url';
-
 const myThemePackPlugin = (options = {}) => [{
   type: 'context',
   name: 'my-theme-pack:context',
   provider: (compilation) => {
     // you can use other directory names besides templates/ this way!
     const templateLocation = options.__isDevelopment
-      ? path.join(compilation.context.userWorkspace, 'layouts')
-      : fileURLToPath(new URL('dist/layouts', import.meta.url));
+      ? new URL('./layouts/', compilation.context.userWorkspace)
+      : new URL('dist/layouts', import.meta.url);
 
     return {
       templates: [
@@ -156,7 +151,6 @@ Additionally, we make sure to pass the flag from above for `__isDevelopment` to
 // shared from another test
 import { myThemePackPlugin } from './my-theme-pack.js';
 import fs from 'fs';
-import path from 'path';
 import { ResourceInterface } from '@greenwood/cli/src/lib/resource-interface.js';
 
 const packageName = JSON.parse(fs.readFileSync('./package.json', 'utf-8')).name;
@@ -168,15 +162,16 @@ class MyThemePackDevelopmentResource extends ResourceInterface {
   }
 
   async shouldResolve(url) {
+    const { pathname } = url;
     // eslint-disable-next-line no-underscore-dangle
-    return Promise.resolve((process.env.__GWD_COMMAND__ === 'develop') && url.indexOf(`/node_modules/${packageName}/`) >= 0);
+    return process.env.__GWD_COMMAND__ === 'develop' && pathname.indexOf(`/node_modules/${packageName}/`) >= 0;
   }
 
   async resolve(url) {
     const { userWorkspace } = this.compilation.context;
     const filePath = this.getBareUrlPath(url).split(`/node_modules/${packageName}/dist/`)[1];
 
-    return Promise.resolve(path.join(userWorkspace, filePath));
+    return new URL(`./${filePath}`, userWorkspace, filePath);
   }
 }
 
diff --git a/www/pages/plugins/context.md b/www/pages/plugins/context.md
index b3734ff6d..cc67530d7 100644
--- a/www/pages/plugins/context.md
+++ b/www/pages/plugins/context.md
@@ -45,9 +45,7 @@ Your plugin might look like this:
  *     acme-theme-pack.js
  *     package.json
  */
-import { fileURLToPath } from 'url';
-
-export function myCopyPlugin() {
+export function myContextPlugin() {
   return {
     type: 'context',
     name: 'acme-theme-pack:context',
@@ -55,7 +53,7 @@ export function myCopyPlugin() {
       return {
         templates: [
           // when the plugin is installed import.meta.url will be /path/to/node_modules/<your-package>/
-          fileURLToPath(new URL('./dist/layouts', import.meta.url))
+          new URL('./dist/layouts/', import.meta.url)
         ]
       };
     }
diff --git a/www/pages/plugins/copy.md b/www/pages/plugins/copy.md
index da62156ee..9070e5227 100644
--- a/www/pages/plugins/copy.md
+++ b/www/pages/plugins/copy.md
@@ -10,11 +10,8 @@ index: 2
 The copy plugin allows users to copy files around as part of the [build](/docs/#cli) command.  For example, Greenwood uses this feature to copy all files in the user's _/assets/_ directory to final output directory automatically.  You can use this plugin to copy single files, or entire directories.
 
 ## API
-This plugin supports providing an array of "location" objects that can either be files or directories.
-
+This plugin supports providing an array of "paired" URL objects that can either be files or directories, by providing a `from` and `to` location.
 ```js
-import path from 'path';
-
 export function myCopyPlugin() {
   return {
     type: 'copy',
@@ -23,13 +20,13 @@ export function myCopyPlugin() {
       const { context } = compilation;
 
       return [{
-        // can only copy a file to a file
-        from: path.join(context.userWorkspace, 'robots.txt'),
-        to: path.join(context.outputDir, 'robots.txt')
+        // copy a file
+        from: new URL('./robots.txt', context.userWorkspace),
+        to: new URL('./robots.txt', context.outputDir)
       }, {
-        // can only copy a directory to a directory
-        from: path.join(context.userWorkspace, 'pdfs'),
-        to: path.join(context.outputDir, 'pdfs')
+        // copy a directory (notice the trailing /)
+        from: new URL('./pdfs/', context.userWorkspace),
+        to: new URL('./pdfs/', context.outputDir)
       }];
     }
   };
diff --git a/www/pages/plugins/index.md b/www/pages/plugins/index.md
index f1e3eb47e..452b04784 100644
--- a/www/pages/plugins/index.md
+++ b/www/pages/plugins/index.md
@@ -43,7 +43,7 @@ export default {
         }
       }
     }
-  }]
+  ]
 
 }
 ```
@@ -72,7 +72,7 @@ export default {
 #### Context
 This provides access to all the input / output directories and file paths Greenwood uses to build the site and output all the generated files.  Context is especially useful for copying files or writing to the build directory.
 
-Here are paths you can get from `context`, all of which are absolute URLs:
+Here are paths you can get from `context`, all of which are instances of [`URL`](https://developer.mozilla.org/en-US/docs/Web/API/URL) and use the `file://` protocol:
 
 - `outputDir`: Where Greenwood outputs the final static site
 - `pagesDir`: Path to the _pages/_ directory in the user's workspace
@@ -81,26 +81,7 @@ Here are paths you can get from `context`, all of which are absolute URLs:
 - `userTemplatesDir`: Path to the _templates/_ directory in the user's workspace
 - `userWorkspace`: Path to the workspace directory (_src/_ by default)
 
-
-Example using `context` to write to `publicDir` from _greenwood.config.js_
-```javascript
-import fs from 'fs';
-import path from 'path';
-
-export default {
-
-  plugins: [{
-    name: 'my-plugin'
-    type: 'resource',
-    provider: (compilation) => {
-      const { outputDir } = compilation.context;
-
-      fs.writeFileSync(path.join(outputDir, 'robots.txt'), 'Hello World!');
-    }
-  }]
-
-}
-```
+> You can see a good example of this in use in our [context plugin docs](/plugins/copy/)
 
 ### Plugin Types
 While each API has its own documentation section on the left sidebar of this page, here is a quick overview of the current set of Plugin APIs Greenwood supports.
diff --git a/www/pages/plugins/resource.md b/www/pages/plugins/resource.md
index e5069b640..8464489f7 100644
--- a/www/pages/plugins/resource.md
+++ b/www/pages/plugins/resource.md
@@ -7,160 +7,181 @@ index: 3
 
 ## Resource
 
-Resource plugins allow the manipulation of files loaded through ESM.  Depending on if you need to support a file with a custom extension, or to manipulate standard file extensions, Resource plugins provide the lifecycle hooks into Greenwood to do things like:
-- Integrating Site Analytics (Google, Snowplow) or third snippets into generated _index.html_ pages
-- Processing TypeScript into JavaScript
+Resource plugins allow for the manipulation and transformation of files served and bundled by Greenwood.  Whether you need to support a file with a custom extension or transform the contents of a file from one type to the other, resource plugins provide the lifecycle hooks into Greenwood to enable these customizations.  Examples from Greenwood's own plugin system include:
+* Minifying and bundling CSS
+* Compiling TypeScript into JavaScript
+* Converting vanilla CSS into ESM
+* Injecting site analytics or other third party snippets into your HTML
 
-This API is also used as part of our bundling process to "teach" Rollup how to process any non JavaScript files!
+It uses standard Web APIs for facilitating these transformations such as [`URL`](https://developer.mozilla.org/en-US/docs/Web/API/URL), [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request), and [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response).
 
-### API (Resource Interface)
+### API
 
-> _**Note**: This API is [planning to change soon](https://github.com/ProjectEvergreen/greenwood/issues/948) as part of a general alignment within Greenwood to align the signatures of these lifecycle method to be more consistent with web standards in support of Greenwood adopting compatibility with [serverless and edge runtimes](https://github.com/ProjectEvergreen/greenwood/issues/953)_.
-
-Although JavaScript is loosely typed, a [resource "interface"](https://github.com/ProjectEvergreen/greenwood/tree/master/packages/cli/src/lib/resource-interface.js) has been provided by Greenwood that you can use to start building your own resource plugins.  Effectively you have to define two things:
-- `extensions`: The file types your plugin will operate on
-- `contentType`: A browser compatible contentType to ensure browsers correctly interpret you transformations
+A [resource "interface"](https://github.com/ProjectEvergreen/greenwood/tree/master/packages/cli/src/lib/resource-interface.js) has been provided by Greenwood that you can use to start building your own resource plugins with.
 
 ```javascript
-import fs from 'fs';
-import path from 'path';
 import { ResourceInterface } from '@greenwood/cli/src/lib/resource-interface.js';
 
 class ExampleResource extends ResourceInterface {
   constructor(compilation, options = {}) {
-    this.compilation = compilation;
-    this.options = options;
-    this.extensions = [];
-    this.contentType = '';
+    this.compilation = compilation; // Greenwood's compilation object
+    this.options = options; // any optional configuration provided by the user of your plugin
+    this.extensions = ['foo', 'bar']; // add custom extensions for file watching + live reload here, ex. ts for TypeScript
   }
 
-  // test if this plugin should change a relative URL from the browser to an absolute path on disk
-  // like for node_modules/ resolution. not commonly needed by most resource plugins
-  // return true | false
-  async shouldResolve(url) {
-    return Promise.resolve(false);
-  }
+  // lifecycles go here
+}
 
-  // return an absolute path
-  async resolve(url) {
-    return Promise.resolve(url);
+export function myResourcePlugin(options = {}) {
+  return {
+    type: 'resource',
+    name: 'my-resource-plugin',
+    provider: (compilation) => new ExampleResource(compilation, options)
   }
+};
+```
 
-  // test if this plugin should be used to process a given url / header for the browser
-  // ex: `<script type="module" src="index.ts">`
-  // return true | false
-  async shouldServe(url, headers) {
-    return Promise.resolve(this.extensions.indexOf(path.extname(url)) >= 0);
-  }
+### Lifecycles
+A resource in Greenwood has access to four lifecycles, in this order:
+1. `resolve`
+1. `serve`
+1. `intercept`
+1. `optimize` (only runs at build time)
 
-  // return the new body and / or contentType, e.g. convert file.foo -> file.js
-  async serve(url, headers) {
-    return Promise.resolve({});
-  }
+Each lifecycle also supports a predicate like function, e.g. `shouldResolve` that returns a boolean of `true|false` if this plugin's lifecycle should be invoked for this resource.  You can think of these lifecycles effectively as middleware.
 
-  // test if this plugin should return a new body for an already resolved resource
-  // useful for modifying code on the fly without needing to read the file from disk
-  // return true | false
-  async shouldIntercept(url, body, headers) {
-    return Promise.resolve(false);
-  }
+#### Resolve
 
-  // return the new body
-  async intercept(url, body, headers) {
-    return Promise.resolve({ body, contentType: 'text/...' });
-  }
+When requesting a file, such as `/main.js`, Greenwood needs to know _where_ this resource is located.  This is the first lifecycle that is run and takes in a `URL` and `Request` as parameters, and should return an of a `Request` object.  Below is an example from [Greenwood's codebase](https://github.com/ProjectEvergreen/greenwood/blob/master/packages/cli/src/plugins/resource/plugin-user-workspace.js).
 
-  // test if this plugin should manipulate the body and return a new body prior to any final optimizations happening
-  // ex: add a "banner" to all .js files with a timestamp of the build, or minifying files
-  // return true | false
-  async shouldOptimize(url, body) {
-    return Promise.resolve(false);
-  }
+<!-- eslint-disable no-unused-vars -->
+```js
+import fs from 'fs';
+import { ResourceInterface } from '@greenwood/cli/src/lib/resource-interface.js';
+
+class UserWorkspaceResource extends ResourceInterface {
+  async shouldResolve(url, request) {
+    const { pathname } = url;
+    const { userWorkspace } = this.compilation.context;
+    const hasExtension = !['', '/'].includes(pathname.split('.').pop());
 
-  // return the new body
-  async optimize (url, body) {
-    return Promise.resolve(body);
+    return hasExtension
+      && !pathname.startsWith('/node_modules')
+      && fs.existsSync(new URL(`.${pathname}`, userWorkspace).pathname);
   }
-}
 
-export function myResourcePlugin(options = {}) {
-  return {
-    type: 'resource',
-    name: 'plugin-example',
-    provider: (compilation) => new ExampleResource(compilation, options)
+  async resolve(url, request) {
+    const { pathname } = url;
+    const { userWorkspace } = this.compilation.context;
+    const workspaceUrl = new URL(`.${pathname}`, userWorkspace);
+
+    return new Request(workspaceUrl);
   }
-};
+}
 ```
+<!-- eslint-enable no-unused-vars -->
 
-## Example
-Below is an example of turning files that have a _.foo_ extension into JavaScript.
+> For most cases, you will not need to use this lifecycle as by default Greenwood will first check if it can resolve a request to a file either in the current workspace or _/node_modules/_.  If it finds a match, it will transform the request into a `file://` protocol with the full local path, otherwise the request will remain as the default of `http://`.
+
+#### Serve
+
+When requesting a file, such as `/main.js`, Greenwood needs to return a response so that the contents can be served or bundled appropriately.  This is done by passing an instance of `URL` and `Request` and returning an instance of `Response`.  For example, Greenwood uses this lifecycle extensively to serve all the standard web content types like HTML, JS, CSS, images, fonts, etc and also providing the appropriate `Content-Type` header.  If you are supporting custom extensions, this is where you would transform the contents into something a browser would understand; like compiling from TypeScript to JavaScript.
+
+Below is an example from [Greenwood's codebase](https://github.com/ProjectEvergreen/greenwood/blob/master/packages/cli/src/plugins/resource/plugin-standard-javascript.js) for serving JavaScript files.
 
 <!-- eslint-disable no-unused-vars -->
 ```js
-// file.foo
-interface User {
-  id: number
-  firstName: string
-  lastName: string
-  role: string
-}
+import fs from 'fs';
+import { ResourceInterface } from '@greenwood/cli/src/lib/resource-interface.js';
+
+class StandardJavaScriptResource extends ResourceInterface {
+
+  async shouldServe(url, request) {
+    return url.protocol === 'file:' && url.pathname.split('.').pop() === 'js';
+  }
 
-console.log('hello from file.foo with non standard JavaScript in it.');
+  async serve(url, request) {
+    const body = await fs.promises.readFile(url, 'utf-8');
+    
+    return new Response(body, {
+      headers: {
+        'Content-Type': 'text/javascript'
+      }
+    });
+  }
+}
 ```
+<!-- eslint-enable no-unused-vars -->
+
+> If this was for a TypeScript file (_.ts_) for example, this would be the lifecycle where you would run `tsc`.
+
+#### Intercept
+
+After the `serve` lifecycle comes the `intercept` lifecycle.  This lifecycle is useful for transforming an already handled resource, or to in anyway augment an already handled response before it is served or bundle.  This can be done by returning an instance of a `Response`.  It takes in as parameters an instance of `URL`, `Request`, and `Response`.
 
+Below is an example from [Greenwood's codebase](https://github.com/ProjectEvergreen/greenwood/blob/master/packages/plugin-import-css/src/index.js) for converting a standard CSS file response into ESM so that you can `import` _.css_ files.  You'll see in this example we're return a module instead of just a CSS string, and changing the `Content-Type` of the response to `text/javascript`.
+
+<!-- eslint-disable no-unused-vars -->
 ```js
-// plugin-foo.js
-import fs from 'fs';
 import { ResourceInterface } from '@greenwood/cli/src/lib/resource-interface.js';
 
-class FooResource extends ResourceInterface {
+class ImportCssResource extends ResourceInterface {
   constructor(compilation, options) {
     super(compilation, options);
+  }
 
-    this.extensions = ['.foo'];
-    this.contentType = 'text/javascript';
+  // ...
+
+  async shouldIntercept(url, request, response) {
+    const { pathname } = url;
+    const accepts = request.headers.get('accept') || '';
+    const notFromBrowser = accepts.indexOf('text/css') < 0 && accepts.indexOf('application/signed-exchange') < 0;
+
+    // https://github.com/ProjectEvergreen/greenwood/issues/492
+    return pathname.split('.').pop() === 'css' && 
+      (notFromBrowser || url.searchParams.has('type') && url.searchParams.get('type') === 'css');
   }
 
-  async serve(url) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        let body = await fs.promises.readFile(url, 'utf-8');
-
-        // remove non standard JavaScript usage so browser is happy
-        body = body.replace(/interface (.*){(.*)}/s, '');
-
-        // and we can return .foo as .js!
-        resolve({
-          body,
-          contentType: this.contentType
-        });
-      } catch (e) {
-        reject(e);
-      }
+  async intercept(url, request, response) {
+    const body = await response.text();
+    const cssInJsBody = `const css = \`${body.replace(/\r?\n|\r/g, ' ').replace(/\\/g, '\\\\')}\`;\nexport default css;`;
+    
+    return new Response(cssInJsBody, {
+      headers: new Headers({
+        'Content-Type': 'text/javascript'
+      })
     });
   }
 }
-
-export function myFooPlugin(options = {}) {
-  return {
-    type: 'resource',
-    name: 'plugin-foo',
-    provider: (compilation) => new FooResource(compilation, options)
-  };
-}
 ```
+<!-- eslint-enable no-unused-vars -->
 
-```js
-// greenwood.config.js
-import { myFooPlugin } from './plugin-foo.js';
+#### Optimize
 
-export default {
+This lifecycle is only run during a build and after the `intercept` lifecycle, and as the name implies is a way to do any final production ready optimizations or transformations. It takes as parameters an instance of `URL` and `Response` and should return an instance of `Response`.
 
-  plugins: [
-    myFooPlugin({ /* custom options */ })
-  ]
+Below is an example from [Greenwood's codebase](https://github.com/ProjectEvergreen/greenwood/blob/master/packages/plugin-import-css/src/index.js) for minifying CSS.  (The actual function for minifying has been ommitted for brevity)
 
-};
+<!-- eslint-disable no-unused-vars -->
+```js
+class StandardCssResource extends ResourceInterface {
+  async shouldOptimize(url, response) {
+    const { protocol, pathname } = url;
+
+    return this.compilation.config.optimization !== 'none'
+      && protocol === 'file:'
+      && pathname.split('.').pop() === 'css'
+      && response.headers.get('Content-Type').indexOf('text/css') >= 0;
+  }
+
+  async optimize(url, response) {
+    const body = await response.text();
+    const optimizedBody = bundleCss(body /* ... */);
+
+    return new Response(optimizedBody);
+  }
+}
 ```
+<!-- eslint-enable no-unused-vars -->
 
 > _You can see [more in-depth examples of resource plugin](https://github.com/ProjectEvergreen/greenwood/tree/master/packages/cli/src/plugins/resource/) by reviewing the default plugins maintained in Greenwood's CLI package._
\ No newline at end of file
diff --git a/www/pages/plugins/rollup.md b/www/pages/plugins/rollup.md
index 71a832a50..2e82d1643 100644
--- a/www/pages/plugins/rollup.md
+++ b/www/pages/plugins/rollup.md
@@ -13,7 +13,7 @@ Though rare, there may be cases and opportunities for tapping into the bundling
 Install your favorite rollup plugin(s), then create a simple object to provide those plugins to Greenwood.
 
 ```javascript
-import bannerRollup = from 'rollup-plugin-banner';
+import bannerRollup from 'rollup-plugin-banner';
 import fs from 'fs';
 
 const packageJson = JSON.parse(fs.readFileSync('./package.json', 'utf-8'));