@module-federation/treeshake-server 0.0.0-chore-bump-node-22-20260710161714

package/dist/server.mjs

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { createServer, createOssAdapterRegistry, createLogger, DEFAULT_STATIC_ROOT, createApp, createAdapterDeps } from "./876.mjs";
+const DEFAULT_PRUNE_INTERVAL_MS = 3600000;
+function envStr(env, name, fallback) {
+    const v = env[name];
+    if (void 0 === v || '' === v) return fallback;
+    return v;
+}
+function envNum(env, name, fallback) {
+    const v = envStr(env, name);
+    if (!v) return fallback;
+    const n = Number(v);
+    return Number.isFinite(n) ? n : fallback;
+}
+function resolveOssEnv(params) {
+    const adapterId = envStr(params.env, 'ADAPTER_ID', params.defaultAdapterId) ?? 'local';
+    const adapter = params.registry.getAdapterById(adapterId);
+    const adapterConfig = adapter.fromEnv ? adapter.fromEnv(params.env) : {};
+    return {
+        adapterId,
+        adapterConfig,
+        corsOrigin: envStr(params.env, 'CORS_ORIGIN', '*') ?? '*',
+        staticRootDir: envStr(params.env, 'LOCAL_STORE_DIR', DEFAULT_STATIC_ROOT) ?? DEFAULT_STATIC_ROOT,
+        logLevel: envStr(params.env, 'LOG_LEVEL', 'info') ?? 'info',
+        port: envNum(params.env, 'PORT', 3000),
+        hostname: envStr(params.env, 'HOST', '0.0.0.0') ?? '0.0.0.0',
+        pruneIntervalMs: envNum(params.env, 'PNPM_PRUNE_INTERVAL_MS', DEFAULT_PRUNE_INTERVAL_MS),
+        runtimeEnv: params.env
+    };
+}
+const defaultBasePath = '/tree-shaking';
+const contentTypeByExt = (filePath)=>{
+    if (filePath.endsWith('.html')) return 'text/html; charset=utf-8';
+    if (filePath.endsWith('.js')) return "application/javascript";
+    if (filePath.endsWith('.css')) return 'text/css';
+    if (filePath.endsWith('.json')) return 'application/json';
+    if (filePath.endsWith('.svg')) return 'image/svg+xml';
+    if (filePath.endsWith('.png')) return 'image/png';
+    if (filePath.endsWith('.jpg') || filePath.endsWith('.jpeg')) return 'image/jpeg';
+    if (filePath.endsWith('.webp')) return 'image/webp';
+    if (filePath.endsWith('.ico')) return 'image/x-icon';
+    return 'application/octet-stream';
+};
+const safeResolve = (rootDir, requestPath)=>{
+    const rootResolved = node_path.resolve(rootDir);
+    const rel = requestPath.replace(/^\/+/, '');
+    const filePath = node_path.resolve(rootResolved, rel);
+    if (filePath !== rootResolved && !filePath.startsWith(`${rootResolved}${node_path.sep}`)) return null;
+    return filePath;
+};
+function createEmbeddedFrontendAdapter(opts) {
+    const basePath = opts.basePath ?? defaultBasePath;
+    const normalizedBase = '/' === basePath ? '' : basePath.replace(/\/$/, '');
+    const distDir = opts.distDir;
+    const indexFile = opts.indexFile ?? 'index.html';
+    const spaFallback = opts.spaFallback ?? true;
+    const handler = async (c)=>{
+        let requestPath = c.req.path;
+        try {
+            requestPath = decodeURIComponent(requestPath);
+        } catch  {
+            return c.text('Not Found', 404);
+        }
+        let relPath = requestPath;
+        if (normalizedBase && requestPath.startsWith(normalizedBase)) relPath = requestPath.slice(normalizedBase.length);
+        if (!relPath || '/' === relPath) relPath = `/${indexFile}`;
+        const filePath = safeResolve(distDir, relPath);
+        if (filePath) try {
+            const stat = await node_fs.promises.stat(filePath);
+            if (stat.isFile()) {
+                const buf = await node_fs.promises.readFile(filePath);
+                return new Response(new Uint8Array(buf), {
+                    status: 200,
+                    headers: {
+                        'Content-Type': contentTypeByExt(filePath)
+                    }
+                });
+            }
+        } catch  {}
+        if (!spaFallback) return c.text('Not Found', 404);
+        const fallbackPath = safeResolve(distDir, `/${indexFile}`);
+        if (!fallbackPath) return c.text('Not Found', 404);
+        try {
+            const buf = await node_fs.promises.readFile(fallbackPath);
+            return new Response(new Uint8Array(buf), {
+                status: 200,
+                headers: {
+                    'Content-Type': contentTypeByExt(fallbackPath)
+                }
+            });
+        } catch  {
+            return c.text('Not Found', 404);
+        }
+    };
+    return {
+        id: 'treeshake-embedded-frontend',
+        register (app) {
+            const base = normalizedBase || '/';
+            app.get(base, handler);
+            app.get(`${base}/*`, handler);
+        }
+    };
+}
+const hasIndexHtml = (dir)=>Boolean(dir && node_fs.existsSync(node_path.join(dir, 'index.html')));
+const resolveFrontendDistDir = ()=>{
+    const envDir = process.env.TREESHAKE_FRONTEND_DIST;
+    if (envDir) {
+        if (hasIndexHtml(envDir)) return envDir;
+        throw new Error(`TREESHAKE_FRONTEND_DIST is set but index.html is missing: ${envDir}`);
+    }
+    const candidates = [
+        node_path.resolve(__dirname, 'frontend'),
+        node_path.resolve(__dirname, '..', 'frontend')
+    ];
+    for (const candidate of candidates)if (hasIndexHtml(candidate)) return candidate;
+    const workspaceCandidates = [
+        node_path.resolve(process.cwd(), 'packages', 'treeshake-frontend', 'dist'),
+        node_path.resolve(process.cwd(), 'treeshake-frontend', 'dist')
+    ];
+    for (const candidate of workspaceCandidates)if (hasIndexHtml(candidate)) return candidate;
+};
+async function main() {
+    const registry = createOssAdapterRegistry();
+    const resolved = resolveOssEnv({
+        env: {
+            ...process.env,
+            ADAPTER_ID: 'local'
+        },
+        registry,
+        defaultAdapterId: 'local'
+    });
+    const logger = createLogger({
+        level: resolved.logLevel
+    });
+    const deps = await createAdapterDeps({
+        registry,
+        adapterId: resolved.adapterId,
+        adapterConfig: resolved.adapterConfig,
+        logger
+    });
+    const frontendAdapters = [];
+    const distDir = resolveFrontendDistDir();
+    if (!distDir) throw new Error('Treeshake UI dist not found. Rebuild the CLI bundle or set TREESHAKE_FRONTEND_DIST.');
+    frontendAdapters.push(createEmbeddedFrontendAdapter({
+        basePath: process.env.TREESHAKE_FRONTEND_BASE_PATH ?? '/tree-shaking',
+        distDir,
+        spaFallback: '0' !== process.env.TREESHAKE_FRONTEND_SPA_FALLBACK && 'false' !== process.env.TREESHAKE_FRONTEND_SPA_FALLBACK
+    }));
+    const app = createApp(deps, {
+        corsOrigin: resolved.corsOrigin,
+        staticRootDir: resolved.staticRootDir,
+        pruneIntervalMs: resolved.pruneIntervalMs,
+        logger,
+        runtimeEnv: resolved.runtimeEnv,
+        frontendAdapters
+    });
+    createServer({
+        app,
+        port: resolved.port,
+        hostname: resolved.hostname
+    });
+    console.log('Build service listening.');
+    if (frontendAdapters.length) console.log('Treeshake UI available.');
+}
+main().catch((err)=>{
+    console.error(err);
+    process.exit(1);
+});

