@run0/jiki 0.1.0

package/dist/browser-bundle.d.ts

@@ -0,0 +1,40 @@
+import { MemFS } from "./memfs";
+export interface BrowserBundle {
+    modules: Map<string, string>;
+    entryPath: string;
+    depMap: Map<string, string>;
+}
+export interface BundleError {
+    packageName: string;
+    message: string;
+}
+export declare function extractPackageName(id: string): string;
+/**
+ * Bundle a package from the VFS for browser consumption.
+ * Reads the package entry point, transforms ESM to CJS, and recursively
+ * bundles all local dependencies. External packages and Node builtins are skipped.
+ */
+export declare function bundlePackageForBrowser(vfs: MemFS, packageName: string, externals: Set<string>): BrowserBundle;
+/**
+ * Generate a `<script>` containing a require() shim and all bundled modules.
+ * Globals map package names to window properties (e.g. { "react": "React" }).
+ */
+export declare function generateRequireScript(bundles: Map<string, BrowserBundle>, globals: Record<string, string>): string;
+/**
+ * Transform ES module `import` statements into `window.require()` calls.
+ * Used to pre-process component source before host-side JSX transpilation
+ * via esbuild. The output is plain JS that can run in a regular `<script>` tag.
+ *
+ * Uses `var` (not `const`) so declarations hoist to function/global scope.
+ * Uses `window.require` (not bare `require`) to avoid strict-mode scoping issues.
+ */
+export declare function preprocessImports(code: string): string;
+/**
+ * Scan source files for bare-specifier imports (e.g. `import { X } from 'pkg'`
+ * or `import { Y } from '@scope/pkg/subpath'`).
+ * Returns a set of unique full import specifiers found, preserving subpaths
+ * so they can be individually resolved and bundled.
+ * Handles: named imports, default imports, namespace imports, multi-line destructuring.
+ * Skips: `import type` (TS type-only imports), side-effect imports without a specifier.
+ */
+export declare function scanBareImports(sources: string[]): Set<string>;

package/dist/builtins.d.ts

@@ -0,0 +1,22 @@
+import { bufferModule as _bufferMod } from "./polyfills/stream";
+export { _bufferMod as bufferPolyfill };
+export declare function resolveBuiltin(name: string): unknown | undefined;
+export declare function isBuiltinModule(name: string): boolean;
+/**
+ * Register a custom polyfill for a built-in module name.
+ * Replaces any existing polyfill for the same name.
+ * The factory is called lazily on first `require()`.
+ */
+export declare function registerBuiltin(name: string, factory: () => unknown): void;
+/**
+ * Register multiple custom polyfills at once.
+ */
+export declare function registerBuiltins(map: Record<string, () => unknown>): void;
+/**
+ * Unregister a custom polyfill, reverting to the default (if any was
+ * overridden) or removing the module entirely.
+ */
+export declare function unregisterBuiltin(name: string): void;
+/** Return a list of all registered builtin module names. */
+export declare function listBuiltins(): string[];
+export declare const builtinModules: Record<string, unknown>;

package/dist/code-transform.d.ts

@@ -0,0 +1,7 @@
+declare const tsCache: Map<string, string>;
+export { tsCache as transpileCache };
+export declare function removeShebang(source: string): string;
+export declare function transformEsmToCjs(source: string, file: string): string;
+export declare function processSource(source: string, file: string, sourceMaps?: boolean): string;
+export declare function getProcessedSource(rawSource: string, filepath: string, cache: Map<string, string>, sourceMaps?: boolean): string;
+export declare function ensureTranspiled(file: string, source: string): Promise<void>;

package/dist/config/cdn.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Centralized CDN version pins and URLs.
+ * Change versions here to update them across the entire platform.
+ */
+export declare const REACT_VERSION = "18.2.0";
+export declare const ESBUILD_WASM_VERSION = "0.20.0";
+export declare const REACT_REFRESH_VERSION = "0.14.0";
+export declare const REACT_CDN = "https://esm.sh/react@18.2.0";
+export declare const REACT_DOM_CDN = "https://esm.sh/react-dom@18.2.0";
+export declare const REACT_REFRESH_CDN = "https://esm.sh/react-refresh@0.14.0/runtime";
+export declare const ESBUILD_WASM_ESM_CDN = "https://esm.sh/esbuild-wasm@0.20.0";
+export declare const ESBUILD_WASM_BINARY_CDN = "https://unpkg.com/esbuild-wasm@0.20.0/esbuild.wasm";
+export declare const TAILWIND_CDN_URL = "https://cdn.tailwindcss.com";

