@vertesia/build-tools 1.3.0 → 1.4.0-dev.20260615.042033Z

package/src/import-transform/detector.ts

@@ -0,0 +1,56 @@
+/**
+ * Finds Vertesia query-style import specifiers inside a JavaScript source
+ * file and maps each one to the transformer that should handle it.
+ *
+ * The detector is regex-based and works on `tsc` output where import
+ * specifiers are preserved literally. It identifies any string literal that
+ * contains a known marker (`?skill`, `?raw`, …, or `/SKILL.md`) and then
+ * matches the specifier against the configured transformer patterns.
+ */
+
+import type { TransformerRule } from '../core/types.js';
+import { QUERY_STRING_LITERAL } from './patterns.js';
+
+export interface ImportOccurrence {
+    /** The transformer whose pattern matched the specifier. */
+    transformer: TransformerRule;
+
+    /** The original specifier text (the value between the quotes). */
+    specifier: string;
+
+    /** Offset in the source where the opening quote begins. */
+    quoteStart: number;
+
+    /** Offset in the source where the closing quote ends (exclusive). */
+    quoteEnd: number;
+
+    /** The quote character used in the source. */
+    quote: "'" | '"' | '`';
+}
+
+export function detectQueryImports(content: string, transformers: TransformerRule[]): ImportOccurrence[] {
+    const occurrences: ImportOccurrence[] = [];
+    QUERY_STRING_LITERAL.lastIndex = 0;
+
+    let match: RegExpExecArray | null;
+    // biome-ignore lint/suspicious/noAssignInExpressions: standard regex.exec loop
+    while ((match = QUERY_STRING_LITERAL.exec(content)) !== null) {
+        const quote = match[1] as "'" | '"' | '`';
+        const specifier = match[2];
+
+        for (const transformer of transformers) {
+            if (transformer.pattern.test(specifier)) {
+                occurrences.push({
+                    transformer,
+                    specifier,
+                    quoteStart: match.index,
+                    quoteEnd: match.index + match[0].length,
+                    quote,
+                });
+                break;
+            }
+        }
+    }
+
+    return occurrences;
+}

package/src/import-transform/index.ts

