@emkodev/emroute 1.7.2 → 1.8.0-beta.1

package/runtime/abstract.runtime.ts

@@ -1,6 +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 { 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'],
@@ -31,12 +32,18 @@ export type FetchReturn = ReturnType<typeof fetch>;
 
 export const DEFAULT_ROUTES_DIR = '/routes';
 export const DEFAULT_WIDGETS_DIR = '/widgets';
-export const ROUTES_MANIFEST_PATH = '/routes.manifest.json';
-export const WIDGETS_MANIFEST_PATH = '/widgets.manifest.json';
+export const DEFAULT_ELEMENTS_DIR = '/elements';
+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;
   widgetsDir?: string;
+  elementsDir?: string;
 }
 
 /**
@@ -72,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;
       });
     }
@@ -148,6 +186,274 @@ 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, kind, ext] = match;
+
+    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 as keyof RouteFiles] === filePath) {
+          delete target.files[ext as keyof RouteFiles];
+          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;
+    const match = filename.match(/^(.+?)\.widget\.(ts|js|html|md|css)$/);
+    if (!match) return;
+
+    const [, name, ext] = match;
+    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;
+    const match = filename.match(/^(.+?)\.element\.(ts|js)$/);
+    if (!match) return;
+
+    const [, name] = match;
+    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;
+      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;
+      jsPath = `${dir}/${name}/${name}.widget.js`;
+    } else {
+      const match = filename.match(/^(.+?)\.(element)\.ts$/);
+      if (!match) return;
+      const [, name] = match;
+      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.
@@ -164,15 +470,123 @@ 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;
+
+    // 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, ext] = match;
+    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;
+
+    const match = filename.match(/^(.+?)\.element\.(ts|js)$/);
+    if (!match) return;
+
+    const [, name] = match;
+    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;
   private widgetsManifestCache: Response | null = null;
+  private elementsManifestCache: Response | null = null;
 
   /** Clear cached manifests so the next query triggers a fresh scan. */
   invalidateManifests(): void {
     this.routesManifestCache = null;
     this.widgetsManifestCache = null;
+    this.elementsManifestCache = null;
   }
 
   /**
@@ -215,6 +629,25 @@ export abstract class Runtime {
     return this.widgetsManifestCache.clone();
   }
 
+  /**
+   * Resolve the elements manifest. Called when the concrete runtime returns
+   * 404 for ELEMENTS_MANIFEST_PATH. Scans `config.elementsDir` (or default).
+   */
+  async resolveElementsManifest(): Promise<Response> {
+    if (this.elementsManifestCache) return this.elementsManifestCache.clone();
+
+    const elementsDir = this.config.elementsDir ?? DEFAULT_ELEMENTS_DIR;
+
+    const dirResponse = await this.query(elementsDir + '/');
+    if (dirResponse.status === 404) {
+      return new Response('Not Found', { status: 404 });
+    }
+
+    const entries = await this.scanElements(elementsDir, elementsDir.replace(/^\//, ''));
+    this.elementsManifestCache = Response.json(entries);
+    return this.elementsManifestCache.clone();
+  }
+
   // ── Scanning ──────────────────────────────────────────────────────────
 
   protected async *walkDirectory(dir: string): AsyncGenerator<string> {
@@ -344,4 +777,46 @@ export abstract class Runtime {
     entries.sort((a, b) => a.name.localeCompare(b.name));
     return entries;
   }
+
+  protected async scanElements(
+    elementsDir: string,
+    pathPrefix?: string,
+  ): Promise<ElementManifestEntry[]> {
+    const entries: ElementManifestEntry[] = [];
+
+    const trailingDir = elementsDir.endsWith('/') ? elementsDir : elementsDir + '/';
+    const response = await this.query(trailingDir);
+    const listing: string[] = await response.json();
+
+    for (const item of listing) {
+      if (!item.endsWith('/')) continue;
+
+      const name = item.slice(0, -1);
+
+      // Custom element names must contain a hyphen (web spec requirement)
+      if (!name.includes('-')) {
+        console.warn(`[emroute] Skipping element "${name}": custom element names must contain a hyphen (e.g. "my-element")`);
+        continue;
+      }
+
+      // Try .element.ts first, then .element.js
+      let moduleFile = `${name}.element.ts`;
+      let modulePath = `${trailingDir}${name}/${moduleFile}`;
+      if ((await this.query(modulePath)).status === 404) {
+        moduleFile = `${name}.element.js`;
+        modulePath = `${trailingDir}${name}/${moduleFile}`;
+        if ((await this.query(modulePath)).status === 404) continue;
+      }
+
+      const prefix = pathPrefix ? `${pathPrefix}/` : '';
+      entries.push({
+        name,
+        modulePath: `${prefix}${name}/${moduleFile}`,
+        tagName: name,
+      });
+    }
+
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    return entries;
+  }
 }

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,
@@ -8,6 +8,7 @@ import {
   Runtime,
   type RuntimeConfig,
   WIDGETS_MANIFEST_PATH,
+  ELEMENTS_MANIFEST_PATH,
 } from '../../abstract.runtime.ts';
 
 export class BunFsRuntime extends Runtime {
@@ -29,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);
     }
@@ -99,6 +102,7 @@ export class BunFsRuntime extends Runtime {
         const pathname = path.slice(this.root.length);
         if (pathname === ROUTES_MANIFEST_PATH) return this.resolveRoutesManifest();
         if (pathname === WIDGETS_MANIFEST_PATH) return this.resolveWidgetsManifest();
+        if (pathname === ELEMENTS_MANIFEST_PATH) return this.resolveElementsManifest();
         return new Response('Not Found', { status: 404 });
       }
       return new Response(`Internal Error: ${error}`, { status: 500 });
@@ -128,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

@@ -7,12 +7,14 @@ import {
   Runtime,
   type RuntimeConfig,
   WIDGETS_MANIFEST_PATH,
+  ELEMENTS_MANIFEST_PATH,
 } from '../../abstract.runtime.ts';
 
 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']>;
 
@@ -28,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");
   }
@@ -41,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);
     }
@@ -108,6 +113,7 @@ export class BunSqliteRuntime extends Runtime {
     if (!row) {
       if (path === ROUTES_MANIFEST_PATH) return this.resolveRoutesManifest();
       if (path === WIDGETS_MANIFEST_PATH) return this.resolveWidgetsManifest();
+      if (path === ELEMENTS_MANIFEST_PATH) return this.resolveElementsManifest();
       return new Response('Not Found', { status: 404 });
     }
 
@@ -130,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 =