@rsdoctor/core 2.0.0-alpha.0 → 2.0.0-alpha.1

package/dist/sdk/server/apis/fs.js

@@ -0,0 +1,28 @@
+import "node:module";
+import { SDK } from "@rsdoctor/shared/types";
+import { BaseAPI } from "./base.js";
+import { Router } from "../router.js";
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+class FileSystemAPI extends BaseAPI {
+    async applyErrorFix() {
+        const { body } = this.ctx.req;
+        const data = body;
+        await this.ctx.sdk.applyErrorFix(data.id);
+        return 'success';
+    }
+}
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.ApplyErrorFix),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], FileSystemAPI.prototype, "applyErrorFix", null);
+export { FileSystemAPI };

package/dist/sdk/server/apis/graph.d.ts

@@ -0,0 +1,12 @@
+import { SDK } from '@rsdoctor/shared/types';
+import { BaseAPI } from './base.js';
+export declare class GraphAPI extends BaseAPI {
+    getAssetsSummary(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetAssetsSummary>>;
+    getModuleGraphForAsset(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetAssetDetails>>;
+    getChunksByModuleId(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetChunksByModuleId>>;
+    getModuleDetails(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetModuleDetails>>;
+    getDependencyByResolvedRequest(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetModulesByModuleIds>>;
+    getModuleCodeByModuleId(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetModuleCodeByModuleId>>;
+    getModuleCodeByModuleIds(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetModuleCodeByModuleIds>>;
+    getEntryModulesSummary(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetEntryPoints>>;
+}

package/dist/sdk/server/apis/graph.js

@@ -0,0 +1,116 @@
+import "node:module";
+import { SDK } from "@rsdoctor/shared/types";
+import { BaseAPI } from "./base.js";
+import { Router } from "../router.js";
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+class GraphAPI extends BaseAPI {
+    async getAssetsSummary() {
+        const { req } = this.ctx;
+        const { withFileContent } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetAssetsSummary, {
+            withFileContent
+        });
+    }
+    async getModuleGraphForAsset() {
+        const { req } = this.ctx;
+        const { assetPath } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetAssetDetails, {
+            assetPath
+        });
+    }
+    async getChunksByModuleId() {
+        const { req } = this.ctx;
+        const { moduleId } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetChunksByModuleId, {
+            moduleId
+        });
+    }
+    async getModuleDetails() {
+        const { req } = this.ctx;
+        const { moduleId } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetModuleDetails, {
+            moduleId
+        });
+    }
+    async getDependencyByResolvedRequest() {
+        const { req } = this.ctx;
+        const { moduleIds = [] } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetModulesByModuleIds, {
+            moduleIds
+        });
+    }
+    async getModuleCodeByModuleId() {
+        const { req } = this.ctx;
+        const { moduleId } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetModuleCodeByModuleId, {
+            moduleId
+        });
+    }
+    async getModuleCodeByModuleIds() {
+        const { req } = this.ctx;
+        const { moduleIds } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetModuleCodeByModuleIds, {
+            moduleIds
+        });
+    }
+    async getEntryModulesSummary() {
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetEntryPoints);
+    }
+}
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetAssetsSummary),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], GraphAPI.prototype, "getAssetsSummary", null);
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetAssetDetails),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], GraphAPI.prototype, "getModuleGraphForAsset", null);
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetChunksByModuleId),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], GraphAPI.prototype, "getChunksByModuleId", null);
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetModuleDetails),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], GraphAPI.prototype, "getModuleDetails", null);
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetModulesByModuleIds),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], GraphAPI.prototype, "getDependencyByResolvedRequest", null);
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetModuleCodeByModuleId),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], GraphAPI.prototype, "getModuleCodeByModuleId", null);
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetModuleCodeByModuleIds),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], GraphAPI.prototype, "getModuleCodeByModuleIds", null);
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetEntryPoints),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], GraphAPI.prototype, "getEntryModulesSummary", null);
+export { GraphAPI };

package/dist/sdk/server/apis/index.d.ts

@@ -0,0 +1,10 @@
+export * from './alerts.js';
+export * from './bundle-diff.js';
+export { DataAPI } from './data.js';
+export * from './fs.js';
+export * from './loader.js';
+export * from './graph.js';
+export * from './plugin.js';
+export * from './project.js';
+export * from './renderer.js';
+export * from './resolver.js';

package/dist/sdk/server/apis/index.js

