ic-mops 0.39.2 → 0.41.0

package/dist/commands/bench.d.ts

@@ -1,12 +1,15 @@
+import { Benchmarks } from '../declarations/main/main.did.js';
 type BenchOptions = {
     replica: 'dfx' | 'pocket-ic';
     replicaVersion: string;
-    moc: string;
+    compiler: 'moc';
+    compilerVersion: string;
     gc: 'copying' | 'compacting' | 'generational' | 'incremental';
     forceGc: boolean;
     save: boolean;
     compare: boolean;
     verbose: boolean;
+    silent: boolean;
 };
-export declare function bench(filter?: string, optionsArg?: Partial<BenchOptions>): Promise<boolean>;
+export declare function bench(filter?: string, optionsArg?: Partial<BenchOptions>): Promise<Benchmarks>;
 export {};

package/dist/commands/bench.js

@@ -7,7 +7,7 @@ import { markdownTable } from 'markdown-table';
 import logUpdate from 'log-update';
 import { execaCommand } from 'execa';
 import stringWidth from 'string-width';
-import { getRootDir } from '../mops.js';
+import { getRootDir, readConfig } from '../mops.js';
 import { parallel } from '../parallel.js';
 import { absToRel } from './test/utils.js';
 import { getMocVersion } from '../helpers/get-moc-version.js';