@@ -0,0 +1,171 @@
+/**
+ * Standalone import transformer for Vertesia query-style imports.
+ *
+ * Operates directly on the JavaScript output of `tsc`:
+ *
+ *   1. Walk `libDir` for `.js` files containing query imports.
+ *   2. For each occurrence, resolve back to the corresponding source asset
+ *      under `srcDir`, run the transformer, and write the generated module
+ *      as a sibling chunk in `libDir`.
+ *   3. Rewrite the importing file in place so the original `?skill` /
+ *      `SKILL.md` specifier points at the new chunk.
+ *   4. Copy any transformer-declared assets (scripts, handlebars, …) and
+ *      bundle any discovered widget `.tsx` siblings via esbuild.
+ *
+ * Emitted chunks are re-scanned for nested query imports (e.g. a `?skills`
+ * collection chunk that imports `SKILL.md` siblings), so the pipeline
+ * matches rollup's recursive resolveId/load behavior.
+ */
+
+import path from 'node:path';
+import { compileWidgets, type WidgetCompilerConfig } from '../core/compilers/widget.js';
+import type { AssetFile, TransformerRule } from '../core/types.js';
+import { copyAssets } from '../core/utils/asset-copy.js';
+import type { WidgetMetadata } from '../core/utils/asset-discovery.js';
+import { emitChunk } from './chunk-emitter.js';
+import { detectQueryImports } from './detector.js';
+import { SNIFF_PATTERN } from './patterns.js';
+import { resolveImport } from './resolver.js';
+import { type ImportReplacement, writeRewrittenFile } from './rewriter.js';
+import { scanLibForQueryImports } from './scanner.js';
+
+export interface TransformImportsOptions {
+    /** Root of the compiled JavaScript output (e.g. `./lib`). */
+    libDir: string;
+
+    /** Root of the original sources, mirroring `libDir` (e.g. `./src`). */
+    srcDir: string;
+
+    /** Transformers to apply. */
+    transformers: TransformerRule[];
+
+    /**
+     * Root directory where script assets are copied and widgets are written.
+     * - String: assets and widgets are emitted under this directory.
+     * - `false`: asset copying and widget compilation are skipped.
+     * - Default: `libDir` (so widgets land in `lib/<widgetsDir>/`).
+     */
+    assetsDir?: string | false;
+
+    /** Sub-directory under `assetsDir` for widget bundles. Default: 'widgets'. */
+    widgetsDir?: string;
+
+    /** Configuration forwarded to the esbuild widget bundler. */
+    widgetConfig?: WidgetCompilerConfig;
+}
+
+export interface TransformImportsResult {
+    filesProcessed: number;
+    chunksEmitted: number;
+    assetsCopied: number;
+    widgetsCompiled: number;
+}
+
+interface WorkItem {
+    path: string;
+    content: string;
+}
+
+export async function transformImports(opts: TransformImportsOptions): Promise<TransformImportsResult> {
+    const { libDir, srcDir, transformers, widgetsDir = 'widgets', widgetConfig } = opts;
+    const assetsDir = opts.assetsDir === undefined ? libDir : opts.assetsDir;
+    const shouldCopyAssets = assetsDir !== false;
+    const shouldCompileWidgets = assetsDir !== false;
+
+    if (!transformers || transformers.length === 0) {
+        throw new Error('transformImports: At least one transformer must be configured');
+    }
+
+    const seenFiles = new Set<string>();
+    const workQueue: WorkItem[] = [];
+
+    for (const file of scanLibForQueryImports(libDir)) {
+        if (!seenFiles.has(file.path)) {
+            seenFiles.add(file.path);
+            workQueue.push(file);
+        }
+    }
+
+    const emittedChunks = new Set<string>();
+    const seenWidgets = new Map<string, WidgetMetadata>();
+    const assetsToCopy: AssetFile[] = [];
+    let chunksEmitted = 0;
+    let filesProcessed = 0;
+
+    while (workQueue.length > 0) {
+        const file = workQueue.shift() as WorkItem;
+        const occurrences = detectQueryImports(file.content, transformers);
+        if (occurrences.length === 0) {
+            continue;
+        }
+
+        const replacements: ImportReplacement[] = [];
+
+        for (const occ of occurrences) {
+            const resolved = resolveImport(file.path, occ.specifier, libDir, srcDir);
+
+            if (!emittedChunks.has(resolved.chunkLibPath)) {
+                const emitted = await emitChunk(resolved.resolvedSrcPath, resolved.chunkLibPath, occ.transformer);
+                emittedChunks.add(resolved.chunkLibPath);
+                chunksEmitted++;
+
+                if (emitted.assets.length > 0 && shouldCopyAssets) {
+                    assetsToCopy.push(...emitted.assets);
+                }
+                if (emitted.widgets.length > 0 && shouldCompileWidgets) {
+                    for (const widget of emitted.widgets) {
+                        if (!seenWidgets.has(widget.path)) {
+                            seenWidgets.set(widget.path, widget);
+                        }
+                    }
+                }
+
+                // Chunks may themselves contain query imports (e.g. ?skills
+                // collection chunks emit `import './foo/SKILL.md'` lines).
+                if (SNIFF_PATTERN.test(emitted.content) && !seenFiles.has(resolved.chunkLibPath)) {
+                    seenFiles.add(resolved.chunkLibPath);
+                    workQueue.push({ path: resolved.chunkLibPath, content: emitted.content });
+                }
+            }
+
+            replacements.push({
+                quoteStart: occ.quoteStart,
+                quoteEnd: occ.quoteEnd,
+                quote: occ.quote,
+                newSpecifier: resolved.chunkSpecifier,
+            });
+        }
+
+        if (writeRewrittenFile(file.path, file.content, replacements)) {
+            filesProcessed++;
+        }
+    }
+
+    let assetsCopied = 0;
+    if (shouldCopyAssets && assetsToCopy.length > 0) {
+        assetsCopied = copyAssets(assetsToCopy, assetsDir as string);
+    }
+
+    let widgetsCompiled = 0;
+    if (shouldCompileWidgets && seenWidgets.size > 0) {
+        const widgetInputs = Array.from(seenWidgets.values()).map((widget) => ({
+            name: widget.name,
+            entry: mapSrcWidgetToLib(widget.path, srcDir, libDir),
+        }));
+        const widgetOutput = path.join(assetsDir as string, widgetsDir);
+        widgetsCompiled = await compileWidgets(widgetInputs, widgetOutput, widgetConfig);
+    }
+
+    return { filesProcessed, chunksEmitted, assetsCopied, widgetsCompiled };
+}
+
+/**
+ * Map a widget `.tsx` source path to its tsc-compiled `.js` counterpart in lib/.
+ */
+function mapSrcWidgetToLib(srcTsxPath: string, srcDir: string, libDir: string): string {
+    const srcRoot = path.resolve(srcDir);
+    const libRoot = path.resolve(libDir);
+    const rel = path.relative(srcRoot, srcTsxPath);
+    const libRel = rel.replace(/\.tsx$/, '.js');
+    return path.join(libRoot, libRel);
+}