@@ -0,0 +1,11 @@
+import "node:module";
+export * from "./alerts.js";
+export * from "./bundle-diff.js";
+export * from "./fs.js";
+export * from "./loader.js";
+export * from "./graph.js";
+export * from "./plugin.js";
+export * from "./project.js";
+export * from "./renderer.js";
+export * from "./resolver.js";
+export { DataAPI } from "./data.js";

package/dist/sdk/server/apis/loader.d.ts

@@ -0,0 +1,15 @@
+import { SDK } from '@rsdoctor/shared/types';
+import { BaseAPI } from './base.js';
+export declare class LoaderAPI extends BaseAPI {
+    /** report loader data api */
+    reportLoader(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.ReportLoader>>;
+    /** report sourcemap data api */
+    reportSourceMap(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.ReportLoader>>;
+    getLoaderNames(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderNames>>;
+    getLoaderChartData(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderChartData>>;
+    getLoaderFileTree(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFileTree>>;
+    getLoaderFileDetails(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFileDetails>>;
+    getLoaderFolderStatistics(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFolderStatistics>>;
+    getLoaderFileFirstInput(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFileFirstInput>>;
+    getLoaderFileInputAndOutput(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFileInputAndOutput>>;
+}

package/dist/sdk/server/apis/loader.js

@@ -0,0 +1,120 @@
+import "node:module";
+import { SDK } from "@rsdoctor/shared/types";
+import { BaseAPI } from "./base.js";
+import { Router } from "../router.js";
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+class LoaderAPI extends BaseAPI {
+    async reportLoader() {
+        const { req, sdk } = this.ctx;
+        const { body } = req;
+        sdk.reportLoader(body);
+        return 'ok';
+    }
+    async reportSourceMap() {
+        const { req: { body }, sdk } = this.ctx;
+        sdk.reportSourceMap(body);
+        return 'ok';
+    }
+    async getLoaderNames() {
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetLoaderNames);
+    }
+    async getLoaderChartData() {
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetLoaderChartData);
+    }
+    async getLoaderFileTree() {
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetLoaderFileTree);
+    }
+    async getLoaderFileDetails() {
+        const { req } = this.ctx;
+        const { path } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetLoaderFileDetails, {
+            path
+        });
+    }
+    async getLoaderFolderStatistics() {
+        const { req } = this.ctx;
+        const { folder } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetLoaderFolderStatistics, {
+            folder
+        });
+    }
+    async getLoaderFileFirstInput() {
+        const { req } = this.ctx;
+        const { file } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetLoaderFileFirstInput, {
+            file
+        });
+    }
+    async getLoaderFileInputAndOutput() {
+        const { req } = this.ctx;
+        const { file, loader, loaderIndex } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetLoaderFileInputAndOutput, {
+            file,
+            loader,
+            loaderIndex
+        });
+    }
+}
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.ReportLoader),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], LoaderAPI.prototype, "reportLoader", null);
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.ReportSourceMap),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], LoaderAPI.prototype, "reportSourceMap", null);
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetLoaderNames),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], LoaderAPI.prototype, "getLoaderNames", null);
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetLoaderChartData),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], LoaderAPI.prototype, "getLoaderChartData", null);
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetLoaderFileTree),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], LoaderAPI.prototype, "getLoaderFileTree", null);
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetLoaderFileDetails),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], LoaderAPI.prototype, "getLoaderFileDetails", null);
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetLoaderFolderStatistics),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], LoaderAPI.prototype, "getLoaderFolderStatistics", null);
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetLoaderFileFirstInput),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], LoaderAPI.prototype, "getLoaderFileFirstInput", null);
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetLoaderFileInputAndOutput),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], LoaderAPI.prototype, "getLoaderFileInputAndOutput", null);
+export { LoaderAPI };

package/dist/sdk/server/apis/plugin.d.ts

@@ -0,0 +1,6 @@
+import { SDK } from '@rsdoctor/shared/types';
+import { BaseAPI } from './base.js';
+export declare class PluginAPI extends BaseAPI {
+    getPluginSummary(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetPluginSummary>>;
+    getPluginData(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetPluginData>>;
+}

package/dist/sdk/server/apis/plugin.js

@@ -0,0 +1,39 @@
+import "node:module";
+import { SDK } from "@rsdoctor/shared/types";
+import { BaseAPI } from "./base.js";
+import { Router } from "../router.js";
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+class PluginAPI extends BaseAPI {
+    async getPluginSummary() {
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetPluginSummary);
+    }
+    async getPluginData() {
+        const { req } = this.ctx;
+        const { hooks = [], tapNames = [] } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetPluginData, {
+            hooks,
+            tapNames
+        });
+    }
+}
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetPluginSummary),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], PluginAPI.prototype, "getPluginSummary", null);
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetPluginData),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], PluginAPI.prototype, "getPluginData", null);
+export { PluginAPI };