package/dist/container.d.ts

@@ -0,0 +1,101 @@
+import { MemFS } from "./memfs";
+import { Kernel } from "./kernel";
+import { PackageManager, InstallOptions, InstallResult } from "./npm/index";
+import { Shell, ShellOptions } from "./shell";
+import type { IExecuteResult, VFSSnapshot } from "./runtime-interface";
+import { PluginRegistry, type JikiPlugin } from "./plugin";
+import type { PersistenceAdapter } from "./persistence";
+import { SandboxGuard, type SandboxOptions } from "./sandbox";
+import { Metrics } from "./metrics";
+import { NetworkInterceptor, type MockResponse } from "./network-interceptor";
+export interface ContainerOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    registry?: string;
+    /** `'npm'` (default) or `'pnpm'` */
+    packageManager?: "npm" | "pnpm";
+    /** Automatically install missing packages on require() */
+    autoInstall?: boolean;
+    onConsole?: (method: string, args: unknown[]) => void;
+    onStdout?: (data: string) => void;
+    onStderr?: (data: string) => void;
+    /** Plugins to register on this container. */
+    plugins?: JikiPlugin[];
+    /** Persistence adapter for surviving page refreshes. */
+    persistence?: PersistenceAdapter;
+    /** Enable inline source maps for TypeScript/JSX transpilation (default: false). */
+    sourceMaps?: boolean;
+    /**
+     * Worker mode for CPU-intensive operations.
+     * - `false` (default) — everything on the main thread
+     * - `true` — transpilation runs in a Web Worker
+     * - `'auto'` — use workers when available (browser), skip in Node.js
+     */
+    worker?: boolean | "auto";
+    /** Resource limits and access controls. */
+    sandbox?: SandboxOptions;
+}
+export interface RunOptions extends ShellOptions {
+    signal?: AbortSignal;
+}
+export interface RunResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export declare class Container {
+    readonly vfs: MemFS;
+    readonly runtime: Kernel;
+    readonly packageManager: PackageManager;
+    readonly shell: Shell;
+    /** Plugin registry for this container. */
+    readonly plugins: PluginRegistry;
+    /** Sandbox guard enforcing resource limits. */
+    readonly sandbox: SandboxGuard;
+    /** Performance metrics for this container. */
+    readonly metrics: Metrics;
+    /** Network request interceptor for mocking fetch calls. */
+    readonly network: NetworkInterceptor;
+    private _pnpmPm?;
+    private _containerCwd;
+    private _containerRegistry?;
+    private _workerMode;
+    constructor(options?: ContainerOptions);
+    private get lazyPnpmPm();
+    init(options?: {
+        wasmURL?: string | URL;
+    }): Promise<void>;
+    writeFile(path: string, content: string | Uint8Array): void;
+    readFile(path: string): string;
+    readFile(path: string, encoding: null): Uint8Array;
+    mkdir(path: string): void;
+    readdir(path: string): string[];
+    exists(path: string): boolean;
+    rm(path: string): void;
+    execute(code: string, filename?: string): IExecuteResult;
+    runFile(filename: string): IExecuteResult;
+    run(command: string, options?: RunOptions): Promise<RunResult>;
+    sendInput(data: string): void;
+    /** Register a custom polyfill for a built-in module. */
+    registerPolyfill(name: string, factory: () => unknown): void;
+    /** Register multiple custom polyfills at once. */
+    registerPolyfills(map: Record<string, () => unknown>): void;
+    /** Unregister a custom polyfill. */
+    unregisterPolyfill(name: string): void;
+    /** Mock a fetch URL with a static response. */
+    mockFetch(pattern: string | RegExp, response: MockResponse): void;
+    /** Register a dynamic fetch interceptor. */
+    onFetch(handler: (url: string, init?: RequestInit) => MockResponse | null | undefined | Promise<MockResponse | null | undefined>): void;
+    /** Get a snapshot of performance metrics. */
+    getMetrics(): import("./metrics").MetricsSnapshot;
+    install(packages: string | string[], options?: InstallOptions): Promise<InstallResult>;
+    installDependencies(options?: InstallOptions): Promise<InstallResult>;
+    toSnapshot(): VFSSnapshot;
+    static fromSnapshot(snapshot: VFSSnapshot, options?: ContainerOptions): Container;
+    export(path?: string): Record<string, unknown>;
+    destroy(): void;
+}
+/** Register a plugin on an existing container (post-construction). */
+export declare function registerPlugin(container: Container, plugin: JikiPlugin): void;
+export declare function boot(options?: ContainerOptions): Container;
+export { boot as createContainer };