package/src/import-transform/patterns.ts

@@ -0,0 +1,34 @@
+/**
+ * Shared regex fragments used by the scanner, detector, and orchestrator to
+ * identify Vertesia query-style imports. Keep these in sync with the
+ * `pattern` field of each transformer in `core/transformers/`.
+ */
+
+/**
+ * Suffix tokens for `?xxx` query imports.
+ */
+export const QUERY_SUFFIXES = ['skill', 'raw', 'prompt', 'template', 'skills', 'templates'] as const;
+
+/**
+ * Bare filename tokens that mark an import as a transform target without a
+ * `?query` suffix (e.g. `import skill from './my-skill/SKILL.md'`).
+ */
+export const BARE_FILENAMES = ['SKILL.md', 'TEMPLATE.md'] as const;
+
+const QUERY_GROUP = QUERY_SUFFIXES.join('|');
+const BARE_GROUP = BARE_FILENAMES.map((name) => `\\/${name.replace('.', '\\.')}`).join('|');
+
+/**
+ * Coarse sniff for whether a file body could contain any query-style imports.
+ * Cheap regex check before invoking the more expensive detector.
+ */
+export const SNIFF_PATTERN = new RegExp(`\\?(?:${QUERY_GROUP})\\b|(?:${BARE_GROUP})\\b`);
+
+/**
+ * Matches a quoted string literal whose contents end with a query marker.
+ * Capture group 1 is the quote character; capture group 2 is the specifier.
+ */
+export const QUERY_STRING_LITERAL = new RegExp(
+    `(['"\`])([^'"\`]*?(?:\\?(?:${QUERY_GROUP})|${BARE_GROUP})[^'"\`]*)\\1`,
+    'g',
+);

package/src/import-transform/resolver.ts

@@ -0,0 +1,57 @@
+/**
+ * Resolves a query-style import specifier to:
+ *   1. the source file path in `src/` (where the original asset lives), and
+ *   2. the chunk path in `lib/` (where the generated module will be written),
+ *      and the new relative specifier to write back into the importing file.
+ *
+ * Path mapping rule: lib/ and src/ are mirror trees, so a file at
+ * `<libDir>/<rel>` corresponds to `<srcDir>/<rel>`.
+ */
+
+import path from 'node:path';
+
+export interface ResolvedImport {
+    /** Specifier with any `?query` suffix stripped. */
+    cleanSpecifier: string;
+
+    /** Absolute lib/ path of the resolved (extension-preserved) target. */
+    resolvedLibPath: string;
+
+    /** Absolute src/ path of the same target. */
+    resolvedSrcPath: string;
+
+    /** Absolute lib/ path where the generated chunk will be written. */
+    chunkLibPath: string;
+
+    /** Relative specifier (importer-relative) that should replace the original. */
+    chunkSpecifier: string;
+}
+
+export function resolveImport(
+    importerLibPath: string,
+    specifier: string,
+    libDir: string,
+    srcDir: string,
+): ResolvedImport {
+    const queryIndex = specifier.indexOf('?');
+    const cleanSpecifier = queryIndex >= 0 ? specifier.substring(0, queryIndex) : specifier;
+
+    const importerDir = path.dirname(importerLibPath);
+    const resolvedLibPath = path.resolve(importerDir, cleanSpecifier);
+
+    const libRoot = path.resolve(libDir);
+    const srcRoot = path.resolve(srcDir);
+    const relFromLib = path.relative(libRoot, resolvedLibPath);
+    const resolvedSrcPath = path.join(srcRoot, relFromLib);
+
+    const chunkLibPath = `${resolvedLibPath}.js`;
+    const chunkSpecifier = `${cleanSpecifier}.js`;
+
+    return {
+        cleanSpecifier,
+        resolvedLibPath,
+        resolvedSrcPath,
+        chunkLibPath,
+        chunkSpecifier,
+    };
+}