package/dist/sdk/server/apis/project.d.ts

@@ -0,0 +1,8 @@
+import { SDK } from '@rsdoctor/shared/types';
+import { BaseAPI } from './base.js';
+export declare class ProjectAPI extends BaseAPI {
+    env(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.Env>>;
+    manifest(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.Manifest>>;
+    getProjectInfo(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetProjectInfo>>;
+    getClientRoutes(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetClientRoutes>>;
+}

package/dist/sdk/server/apis/project.js

@@ -0,0 +1,59 @@
+import "node:module";
+import { SDK } from "@rsdoctor/shared/types";
+import { BaseAPI } from "./base.js";
+import { Router } from "../router.js";
+import { getLocalIpAddress } from "../utils.js";
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+class ProjectAPI extends BaseAPI {
+    async env() {
+        const { server } = this.ctx;
+        return {
+            ip: getLocalIpAddress(),
+            port: server.port
+        };
+    }
+    async manifest() {
+        const { sdk } = this.ctx;
+        const data = sdk.getManifestData();
+        return JSON.stringify(data);
+    }
+    async getProjectInfo() {
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetProjectInfo);
+    }
+    async getClientRoutes() {
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetClientRoutes);
+    }
+}
+_ts_decorate([
+    Router.get(SDK.ServerAPI.API.Env),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], ProjectAPI.prototype, "env", null);
+_ts_decorate([
+    Router.get(SDK.ServerAPI.API.Manifest),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], ProjectAPI.prototype, "manifest", null);
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetProjectInfo),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], ProjectAPI.prototype, "getProjectInfo", null);
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetClientRoutes),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], ProjectAPI.prototype, "getClientRoutes", null);
+export { ProjectAPI };

package/dist/sdk/server/apis/renderer.d.ts

@@ -0,0 +1,6 @@
+import { SDK } from '@rsdoctor/shared/types';
+import { BaseAPI } from './base.js';
+export declare class RendererAPI extends BaseAPI {
+    /** sdk manifest api */
+    entryHtml(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.EntryHtml>>;
+}

package/dist/sdk/server/apis/renderer.js

@@ -0,0 +1,33 @@
+import "node:module";
+import { SDK } from "@rsdoctor/shared/types";
+import node_fs from "node:fs";
+import { createRequire } from "module";
+import { BaseAPI } from "./base.js";
+import { Router } from "../router.js";
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+const renderer_require = createRequire(import.meta.url);
+class RendererAPI extends BaseAPI {
+    async entryHtml() {
+        const { server, res } = this.ctx;
+        const clientHtmlPath = server.innerClientPath ? server.innerClientPath : renderer_require.resolve('@rsdoctor/client');
+        const clientHtml = node_fs.readFileSync(clientHtmlPath, 'utf-8');
+        res.setHeader('Content-Type', 'text/html');
+        res.setHeader('Cache-Control', 'no-store');
+        return clientHtml;
+    }
+}
+_ts_decorate([
+    Router.get(SDK.ServerAPI.API.EntryHtml),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], RendererAPI.prototype, "entryHtml", null);
+export { RendererAPI };

package/dist/sdk/server/apis/resolver.d.ts

@@ -0,0 +1,6 @@
+import { SDK } from '@rsdoctor/shared/types';
+import { BaseAPI } from './base.js';
+export declare class ResolverAPI extends BaseAPI {
+    getResolverFileTree(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetResolverFileTree>>;
+    getResolverFileDetails(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetResolverFileDetails>>;
+}

package/dist/sdk/server/apis/resolver.js

@@ -0,0 +1,38 @@
+import "node:module";
+import { SDK } from "@rsdoctor/shared/types";
+import { BaseAPI } from "./base.js";
+import { Router } from "../router.js";
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+class ResolverAPI extends BaseAPI {
+    async getResolverFileTree() {
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetResolverFileTree);
+    }
+    async getResolverFileDetails() {
+        const { req } = this.ctx;
+        const { filepath } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetResolverFileDetails, {
+            filepath
+        });
+    }
+}
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetResolverFileTree),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], ResolverAPI.prototype, "getResolverFileTree", null);
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetResolverFileDetails),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], ResolverAPI.prototype, "getResolverFileDetails", null);
+export { ResolverAPI };

package/dist/sdk/server/client.d.ts