package/dist/services/buildService.d.ts

@@ -0,0 +1,8 @@
+import { type BuildType, type NormalizedConfig } from '../domain/build/normalize-config';
+import type { SharedFilePath } from './uploadService';
+export declare const createUniqueTempDirByKey: (key: string) => Promise<string>;
+export declare const runBuild: (normalizedConfig: NormalizedConfig, excludeShared: Array<[string, string]>, type: BuildType) => Promise<{
+    sharedFilePaths: SharedFilePath[];
+    dir: string;
+}>;
+export declare function cleanUp(tmpDir?: string): Promise<void>;

package/dist/services/cacheService.d.ts

@@ -0,0 +1,15 @@
+import { type BuildType, type NormalizedConfig } from '../domain/build/normalize-config';
+import type { ObjectStore } from '../ports/objectStore';
+import type { UploadResult } from './uploadService';
+export declare function createCacheHash(config: NormalizedConfig[string], type: BuildType): string;
+export declare function retrieveCDNPath({ config, sharedKey, type, }: {
+    config: NormalizedConfig[string];
+    sharedKey: string;
+    type: BuildType;
+}): string;
+export declare function hitCache(sharedKey: string, config: NormalizedConfig[string], type: BuildType, store: ObjectStore): Promise<string | null>;
+export declare const retrieveCacheItems: (normalizedConfig: NormalizedConfig, type: BuildType, store: ObjectStore) => Promise<{
+    cacheItems: UploadResult[];
+    excludeShared: [sharedName: string, version: string][];
+    restConfig: NormalizedConfig;
+}>;