package/dist/dev-server.d.ts

@@ -0,0 +1,69 @@
+import { EventEmitter } from "./polyfills/events";
+import { MemFS } from "./memfs";
+import { BufferImpl as Buffer } from "./polyfills/stream";
+export interface DevServerOptions {
+    port: number;
+    root?: string;
+}
+export interface ResponseData {
+    statusCode: number;
+    statusMessage: string;
+    headers: Record<string, string>;
+    body: Buffer;
+}
+export interface HMRUpdate {
+    type: "update" | "full-reload";
+    path: string;
+    timestamp?: number;
+}
+/**
+ * Check if a filename contains a content hash (e.g., app.a1b2c3d4.js, chunk-HASH.css).
+ * Content-hashed files are safe to cache immutably since the hash changes when content changes.
+ */
+declare function hasContentHash(filepath: string): boolean;
+/**
+ * Determine the appropriate Cache-Control header for a given file path.
+ * - Content-hashed assets get immutable caching (1 year)
+ * - HTML and non-hashed assets get no-cache for development freshness
+ */
+declare function inferCacheControl(filepath: string): string;
+export declare abstract class DevServer extends EventEmitter {
+    protected vfs: MemFS;
+    protected port: number;
+    protected root: string;
+    protected running: boolean;
+    constructor(vfs: MemFS, options: DevServerOptions);
+    abstract handleRequest(method: string, url: string, headers: Record<string, string>, body?: Buffer): Promise<ResponseData>;
+    abstract startWatching(): void;
+    /**
+     * CORS headers added to all responses for cross-origin iframe support.
+     * This is essential since the dev server is typically accessed from
+     * a sandboxed iframe on a different origin.
+     */
+    private static readonly CORS_HEADERS;
+    /**
+     * Add CORS headers to a response.
+     */
+    protected addCorsHeaders(response: ResponseData): ResponseData;
+    /**
+     * Handle CORS preflight OPTIONS requests.
+     */
+    protected handleOptionsRequest(): ResponseData;
+    stop(): void;
+    start(): void;
+    isRunning(): boolean;
+    getPort(): number;
+    protected serveFile(filePath: string): ResponseData;
+    protected resolvePath(urlPath: string): string;
+    protected notFound(path: string): ResponseData;
+    protected serverError(error: unknown): ResponseData;
+    protected redirect(location: string, status?: 301 | 302 | 307 | 308): ResponseData;
+    protected getMimeType(path: string): string;
+    protected exists(path: string): boolean;
+    protected isDirectory(path: string): boolean;
+    protected broadcastChange(update: HMRUpdate): void;
+    /** @deprecated Use broadcastChange instead */
+    protected emitHMRUpdate(update: HMRUpdate): void;
+}
+export { hasContentHash, inferCacheControl };
+export default DevServer;

package/dist/errors.d.ts

@@ -0,0 +1,19 @@
+export type ErrorCategory = "build" | "runtime" | "bundle" | "install" | "filesystem";
+export interface ContainerError {
+    id: string;
+    category: ErrorCategory;
+    title: string;
+    message: string;
+    file?: string;
+    line?: number;
+    column?: number;
+    stack?: string;
+    timestamp: number;
+    raw?: unknown;
+    /** Actionable fix suggestions for the error. */
+    suggestions?: string[];
+}
+export declare function parseError(category: ErrorCategory, raw: unknown): ContainerError;
+export declare function formatErrorText(error: ContainerError): string;
+export declare function formatErrorHtml(error: ContainerError): string;
+export declare function errorOverlayScript(): string;