@@ -0,0 +1,3 @@
+export declare const resolveClientHtmlPath: (innerClientPath?: string) => string;
+export declare const resolveClientDistPath: (innerClientPath?: string) => string;
+export declare const resolveClientDiffHtmlPath: (innerClientPath?: string) => string;

package/dist/sdk/server/client.js

@@ -0,0 +1,8 @@
+import "node:module";
+import path from "path";
+import { createRequire } from "module";
+const client_require = createRequire(import.meta.url);
+const resolveClientHtmlPath = (innerClientPath)=>innerClientPath || client_require.resolve('@rsdoctor/client');
+const resolveClientDistPath = (innerClientPath)=>path.dirname(resolveClientHtmlPath(innerClientPath));
+const resolveClientDiffHtmlPath = (innerClientPath)=>path.resolve(resolveClientDistPath(innerClientPath), 'diff.html');
+export { resolveClientDiffHtmlPath, resolveClientDistPath, resolveClientHtmlPath };

package/dist/sdk/server/fakeServer.d.ts

@@ -0,0 +1,9 @@
+import { SDK } from '@rsdoctor/shared/types';
+import { RsdoctorServer } from './index.js';
+export declare class RsdoctorFakeServer extends RsdoctorServer {
+    protected sdk: SDK.RsdoctorBuilderSDKInstance;
+    constructor(sdk: SDK.RsdoctorBuilderSDKInstance, port?: number);
+    bootstrap(): Promise<void>;
+    openClientPage(): Promise<void>;
+    dispose: () => Promise<void>;
+}

package/dist/sdk/server/fakeServer.js

@@ -0,0 +1,12 @@
+import "node:module";
+import { Server } from "../../build-utils/index.js";
+import { RsdoctorServer } from "./index.js";
+class RsdoctorFakeServer extends RsdoctorServer {
+    async bootstrap() {}
+    async openClientPage() {}
+    constructor(sdk, port = Server.defaultPort){
+        super(sdk, port), this.sdk = sdk, this.dispose = async ()=>{};
+        this.sdk = sdk;
+    }
+}
+export { RsdoctorFakeServer };

package/dist/sdk/server/index.d.ts

@@ -0,0 +1,44 @@
+import { Common, SDK, Thirdparty, Client } from '@rsdoctor/shared/types';
+export * from './utils.js';
+export type ISocketType = {
+    port: number;
+    socketUrl: string;
+    token: string;
+};
+export type RsdoctorServerOptions = {
+    innerClientPath?: string;
+    printServerUrl?: boolean;
+    cors?: SDK.RsdoctorServerConfig['cors'];
+};
+export declare class RsdoctorServer implements SDK.RsdoctorServerInstance {
+    protected sdk: SDK.RsdoctorBuilderSDKInstance;
+    private _server;
+    port: number;
+    private _socket?;
+    private disposed;
+    private _router;
+    private _innerClientPath;
+    private _printServerUrl;
+    private _cors;
+    private _socketToken;
+    constructor(sdk: SDK.RsdoctorBuilderSDKInstance, port?: number, config?: RsdoctorServerOptions);
+    get app(): SDK.RsdoctorServerInstance['app'];
+    get host(): string;
+    get origin(): string;
+    get socketUrl(): ISocketType;
+    get innerClientPath(): string;
+    private createInnerServer;
+    private resolveCorsOptions;
+    bootstrap(): Promise<void>;
+    protected wrapNextHandleFunction(method: 'GET' | 'POST', cb: (...args: Parameters<Thirdparty.connect.NextHandleFunction>) => Common.PlainObject | string): Thirdparty.connect.NextHandleFunction;
+    proxy(api: SDK.ServerAPI.API, method: 'GET' | 'POST', cb: (...args: Parameters<Thirdparty.connect.NextHandleFunction>) => Common.PlainObject | string): void;
+    get: SDK.RsdoctorServerInstance['get'];
+    post: SDK.RsdoctorServerInstance['post'];
+    getClientUrl(route: Client.RsdoctorClientRoutes, baselineUrl: string, currentUrl: string): string;
+    getClientUrl(route?: 'homepage'): string;
+    openClientPage(route: Client.RsdoctorClientRoutes, baselineUrl: string, currentUrl: string): Promise<void>;
+    openClientPage(route?: 'homepage'): Promise<void>;
+    sendAPIDataToClient<T extends SDK.ServerAPI.API | SDK.ServerAPI.APIExtends>(api: T, msg: SDK.ServerAPI.SocketResponseType<T>): void;
+    broadcast(): Promise<void>;
+    dispose: (exitCode?: number) => Promise<void>;
+}