package/dist/services/pnpmMaintenance.d.ts

@@ -0,0 +1,4 @@
+export declare const markInstallStart: () => void;
+export declare const markInstallEnd: () => void;
+export declare const maybePrune: () => Promise<void>;
+export declare const startPeriodicPrune: (intervalMs?: number) => void;

package/dist/services/uploadService.d.ts

@@ -0,0 +1,36 @@
+import { type BuildType, type NormalizedConfig } from '../domain/build/normalize-config';
+import type { Config } from '../domain/build/schema';
+import type { ObjectStore } from '../ports/objectStore';
+import type { ProjectPublisher } from '../ports/projectPublisher';
+export interface SharedFilePath {
+    name: string;
+    version: string;
+    filepath: string;
+    globalName: string;
+    type: BuildType;
+    canTreeShaking: boolean;
+    modules?: string[];
+}
+export interface UploadResult {
+    name: string;
+    version: string;
+    globalName: string;
+    cdnUrl: string;
+    type: BuildType;
+    modules?: string[];
+    canTreeShaking?: boolean;
+}
+/**
+ * Upload shared files to CDN
+ * @param sharedFilePaths Array of shared file paths to upload
+ * @returns Array of upload results with CDN URLs
+ */
+export declare function uploadToCacheStore(sharedFilePaths: SharedFilePath[], normalizedConfig: NormalizedConfig, store: ObjectStore): Promise<UploadResult[]>;
+export interface UploadOpts {
+    bucketName: string;
+    scmName: string;
+    cdnRegion: string;
+    publicRoot: string;
+}
+export declare function uploadProject(uploadResults: UploadResult[], sharedFilePaths: SharedFilePath[], normalizedConfig: NormalizedConfig, publisher: ProjectPublisher, store: ObjectStore): Promise<UploadResult[]>;
+export declare function upload(sharedFilePaths: SharedFilePath[], uploadResults: UploadResult[], normalizedConfig: NormalizedConfig, uploadOptions: Config['uploadOptions'], store: ObjectStore, publisher?: ProjectPublisher): Promise<UploadResult[]>;

package/dist/template/re-shake-share/Collect.js

