@eighty4/dank 0.0.4-2 → 0.0.4-3

package/lib_js/html.js

@@ -1,14 +1,14 @@
 import EventEmitter from "node:events";
 import { readFile } from "node:fs/promises";
-import { dirname, join, relative } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { extname } from "node:path/posix";
 import { defaultTreeAdapter, parse, parseFragment, serialize } from "parse5";
+import { DankError } from "./errors.js";
 class HtmlEntrypoint extends EventEmitter {
-  #build;
-  #decorations;
+  #c;
+  #clientJS;
   #document = defaultTreeAdapter.createDocument();
-  // todo cache entrypoints set for quicker diffing
-  // #entrypoints: Set<string> = new Set()
+  #entrypoints = /* @__PURE__ */ new Set();
   // path within pages dir omitting pages/ segment
   #fsPath;
   #partials = [];
@@ -16,15 +16,14 @@ class HtmlEntrypoint extends EventEmitter {
   #scripts = [];
   #update = Object();
   #url;
-  constructor(build, resolver, url, fsPath, decorations) {
+  constructor(c, resolver, url, fsPath) {
     super({ captureRejections: true });
-    this.#build = build;
+    this.#c = c;
+    this.#clientJS = ClientJS.initialize(c);
     this.#resolver = resolver;
-    this.#decorations = decorations;
     this.#url = url;
     this.#fsPath = fsPath;
     this.on("change", this.#onChange);
-    this.emit("change");
   }
   get fsPath() {
     return this.#fsPath;
@@ -32,46 +31,103 @@ class HtmlEntrypoint extends EventEmitter {
   get url() {
     return this.#url;
   }
-  async #html() {
+  async process() {
+    await this.#onChange();
+  }
+  output(hrefs) {
+    this.#injectPartials();
+    this.#rewriteHrefs(hrefs);
+    return serialize(this.#document);
+  }
+  usesPartial(fsPath) {
+    return this.#partials.some((partial) => partial.fsPath === fsPath);
+  }
+  #onChange = async () => {
+    const update = this.#update = Object();
+    let html;
     try {
-      return await readFile(join(this.#build.dirs.pages, this.#fsPath), "utf8");
+      html = await this.#readFromPages(this.#fsPath);
     } catch (e) {
-      errorExit(this.#fsPath + " does not exist");
+      this.#error(`url \`${this.#url}\` html file \`${join(this.#c.dirs.pages, this.#fsPath)}\` does not exist`);
+      return;
     }
-  }
-  // todo if partial changes, hot swap content in page
-  #onChange = async (_partial) => {
-    const update = this.#update = Object();
-    const html = await this.#html();
     const document = parse(html);
     const imports = {
       partials: [],
       scripts: []
     };
+    let partials;
     this.#collectImports(document, imports);
-    const partials = await this.#resolvePartialContent(imports.partials);
+    const partialResults = await this.#resolvePartialContent(imports.partials);
+    partials = partialResults.filter((p) => p !== false);
+    if (partials.length !== partialResults.length) {
+      this.#error(`update to \`${join(this.#c.dirs.pages, this.#fsPath)}\` did not update to \`${this.#url}\` because of unresolved partials`);
+      return;
+    }
+    if (this.#clientJS !== null) {
+      const decoration = await this.#clientJS.retrieve(this.#c.esbuildPort);
+      this.#addScriptDecoration(document, decoration.js);
+    }
     if (update !== this.#update) {
       return;
     }
-    this.#addDecorations(document);
-    this.#update = update;
     this.#document = document;
     this.#partials = partials;
     this.#scripts = imports.scripts;
     const entrypoints = mergeEntrypoints(imports, ...partials.map((p) => p.imports));
-    this.emit("entrypoints", entrypoints);
-    this.emit("partials", this.#partials.map((p) => p.fsPath));
+    if (this.#haveEntrypointsChanged(entrypoints)) {
+      this.emit("entrypoints", entrypoints);
+    }
     if (this.listenerCount("output")) {
       this.emit("output", this.output());
     }
   };
-  // Emits `partial` on detecting a partial reference for `dank serve` file watches
-  // to respond to dependent changes
-  // todo safeguard recursive partials that cause circular imports
+  #error(e) {
+    let message;
+    let error;
+    if (typeof e === "string") {
+      message = e;
+      error = new DankError(e);
+    } else {
+      message = e.message;
+      error = e;
+    }
+    if (this.listenerCount("error")) {
+      this.emit("error", error);
+    } else {
+      throw error;
+    }
+  }
+  #haveEntrypointsChanged(entrypoints) {
+    const set = new Set(entrypoints.map((entrypoint) => entrypoint.in));
+    const changed = set.symmetricDifference(this.#entrypoints).size > 0;
+    this.#entrypoints = set;
+    return changed;
+  }
+  async #readFromPages(p) {
+    return await readFile(this.#resolver.absPagesPath(p), "utf8");
+  }
   async #resolvePartialContent(partials) {
     return await Promise.all(partials.map(async (p) => {
-      this.emit("partial", p.fsPath);
-      const html = await readFile(join(this.#build.dirs.pages, p.fsPath), "utf8");
+      let html;
+      if (isAbsolute(p.specifier)) {
+        this.#error(`partials cannot be referenced with an absolute path like \`${p.specifier}\` in webpage \`${join(this.#c.dirs.pages, this.#fsPath)}\``);
+        return false;
+      }
+      if (!this.#resolver.isPagesSubpathInPagesDir(p.fsPath)) {
+        this.#error(`partials cannot be referenced from outside the pages dir like \`${p.specifier}\` in webpage \`${join(this.#c.dirs.pages, this.#fsPath)}\``);
+        return false;
+      }
+      if (extname(p.fsPath) !== ".html") {
+        this.#error(`partial path \`${p.fsPath}\` referenced by \`${this.#fsPath}\` is not a valid partial path`);
+        return false;
+      }
+      try {
+        html = await this.#readFromPages(p.fsPath);
+      } catch (e) {
+        this.#error(`partial \`${join("pages", p.fsPath)}\` imported by \`${join("pages", this.#fsPath)}\` does not exist`);
+        return false;
+      }
       const fragment = parseFragment(html);
       const imports = {
         partials: [],
@@ -81,7 +137,7 @@ class HtmlEntrypoint extends EventEmitter {
         this.#rewritePartialRelativePaths(node, p.fsPath);
       });
       if (imports.partials.length) {
-        errorExit(`partial ${p.fsPath} cannot recursively import partials`);
+        this.#error(`partials cannot import another partial like \`${join(this.#c.dirs.pages, p.fsPath)}\``);
       }
       const content = {
         ...p,
@@ -106,25 +162,11 @@ class HtmlEntrypoint extends EventEmitter {
       }
     }
   }
-  #addDecorations(document) {
-    if (!this.#decorations?.length) {
-      return;
-    }
-    for (const decoration of this.#decorations) {
-      switch (decoration.type) {
-        case "script":
-          const scriptNode = parseFragment(`<script type="module">${decoration.js}</script>`).childNodes[0];
-          const htmlNode = document.childNodes.find((node) => node.nodeName === "html");
-          const headNode = htmlNode.childNodes.find((node) => node.nodeName === "head");
-          defaultTreeAdapter.appendChild(headNode || htmlNode, scriptNode);
-          break;
-      }
-    }
-  }
-  output(hrefs) {
-    this.#injectPartials();
-    this.#rewriteHrefs(hrefs);
-    return serialize(this.#document);
+  #addScriptDecoration(document, js) {
+    const scriptNode = parseFragment(`<script type="module">${js}</script>`).childNodes[0];
+    const htmlNode = document.childNodes.find((node) => node.nodeName === "html");
+    const headNode = htmlNode.childNodes.find((node) => node.nodeName === "head");
+    defaultTreeAdapter.appendChild(headNode || htmlNode, scriptNode);
   }
   // rewrites hrefs to content hashed urls
   // call without hrefs to rewrite tsx? ext to js
@@ -136,13 +178,13 @@ class HtmlEntrypoint extends EventEmitter {
   }
   async #injectPartials() {
     for (const { commentNode, fragment } of this.#partials) {
-      if (!this.#build.production) {
+      if (!this.#c.flags.production) {
         defaultTreeAdapter.insertBefore(commentNode.parentNode, defaultTreeAdapter.createCommentNode(commentNode.data), commentNode);
       }
       for (const node of fragment.childNodes) {
         defaultTreeAdapter.insertBefore(commentNode.parentNode, node, commentNode);
       }
-      if (this.#build.production) {
+      if (this.#c.flags.production) {
         defaultTreeAdapter.detachNode(commentNode);
       }
     }
@@ -155,17 +197,11 @@ class HtmlEntrypoint extends EventEmitter {
       if (childNode.nodeName === "#comment" && "data" in childNode) {
         const partialMatch = childNode.data.match(/\{\{(?<pp>.+)\}\}/);
         if (partialMatch) {
-          const partialSpecifier = partialMatch.groups.pp.trim();
-          if (partialSpecifier.startsWith("/")) {
-            errorExit(`partial ${partialSpecifier} in webpage ${this.#fsPath} cannot be an absolute path`);
-          }
-          const partialPath = join(dirname(this.#fsPath), partialSpecifier);
-          if (!this.#resolver.isPagesSubpathInPagesDir(partialPath)) {
-            errorExit(`partial ${partialSpecifier} in webpage ${this.#fsPath} cannot be outside of the pages directory`);
-          }
+          const specifier = partialMatch.groups.pp.trim();
           collection.partials.push({
-            fsPath: partialPath,
-            commentNode: childNode
+            commentNode: childNode,
+            fsPath: join(dirname(this.#fsPath), specifier),
+            specifier
           });
         }
       } else if (childNode.nodeName === "script") {
@@ -184,9 +220,9 @@ class HtmlEntrypoint extends EventEmitter {
     }
   }
   #parseImport(type, href, elem) {
-    const inPath = join(this.#build.dirs.pages, dirname(this.#fsPath), href);
+    const inPath = join(this.#c.dirs.pages, dirname(this.#fsPath), href);
     if (!this.#resolver.isProjectSubpathInPagesDir(inPath)) {
-      errorExit(`href ${href} in webpage ${this.#fsPath} cannot reference sources outside of the pages directory`);
+      throw new DankError(`href \`${href}\` in webpage \`${join(this.#c.dirs.pages, this.#fsPath)}\` cannot reference sources outside of the pages directory`);
     }
     let outPath = join(dirname(this.#fsPath), href);
     if (type === "script" && !outPath.endsWith(".js")) {
@@ -230,9 +266,36 @@ function rewriteHrefs(scripts, hrefs) {
     }
   }
 }
-function errorExit(msg) {
-  console.log(`\x1B[31merror:\x1B[0m`, msg);
-  process.exit(1);
+class ClientJS {
+  static #instance = null;
+  static initialize(c) {
+    if (c.mode === "build" || c.flags.preview) {
+      return null;
+    } else if (!ClientJS.#instance) {
+      ClientJS.#instance = new ClientJS(c.esbuildPort);
+    }
+    return ClientJS.#instance;
+  }
+  #esbuildPort;
+  #read;
+  #result;
+  constructor(esbuildPort) {
+    this.#esbuildPort = esbuildPort;
+    this.#read = readFile(resolve(import.meta.dirname, join("..", "client", "client.js")), "utf-8");
+    this.#result = this.#read.then(this.#transform);
+  }
+  async retrieve(esbuildPort) {
+    if (esbuildPort !== this.#esbuildPort) {
+      this.#result = this.#read.then(this.#transform);
+    }
+    return await this.#result;
+  }
+  #transform = (js) => {
+    return {
+      type: "script",
+      js: js.replace("3995", "" + this.#esbuildPort)
+    };
+  };
 }
 export {
   HtmlEntrypoint

package/lib_js/http.js

@@ -4,23 +4,23 @@ import { createServer } from "node:http";
 import { extname, join } from "node:path";
 import { Readable } from "node:stream";
 import mime from "mime";
-function startWebServer(serve, frontendFetcher, httpServices, pageRoutes) {
-  const serverAddress = "http://localhost:" + serve.dankPort;
+function startWebServer(port, flags, dirs, urlRewriteProvider, frontendFetcher, httpServices) {
+  const serverAddress = "http://localhost:" + port;
   const handler = (req, res) => {
     if (!req.url || !req.method) {
       res.end();
     } else {
       const url = new URL(serverAddress + req.url);
       const headers = convertHeadersToFetch(req.headers);
-      frontendFetcher(url, headers, res, () => onNotFound(req, url, headers, httpServices, pageRoutes, serve, res));
+      frontendFetcher(url, headers, res, () => onNotFound(req, url, headers, httpServices, flags, dirs, urlRewriteProvider, res));
     }
   };
-  createServer(serve.logHttp ? createLogWrapper(handler) : handler).listen(serve.dankPort);
-  console.log(serve.preview ? "preview" : "dev", `server is live at http://127.0.0.1:${serve.dankPort}`);
+  createServer(flags.logHttp ? createLogWrapper(handler) : handler).listen(port);
+  console.log(flags.preview ? "preview" : "dev", `server is live at http://127.0.0.1:${port}`);
 }
-async function onNotFound(req, url, headers, httpServices, pageRoutes, serve, res) {
+async function onNotFound(req, url, headers, httpServices, flags, dirs, urlRewriteProvider, res) {
   if (req.method === "GET" && extname(url.pathname) === "") {
-    const urlRewrite = tryUrlRewrites(url, pageRoutes, serve);
+    const urlRewrite = tryUrlRewrites(flags, dirs, urlRewriteProvider.urlRewrites, url);
     if (urlRewrite) {
       streamFile(urlRewrite, res);
       return;
@@ -42,9 +42,9 @@ async function sendFetchResponse(res, fetchResponse) {
     res.end();
   }
 }
-function tryUrlRewrites(url, pageRoutes, serve) {
-  const urlRewrite = pageRoutes.urlRewrites.find((urlRewrite2) => urlRewrite2.pattern.test(url.pathname));
-  return urlRewrite ? join(serve.dirs.buildWatch, urlRewrite.url, "index.html") : null;
+function tryUrlRewrites(flags, dirs, urlRewrites, url) {
+  const urlRewrite = urlRewrites.find((urlRewrite2) => urlRewrite2.pattern.test(url.pathname));
+  return urlRewrite ? join(flags.preview ? dirs.buildDist : dirs.buildWatch, urlRewrite.url, "index.html") : null;
 }
 async function tryHttpServices(req, url, headers, httpServices) {
   if (url.pathname.startsWith("/.well-known/")) {
@@ -91,24 +91,24 @@ function createLogWrapper(handler) {
     handler(req, res);
   };
 }
-function createBuiltDistFilesFetcher(dir, manifest) {
+function createBuiltDistFilesFetcher(dirs, manifest) {
   return (url, _headers, res, notFound) => {
     if (manifest.pageUrls.has(url.pathname)) {
-      streamFile(join(dir, url.pathname, "index.html"), res);
+      streamFile(join(dirs.projectResolved, dirs.buildDist, url.pathname, "index.html"), res);
     } else if (manifest.files.has(url.pathname)) {
-      streamFile(join(dir, url.pathname), res);
+      streamFile(join(dirs.projectResolved, dirs.buildDist, url.pathname), res);
     } else {
       notFound();
     }
   };
 }
-function createDevServeFilesFetcher(pageRoutes, serve) {
-  const proxyAddress = "http://127.0.0.1:" + serve.esbuildPort;
+function createDevServeFilesFetcher(esbuildPort, dirs, registry) {
+  const proxyAddress = "http://127.0.0.1:" + esbuildPort;
   return (url, _headers, res, notFound) => {
-    if (pageRoutes.urls.includes(url.pathname)) {
-      streamFile(join(serve.dirs.buildWatch, url.pathname, "index.html"), res);
+    if (registry.pageUrls.includes(url.pathname)) {
+      streamFile(join(dirs.buildWatch, url.pathname, "index.html"), res);
     } else {
-      const maybePublicPath = join(serve.dirs.public, url.pathname);
+      const maybePublicPath = join(dirs.public, url.pathname);
       exists(maybePublicPath).then((fromPublic) => {
         if (fromPublic) {
           streamFile(maybePublicPath, res);

package/lib_js/public.js

@@ -1,12 +1,12 @@
 import { copyFile, mkdir, readdir, stat } from "node:fs/promises";
 import { platform } from "node:os";
 import { join } from "node:path";
-async function copyAssets(build) {
+async function copyAssets(dirs) {
   try {
-    const stats = await stat(build.dirs.public);
+    const stats = await stat(dirs.public);
     if (stats.isDirectory()) {
-      await mkdir(build.dirs.buildDist, { recursive: true });
-      return await recursiveCopyAssets(build);
+      await mkdir(dirs.buildDist, { recursive: true });
+      return await recursiveCopyAssets(dirs);
     } else {
       throw Error("./public cannot be a file");
     }
@@ -15,11 +15,11 @@ async function copyAssets(build) {
   }
 }
 const IGNORE = platform() === "darwin" ? [".DS_Store"] : [];
-async function recursiveCopyAssets(build, dir = "") {
+async function recursiveCopyAssets(dirs, dir = "") {
   const copied = [];
-  const to = join(build.dirs.buildDist, dir);
+  const to = join(dirs.buildDist, dir);
   let madeDir = dir === "";
-  const listingDir = join(build.dirs.public, dir);
+  const listingDir = join(dirs.public, dir);
   for (const p of await readdir(listingDir)) {
     if (IGNORE.includes(p)) {
       continue;
@@ -27,10 +27,10 @@ async function recursiveCopyAssets(build, dir = "") {
     try {
       const stats = await stat(join(listingDir, p));
       if (stats.isDirectory()) {
-        copied.push(...await recursiveCopyAssets(build, join(dir, p)));
+        copied.push(...await recursiveCopyAssets(dirs, join(dir, p)));
       } else {
         if (!madeDir) {
-          await mkdir(join(build.dirs.buildDist, dir), {
+          await mkdir(join(dirs.buildDist, dir), {
             recursive: true
           });
           madeDir = true;

package/lib_js/{metadata.js → registry.js}

@@ -1,64 +1,85 @@
 import EventEmitter from "node:events";
 import { writeFile } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
-class ResolverImpl {
-  #dirs;
-  constructor(dirs) {
-    this.#dirs = dirs;
-  }
-  isProjectSubpathInPagesDir(p) {
-    return resolve(join(this.#dirs.projectResolved, p)).startsWith(this.#dirs.pagesResolved);
-  }
-  isPagesSubpathInPagesDir(p) {
-    return this.isProjectSubpathInPagesDir(join(this.#dirs.pages, p));
-  }
-  resolveHrefInPagesDir(from, href) {
-    const p = join(dirname(from), href);
-    if (this.isProjectSubpathInPagesDir(p)) {
-      return p;
-    } else {
-      return "outofbounds";
-    }
-  }
-}
+import { join } from "node:path";
+import { Resolver } from "./dirs.js";
+import { HtmlEntrypoint } from "./html.js";
 class WebsiteRegistry extends EventEmitter {
-  #build;
-  // paths of bundled esbuild outputs
+  // paths of bundled esbuild outputs, as built by esbuild
   #bundles = /* @__PURE__ */ new Set();
+  #c;
   // public dir assets
   #copiedAssets = null;
   // map of entrypoints to their output path
   #entrypointHrefs = {};
-  #pageUrls = [];
+  #pages = {};
   #resolver;
   #workers = null;
-  constructor(build) {
+  constructor(config) {
     super();
-    this.#build = build;
-    this.#resolver = new ResolverImpl(build.dirs);
+    this.#c = config;
+    this.#resolver = new Resolver(config.dirs);
+  }
+  get config() {
+    return this.#c;
   }
   set copiedAssets(copiedAssets) {
     this.#copiedAssets = copiedAssets === null ? null : new Set(copiedAssets);
   }
-  set pageUrls(pageUrls) {
-    this.#pageUrls = pageUrls;
+  get htmlEntrypoints() {
+    return Object.values(this.#pages).map((p) => p.html);
+  }
+  get pageUrls() {
+    return Object.keys(this.#pages);
   }
   get resolver() {
     return this.#resolver;
   }
-  // bundleOutputs(type?: 'css' | 'js'): Array<string> {
-  //     if (!type) {
-  //         return Array.from(this.#bundles)
-  //     } else {
-  //         return Array.from(this.#bundles).filter(p => p.endsWith(type))
-  //     }
-  // }
+  get urlRewrites() {
+    return Object.values(this.#pages).filter((pr) => typeof pr.urlRewrite !== "undefined").map((pr) => pr.urlRewrite);
+  }
+  get webpageEntryPoints() {
+    const unique = /* @__PURE__ */ new Set();
+    return Object.values(this.#pages).flatMap((p) => p.bundles).filter((entryPoint) => {
+      if (unique.has(entryPoint.in)) {
+        return false;
+      } else {
+        unique.add(entryPoint.in);
+        return true;
+      }
+    });
+  }
+  get webpageAndWorkerEntryPoints() {
+    const unique = /* @__PURE__ */ new Set();
+    const pageBundles = Object.values(this.#pages).flatMap((p) => p.bundles);
+    const workerBundles = this.workerEntryPoints;
+    const bundles = workerBundles ? [...pageBundles, ...workerBundles] : pageBundles;
+    return bundles.filter((entryPoint) => {
+      if (unique.has(entryPoint.in)) {
+        return false;
+      } else {
+        unique.add(entryPoint.in);
+        return true;
+      }
+    });
+  }
+  get workerEntryPoints() {
+    return this.#workers?.map(({ workerEntryPoint }) => ({
+      in: workerEntryPoint,
+      out: workerEntryPoint.replace(/^pages[\//]/, "").replace(/\.(mj|t)s$/, ".js")
+    })) || null;
+  }
+  get workers() {
+    return this.#workers;
+  }
   buildRegistry() {
-    return new BuildRegistry(this.#build, this.#onBuildManifest);
+    return new BuildRegistry(this.#c.dirs, this.#resolver, this.#onBuildManifest);
+  }
+  configSync() {
+    this.#configDiff();
   }
   files() {
     const files = /* @__PURE__ */ new Set();
-    for (const pageUrl of this.#pageUrls)
+    for (const pageUrl of Object.keys(this.#pages))
       files.add(pageUrl === "/" ? "/index.html" : `${pageUrl}/index.html`);
     for (const f of this.#bundles)
       files.add(f);
@@ -75,29 +96,69 @@ class WebsiteRegistry extends EventEmitter {
       throw Error(`mapped href for ${lookup} not found`);
     }
   }
-  workerEntryPoints() {
-    return this.#workers?.map(({ workerEntryPoint }) => ({
-      in: workerEntryPoint,
-      out: workerEntryPoint.replace(/^pages[\//]/, "").replace(/\.(mj|t)s$/, ".js")
-    })) || null;
-  }
-  workers() {
-    return this.#workers;
-  }
   async writeManifest(buildTag) {
     const manifest = this.#manifest(buildTag);
-    await writeFile(join(this.#build.dirs.projectRootAbs, this.#build.dirs.buildRoot, "website.json"), JSON.stringify({
+    await writeFile(join(this.#c.dirs.projectRootAbs, this.#c.dirs.buildRoot, "website.json"), JSON.stringify({
       buildTag,
       files: Array.from(manifest.files),
       pageUrls: Array.from(manifest.pageUrls)
     }, null, 4));
     return manifest;
   }
+  #configDiff() {
+    const updatePages = this.#c.devPages ? { ...this.#c.pages, ...this.#c.devPages } : { ...this.#c.pages };
+    const prevPages = new Set(Object.keys(this.#pages));
+    for (const [urlPath, mapping] of Object.entries(updatePages)) {
+      const existingPage = prevPages.delete(urlPath);
+      if (existingPage) {
+        this.#configPageUpdate(urlPath, mapping);
+      } else {
+        this.#configPageAdd(urlPath, mapping);
+      }
+    }
+    for (const prevPage of prevPages) {
+      this.#configPageRemove(prevPage);
+    }
+  }
+  #configPageAdd(urlPath, mapping) {
+    const html = new HtmlEntrypoint(this.#c, this.#resolver, urlPath, mapping.webpage);
+    const urlRewrite = mapping.pattern ? { pattern: mapping.pattern, url: urlPath } : void 0;
+    this.#pages[urlPath] = {
+      pageUrl: urlPath,
+      fsPath: mapping.webpage,
+      html,
+      urlRewrite,
+      bundles: []
+    };
+    html.on("entrypoints", (entrypoints) => this.#setWebpageBundles(html.url, entrypoints));
+    this.emit("webpage", html);
+  }
+  #configPageUpdate(urlPath, mapping) {
+    const existingRegistration = this.#pages[urlPath];
+    if (existingRegistration.fsPath !== mapping.webpage) {
+      this.#configPageRemove(urlPath);
+      this.#configPageAdd(urlPath, mapping);
+    } else if (existingRegistration.urlRewrite?.pattern.source !== mapping.pattern?.source) {
+      if (mapping.pattern) {
+        existingRegistration.urlRewrite = {
+          url: urlPath,
+          pattern: mapping.pattern
+        };
+      } else {
+        existingRegistration.urlRewrite = void 0;
+      }
+    }
+  }
+  #configPageRemove(urlPath) {
+    const registration = this.#pages[urlPath];
+    registration.html.removeAllListeners();
+    delete this.#pages[urlPath];
+  }
   #manifest(buildTag) {
     return {
       buildTag,
       files: this.files(),
-      pageUrls: new Set(this.#pageUrls)
+      pageUrls: new Set(Object.keys(this.#pages))
     };
   }
   #onBuildManifest = (build) => {
@@ -136,14 +197,23 @@ class WebsiteRegistry extends EventEmitter {
       this.emit("workers");
     }
   };
+  #setWebpageBundles(url, bundles) {
+    this.#pages[url].bundles = bundles;
+    this.emit("entrypoints");
+  }
 }
 class BuildRegistry {
+  #dirs;
   #onComplete;
   #resolver;
   #workers = null;
-  constructor(build, onComplete) {
+  constructor(dirs, resolver, onComplete) {
+    this.#dirs = dirs;
     this.#onComplete = onComplete;
-    this.#resolver = new ResolverImpl(build.dirs);
+    this.#resolver = resolver;
+  }
+  get dirs() {
+    return this.#dirs;
   }
   get resolver() {
     return this.#resolver;