package/src/import-transform/rewriter.ts

@@ -0,0 +1,48 @@
+/**
+ * Rewrites query-style import specifiers inside a JavaScript source file to
+ * point at the chunks emitted by the chunk-emitter.
+ *
+ * All replacements are intra-line (only the quoted string changes), which
+ * preserves line numbers — so existing source maps remain valid at the line
+ * level without re-emitting them.
+ */
+
+import { writeFileSync } from 'node:fs';
+
+export interface ImportReplacement {
+    /** Offset where the opening quote begins in the original content. */
+    quoteStart: number;
+
+    /** Offset where the closing quote ends (exclusive). */
+    quoteEnd: number;
+
+    /** Quote character to wrap the new specifier with. */
+    quote: "'" | '"' | '`';
+
+    /** Replacement specifier (without quotes). */
+    newSpecifier: string;
+}
+
+export function rewriteImports(content: string, replacements: ImportReplacement[]): string {
+    if (replacements.length === 0) {
+        return content;
+    }
+
+    const sorted = [...replacements].sort((a, b) => b.quoteStart - a.quoteStart);
+
+    let out = content;
+    for (const r of sorted) {
+        const literal = `${r.quote}${r.newSpecifier}${r.quote}`;
+        out = out.slice(0, r.quoteStart) + literal + out.slice(r.quoteEnd);
+    }
+    return out;
+}
+
+export function writeRewrittenFile(filePath: string, content: string, replacements: ImportReplacement[]): boolean {
+    if (replacements.length === 0) {
+        return false;
+    }
+    const next = rewriteImports(content, replacements);
+    writeFileSync(filePath, next, 'utf-8');
+    return true;
+}

package/src/import-transform/scanner.ts

@@ -0,0 +1,55 @@
+/**
+ * Walks a compiled library directory to find candidate JavaScript files
+ * that may contain Vertesia query-style imports (`?skill`, `?raw`, …) or
+ * `SKILL.md` imports.
+ *
+ * Returns absolute paths to `.js` files whose content matches a quick
+ * content sniff for any of the trigger tokens, avoiding a re-read in the
+ * detector.
+ */
+
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { SNIFF_PATTERN } from './patterns.js';
+
+export interface ScannedFile {
+    /** Absolute path to the file. */
+    path: string;
+
+    /** File content, captured during scanning. */
+    content: string;
+}
+
+export function scanLibForQueryImports(libDir: string): ScannedFile[] {
+    const results: ScannedFile[] = [];
+    walk(libDir, results);
+    return results;
+}
+
+function walk(dir: string, out: ScannedFile[]): void {
+    let entries: string[];
+    try {
+        entries = readdirSync(dir);
+    } catch {
+        return;
+    }
+
+    for (const entry of entries) {
+        const full = path.join(dir, entry);
+        let stats: ReturnType<typeof statSync>;
+        try {
+            stats = statSync(full);
+        } catch {
+            continue;
+        }
+
+        if (stats.isDirectory()) {
+            walk(full, out);
+        } else if (stats.isFile() && full.endsWith('.js')) {
+            const content = readFileSync(full, 'utf-8');
+            if (SNIFF_PATTERN.test(content)) {
+                out.push({ path: full, content });
+            }
+        }
+    }
+}

package/src/index.ts