@@ -0,0 +1,115 @@
+function getProvidedExports(compilation, mod, statsModules, identifier) {
+    try {
+        const mg = compilation.moduleGraph;
+        if (!mg) return 'unknown';
+        const exportsInfo = mg.getExportsInfo(mod);
+        if (!exportsInfo) return 'unknown';
+        const provided = exportsInfo.getProvidedExports && exportsInfo.getProvidedExports();
+        if (Array.isArray(provided)) return provided.filter((x)=>'string' == typeof x);
+        const statModule = statsModules.find((x)=>x.identifier === identifier);
+        if (!statModule) return 'unknown';
+        if (statModule.providedExports) return statModule.providedExports;
+        return 'unknown';
+    } catch (e) {
+        return 'unknown';
+    }
+}
+function isEsmLikeModule(mod) {
+    const bm = mod && mod.buildMeta;
+    if (!bm) return;
+    if ('string' == typeof bm.exportsType) return 'default' !== bm.exportsType;
+    if ('boolean' == typeof bm.strictHarmonyModule) return bm.strictHarmonyModule;
+    if ('boolean' == typeof bm.harmonyModule) return bm.harmonyModule;
+}
+function isSideEffectFree(mod) {
+    const fm = mod && mod.factoryMeta;
+    if (fm && 'boolean' == typeof fm.sideEffectFree) return fm.sideEffectFree;
+    const bm = mod && mod.buildMeta;
+    if (bm && 'boolean' == typeof bm.sideEffectFree) return bm.sideEffectFree;
+    return false;
+}
+class SharedTreeShakingAuditPlugin {
+    constructor(opts){
+        opts = opts || {};
+        this.options = {
+            libs: opts.libs || [],
+            filename: opts.filename || 'shared-tree-shaking-report.json',
+            entryOnly: void 0 !== opts.entryOnly ? !!opts.entryOnly : true,
+            debug: !!opts.debug
+        };
+    }
+    apply(compiler) {
+        const pluginName = 'SharedTreeShakingAuditPlugin';
+        compiler.hooks.thisCompilation.tap(pluginName, (compilation)=>{
+            const collectSharedEntryPlugin = compiler.options.plugins.find((p)=>'CollectSharedEntryPlugin' === p.name);
+            if (!collectSharedEntryPlugin) return;
+            const stage = compiler.webpack && compiler.webpack.Compilation && compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE || 4000;
+            compilation.hooks.processAssets.tapPromise({
+                name: pluginName,
+                stage
+            }, async ()=>{
+                const reports = [];
+                const statsModules = compilation.getStats().toJson().modules;
+                for (const libName of this.options.libs){
+                    const report = {
+                        lib: libName,
+                        resolvedEntry: void 0,
+                        entryModuleIdentifier: void 0,
+                        canTreeShaking: false,
+                        reasons: [],
+                        evidence: {},
+                        exports: 'unknown'
+                    };
+                    if (!libName) {
+                        report.reasons.push('lib configuration is empty');
+                        reports.push(report);
+                        continue;
+                    }
+                    let entryModule;
+                    for (const mod of compilation.modules){
+                        const res = mod && mod.resource;
+                        if (res && 'string' == typeof res) {
+                            if (mod.rawRequest === libName) {
+                                entryModule = mod;
+                                break;
+                            }
+                        }
+                    }
+                    if (!entryModule) {
+                        report.reasons.push(`can not find module for ${libName}`);
+                        reports.push(report);
+                        continue;
+                    }
+                    report.entryModuleIdentifier = 'function' == typeof entryModule.identifier && entryModule.identifier() || entryModule.debugId || 'unknown';
+                    const providedExports = getProvidedExports(compilation, entryModule, statsModules, report.entryModuleIdentifier);
+                    report.exports = providedExports;
+                    const esmLike = isEsmLikeModule(entryModule);
+                    const sideEffectFree = isSideEffectFree(entryModule);
+                    report.evidence.isEsmLike = esmLike;
+                    report.evidence.sideEffectFree = sideEffectFree;
+                    report.evidence.buildMeta = entryModule.buildMeta;
+                    report.evidence.factoryMeta = entryModule.factoryMeta;
+                    if (false === esmLike) report.reasons.push('entry module is not ESM (likely CJS), static treeshake is hard');
+                    if (false === sideEffectFree) report.reasons.push('sideEffectFree=false, treeshake might be forbidden');
+                    const canTreeshake = false !== esmLike && false !== sideEffectFree;
+                    report.canTreeShaking = canTreeshake;
+                    if (canTreeshake) report.reasons.push('entry module is ESM-like and not marked as side-effect, necessary conditions are met');
+                    if (this.options.debug) compilation.warnings.push(new Error(`[${pluginName}] ${libName} entry=${resolvedEntry} exports=${Array.isArray(providedExports) ? providedExports.length : providedExports}`));
+                    reports.push(report);
+                }
+                const output = {
+                    generatedAt: new Date().toISOString(),
+                    libs: reports
+                };
+                const json = JSON.stringify(output, null, 2);
+                const RawSource = compiler.webpack && compiler.webpack.sources && compiler.webpack.sources.RawSource ? compiler.webpack.sources.RawSource : null;
+                if (RawSource) compilation.emitAsset(this.options.filename, new RawSource(json));
+                else compilation.assets[this.options.filename] = {
+                    source: ()=>json,
+                    size: ()=>json.length
+                };
+            });
+        });
+    }
+}
+export default SharedTreeShakingAuditPlugin;

