registerEnvGlobalPackedFuncs() {
	        // Register the timer function to enable the time_evaluator.
	        const perf = compact.getPerformance();
	        // Helper function to time the finvoke
	        const timeExecution = (finvoke, dev, nstep, repeat, minRepeatMs, limitZeroTimeIterations, cooldownIntervalMs, repeatsToCooldown) => __awaiter(this, void 0, void 0, function* () {
	            // detach and explicit dispose when tasks is fullfilled
	            // the promise will immediately return and we need to makesure
	            // finvoke do not get recycled.
	            this.ctx.detachFromCurrentScope(finvoke);
	            finvoke(this.scalar(1, "int32"));
	            yield dev.sync();
	            const result = [];
	            let setupNumber = nstep;
	            for (let i = 0; i < repeat; ++i) {
	                let durationMs = 0.0;
	                let absoluteZeroTimes = 0;
	                do {
	                    if (durationMs > 0.0) {
	                        let golden_ratio = 1.618;
	                        setupNumber = Math.floor(Math.max(minRepeatMs / (durationMs / setupNumber) + 1, setupNumber * golden_ratio));
	                    }
	                    const tstart = perf.now();
	                    finvoke(this.scalar(setupNumber, "int32"));
	                    yield dev.sync();
	                    const tend = perf.now();
	                    durationMs = tend - tstart;
	                    if (durationMs == 0) {
	                        absoluteZeroTimes++;
	                    }
	                } while (durationMs < minRepeatMs && absoluteZeroTimes < limitZeroTimeIterations);
	                const speed = durationMs / setupNumber / 1000;
	                result.push(speed);
	                if (cooldownIntervalMs > 0.0 && (i % repeatsToCooldown) == 0) {
	                    yield new Promise(r => setTimeout(r, cooldownIntervalMs));
	                }
	            }
	            const ret = new Float64Array(result.length);
	            ret.set(result);
	            // dispose finvoke
	            finvoke.dispose();
	            return new Uint8Array(ret.buffer);
	        });
	        const addOne = (x) => __awaiter(this, void 0, void 0, function* () {
	            yield new Promise(resolve => setTimeout(resolve, 100));
	            return x + 1;
	        });
	        this.registerAsyncServerFunc("wasm.TimeExecution", timeExecution);
	        this.registerAsyncServerFunc("testing.asyncAddOne", addOne);
	    }
Register global packed functions needed by the backend to the env.