@@ -28,16 +28,24 @@ let globConfig = {
 export async function bench(filter = '', optionsArg = {}) {
     let defaultOptions = {
         replica: 'dfx',
-        moc: getMocVersion(),
-        replicaVersion: '0.0.0',
+        replicaVersion: '',
+        compiler: 'moc',
+        compilerVersion: getMocVersion(),
         gc: 'copying',
         forceGc: true,
         save: false,
         compare: false,
         verbose: false,
+        silent: false,
     };
     let options = { ...defaultOptions, ...optionsArg };
-    options.replicaVersion = options.replica == 'dfx' ? getDfxVersion() : '1.0.0';
+    if (options.replica == 'dfx') {
+        options.replicaVersion = getDfxVersion();
+    }
+    else if (options.replica == 'pocket-ic') {
+        let config = readConfig();
+        options.replicaVersion = config.toolchain?.['pocket-ic'] || '';
+    }
     options.verbose && console.log(options);
     let replica = new BenchReplica(options.replica, options.verbose);
     let rootDir = getRootDir();
@@ -48,26 +56,30 @@ export async function bench(filter = '', optionsArg = {}) {
     let files = globSync(path.join(rootDir, globStr), globConfig);
     if (!files.length) {
         if (filter) {
-            console.log(`No benchmark files found for filter '${filter}'`);
-            return false;
+            options.silent || console.log(`No benchmark files found for filter '${filter}'`);
+            return [];
+        }
+        if (!options.silent) {
+            console.log('No *.bench.mo files found');
+            console.log('Put your benchmark code in \'bench\' directory in *.bench.mo files');
         }
-        console.log('No *.bench.mo files found');
-        console.log('Put your benchmark code in \'bench\' directory in *.bench.mo files');
-        return false;
+        return [];
     }
     files.sort();
     let benchDir = `${getRootDir()}/.mops/.bench/`;
     fs.rmSync(benchDir, { recursive: true, force: true });
     fs.mkdirSync(benchDir, { recursive: true });
-    console.log('Benchmark files:');
-    for (let file of files) {
-        console.log(chalk.gray(`• ${absToRel(file)}`));
+    if (!options.silent) {
+        console.log('Benchmark files:');
+        for (let file of files) {
+            console.log(chalk.gray(`• ${absToRel(file)}`));
+        }
+        console.log('');
+        console.log('='.repeat(50));
+        console.log('');
     }
-    console.log('');
-    console.log('='.repeat(50));
-    console.log('');
-    await replica.start();
-    console.log('Deploying canisters...');
+    await replica.start({ silent: options.silent });
+    options.silent || console.log('Deploying canisters...');
     await parallel(os.cpus().length, files, async (file) => {
         try {
             await deployBenchFile(file, options, replica);
@@ -78,12 +90,16 @@ export async function bench(filter = '', optionsArg = {}) {
             throw err;
         }
     });
+    let benchResults = [];
     await parallel(1, files, async (file) => {
-        console.log('\n' + '—'.repeat(50));
-        console.log(`\nRunning ${chalk.gray(absToRel(file))}...`);
-        console.log('');
+        if (!options.silent) {
+            console.log('\n' + '—'.repeat(50));
+            console.log(`\nRunning ${chalk.gray(absToRel(file))}...`);
+            console.log('');
+        }
         try {
-            await runBenchFile(file, options, replica);
+            let benchResult = await runBenchFile(file, options, replica);
+            benchResults.push(benchResult);
         }
         catch (err) {
             console.error('Unexpected error. Stopping replica...');
@@ -91,10 +107,10 @@ export async function bench(filter = '', optionsArg = {}) {
             throw err;
         }
     });
-    console.log('Stopping replica...');
+    options.silent || console.log('Stopping replica...');
     await replica.stop();
     fs.rmSync(benchDir, { recursive: true, force: true });
-    return true;
+    return benchResults;
 }
 function getMocArgs(options) {
     let args = '';
@@ -152,6 +168,8 @@ async function runBenchFile(file, options, replica) {
         }
     }
     let results = new Map();
+    let instructionsCells = Array.from({ length: schema.rows.length }, () => []);
+    let heapCells = Array.from({ length: schema.rows.length }, () => []);
     let formatNumber = (n) => {
         return n.toLocaleString('en-US').replaceAll(',', '_');
     };
@@ -199,17 +217,19 @@ async function runBenchFile(file, options, replica) {
 			\n\n${chalk.blue('Heap')}\n\n${getTable('rts_heap_size')}
 		`);
     };
-    if (!process.env.CI) {
+    if (!process.env.CI && !options.silent) {
         printResults();
     }
     // run all cells
     for (let [rowIndex, row] of schema.rows.entries()) {
         for (let [colIndex, col] of schema.cols.entries()) {
-            // let res = await actor.runCellQuery(BigInt(rowIndex), BigInt(colIndex));
-            // let res = await actor.runCellUpdate(BigInt(rowIndex), BigInt(colIndex));
             let res = await actor.runCellUpdateAwait(BigInt(rowIndex), BigInt(colIndex));
             results.set(`${row}:${col}`, res);
-            if (!process.env.CI) {
+            // @ts-ignore
+            instructionsCells[rowIndex][colIndex] = res.instructions;
+            // @ts-ignore
+            heapCells[rowIndex][colIndex] = res.rts_heap_size;
+            if (!process.env.CI && !options.silent) {
                 printResults();
             }
         }
@@ -223,7 +243,7 @@ async function runBenchFile(file, options, replica) {
         console.log(`Saving results to ${chalk.gray(absToRel(resultsJsonFile))}`);
         let json = {
             version: 1,
-            moc: options.moc,
+            moc: options.compilerVersion,
             replica: options.replica,
             replicaVersion: options.replicaVersion,
             gc: options.gc,
@@ -240,5 +260,22 @@ async function runBenchFile(file, options, replica) {
             }
         }, 2));
     }
-    return { schema, results };
+    // for backend
+    return {
+        name: schema.name,
+        description: schema.description,
+        file: absToRel(file),
+        gc: options.gc,
+        forceGC: options.forceGc,
+        replica: options.replica,
+        replicaVersion: options.replicaVersion,
+        compiler: options.compiler,
+        compilerVersion: options.compilerVersion,
+        rows: schema.rows,
+        cols: schema.cols,
+        metrics: [
+            ['instructions', instructionsCells],
+            ['rts_heap_size', heapCells],
+        ],
+    };
 }

package/dist/commands/init.js

@@ -51,7 +51,7 @@ export async function init({ yes = false } = {}) {
         onCancel() {
             console.log('aborted');
             process.exit(0);
-        }
+        },
     };
     // type
     let { type } = await prompts({

package/dist/commands/publish.d.ts

@@ -1,4 +1,5 @@
 export declare function publish(options?: {
     docs?: boolean;
     test?: boolean;
+    bench?: boolean;
 }): Promise<void>;

package/dist/commands/publish.js

@@ -5,14 +5,14 @@ import logUpdate from 'log-update';
 import { globbySync } from 'globby';
 import { minimatch } from 'minimatch';
 import prompts from 'prompts';
-import { fromMarkdown } from 'mdast-util-from-markdown';
-import { toMarkdown } from 'mdast-util-to-markdown';
 import { checkConfigFile, getIdentity, getRootDir, progressBar, readConfig } from '../mops.js';
 import { mainActor } from '../api/actors.js';
 import { parallel } from '../parallel.js';
 import { docs } from './docs.js';
 import { testWithReporter } from './test/test.js';
 import { SilentReporter } from './test/reporters/silent-reporter.js';
+import { findChangelogEntry } from '../helpers/find-changelog-entry.js';
+import { bench } from './bench.js';
 export async function publish(options = {}) {
     if (!checkConfigFile()) {
         return;
@@ -145,7 +145,7 @@ export async function publish(options = {}) {
         return {
             ...dep,
             version: dep.version || '',
-            repo: dep.repo || ''
+            repo: dep.repo || '',
         };
     };
     // map fields
@@ -231,6 +231,24 @@ export async function publish(options = {}) {
             process.exit(1);
         }
     }
+    // bench
+    let benchmarks = [];
+    if (options.bench) {
+        console.log('Running benchmarks...');
+        try {
+            benchmarks = await bench('', {
+                replica: config.toolchain?.['pocket-ic'] ? 'pocket-ic' : 'dfx',
+                gc: 'copying',
+                forceGc: true,
+                silent: true,
+            });
+        }
+        catch (err) {
+            console.error(err);
+            console.log(chalk.red('Error: ') + 'benchmarks failed');
+            process.exit(1);
+        }
+    }
     // progress
     let total = files.length + 2;
     let step = 0;
@@ -255,6 +273,10 @@ export async function publish(options = {}) {
             passedNames: reporter.passedNamesFlat,
         });
     }
+    // upload benchmarks
+    if (options.bench) {
+        await actor.uploadBenchmarks(puiblishingId, benchmarks);
+    }
     // upload changelog
     if (changelog) {
         await actor.uploadNotes(puiblishingId, changelog);
@@ -332,25 +354,3 @@ async function fetchGitHubReleaseNotes(repo, version) {
     }
     return release.body;
 }
-function findChangelogEntry(changelog, version) {
-    let tree = fromMarkdown(changelog);
-    let found = false;
-    let nodes = [];
-    for (let node of tree.children) {
-        if (found) {
-            if (node.type === 'heading') {
-                break;
-            }
-            else {
-                nodes.push(node);
-            }
-        }
-        else if (node.type === 'heading' && toMarkdown(node).match(new RegExp(`\\b${version}\\b`))) {
-            found = true;
-        }
-    }
-    return toMarkdown({
-        type: 'root',
-        children: nodes,
-    });
-}

package/dist/commands/self.d.ts

@@ -0,0 +1,3 @@
+export declare function getLatestVersion(): Promise<string>;
+export declare function update(): Promise<void>;
+export declare function uninstall(): Promise<void>;

package/dist/commands/self.js

@@ -0,0 +1,62 @@
+import child_process, { execSync } from 'node:child_process';
+import chalk from 'chalk';
+import { version, globalConfigDir } from '../mops.js';
+import { cleanCache } from '../cache.js';
+import { toolchain } from './toolchain/index.js';
+let url = 'https://x344g-ziaaa-aaaap-abl7a-cai.icp0.io';
+function detectPackageManager() {
+    let res = '';
+    try {
+        res = execSync('which mops').toString();
+    }
+    catch (e) { }
+    if (!res) {
+        console.error(chalk.red('Couldn\'t detect package manager'));
+        process.exit(1);
+    }
+    if (res.includes('pnpm/')) {
+        return 'pnpm';
+    }
+    // else if (res.includes('bun/')) {
+    // 	return 'bun';
+    // }
+    else {
+        return 'npm';
+    }
+}
+export async function getLatestVersion() {
+    let res = await fetch(url + '/tags/latest');
+    return res.text();
+}
+export async function update() {
+    let latest = await getLatestVersion();
+    let current = version();
+    if (latest === current) {
+        console.log(chalk.green('You are up to date. Version: ' + current));
+    }
+    else {
+        console.log('Current version: ' + chalk.yellow(current));
+        console.log('Updating to version: ' + chalk.green(latest));
+        let pm = detectPackageManager();
+        let npmArgs = pm === 'npm' ? ['--no-fund', '--silent'] : [];
+        let proc = child_process.spawn(pm, ['add', '-g', ...npmArgs, `${url}/versions/${latest}.tgz`], { stdio: 'inherit', detached: false });
+        proc.on('exit', (res) => {
+            if (res !== 0) {
+                console.log(chalk.red('Failed to update.'));
+                process.exit(1);
+            }
+            console.log(chalk.green('Success'));
+        });
+    }
+}
+export async function uninstall() {
+    console.log('Cleaning cache...');
+    cleanCache();
+    console.log('Resetting toolchain management...');
+    toolchain.init({ reset: true, silent: true });
+    console.log('Uninstalling mops CLI...');
+    let pm = detectPackageManager();
+    child_process.spawn(pm, ['remove', '-g', '--silent', 'ic-mops'], { stdio: 'inherit', detached: false });
+    console.log(chalk.yellow('Config directory has not been deleted: ' + globalConfigDir));
+    console.log('Uninstalled');
+}

package/dist/commands/template.js

@@ -4,6 +4,7 @@ import chalk from 'chalk';
 import prompts from 'prompts';
 import camelCase from 'camelcase';
 import { getRootDir, readConfig } from '../mops.js';
+import { copyTemplateFileSync } from '../templates.js';
 export async function template(templateName, options = {}) {
     if (!templateName) {
         let res = await prompts({
@@ -30,9 +31,8 @@ export async function template(templateName, options = {}) {
             console.log(chalk.yellow('Workflow already exists:'), path.relative(getRootDir(), dest));
             return;
         }
-        let mopsTestYml = new URL('../templates/mops-test.yml', import.meta.url);
         fs.mkdirSync(path.resolve(getRootDir(), '.github/workflows'), { recursive: true });
-        fs.copyFileSync(mopsTestYml, dest);
+        copyTemplateFileSync('mops-test.yml', dest);
         console.log(chalk.green('Created'), path.relative(getRootDir(), dest));
     }
     else if (templateName === 'github-workflow:mops-publish') {
@@ -41,9 +41,8 @@ export async function template(templateName, options = {}) {
             console.log(chalk.yellow('Workflow already exists:'), path.relative(getRootDir(), dest));
             return;
         }
-        let mopsPublishYml = new URL('../templates/mops-publish.yml', import.meta.url);
         fs.mkdirSync(path.resolve(getRootDir(), '.github/workflows'), { recursive: true });
-        fs.copyFileSync(mopsPublishYml, dest);
+        copyTemplateFileSync('mops-publish.yml', dest);
         console.log(chalk.green('Created'), path.relative(getRootDir(), dest));
     }
     else if (templateName?.startsWith('license:')) {
@@ -61,13 +60,13 @@ export async function template(templateName, options = {}) {
             fs.writeFileSync(file, license);
         };
         if (templateName === 'license:MIT') {
-            fs.copyFileSync(new URL('../templates/licenses/MIT', import.meta.url), path.resolve(getRootDir(), 'LICENSE'));
+            copyTemplateFileSync('licenses/MIT', path.resolve(getRootDir(), 'LICENSE'));
             setYearAndOwner(path.resolve(getRootDir(), 'LICENSE'));
             console.log(chalk.green('Created'), path.relative(getRootDir(), 'LICENSE'));
         }
         else if (templateName === 'license:Apache-2.0') {
-            fs.copyFileSync(new URL('../templates/licenses/Apache-2.0', import.meta.url), path.resolve(getRootDir(), 'LICENSE'));
-            fs.copyFileSync(new URL('../templates/licenses/Apache-2.0-NOTICE', import.meta.url), path.resolve(getRootDir(), 'NOTICE'));
+            copyTemplateFileSync('licenses/Apache-2.0', path.resolve(getRootDir(), 'LICENSE'));
+            copyTemplateFileSync('licenses/Apache-2.0-NOTICE', path.resolve(getRootDir(), 'NOTICE'));
             setYearAndOwner(path.resolve(getRootDir(), 'NOTICE'));
             console.log(chalk.green('Created'), path.relative(getRootDir(), 'LICENSE'));
             console.log(chalk.green('Created'), path.relative(getRootDir(), 'NOTICE'));
@@ -75,12 +74,12 @@ export async function template(templateName, options = {}) {
     }
     else if (templateName === 'lib.mo') {
         fs.mkdirSync(path.join(getRootDir(), 'src'), { recursive: true });
-        fs.copyFileSync(new URL('../templates/src/lib.mo', import.meta.url), path.resolve(getRootDir(), 'src/lib.mo'));
+        copyTemplateFileSync('src/lib.mo', path.resolve(getRootDir(), 'src/lib.mo'));
         console.log(chalk.green('Created'), path.relative(getRootDir(), 'src/lib.mo'));
     }
     else if (templateName === 'lib.test.mo') {
         fs.mkdirSync(path.join(getRootDir(), 'test'), { recursive: true });
-        fs.copyFileSync(new URL('../templates/test/lib.test.mo', import.meta.url), path.resolve(getRootDir(), 'test/lib.test.mo'));
+        copyTemplateFileSync('test/lib.test.mo', path.resolve(getRootDir(), 'test/lib.test.mo'));
         console.log(chalk.green('Created'), path.relative(getRootDir(), 'test/lib.test.mo'));
     }
     else if (templateName === 'readme') {
@@ -89,7 +88,7 @@ export async function template(templateName, options = {}) {
             console.log(chalk.yellow('README.md already exists'));
             return;
         }
-        fs.copyFileSync(new URL('../templates/README.md', import.meta.url), dest);
+        copyTemplateFileSync('README.md', dest);
         let config = readConfig();
         let data = fs.readFileSync(dest).toString();
         data = data.replace(/<year>/g, new Date().getFullYear().toString());

package/dist/commands/test/mmf1.js

@@ -24,7 +24,7 @@ export class MMF1 {
         if (this.srategy === 'store') {
             this.output.push({
                 type,
-                message: args.join(' ')
+                message: args.join(' '),
             });
         }
         else if (this.srategy === 'print') {

package/dist/commands/test/test.js

@@ -142,14 +142,14 @@ export async function testWithReporter(reporter, filter = '', mode = 'interprete
                             '-C', 'cache=n',
                             '-W', 'bulk-memory',
                             '-W', 'multi-memory',
-                            '-W', 'max-wasm-stack=2000000',
+                            '-W', 'max-wasm-stack=4000000',
                             '-W', 'nan-canonicalization=y',
                             wasmFile,
                         ];
                     }
                     else {
                         wasmtimeArgs = [
-                            '--max-wasm-stack=2000000',
+                            '--max-wasm-stack=4000000',
                             '--enable-cranelift-nan-canonicalization',
                             '--wasm-features',
                             'multi-memory,bulk-memory',

package/dist/commands/toolchain/pocket-ic.d.ts

@@ -1,10 +1,6 @@
 export declare let repo: string;
 export declare let getLatestReleaseTag: () => Promise<string>;
-export declare let getReleases: () => Promise<{
-    tag_name: string;
-    published_at: Date;
-    draft: boolean;
-}[]>;
+export declare let getReleases: () => Promise<any>;
 export declare let isCached: (version: string) => boolean;
 export declare let download: (version: string, { silent, verbose }?: {
     silent?: boolean | undefined;

package/dist/commands/toolchain/pocket-ic.js

@@ -5,28 +5,10 @@ import * as toolchainUtils from './toolchain-utils.js';
 let cacheDir = path.join(globalCacheDir, 'pocket-ic');
 export let repo = 'dfinity/pocketic';
 export let getLatestReleaseTag = async () => {
-    return '1.0.0';
-    // return toolchainUtils.getLatestReleaseTag(repo);
+    return toolchainUtils.getLatestReleaseTag(repo);
 };
 export let getReleases = async () => {
-    // return toolchainUtils.getReleases(repo);
-    return [
-        {
-            tag_name: '2.0.1',
-            published_at: new Date('2023-11-23'),
-            draft: false,
-        },
-        {
-            tag_name: '2.0.0',
-            published_at: new Date('2023-11-21'),
-            draft: false,
-        },
-        {
-            tag_name: '1.0.0',
-            published_at: new Date('2023-10-12'),
-            draft: false,
-        },
-    ];
+    return toolchainUtils.getReleases(repo);
 };
 export let isCached = (version) => {
     let dir = path.join(cacheDir, version);
@@ -45,14 +27,9 @@ export let download = async (version, { silent = false, verbose = false } = {})
     }
     let platfrom = process.platform == 'darwin' ? 'darwin' : 'linux';
     let arch = 'x86_64';
-    let hashes = {
-        '2.0.1': '69e1408347723dbaa7a6cd2faa9b65c42abbe861',
-        '2.0.0': '29ec86dc9f9ca4691d4d4386c8b2aa41e14d9d16',
-        '1.0.0': '307d5847c1d2fe1f5e19181c7d0fcec23f4658b3',
-    };
-    let url = `https://download.dfinity.systems/ic/${hashes[version]}/openssl-static-binaries/${arch}-${platfrom}/pocket-ic.gz`;
+    let url = `https://github.com/dfinity/pocketic/releases/download/${version}/pocket-ic-${arch}-${platfrom}.gz`;
     if (verbose && !silent) {
         console.log(`Downloading ${url}`);
     }
-    await toolchainUtils.downloadAndExtract(url, path.join(cacheDir, version));
+    await toolchainUtils.downloadAndExtract(url, path.join(cacheDir, version), 'pocket-ic');
 };

package/dist/commands/toolchain/toolchain-utils.d.ts

@@ -1,3 +1,3 @@
-export declare let downloadAndExtract: (url: string, dest: string) => Promise<void>;
+export declare let downloadAndExtract: (url: string, destDir: string, destFileName?: string) => Promise<void>;
 export declare let getLatestReleaseTag: (repo: string) => Promise<string>;
 export declare let getReleases: (repo: string) => Promise<any>;

package/dist/commands/toolchain/toolchain-utils.js

@@ -8,7 +8,7 @@ import { deleteSync } from 'del';
 import { Octokit } from 'octokit';
 import tar from 'tar';
 import { getRootDir } from '../../mops.js';
-export let downloadAndExtract = async (url, dest) => {
+export let downloadAndExtract = async (url, destDir, destFileName = '') => {
     let res = await fetch(url);
     if (res.status !== 200) {
         console.error(`ERROR ${res.status} ${url}`);
@@ -20,7 +20,7 @@ export let downloadAndExtract = async (url, dest) => {
     let archive = path.join(tmpDir, path.basename(url));
     fs.mkdirSync(tmpDir, { recursive: true });
     fs.writeFileSync(archive, buffer);
-    fs.mkdirSync(dest, { recursive: true });
+    fs.mkdirSync(destDir, { recursive: true });
     if (archive.endsWith('.xz')) {
         let decompressTarxz = await import('decomp-tarxz');
         await decompress(archive, tmpDir, {
@@ -28,16 +28,16 @@ export let downloadAndExtract = async (url, dest) => {
         }).catch(() => {
             deleteSync([tmpDir]);
         });
-        fs.cpSync(path.join(tmpDir, path.parse(archive).name.replace('.tar', '')), dest, { recursive: true });
+        fs.cpSync(path.join(tmpDir, path.parse(archive).name.replace('.tar', '')), destDir, { recursive: true });
     }
     else if (archive.endsWith('tar.gz')) {
         await tar.extract({
             file: archive,
-            cwd: dest,
+            cwd: destDir,
         });
     }
     else if (archive.endsWith('.gz')) {
-        let destFile = path.join(dest, path.parse(archive).name);
+        let destFile = path.join(destDir, destFileName || path.parse(archive).name);
         fs.writeFileSync(destFile, unzipSync(buffer));
         chmodSync(destFile, 0o700);
     }
@@ -57,8 +57,8 @@ export let getReleases = async (repo) => {
     let res = await octokit.request(`GET /repos/${repo}/releases`, {
         per_page: 10,
         headers: {
-            'X-GitHub-Api-Version': '2022-11-28'
-        }
+            'X-GitHub-Api-Version': '2022-11-28',
+        },
     });
     if (res.status !== 200) {
         console.log('Releases fetch error');

package/dist/commands/transfer-ownership.js

@@ -13,7 +13,7 @@ export async function transferOwnership(toPrincipal) {
         onCancel() {
             console.log('aborted');
             process.exit(0);
-        }
+        },
     };
     console.log(chalk.red('Warning: ') + 'This action cannot be undone!');
     let { confirm } = await prompts({

package/dist/declarations/bench/bench.did.d.ts

@@ -1,5 +1,6 @@
 import type { Principal } from '@dfinity/principal';
 import type { ActorMethod } from '@dfinity/agent';
+import type { IDL } from '@dfinity/candid';
 
 export interface BenchResult {
   'instructions' : bigint,
@@ -24,3 +25,5 @@ export interface anon_class_10_1 {
   'runCellUpdateAwait' : ActorMethod<[bigint, bigint], BenchResult>,
 }
 export interface _SERVICE extends anon_class_10_1 {}
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const init: ({ IDL }: { IDL: IDL }) => IDL.Type[];