package/dist/template/re-shake-share/EmitManifest.js

@@ -0,0 +1,49 @@
+import fs from 'fs';
+import path from 'path';
+class EmitManifest {
+    constructor(secondaryTreeShaking){
+        this.secondaryTreeShaking = secondaryTreeShaking;
+    }
+    apply(compiler) {
+        const { secondaryTreeShaking } = this;
+        compiler.hooks.compilation.tap('SecondaryTreeShakingPlugin', (compilation)=>{
+            compilation.hooks.processAssets.tapPromise({
+                name: 'SecondaryTreeShakingPlugin',
+                stage: compilation.constructor.PROCESS_ASSETS_STAGE_ADDITIONAL - 1000
+            }, async ()=>{
+                const treeshakeSharedPlugin = compiler.options.plugins.find((p)=>'TreeShakingSharedPlugin' === p.name);
+                if (!treeshakeSharedPlugin) return;
+                const mfConfig = treeshakeSharedPlugin.mfConfig;
+                const fakeManifest = {
+                    shared: []
+                };
+                const { shared } = fakeManifest;
+                Object.entries(mfConfig.shared).forEach(([sharedName, sharedConfig])=>{
+                    shared.push({
+                        name: sharedName,
+                        version: sharedConfig.version
+                    });
+                });
+                try {
+                    if (!secondaryTreeShaking) {
+                        const treeshakeReport = fs.readFileSync(path.resolve(compilation.options.output.path, 'independent-packages/shared-tree-shaking-report.json'));
+                        const content = JSON.parse(treeshakeReport);
+                        content.libs.forEach((libInfo)=>{
+                            const { lib, canTreeShaking, exports } = libInfo;
+                            const targetShared = shared.find((s)=>s.name === lib);
+                            if (targetShared) {
+                                targetShared.canTreeshake = canTreeShaking;
+                                targetShared.usedExports = exports;
+                            }
+                        });
+                    }
+                } catch (e) {
+                    console.error(e);
+                }
+                compilation.emitAsset('mf-manifest.json', new compiler.webpack.sources.RawSource(JSON.stringify(fakeManifest)));
+                compilation.emitAsset('mf-stats.json', new compiler.webpack.sources.RawSource(JSON.stringify(fakeManifest)));
+            });
+        });
+    }
+}
+export default EmitManifest;

package/dist/template/re-shake-share/index.ts

@@ -0,0 +1 @@
+${SHARED_IMPORT}

package/dist/template/re-shake-share/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "re-shake",
+  "version": "1.0.0",
+  "scripts": {
+    "build": "SECONDARY_TREE_SHAKING=true rspack build",
+    "build:full": "rspack build"
+  },
+  "license": "ISC",
+  "dependencies": {
+    "@rspack/cli": "1.5.8",
+    "@rspack/core": "1.5.8"
+  },
+  "pnpm": {
+    "overrides": {
+      "@rspack/core": "npm:@rspack-canary/core@1.7.3-canary-58d41d16-20260115035302"
+    },
+    "peerDependencyRules": {
+      "allowAny": [
+        "@rspack/*"
+      ]
+    }
+  }
+}

package/dist/template/re-shake-share/rspack.config.ts