package/dist/frameworks/code-transforms.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Code transformation utilities for ESM/CJS conversion, CSS imports,
+ * npm import redirection, and React Refresh registration.
+ */
+export interface CssModuleContext {
+    readFile: (path: string) => string;
+    exists: (path: string) => boolean;
+}
+export declare function transformEsmToCjsSimple(code: string): string;
+export declare function resolveRelativePath(dir: string, relativePath: string): string;
+export declare function resolveCssModulePath(cssPath: string, currentFile: string | undefined, ctx: CssModuleContext): string | null;
+/**
+ * Generate replacement code for a CSS Module import.
+ * Parses the CSS file, extracts class names via regex (no css-tree dependency),
+ * generates scoped names, and injects the scoped CSS via a style tag.
+ */
+export declare function generateCssModuleReplacement(varName: string, cssPath: string, currentFile: string | undefined, ctx: CssModuleContext): string;
+/**
+ * Strip CSS imports from code. CSS Module imports (*.module.css) are converted
+ * to inline objects with class name mappings. Regular CSS imports are removed.
+ */
+export declare function stripCssImports(code: string, currentFile: string | undefined, ctx: CssModuleContext): string;
+/**
+ * Redirect bare npm package imports to esm.sh CDN URLs.
+ * Uses acorn AST for precision, falls back to regex.
+ */
+export declare function redirectNpmImports(code: string, additionalLocalPackages?: string[], dependencies?: Record<string, string>, esmShDeps?: string, installedPackages?: Set<string>): string;
+/**
+ * Add React Refresh registration to transformed code.
+ * Enables true HMR (state-preserving) for React components.
+ */
+export declare function addReactRefresh(code: string, filename: string): string;

package/dist/frameworks/next-api-handler.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Next.js API route handling
+ * Standalone functions extracted from NextDevServer for creating mock
+ * request/response objects and executing API handlers.
+ */
+import { ResponseData } from "../dev-server";
+import { BufferImpl as Buffer } from "../polyfills/stream";
+/**
+ * Parse cookie header into key-value pairs
+ */
+export declare function parseCookies(cookieHeader: string): Record<string, string>;
+/**
+ * Create mock Next.js request object
+ */
+export declare function createMockRequest(method: string, pathname: string, headers: Record<string, string>, body?: Buffer): {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    query: {
+        [k: string]: string;
+    };
+    body: any;
+    cookies: Record<string, string>;
+};
+/**
+ * Create mock Next.js response object with streaming support
+ */
+export declare function createMockResponse(): {
+    headersSent: boolean;
+    status(code: number): /*elided*/ any;
+    setHeader(name: string, value: string): /*elided*/ any;
+    getHeader(name: string): string;
+    write(chunk: string | Buffer): boolean;
+    readonly writable: boolean;
+    json(data: unknown): /*elided*/ any;
+    send(data: string | object): /*elided*/ any;
+    end(data?: string): /*elided*/ any;
+    redirect(statusOrUrl: number | string, url?: string): /*elided*/ any;
+    isEnded(): boolean;
+    waitForEnd(): Promise<void>;
+    toResponse(): ResponseData;
+};
+/**
+ * Create a streaming mock response that calls callbacks as data is written
+ */
+export declare function createStreamingMockResponse(onStart: (statusCode: number, statusMessage: string, headers: Record<string, string>) => void, onChunk: (chunk: string | Uint8Array) => void, onEnd: () => void): {
+    headersSent: boolean;
+    status(code: number): /*elided*/ any;
+    setHeader(name: string, value: string): /*elided*/ any;
+    getHeader(name: string): string;
+    write(chunk: string | Buffer): boolean;
+    readonly writable: boolean;
+    json(data: unknown): /*elided*/ any;
+    send(data: string | object): /*elided*/ any;
+    end(data?: string): /*elided*/ any;
+    redirect(statusOrUrl: number | string, url?: string): /*elided*/ any;
+    isEnded(): boolean;
+    waitForEnd(): Promise<void>;
+    toResponse(): ResponseData;
+};
+/** Type for mock response objects */
+export type MockResponse = ReturnType<typeof createMockResponse>;
+export type MockRequest = ReturnType<typeof createMockRequest>;
+export type StreamingMockResponse = ReturnType<typeof createStreamingMockResponse>;
+/**
+ * Create builtin modules map for API handler execution.
+ */
+export declare function createBuiltinModules(): Record<string, unknown>;
+/**
+ * Execute API handler code in a sandboxed context
+ */
+export declare function executeApiHandler(code: string, req: MockRequest, res: MockResponse | StreamingMockResponse, env: Record<string, string> | undefined, builtinModules: Record<string, unknown>, vfsRequire?: (id: string) => unknown): Promise<unknown>;

