@rsdoctor/core 1.6.1 → 2.0.0-alpha.1

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

@@ -0,0 +1,30 @@
+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 AlertsAPI extends BaseAPI {
+    async getPackageRelationAlertDetails() {
+        const { req } = this.ctx;
+        const { id, target } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetPackageRelationAlertDetails, {
+            id,
+            target
+        });
+    }
+}
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetPackageRelationAlertDetails),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], AlertsAPI.prototype, "getPackageRelationAlertDetails", null);
+export { AlertsAPI };

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

@@ -0,0 +1,11 @@
+import { Data } from '../../../common/index.js';
+import { Manifest, SDK } from '@rsdoctor/shared/types';
+export declare class BaseAPI implements Manifest.ManifestDataLoader {
+    [key: string | symbol]: any;
+    readonly ctx: SDK.ServerAPI.APIContext;
+    protected dataLoader: Data.APIDataLoader;
+    constructor(sdk: SDK.RsdoctorSDKInstance, server: SDK.RsdoctorServerInstance);
+    loadManifest(): Promise<Manifest.RsdoctorManifestWithShardingFiles>;
+    loadData<T extends Manifest.RsdoctorManifestMappingKeys>(key: T): Promise<Manifest.InferManifestDataValue<T>>;
+    loadData(key: string): Promise<void>;
+}

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

@@ -0,0 +1,22 @@
+import "node:module";
+import { Data } from "../../../common/index.js";
+class BaseAPI {
+    async loadManifest() {
+        return this.ctx.sdk.getManifestData();
+    }
+    async loadData(key) {
+        const data = this.ctx.sdk.getStoreData();
+        const sep = '.';
+        let res = data[key];
+        if (key.includes(sep)) res = key.split(sep).reduce((t, k)=>t[k], data);
+        return res;
+    }
+    constructor(sdk, server){
+        this.ctx = {
+            sdk,
+            server
+        };
+        this.dataLoader = new Data.APIDataLoader(this);
+    }
+}
+export { BaseAPI };

package/dist/sdk/server/apis/bundle-diff.d.ts

@@ -0,0 +1,6 @@
+import { SDK } from '@rsdoctor/shared/types';
+import { BaseAPI } from './base.js';
+export declare class BundleDiffAPI extends BaseAPI {
+    getBundleDiffSummary(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetBundleDiffSummary>>;
+    bundleDiffManifest(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.BundleDiffManifest>>;
+}

package/dist/sdk/server/apis/bundle-diff.js

@@ -0,0 +1,51 @@
+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 BundleDiffAPI extends BaseAPI {
+    async getBundleDiffSummary() {
+        const { sdk } = this.ctx;
+        const { root, hash, errors, chunkGraph, moduleGraph, packageGraph, configs, moduleCodeMap, cloudManifestUrl } = sdk.getStoreData();
+        let outputFilename = '';
+        if ('string' == typeof configs?.[0]?.config?.output?.filename) outputFilename = configs?.[0]?.config?.output?.filename;
+        return {
+            root,
+            hash,
+            errors,
+            chunkGraph,
+            moduleGraph,
+            packageGraph,
+            outputFilename,
+            moduleCodeMap,
+            cloudManifestUrl
+        };
+    }
+    async bundleDiffManifest() {
+        const { sdk } = this.ctx;
+        const data = sdk.getStoreData();
+        return data;
+    }
+}
+_ts_decorate([
+    Router.get(SDK.ServerAPI.API.GetBundleDiffSummary),
+    Router.post(SDK.ServerAPI.API.GetBundleDiffSummary),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], BundleDiffAPI.prototype, "getBundleDiffSummary", null);
+_ts_decorate([
+    Router.get(SDK.ServerAPI.API.BundleDiffManifest),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], BundleDiffAPI.prototype, "bundleDiffManifest", null);
+export { BundleDiffAPI };

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

@@ -0,0 +1,6 @@
+import { SDK } from '@rsdoctor/shared/types';
+import { BaseAPI } from './base.js';
+export declare class DataAPI extends BaseAPI {
+    loadDataByKey(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.LoadDataByKey>>;
+    sendMessageToClient(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.SendAPIDataToClient>>;
+}

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

@@ -0,0 +1,44 @@
+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 DataAPI extends BaseAPI {
+    async loadDataByKey() {
+        const { req } = this.ctx;
+        const { url } = req;
+        let { key } = req.body;
+        if (!key && url) {
+            const uri = new URL(url, 'http://127.0.0.1');
+            key = uri.pathname.replace(/^\//, '');
+        }
+        const data = await this.loadData(key);
+        return data;
+    }
+    async sendMessageToClient() {
+        const { req, server } = this.ctx;
+        const { api, data } = req.body;
+        await server.sendAPIDataToClient(api, data);
+    }
+}
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.LoadDataByKey),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], DataAPI.prototype, "loadDataByKey", null);
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.SendAPIDataToClient),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], DataAPI.prototype, "sendMessageToClient", null);
+export { DataAPI };

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

@@ -0,0 +1,5 @@
+import { SDK } from '@rsdoctor/shared/types';
+import { BaseAPI } from './base.js';
+export declare class FileSystemAPI extends BaseAPI {
+    applyErrorFix(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.ApplyErrorFix>>;
+}

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>>;
+}