@@ -0,0 +1,33 @@
+import { sharing } from "@rspack/core";
+import path from 'path';
+import CollectPlugin from "./Collect";
+import EmitManifest from './EmitManifest';
+
+
+const SECONDARY_TREE_SHAKING = Boolean(process.env.SECONDARY_TREE_SHAKING)
+
+const mfConfig = ${ MF_CONFIG };
+
+module.exports = {
+	entry: './index.ts',
+	output:{
+		path: path.resolve(process.cwd(), SECONDARY_TREE_SHAKING ? 'dist' : 'full-shared'),
+	},
+	plugins: [
+		new EmitManifest(SECONDARY_TREE_SHAKING),
+		new sharing.TreeShakingSharedPlugin({
+			secondary: SECONDARY_TREE_SHAKING,
+			plugins: ${ PLUGINS },
+			mfConfig,
+		}),
+		!SECONDARY_TREE_SHAKING && new CollectPlugin({
+			libs: Object.entries(mfConfig.shared).map(([k, v]) => {
+				if(!v.treeShaking) {
+					return null;
+				}
+				return k;
+			}).filter(Boolean),
+			filename: "shared-tree-shaking-report.json",
+		}),
+	]
+};

package/dist/utils/runCommand.d.ts

@@ -0,0 +1,20 @@
+export interface CommandOptions {
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+}
+export interface CommandResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export declare class CommandExecutionError extends Error {
+    readonly command: string;
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+    constructor(command: string, exitCode: number, stdout: string, stderr: string);
+}
+/**
+ * Execute a shell command and collect its output.
+ */
+export declare const runCommand: (command: string, options?: CommandOptions) => Promise<CommandResult>;

package/dist/utils/runtimeEnv.d.ts

@@ -0,0 +1,3 @@
+export type RuntimeEnv = Record<string, string | undefined>;
+export declare const setRuntimeEnv: (env: RuntimeEnv) => void;
+export declare const getRuntimeEnv: () => RuntimeEnv;

package/dist/utils/uploadSdk.d.ts

@@ -0,0 +1,10 @@
+export interface UploadDirectoryOptions {
+    outputDir: string;
+    cdnBaseUrl: string;
+    targetPath: string;
+}
+/**
+ * Placeholder for a real CDN upload SDK.
+ * In real usage you should import the vendor SDK and replace this implementation.
+ */
+export declare function uploadDirectory({ outputDir, cdnBaseUrl, targetPath, }: UploadDirectoryOptions): Promise<string>;

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@module-federation/treeshake-server",
+  "version": "0.0.0-chore-bump-node-22-20260710161714",
+  "description": "Build service powered by Hono that installs dependencies, builds with Rspack, and uploads artifacts.",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "treeshake-server": "bin/treeshake-server.js"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "README.md"
+  ],
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@hono/node-server": "1.19.13",
+    "@hono/zod-validator": "0.7.4",
+    "dotenv": "16.4.5",
+    "hono": "4.12.26",
+    "json-stable-stringify": "1.3.0",
+    "nanoid": "5.1.6",
+    "p-limit": "7.2.0",
+    "pino": "10.1.0",
+    "undici": "7.28.0",
+    "zod": "4.1.12"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.3",
+    "@playwright/test": "^1.57.0",
+    "@rstest/core": "^0.6.5",
+    "@types/node": "^20.11.30",
+    "@vercel/nft": "^1.1.1",
+    "pino-pretty": "^13.1.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^6.0.3"
+  },
+  "engines": {
+    "node": ">=20.19.5",
+    "pnpm": ">=10.18.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/module-federation/core.git",
+    "directory": "packages/treeshake-server"
+  },
+  "scripts": {
+    "build": "rslib build && node scripts/copy-frontend.js",
+    "lint": "biome lint src scripts",
+    "prestart": "pnpm exec turbo run build --filter=@module-federation/treeshake-server",
+    "dev": "node scripts/dev.js",
+    "start": "node dist/server.js",
+    "test": "node ../../scripts/ensure-playwright.js && rstest"
+  }
+}