@@ -1,57 +1,82 @@
 /**
- * Vertesia Rollup Import Plugin
+ * Vertesia Build Tools
  *
- * A flexible Rollup plugin for transforming imports with custom compilers and validation.
- * Supports preset transformers for common use cases (skills, raw files) and custom transformers.
+ * Transformers for custom import syntaxes (`?skill`, `?raw`, `?prompt`,
+ * `?template`, `?skills`, `?templates`, and bare `SKILL.md` / `TEMPLATE.md`),
+ * a standalone CLI (`vertesia-build`) that runs them as a post-`tsc` step,
+ * and Vite plugins for dev-mode integration.
+ *
+ * Two consumer entry points:
+ *
+ *   - **Build-time:** invoke the `vertesia-build` CLI from your package
+ *     scripts (after `tsc`). Config lives under `vertesia-build` in your
+ *     `package.json`. The CLI calls `transformImports()` internally — you
+ *     can also call it directly if you need finer control.
+ *
+ *   - **Dev-time (Vite):** import `vertesiaDevServerPlugin` (or
+ *     `apiServerPlugin` for full Hono tool-server wiring) from
+ *     `@vertesia/build-tools/vite`. Same transformers, same behavior,
+ *     applied to source files at request time.
  *
  * @example
  * ```typescript
- * import { vertesiaImportPlugin, skillTransformer, rawTransformer } from '@vertesia/build-tools';
+ * import { transformImports } from '@vertesia/build-tools';
  *
- * export default {
- *   plugins: [
- *     vertesiaImportPlugin({
- *       transformers: [skillTransformer, rawTransformer]
- *     })
- *   ]
- * };
+ * await transformImports({
+ *   libDir: './lib',
+ *   srcDir: './src',
+ *   transformers: ['skill', 'raw'],
+ *   assetsDir: './dist',
+ * });
  * ```
  */
 
-// Core plugin
-export { vertesiaImportPlugin } from './plugin.js';
-
+// esbuild-based widget bundler
+export {
+    compileWidget,
+    compileWidgets,
+    type WidgetCompilerConfig,
+    type WidgetInput,
+} from './core/compilers/widget.js';
+// Parsers
+export { type FrontmatterResult, parseFrontmatter } from './core/parsers/frontmatter.js';
+// Transformers (the pure transformation functions)
+export {
+    type PromptContentType,
+    type PromptDefinition,
+    PromptDefinitionSchema,
+    PromptRole,
+    promptTransformer,
+    type RenderingTemplateDefinition,
+    RenderingTemplateDefinitionSchema,
+    rawTransformer,
+    type SkillContentType,
+    type SkillDefinition,
+    SkillDefinitionSchema,
+    SkillPropertiesSchema,
+    skillCollectionTransformer,
+    skillTransformer,
+    TemplateType,
+    templateCollectionTransformer,
+    templateTransformer,
+} from './core/transformers/index.js';
 // Types
 export type {
-    PluginConfig,
-    TransformerRule,
+    AssetFile,
     TransformerPreset,
+    TransformerRule,
     TransformFunction,
     TransformResult,
-    AssetFile,
-    WidgetConfig
-} from './types.js';
-
-// Presets
+} from './core/types.js';
+// CLI-friendly transformer name registry
 export {
-    skillTransformer,
-    rawTransformer,
-    skillCollectionTransformer,
-    templateTransformer,
-    templateCollectionTransformer,
-    promptTransformer,
-    SkillDefinitionSchema,
-    SkillPropertiesSchema,
-    RenderingTemplateDefinitionSchema,
-    PromptDefinitionSchema,
-    type SkillDefinition,
-    type SkillContentType,
-    type RenderingTemplateDefinition,
-    type PromptDefinition,
-    type PromptContentType,
-    PromptRole,
-    TemplateType
-} from './presets/index.js';
-
-// Utilities
-export { parseFrontmatter, type FrontmatterResult } from './parsers/frontmatter.js';
+    BUILTIN_TRANSFORMER_NAMES,
+    BUILTIN_TRANSFORMERS,
+    resolveTransformerNames,
+} from './import-transform/builtins.js';
+// Standalone import transformer (tsc → vertesia-build pipeline)
+export {
+    type TransformImportsOptions,
+    type TransformImportsResult,
+    transformImports,
+} from './import-transform/index.js';

package/src/vite/api-server.ts

