@emkodev/emroute 1.7.3 → 1.8.0-beta.2

package/runtime/abstract.runtime.ts

@@ -1,7 +1,7 @@
-import type { RouteNode, RouteFiles } from '../src/type/route-tree.type.ts';
-import { resolveTargetNode } from '../src/route/route-tree.util.ts';
-import type { WidgetManifestEntry } from '../src/type/widget.type.ts';
-import type { ElementManifestEntry } from '../src/type/element.type.ts';
+import type { RouteNode, RouteFiles } from '../core/type/route-tree.type.ts';
+import { resolveTargetNode } from '../core/util/route-tree.util.ts';
+import type { WidgetManifestEntry } from '../core/type/widget.type.ts';
+import type { ElementManifestEntry } from '../core/type/element.type.ts';
 
 export const CONTENT_TYPES: Map<string, string> = new Map<string, string>([
   ['.html', 'text/html; charset=utf-8'],
@@ -33,9 +33,12 @@ export type FetchReturn = ReturnType<typeof fetch>;
 export const DEFAULT_ROUTES_DIR = '/routes';
 export const DEFAULT_WIDGETS_DIR = '/widgets';
 export const DEFAULT_ELEMENTS_DIR = '/elements';
-export const ROUTES_MANIFEST_PATH = '/routes.manifest.json';
-export const WIDGETS_MANIFEST_PATH = '/widgets.manifest.json';
-export const ELEMENTS_MANIFEST_PATH = '/elements.manifest.json';
+import {
+  ROUTES_MANIFEST_PATH,
+  WIDGETS_MANIFEST_PATH,
+  ELEMENTS_MANIFEST_PATH,
+} from '../core/runtime/abstract.runtime.ts';
+export { ROUTES_MANIFEST_PATH, WIDGETS_MANIFEST_PATH, ELEMENTS_MANIFEST_PATH };
 
 export interface RuntimeConfig {
   routesDir?: string;
@@ -76,16 +79,47 @@ export abstract class Runtime {
     options?: FetchParams[1],
   ): FetchReturn;
 
-  /** Write. Defaults to PUT; pass `{ method: "DELETE" }` etc. to override. */
+  /** Write or delete. Defaults to PUT; pass `{ method: "DELETE" }` to remove. */
   command(resource: FetchParams[0], options?: FetchParams[1]): FetchReturn {
     const path = typeof resource === 'string'
       ? resource
       : new URL(resource instanceof Request ? resource.url : resource.toString()).pathname;
-    const result = this.handle(resource, { method: 'PUT', ...options });
+    const method = options?.method ?? 'PUT';
+    const isDelete = method === 'DELETE';
+    const result = this.handle(resource, { method, ...options });
     const routesDir = this.config.routesDir ?? DEFAULT_ROUTES_DIR;
+    const widgetsDir = this.config.widgetsDir ?? DEFAULT_WIDGETS_DIR;
+    const elementsDir = this.config.elementsDir ?? DEFAULT_ELEMENTS_DIR;
     if (path.startsWith(routesDir + '/')) {
       return result.then(async (res) => {
-        await this.mergeRouteIntoManifest(path, routesDir);
+        if (isDelete) {
+          await this.pruneRouteFromManifest(path, routesDir);
+        } else {
+          await this.mergeRouteIntoManifest(path, routesDir);
+          await this.retranspileIfNeeded(path, routesDir, 'route');
+        }
+        return res;
+      });
+    }
+    if (path.startsWith(widgetsDir + '/')) {
+      return result.then(async (res) => {
+        if (isDelete) {
+          await this.pruneWidgetFromManifest(path, widgetsDir);
+        } else {
+          await this.mergeWidgetIntoManifest(path, widgetsDir);
+          await this.retranspileIfNeeded(path, widgetsDir, 'widget');
+        }
+        return res;
+      });
+    }
+    if (path.startsWith(elementsDir + '/')) {
+      return result.then(async (res) => {
+        if (isDelete) {
+          await this.pruneElementFromManifest(path, elementsDir);
+        } else {
+          await this.mergeElementIntoManifest(path, elementsDir);
+          await this.retranspileIfNeeded(path, elementsDir, 'element');
+        }
         return res;
       });
     }
@@ -103,13 +137,15 @@ export abstract class Runtime {
   ): Promise<void> {
     const relativePath = filePath.slice(routesDir.length + 1);
     const parts = relativePath.split('/');
-    const filename = parts[parts.length - 1];
+    const filename = parts[parts.length - 1]!;
     const dirSegments = parts.slice(0, -1);
 
     const match = filename.match(/^(.+?)\.(page|error|redirect)\.(ts|js|html|md|css)$/);
     if (!match) return;
 
-    const [, name, kind, ext] = match;
+    const name = match[1]!;
+    const kind = match[2]!;
+    const ext = match[3]!;
 
     // Read current manifest (or start fresh)
     const response = await this.handle(ROUTES_MANIFEST_PATH);
@@ -127,7 +163,7 @@ export abstract class Runtime {
       } else {
         node.children ??= {};
         node.children[dir] ??= {};
-        node = node.children[dir];
+        node = node.children[dir]!;
       }
     }
 
@@ -152,6 +188,277 @@ export abstract class Runtime {
     });
   }
 
+  /**
+   * Remove a route entry from the stored manifest when a file is deleted.
+   * Walks the tree to find the node, clears the relevant field, then
+   * prunes empty ancestor nodes.
+   */
+  private async pruneRouteFromManifest(
+    filePath: string,
+    routesDir: string,
+  ): Promise<void> {
+    const relativePath = filePath.slice(routesDir.length + 1);
+    const parts = relativePath.split('/');
+    const filename = parts[parts.length - 1]!;
+    const dirSegments = parts.slice(0, -1);
+
+    const match = filename.match(/^(.+?)\.(page|error|redirect)\.(ts|js|html|md|css)$/);
+    if (!match) return;
+
+    const name = match[1]!;
+    const kind = match[2]!;
+    const ext = match[3]! as keyof RouteFiles;
+
+    const response = await this.handle(ROUTES_MANIFEST_PATH);
+    if (response.status === 404) return;
+    const tree: RouteNode = await response.json();
+
+    // Walk to the parent node, tracking path for pruning
+    const ancestors: { node: RouteNode; key: string; via: 'children' | 'dynamic' }[] = [];
+    let node = tree;
+    for (const dir of dirSegments) {
+      if (dir.startsWith('[') && dir.endsWith(']')) {
+        if (!node.dynamic) return;
+        ancestors.push({ node, key: dir, via: 'dynamic' });
+        node = node.dynamic.child;
+      } else {
+        if (!node.children?.[dir]) return;
+        ancestors.push({ node, key: dir, via: 'children' });
+        node = node.children[dir]!;
+      }
+    }
+
+    // Clear the field
+    if (kind === 'error') {
+      if (node.errorBoundary === filePath) delete node.errorBoundary;
+    } else {
+      const isRoot = dirSegments.length === 0;
+      const target = this.findTargetNode(node, name, isRoot);
+      if (!target) return;
+
+      if (kind === 'redirect') {
+        if (target.redirect === filePath) delete target.redirect;
+      } else {
+        if (target.files?.[ext] === filePath) {
+          delete target.files[ext];
+          if (Object.keys(target.files).length === 0) delete target.files;
+        }
+      }
+
+      // If target is a child node and now empty, remove it
+      if (target !== node && this.isEmptyNode(target)) {
+        if (name === 'index' && !isRoot) {
+          delete node.wildcard;
+        } else if (name.startsWith('[') && name.endsWith(']')) {
+          delete node.dynamic;
+        } else if (node.children) {
+          delete node.children[name];
+          if (Object.keys(node.children).length === 0) delete node.children;
+        }
+      }
+    }
+
+    // Prune empty ancestors bottom-up
+    for (let i = ancestors.length - 1; i >= 0; i--) {
+      const { node: parent, key, via } = ancestors[i]!;
+      const child = via === 'dynamic' ? parent.dynamic?.child : parent.children?.[key];
+      if (child && this.isEmptyNode(child)) {
+        if (via === 'dynamic') {
+          delete parent.dynamic;
+        } else if (parent.children) {
+          delete parent.children[key];
+          if (Object.keys(parent.children).length === 0) delete parent.children;
+        }
+      }
+    }
+
+    this.routesManifestCache = null;
+    await this.handle(ROUTES_MANIFEST_PATH, {
+      method: 'PUT',
+      body: JSON.stringify(tree),
+    });
+  }
+
+  /** Find a target node without creating it (read-only counterpart to resolveTargetNode). */
+  private findTargetNode(node: RouteNode, name: string, isRoot: boolean): RouteNode | null {
+    if (name === 'index') {
+      return isRoot ? node : (node.wildcard?.child ?? null);
+    }
+    if (name.startsWith('[') && name.endsWith(']')) {
+      return node.dynamic?.child ?? null;
+    }
+    return node.children?.[name] ?? null;
+  }
+
+  private isEmptyNode(node: RouteNode): boolean {
+    return (
+      !node.files &&
+      !node.errorBoundary &&
+      !node.redirect &&
+      !node.children &&
+      !node.dynamic &&
+      !node.wildcard
+    );
+  }
+
+  /**
+   * Remove a widget entry from the stored manifest when a file is deleted.
+   */
+  private async pruneWidgetFromManifest(
+    filePath: string,
+    widgetsDir: string,
+  ): Promise<void> {
+    const relativePath = filePath.slice(widgetsDir.length + 1);
+    const parts = relativePath.split('/');
+    if (parts.length !== 2) return;
+
+    const [dirName, filename] = parts as [string, string];
+    const match = filename.match(/^(.+?)\.widget\.(ts|js|html|md|css)$/);
+    if (!match) return;
+
+    const name = match[1]!;
+    const ext = match[2]!;
+    if (name !== dirName) return;
+
+    const response = await this.handle(WIDGETS_MANIFEST_PATH);
+    if (response.status === 404) return;
+    const entries: WidgetManifestEntry[] = await response.json();
+
+    if (ext === 'ts' || ext === 'js') {
+      // Module deleted → remove entire entry
+      const idx = entries.findIndex((e) => e.name === name);
+      if (idx === -1) return;
+      entries.splice(idx, 1);
+    } else {
+      // Companion deleted → remove from files
+      const entry = entries.find((e) => e.name === name);
+      if (!entry?.files) return;
+      delete (entry.files as Record<string, string>)[ext];
+      if (Object.keys(entry.files).length === 0) delete entry.files;
+    }
+
+    this.widgetsManifestCache = null;
+    await this.handle(WIDGETS_MANIFEST_PATH, {
+      method: 'PUT',
+      body: JSON.stringify(entries),
+    });
+  }
+
+  /**
+   * Remove an element entry from the stored manifest when a file is deleted.
+   */
+  private async pruneElementFromManifest(
+    filePath: string,
+    elementsDir: string,
+  ): Promise<void> {
+    const relativePath = filePath.slice(elementsDir.length + 1);
+    const parts = relativePath.split('/');
+    if (parts.length !== 2) return;
+
+    const [dirName, filename] = parts as [string, string];
+    const match = filename.match(/^(.+?)\.element\.(ts|js)$/);
+    if (!match) return;
+
+    const name = match[1]!;
+    if (name !== dirName) return;
+
+    const response = await this.handle(ELEMENTS_MANIFEST_PATH);
+    if (response.status === 404) return;
+    const entries: ElementManifestEntry[] = await response.json();
+
+    const idx = entries.findIndex((e) => e.name === name);
+    if (idx === -1) return;
+    entries.splice(idx, 1);
+
+    this.elementsManifestCache = null;
+    await this.handle(ELEMENTS_MANIFEST_PATH, {
+      method: 'PUT',
+      body: JSON.stringify(entries),
+    });
+  }
+
+  /**
+   * After a source or companion file is written, check if a built `.js`
+   * artifact exists for that module. If so, re-transpile the `.ts` source
+   * with companions inlined and write the `.js` back.
+   *
+   * Best-effort: silently skips if `transpile()` is not implemented.
+   */
+  private async retranspileIfNeeded(
+    filePath: string,
+    dir: string,
+    kind: 'route' | 'widget' | 'element',
+  ): Promise<void> {
+    // Only act on source/companion files, not the .js output itself
+    if (filePath.endsWith('.js')) return;
+
+    const relativePath = filePath.slice(dir.length + 1);
+    const parts = relativePath.split('/');
+    const filename = parts[parts.length - 1]!;
+
+    // Determine the module base name and the .js output path
+    let jsPath: string;
+    if (kind === 'route') {
+      const match = filename.match(/^(.+?)\.(page)\.(ts|html|md|css)$/);
+      if (!match) return;
+      const name = match[1]!;
+      jsPath = `${dir}/${parts.slice(0, -1).join('/')}${parts.length > 1 ? '/' : ''}${name}.page.js`;
+    } else if (kind === 'widget') {
+      const match = filename.match(/^(.+?)\.(widget)\.(ts|html|md|css)$/);
+      if (!match) return;
+      const name = match[1]!;
+      jsPath = `${dir}/${name}/${name}.widget.js`;
+    } else {
+      const match = filename.match(/^(.+?)\.(element)\.ts$/);
+      if (!match) return;
+      const name = match[1]!;
+      jsPath = `${dir}/${name}/${name}.element.js`;
+    }
+
+    // Check if the .js artifact exists
+    const jsResponse = await this.handle(jsPath);
+    if (jsResponse.status === 404) return;
+
+    // Read the .ts source
+    const tsPath = jsPath.replace(/\.js$/, '.ts');
+    let tsSource: string;
+    try {
+      tsSource = await this.query(tsPath, { as: 'text' });
+    } catch {
+      return; // .ts doesn't exist (maybe .js was hand-written)
+    }
+
+    // Collect companion files and inline them
+    const companionExts = kind === 'element' ? [] : ['html', 'md', 'css'];
+    const files: Record<string, string> = {};
+    for (const ext of companionExts) {
+      const companionPath = tsPath.replace(/\.ts$/, `.${ext}`);
+      try {
+        files[ext] = await this.query(companionPath, { as: 'text' });
+      } catch {
+        // companion doesn't exist — skip
+      }
+    }
+
+    // Transpile
+    let jsCode: string;
+    try {
+      jsCode = await this.transpile(tsSource);
+    } catch {
+      return; // transpile not implemented — skip silently
+    }
+
+    // Append __files export if there are companions
+    if (Object.keys(files).length > 0) {
+      const entries = Object.entries(files)
+        .map(([k, v]) => `${k}: \`${v.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$/g, '\\$')}\``)
+        .join(', ');
+      jsCode += `\nexport const __files = { ${entries} };\n`;
+    }
+
+    await this.handle(jsPath, { method: 'PUT', body: jsCode });
+  }
+
   /**
    * Dynamically import a module from this runtime's storage.
    * Used by the server for SSR imports of `.page.ts` and `.widget.ts` files.
@@ -168,6 +475,113 @@ export abstract class Runtime {
     throw new Error(`transpile not implemented for ${this.constructor.name}`);
   }
 
+  /**
+   * Parse a widget file path and merge it into the stored manifest.
+   * Reads the current manifest, upserts the entry, writes it back.
+   */
+  private async mergeWidgetIntoManifest(
+    filePath: string,
+    widgetsDir: string,
+  ): Promise<void> {
+    const relativePath = filePath.slice(widgetsDir.length + 1);
+    const parts = relativePath.split('/');
+    if (parts.length !== 2) return; // must be widgets/{name}/{file}
+
+    const [dirName, filename] = parts as [string, string];
+
+    // Only act on .widget.{ts,js,html,md,css} files
+    const match = filename.match(/^(.+?)\.widget\.(ts|js|html|md|css)$/);
+    if (!match) return;
+
+    const name = match[1]!;
+    const ext = match[2]!;
+    if (name !== dirName) return; // filename must match directory
+
+    const response = await this.handle(WIDGETS_MANIFEST_PATH);
+    const entries: WidgetManifestEntry[] = response.status === 404
+      ? []
+      : await response.json();
+
+    const prefix = widgetsDir.replace(/^\//, '');
+
+    if (ext === 'ts' || ext === 'js') {
+      // Module file — upsert the entry
+      let entry = entries.find((e) => e.name === name);
+      if (!entry) {
+        entry = {
+          name,
+          modulePath: `${prefix}/${name}/${filename}`,
+          tagName: `widget-${name}`,
+        };
+        entries.push(entry);
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+      } else {
+        entry.modulePath = `${prefix}/${name}/${filename}`;
+      }
+    } else {
+      // Companion file — update files on existing entry
+      const entry = entries.find((e) => e.name === name);
+      if (!entry) return; // no module yet, companion alone is not enough
+      entry.files ??= {};
+      (entry.files as Record<string, string>)[ext] = `${prefix}/${name}/${filename}`;
+    }
+
+    this.widgetsManifestCache = null;
+    await this.handle(WIDGETS_MANIFEST_PATH, {
+      method: 'PUT',
+      body: JSON.stringify(entries),
+    });
+  }
+
+  /**
+   * Parse an element file path and merge it into the stored manifest.
+   * Reads the current manifest, upserts the entry, writes it back.
+   */
+  private async mergeElementIntoManifest(
+    filePath: string,
+    elementsDir: string,
+  ): Promise<void> {
+    const relativePath = filePath.slice(elementsDir.length + 1);
+    const parts = relativePath.split('/');
+    if (parts.length !== 2) return;
+
+    const [dirName, filename] = parts as [string, string];
+
+    const match = filename.match(/^(.+?)\.element\.(ts|js)$/);
+    if (!match) return;
+
+    const name = match[1]!;
+    if (name !== dirName) return;
+
+    // Custom element names must contain a hyphen
+    if (!name.includes('-')) return;
+
+    const response = await this.handle(ELEMENTS_MANIFEST_PATH);
+    const entries: ElementManifestEntry[] = response.status === 404
+      ? []
+      : await response.json();
+
+    const prefix = elementsDir.replace(/^\//, '');
+    let entry = entries.find((e) => e.name === name);
+    if (!entry) {
+      entry = {
+        name,
+        modulePath: `${prefix}/${name}/${filename}`,
+        tagName: name,
+      };
+      entries.push(entry);
+      entries.sort((a, b) => a.name.localeCompare(b.name));
+    } else {
+      entry.modulePath = `${prefix}/${name}/${filename}`;
+    }
+
+    this.elementsManifestCache = null;
+    await this.handle(ELEMENTS_MANIFEST_PATH, {
+      method: 'PUT',
+      body: JSON.stringify(entries),
+    });
+  }
+
   // ── Manifest resolution ─────────────────────────────────────────────
 
   private routesManifestCache: Response | null = null;
@@ -272,14 +686,16 @@ export abstract class Runtime {
     for (const filePath of allFiles) {
       const relativePath = filePath.replace(`${routesDir}/`, '');
       const parts = relativePath.split('/');
-      const filename = parts[parts.length - 1];
+      const filename = parts[parts.length - 1]!;
       const dirSegments = parts.slice(0, -1);
 
       // Parse filename: name.kind.ext (e.g. "about.page.ts", "[id].page.html", "index.error.ts")
       const match = filename.match(/^(.+?)\.(page|error|redirect)\.(ts|js|html|md|css)$/);
       if (!match) continue;
 
-      const [, name, kind, ext] = match;
+      const name = match[1]!;
+      const kind = match[2]!;
+      const ext = match[3]! as keyof RouteFiles;
 
       // Walk directory segments to reach the parent node
       let node = root;
@@ -291,7 +707,7 @@ export abstract class Runtime {
         } else {
           node.children ??= {};
           node.children[dir] ??= {};
-          node = node.children[dir];
+          node = node.children[dir]!;
         }
       }
 
@@ -305,7 +721,7 @@ export abstract class Runtime {
       }
 
       // For page and redirect files, the name determines the final node
-      const target = resolveTargetNode(node, name, dirSegments.length === 0);
+      const target = resolveTargetNode(node, name!, dirSegments.length === 0);
 
       if (kind === 'redirect') {
         target.redirect = filePath;

package/runtime/bun/fs/bun-fs.runtime.ts

@@ -1,4 +1,4 @@
-import { stat, readdir, mkdir } from 'node:fs/promises';
+import { stat, readdir, mkdir, unlink } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import {
   CONTENT_TYPES,
@@ -30,6 +30,8 @@ export class BunFsRuntime extends Runtime {
     switch (method) {
       case 'PUT':
         return this.write(path, body);
+      case 'DELETE':
+        return this.delete(path);
       default:
         return this.read(path);
     }
@@ -130,6 +132,18 @@ export class BunFsRuntime extends Runtime {
     }
   }
 
+  private async delete(path: string): Promise<Response> {
+    try {
+      await unlink(path);
+      return new Response(null, { status: 204 });
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+        return new Response('Not Found', { status: 404 });
+      }
+      return new Response(`Delete failed: ${error}`, { status: 500 });
+    }
+  }
+
   override loadModule(path: string): Promise<unknown> {
     return import(this.root + path);
   }

package/runtime/bun/sqlite/bun-sqlite.runtime.ts

@@ -14,6 +14,7 @@ export class BunSqliteRuntime extends Runtime {
   private readonly db: Database;
   private readonly stmtGet: ReturnType<Database['prepare']>;
   private readonly stmtSet: ReturnType<Database['prepare']>;
+  private readonly stmtDel: ReturnType<Database['prepare']>;
   private readonly stmtList: ReturnType<Database['prepare']>;
   private readonly stmtHas: ReturnType<Database['prepare']>;
 
@@ -29,6 +30,7 @@ export class BunSqliteRuntime extends Runtime {
     `);
     this.stmtGet = this.db.prepare('SELECT data, mtime FROM files WHERE path = ?');
     this.stmtSet = this.db.prepare('INSERT OR REPLACE INTO files (path, data, mtime) VALUES (?, ?, ?)');
+    this.stmtDel = this.db.prepare('DELETE FROM files WHERE path = ?');
     this.stmtList = this.db.prepare("SELECT DISTINCT path FROM files WHERE path LIKE ? || '%'");
     this.stmtHas = this.db.prepare("SELECT 1 FROM files WHERE path LIKE ? || '%' LIMIT 1");
   }
@@ -42,6 +44,8 @@ export class BunSqliteRuntime extends Runtime {
     switch (method) {
       case 'PUT':
         return this.write(pathname, body);
+      case 'DELETE':
+        return this.delete(pathname);
       default:
         return this.read(pathname);
     }
@@ -132,6 +136,11 @@ export class BunSqliteRuntime extends Runtime {
     return new Response(null, { status: 204 });
   }
 
+  private async delete(path: string): Promise<Response> {
+    this.stmtDel.run(path);
+    return new Response(null, { status: 204 });
+  }
+
   private listChildren(prefix: string): string[] {
     const rows = this.stmtList.all(prefix) as { path: string }[];
     const entries = new Set<string>();

package/runtime/fetch.runtime.ts

@@ -2,9 +2,9 @@
  * Fetch Runtime
  *
  * Browser-compatible Runtime that delegates all reads to a remote server
- * via `fetch()`. Used by the thin client in `root` mode — same
- * `createEmrouteServer` runs in the browser, but the Runtime fetches
- * files from the real server instead of reading from disk.
+ * via `fetch()`. Used by EmrouteApp in `root` mode — same Emroute
+ * instance runs in the browser, but the Runtime fetches files from the
+ * real server instead of reading from disk.
  *
  * No bundling, no transpiling, no filesystem access.
  * No directory scanning — the remote server already has manifests.

package/runtime/sitemap.generator.ts

@@ -17,8 +17,8 @@
  * @see https://www.sitemaps.org/protocol.html
  */
 
-import { escapeHtml } from '../src/util/html.util.ts';
-import type { RouteNode } from '../src/type/route-tree.type.ts';
+import { escapeHtml } from '../core/util/html.util.ts';
+import type { RouteNode } from '../core/type/route-tree.type.ts';
 
 /** Valid changefreq values per sitemaps.org protocol. */
 export type Changefreq =

package/runtime/universal/fs/universal-fs.runtime.ts

@@ -1,4 +1,4 @@
-import { readFile, writeFile, stat, readdir, mkdir } from 'node:fs/promises';
+import { readFile, writeFile, stat, readdir, mkdir, unlink } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import {
   CONTENT_TYPES,
@@ -38,6 +38,8 @@ export class UniversalFsRuntime extends Runtime {
     switch (method) {
       case 'PUT':
         return this.write(path, body);
+      case 'DELETE':
+        return this.delete(path);
       default:
         return this.read(path);
     }
@@ -138,6 +140,18 @@ export class UniversalFsRuntime extends Runtime {
     }
   }
 
+  private async delete(path: string): Promise<Response> {
+    try {
+      await unlink(path);
+      return new Response(null, { status: 204 });
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+        return new Response('Not Found', { status: 404 });
+      }
+      return new Response(`Delete failed: ${error}`, { status: 500 });
+    }
+  }
+
   override loadModule(path: string): Promise<unknown> {
     return import(this.root + path);
   }