package/dist/frameworks/next-dev-server.d.ts

@@ -0,0 +1,141 @@
+/**
+ * NextDevServer - Next.js-compatible dev server for the web-containers environment.
+ * Implements file-based routing, API routes, and HMR via postMessage.
+ *
+ * ## Framework Dev Server Roadmap
+ *
+ * Currently supported:
+ * - **Next.js** (Pages Router + App Router) — implemented in this file.
+ *
+ * Planned framework support:
+ * - **Vite SSR** — generic Vite-based dev server with SSR support.
+ * - **Remix** — loader/action-based routing with nested layouts.
+ * - **SvelteKit** — file-based routing with server-side load functions.
+ * - **Nuxt** — Vue-based file-system routing and server routes.
+ * - **Astro** — content-focused with island architecture.
+ * - **SolidStart** — SolidJS file-based routing with SSR.
+ *
+ * To add a new framework dev server, implement the {@link DevServer} base class
+ * from `../dev-server.ts`. The base class provides `handleRequest()` dispatch,
+ * static file serving, HMR event emission, and port management. The subclass
+ * must implement route resolution, code transformation, and HTML generation.
+ *
+ * ## Unsupported Next.js Features
+ *
+ * The following Next.js features are NOT supported in this browser-based runtime:
+ *
+ * - **Middleware** (`middleware.ts`): Edge runtime middleware is not executed.
+ *   Requests go directly to route handlers without middleware interception.
+ *
+ * - **Server Actions**: React Server Actions (`"use server"` directive) are not
+ *   supported. Form submissions using server actions will not work.
+ *
+ * - **React Server Components (RSC)**: All components run as client components.
+ *   The `"use client"` directive is accepted but has no effect since everything
+ *   is already client-side.
+ *
+ * - **Incremental Static Regeneration (ISR)**: `revalidate` options in
+ *   `getStaticProps` or route segment configs are ignored. Pages are always
+ *   rendered on demand.
+ *
+ * - **Internationalization (i18n)**: The `i18n` configuration in `next.config.js`
+ *   is not processed. Locale detection and routing are not performed.
+ *
+ * - **Rewrites and Redirects**: Configuration-based rewrites and redirects from
+ *   `next.config.js` are not applied. Use client-side routing instead.
+ *
+ * - **Parallel Routes and Intercepting Routes**: Advanced App Router patterns
+ *   like `@slot` parallel routes and `(..)` intercepting routes are not supported.
+ *
+ * - **Image Optimization**: The `next/image` component renders a plain `<img>` tag.
+ *   No server-side image optimization is performed.
+ *
+ * - **Edge Runtime**: API routes and pages cannot use `export const runtime = 'edge'`.
+ *   All execution happens in the browser's main thread.
+ */
+import { DevServer, type DevServerOptions, type ResponseData } from "../dev-server";
+import { MemFS } from "../memfs";
+import { BufferImpl as Buffer } from "../polyfills/stream";
+declare global {
+    interface Window {
+        __esbuild?: typeof import("esbuild-wasm");
+        __esbuildInitPromise?: Promise<void>;
+    }
+}
+export interface NextDevServerOptions extends DevServerOptions {
+    pagesDir?: string;
+    appDir?: string;
+    publicDir?: string;
+    preferAppRouter?: boolean;
+    env?: Record<string, string>;
+    basePath?: string;
+    additionalImportMap?: Record<string, string>;
+    additionalLocalPackages?: string[];
+    esmShDeps?: string;
+    /** Timeout in milliseconds for API handler execution. Defaults to 30000 (30s). */
+    apiHandlerTimeout?: number;
+}
+export declare class NextDevServer extends DevServer {
+    private pagesDir;
+    private appDir;
+    private publicDir;
+    private useAppRouter;
+    private watcherCleanup;
+    private hmrTargetWindow;
+    private options;
+    private transformCache;
+    private pathAliases;
+    private basePath;
+    private get routeCtx();
+    constructor(vfs: MemFS, options: NextDevServerOptions);
+    private loadPathAliases;
+    private resolvePathAliases;
+    setEnv(key: string, value: string): void;
+    getEnv(): Record<string, string>;
+    /**
+     * Set the target window for HMR updates (typically iframe.contentWindow).
+     * Enables postMessage-based HMR delivery to sandboxed iframes.
+     */
+    setHMRTarget(targetWindow: Window): void;
+    private generateEnvScript;
+    handleRequest(method: string, url: string, headers: Record<string, string>, body?: Buffer): Promise<ResponseData>;
+    private serveNextShim;
+    private serveRouteInfo;
+    private servePageComponent;
+    private serveAppComponent;
+    private handleApiRoute;
+    private handleAppRouteHandler;
+    private handlePageRoute;
+    private handleAppRouterPage;
+    private _tailwindConfigCache;
+    private loadTailwindConfig;
+    private htmlContext;
+    private generateAppRouterHtml;
+    private generatePageHtml;
+    private serve404Page;
+    private transformAndServe;
+    private transformCode;
+    private _dependencies;
+    private getDependencies;
+    private _installedPackages;
+    private getInstalledPackages;
+    invalidatePackageCache(): void;
+    private doRedirectNpmImports;
+    private doStripCssImports;
+    private getCssModuleContext;
+    private transformApiHandler;
+    protected serveFile(filePath: string): ResponseData;
+    /**
+     * Serve an npm module from /node_modules/ with ESM-to-CJS transform.
+     * Accessed via /_npm/{package}/{file} URLs from the import map.
+     */
+    private serveNpmModule;
+    /**
+     * Start file watching for HMR.
+     * Watches /pages, /app, and /public for changes and emits HMR updates.
+     */
+    startWatching(): void;
+    private handleFileChange;
+    stop(): void;
+}
+export default NextDevServer;