@@ -0,0 +1,142 @@
+/**
+ * Vite plugin set that mounts a Vertesia Hono tool server as middleware on
+ * the Vite dev server. Includes the Vertesia import transformers needed by
+ * `ssrLoadModule` to handle `?skill` / `?template` / `?prompt` / `?raw`
+ * imports in the tool server source.
+ *
+ *   - `vite dev`     → loads the server entry via `ssrLoadModule` (source,
+ *                      with HMR invalidation)
+ *   - `vite preview` → loads the compiled server from `lib/` (validates
+ *                      production output)
+ *
+ * The Hono app is served on the same port as Vite under `/api`.
+ *
+ * @example
+ * ```typescript
+ * // vite.config.ts
+ * import { defineConfig } from 'vite';
+ * import { apiServerPlugin } from '@vertesia/build-tools/vite';
+ *
+ * export default defineConfig({
+ *     plugins: [
+ *         apiServerPlugin({ entry: './src/tool-server/server.ts' }),
+ *     ],
+ * });
+ * ```
+ */
+
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import path from 'node:path';
+import { getRequestListener } from '@hono/node-server';
+import type { Plugin, ViteDevServer } from 'vite';
+import { vertesiaDevServerPlugin } from './dev-server.js';
+
+interface HonoApp {
+    fetch: (request: Request, env?: unknown, executionCtx?: unknown) => Response | Promise<Response>;
+}
+
+type NextHandleFunction = (req: IncomingMessage, res: ServerResponse, next: (err?: unknown) => void) => void;
+
+export interface ApiServerPluginOptions {
+    /**
+     * Tool server entry point (TypeScript source). Resolved by Vite from the
+     * project root in dev mode.
+     * @default './src/tool-server/server.ts'
+     */
+    entry?: string;
+
+    /**
+     * Compiled server module path used in preview mode. Resolved relative to
+     * `process.cwd()` (the consuming project's root when running `vite preview`).
+     * @default './lib/server.js'
+     */
+    compiledEntry?: string;
+
+    /**
+     * Path prefix that routes requests to the Hono server. Requests whose URL
+     * starts with this prefix are forwarded; others fall through to Vite.
+     * @default '/api'
+     */
+    apiPrefix?: string;
+
+    /**
+     * Names of transformers to enable in dev mode. Defaults to all built-ins
+     * (`skill`, `skills`, `template`, `templates`, `prompt`, `raw`).
+     */
+    transformers?: readonly string[];
+}
+
+export function apiServerPlugin(options: ApiServerPluginOptions = {}): Plugin[] {
+    const {
+        entry = './src/tool-server/server.ts',
+        compiledEntry = './lib/server.js',
+        apiPrefix = '/api',
+        transformers,
+    } = options;
+
+    // Resolve compiled entry relative to the consumer's cwd. Vite is run from
+    // the project root by convention, so this lands at the right file.
+    const absoluteCompiledEntry = path.resolve(process.cwd(), compiledEntry);
+
+    return [
+        // Vertesia query-import transformer (skill / raw / prompt / template etc.).
+        vertesiaDevServerPlugin(transformers ? { transformers } : undefined),
+
+        // Hono middleware bridge for dev + preview.
+        {
+            name: 'vertesia-api-server',
+
+            configureServer(server: ViteDevServer) {
+                server.middlewares.use(createDevListener(server, entry, apiPrefix));
+            },
+
+            configurePreviewServer(server) {
+                server.middlewares.use(createPreviewListener(absoluteCompiledEntry, apiPrefix));
+            },
+        },
+    ];
+}
+
+/**
+ * Connect-compatible middleware that loads the Hono app from source via
+ * Vite's `ssrLoadModule` (preserving HMR invalidation on changes).
+ */
+function createDevListener(server: ViteDevServer, entry: string, apiPrefix: string): NextHandleFunction {
+    return async (req, res, next) => {
+        if (!req.url?.startsWith(apiPrefix)) {
+            return next();
+        }
+        try {
+            const mod = await server.ssrLoadModule(entry);
+            const app = mod.default as HonoApp;
+            const requestListener = getRequestListener(app.fetch);
+            void requestListener(req, res);
+        } catch (e) {
+            next(e);
+        }
+    };
+}
+
+/**
+ * Connect-compatible middleware that loads the compiled Hono app from `lib/`
+ * for production validation. The compiled module is cached after first load
+ * (no HMR in preview mode).
+ */
+function createPreviewListener(compiledEntry: string, apiPrefix: string): NextHandleFunction {
+    let appPromise: Promise<HonoApp> | null = null;
+    return async (req, res, next) => {
+        if (!req.url?.startsWith(apiPrefix)) {
+            return next();
+        }
+        try {
+            if (!appPromise) {
+                appPromise = import(compiledEntry).then((mod) => mod.default);
+            }
+            const app = await appPromise;
+            const requestListener = getRequestListener(app.fetch);
+            void requestListener(req, res);
+        } catch (e) {
+            next(e);
+        }
+    };
+}