package/dist/frameworks/next-html-generator.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Next.js HTML page generation
+ * Standalone functions extracted from NextDevServer for generating
+ * App Router HTML, Pages Router HTML, and 404 pages.
+ */
+import { ResponseData } from "../dev-server";
+/** Resolved App Router route with page, layouts, and UI convention files */
+export interface AppRoute {
+    page: string;
+    layouts: string[];
+    params: Record<string, string | string[]>;
+    loading?: string;
+    error?: string;
+    notFound?: string;
+}
+/** Context needed by HTML generation functions */
+export interface HtmlGeneratorContext {
+    port: number;
+    exists: (path: string) => boolean;
+    generateEnvScript: () => string;
+    loadTailwindConfigIfNeeded: () => Promise<string>;
+    /** Additional import map entries (e.g., framework-specific CDN mappings) */
+    additionalImportMap?: Record<string, string>;
+}
+/**
+ * Generate HTML for App Router with nested layouts
+ */
+export declare function generateAppRouterHtml(ctx: HtmlGeneratorContext, route: AppRoute, pathname: string): Promise<string>;
+/**
+ * Generate HTML shell for a Pages Router page
+ */
+export declare function generatePageHtml(ctx: HtmlGeneratorContext, pageFile: string, pathname: string): Promise<string>;
+/**
+ * Serve a basic 404 page
+ */
+export declare function serve404Page(port: number): ResponseData;

package/dist/frameworks/next-route-resolver.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Next.js route resolution
+ * Standalone functions for resolving App Router routes, Pages Router routes,
+ * API routes, and file extensions.
+ */
+import { type AppRoute } from "./next-html-generator";
+/** Context needed by route resolution functions */
+export interface RouteResolverContext {
+    exists: (path: string) => boolean;
+    isDirectory: (path: string) => boolean;
+    readdir: (path: string) => string[];
+}
+export declare function hasAppRouter(appDir: string, ctx: RouteResolverContext): boolean;
+export declare function resolveAppRoute(appDir: string, pathname: string, ctx: RouteResolverContext): AppRoute | null;
+export declare function resolveAppRouteHandler(appDir: string, pathname: string, ctx: RouteResolverContext): string | null;
+export declare function resolvePageFile(pagesDir: string, pathname: string, ctx: RouteResolverContext): string | null;
+export declare function resolveApiFile(pagesDir: string, pathname: string, ctx: RouteResolverContext): string | null;
+export declare function resolveFileWithExtension(pathname: string, ctx: RouteResolverContext): string | null;
+export declare function needsTransform(path: string): boolean;