idlebench 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 IdleBench
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,69 @@
+# idlebench
+
+**The verification CLI for idle compute.**
+
+Run one command to benchmark your machine and publish a verified score to IdleBench — the trust layer for IDLE Protocol compute providers.
+
+## Install & run
+
+```bash
+npx idlebench run
+```
+
+No installation required. Node.js 18+ needed.
+
+## Commands
+
+```bash
+npx idlebench run          # Run full benchmark and upload report
+npx idlebench doctor       # Check local environment readiness
+npx idlebench upload <path> # Upload a saved report JSON
+npx idlebench version      # Show version
+```
+
+## What it checks
+
+| Check | Description |
+|-------|-------------|
+| GPU detection | Model, VRAM via nvidia-smi or systeminformation |
+| CUDA | Availability and version |
+| NVIDIA driver | Driver version |
+| Docker | Installation and daemon status |
+| Docker GPU runtime | Tests docker --gpus all |
+| CPU benchmark | Hash workload + matrix calculation |
+| Network latency | Round-trip to IdleBench API |
+
+## Security
+
+IdleBench **never asks for private keys or seed phrases**. Only your public wallet address is used to identify your provider profile.
+
+All checks run locally. Only the structured benchmark report is uploaded.
+
+## Environment variables
+
+```bash
+IDLEBENCH_API_URL=https://idlebench.com  # Override API URL
+```
+
+## Publish to npm
+
+```bash
+cd idlebench-cli
+npm install
+npm run build
+npm publish --access public
+```
+
+## Local development
+
+```bash
+npm install
+npm run build
+npm link
+idlebench doctor
+idlebench run
+```
+
+## License
+
+MIT

package/dist/commands/doctor.d.ts

@@ -0,0 +1,4 @@
+export declare function runDoctor(options: {
+    apiUrl?: string;
+}): Promise<void>;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/commands/doctor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AAiBA,wBAAsB,SAAS,CAAC,OAAO,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,iBAkG3D"}

package/dist/commands/doctor.js

@@ -0,0 +1,107 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getSystemInfo } from '../lib/system.js';
+import { getGpuInfo } from '../lib/gpu.js';
+import { getDockerInfo } from '../lib/docker.js';
+import { measureLatency } from '../lib/network.js';
+const CHECK = chalk.green('✓');
+const WARN = chalk.yellow('!');
+const FAIL = chalk.red('✗');
+function row(label, value, ok) {
+    const icon = ok === true ? CHECK : ok === false ? FAIL : WARN;
+    const icon2 = ok === undefined ? '' : ` ${icon}`;
+    console.log(`  ${chalk.dim(label.padEnd(24))} ${chalk.white(value)}${icon2}`);
+}
+export async function runDoctor(options) {
+    const apiUrl = options.apiUrl ?? 'https://idlebench.com';
+    console.log();
+    console.log(chalk.bold(' IdleBench Doctor'));
+    console.log(chalk.dim(` Checking your environment for benchmark readiness`));
+    console.log();
+    // Node version
+    const nodeVersion = process.version;
+    const nodeOk = parseInt(nodeVersion.slice(1)) >= 18;
+    row('Node.js', nodeVersion, nodeOk);
+    if (!nodeOk) {
+        console.log(chalk.yellow('  → Node.js 18+ is required'));
+    }
+    // System info
+    const spinner = ora({ text: 'Reading system info...', color: 'green' }).start();
+    let system;
+    try {
+        system = await getSystemInfo();
+        spinner.stop();
+        row('OS', system.os);
+        row('Architecture', system.arch);
+        row('CPU', `${system.cpuModel} (${system.cpuCores} cores)`);
+        row('RAM', `${system.ramGb} GB`);
+    }
+    catch (err) {
+        spinner.fail('Failed to read system info');
+    }
+    console.log();
+    // GPU detection
+    const gpuSpinner = ora({ text: 'Detecting GPU...', color: 'green' }).start();
+    try {
+        const gpu = await getGpuInfo();
+        gpuSpinner.stop();
+        if (gpu.name) {
+            row('GPU', gpu.name, true);
+            if (gpu.vramGb)
+                row('VRAM', `${gpu.vramGb} GB`);
+            row('CUDA', gpu.cudaAvailable ? `Available (${gpu.cudaVersion ?? 'unknown version'})` : 'Not detected', gpu.cudaAvailable);
+            if (gpu.driverVersion)
+                row('NVIDIA Driver', gpu.driverVersion, true);
+            if (gpu.detectionMethod)
+                console.log(chalk.dim(`  (detected via ${gpu.detectionMethod})`));
+        }
+        else {
+            gpuSpinner.stop();
+            row('GPU', 'Not detected', null);
+            console.log(chalk.dim('  → No NVIDIA GPU found. CPU-only resources are still valid.'));
+        }
+    }
+    catch {
+        gpuSpinner.fail('GPU detection failed');
+    }
+    console.log();
+    // Docker
+    const dockerSpinner = ora({ text: 'Checking Docker...', color: 'green' }).start();
+    try {
+        const docker = await getDockerInfo();
+        dockerSpinner.stop();
+        row('Docker', docker.available ? `Installed (v${docker.version})` : 'Not found', docker.available);
+        if (docker.available) {
+            row('Docker GPU Runtime', docker.gpuRuntime ? 'Available' : 'Not available', docker.gpuRuntime);
+            if (!docker.gpuRuntime && docker.gpuRuntimeError) {
+                console.log(chalk.dim(`  → ${docker.gpuRuntimeError}`));
+            }
+        }
+    }
+    catch {
+        dockerSpinner.fail('Docker check failed');
+    }
+    console.log();
+    // Network
+    const netSpinner = ora({ text: 'Testing network...', color: 'green' }).start();
+    try {
+        const latency = await measureLatency(apiUrl);
+        netSpinner.stop();
+        if (latency !== null) {
+            const latencyOk = latency < 500;
+            row('Network', `${latency}ms latency to IdleBench`, latencyOk);
+        }
+        else {
+            row('Network', 'Could not reach IdleBench API', false);
+            console.log(chalk.dim(`  → Tried: ${apiUrl}/api/health/check`));
+        }
+    }
+    catch {
+        netSpinner.fail('Network check failed');
+    }
+    console.log();
+    console.log(chalk.dim(' ─────────────────────────────────────────'));
+    console.log();
+    console.log(chalk.bold(' Ready to benchmark?'), chalk.dim('Run'), chalk.white('npx idlebench run'), chalk.dim('to start.'));
+    console.log();
+}

package/dist/commands/run.d.ts

@@ -0,0 +1,2 @@
+export declare function runBenchmarkCommand(): Promise<void>;
+//# sourceMappingURL=run.d.ts.map

package/dist/commands/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/commands/run.ts"],"names":[],"mappings":"AAmIA,wBAAsB,mBAAmB,kBAgNxC"}

package/dist/commands/run.js

@@ -0,0 +1,302 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { fetch } from 'undici';
+import { getSystemInfo } from '../lib/system.js';
+import { getGpuInfo } from '../lib/gpu.js';
+import { getDockerInfo } from '../lib/docker.js';
+import { getNetworkInfo } from '../lib/network.js';
+import { runBenchmark } from '../lib/benchmark.js';
+import { calculateGpuScore, calculateRuntimeScore, calculateNetworkScore, calculateInferenceScore, calculateStabilityScore, calculateFinalScore, getGrade, } from '../lib/scoring.js';
+import { buildReport, saveReportLocally } from '../lib/report.js';
+const CLI_VERSION = '1.0.0';
+const DEFAULT_API_URL = 'https://idlebench.com';
+function line() {
+    console.log(chalk.dim(' ─────────────────────────────────────────'));
+}
+function header() {
+    console.log();
+    console.log(chalk.bold.white(' IdleBench'));
+    console.log(chalk.dim(' The verification layer for idle compute.'));
+    console.log();
+    console.log(chalk.bgYellow.black(' SECURITY NOTICE ') + chalk.yellow(' IdleBench never asks for private keys or seed phrases.'));
+    console.log();
+    line();
+    console.log();
+}
+function checkRow(label, value, ok) {
+    const icon = ok === true ? chalk.green('✓') : ok === false ? chalk.red('✗') : chalk.yellow('—');
+    console.log(` ${icon}  ${chalk.dim(label.padEnd(26))} ${chalk.white(value)}`);
+}
+function scoreBar(label, score, width = 20) {
+    const filled = Math.round((score / 100) * width);
+    const bar = '█'.repeat(filled) + '░'.repeat(width - filled);
+    const color = score >= 85 ? chalk.green : score >= 70 ? chalk.yellow : chalk.red;
+    console.log(`  ${chalk.dim(label.padEnd(28))} ${color(bar)} ${chalk.bold(score)}`);
+}
+async function promptSetup() {
+    console.log(chalk.dim(' Answer a few questions to configure your benchmark.\n'));
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'providerWallet',
+            message: 'Solana wallet address (public key):',
+            validate: (input) => {
+                if (!input.trim())
+                    return 'Wallet address is required';
+                if (input.trim().length < 32 || input.trim().length > 44) {
+                    return 'Wallet address must be 32-44 characters';
+                }
+                return true;
+            },
+        },
+        {
+            type: 'input',
+            name: 'resourceName',
+            message: 'Resource name:',
+            default: 'My Compute Node',
+            validate: (input) => input.trim().length > 0 || 'Name is required',
+        },
+        {
+            type: 'list',
+            name: 'resourceType',
+            message: 'Resource type:',
+            choices: [
+                { name: 'GPU  — Graphics card or GPU compute node', value: 'GPU' },
+                { name: 'CPU  — CPU-only workstation or server', value: 'CPU' },
+                { name: 'API  — API endpoint or inference service', value: 'API' },
+                { name: 'Agent — AI agent or automation endpoint', value: 'AGENT' },
+                { name: 'PC   — General personal computer', value: 'PC' },
+                { name: 'Other', value: 'OTHER' },
+            ],
+            default: 'GPU',
+        },
+        {
+            type: 'input',
+            name: 'idleGatewayUrl',
+            message: 'IDLE gateway URL (optional, press Enter to skip):',
+            default: '',
+            validate: (input) => {
+                if (!input.trim())
+                    return true;
+                try {
+                    new URL(input.trim());
+                    return true;
+                }
+                catch {
+                    return 'Enter a valid URL or leave blank';
+                }
+            },
+        },
+        {
+            type: 'input',
+            name: 'apiUrl',
+            message: `IdleBench API URL:`,
+            default: DEFAULT_API_URL,
+            validate: (input) => {
+                try {
+                    new URL(input.trim());
+                    return true;
+                }
+                catch {
+                    return 'Enter a valid URL';
+                }
+            },
+        },
+    ]);
+    return {
+        providerWallet: answers.providerWallet.trim(),
+        resourceName: answers.resourceName.trim(),
+        resourceType: answers.resourceType,
+        idleGatewayUrl: answers.idleGatewayUrl.trim() || null,
+        apiUrl: answers.apiUrl.trim(),
+    };
+}
+export async function runBenchmarkCommand() {
+    header();
+    const setup = await promptSetup();
+    const { providerWallet, resourceName, resourceType, idleGatewayUrl, apiUrl } = setup;
+    console.log();
+    line();
+    console.log();
+    console.log(chalk.bold(' Running checks...'));
+    console.log();
+    // System info
+    let system;
+    {
+        const spinner = ora({ text: 'Reading system info', color: 'green' }).start();
+        try {
+            system = await getSystemInfo();
+            spinner.succeed(chalk.dim('System info'));
+            checkRow('OS', system.os);
+            checkRow('CPU', `${system.cpuModel} (${system.cpuCores} cores)`);
+            checkRow('RAM', `${system.ramGb} GB`);
+            checkRow('Architecture', system.arch);
+        }
+        catch (err) {
+            spinner.fail('Failed to read system info');
+            throw err;
+        }
+    }
+    console.log();
+    // GPU
+    let gpu;
+    {
+        const spinner = ora({ text: 'Detecting GPU', color: 'green' }).start();
+        gpu = await getGpuInfo();
+        spinner.succeed(chalk.dim('GPU detection'));
+        if (gpu.name) {
+            checkRow('GPU Model', gpu.name, true);
+            if (gpu.vramGb)
+                checkRow('VRAM', `${gpu.vramGb} GB`);
+            checkRow('CUDA', gpu.cudaAvailable ? `${gpu.cudaVersion ?? 'Available'}` : 'Not available', gpu.cudaAvailable);
+            if (gpu.driverVersion)
+                checkRow('NVIDIA Driver', gpu.driverVersion, true);
+        }
+        else {
+            checkRow('GPU', 'Not detected', null);
+            console.log(chalk.dim('  No GPU detected — running CPU-only checks'));
+        }
+    }
+    console.log();
+    // Docker
+    let docker;
+    {
+        const spinner = ora({ text: 'Checking Docker', color: 'green' }).start();
+        docker = await getDockerInfo();
+        spinner.succeed(chalk.dim('Docker check'));
+        checkRow('Docker', docker.available ? `v${docker.version}` : 'Not installed', docker.available);
+        if (docker.available) {
+            if (docker.gpuRuntime) {
+                checkRow('Docker GPU Runtime', 'Available', true);
+            }
+            else {
+                checkRow('Docker GPU Runtime', docker.gpuRuntimeError ?? 'Not available', false);
+            }
+        }
+    }
+    console.log();
+    // Benchmark
+    let benchmarkResult;
+    {
+        const spinner = ora({ text: 'Running benchmark', color: 'green' }).start();
+        benchmarkResult = await runBenchmark();
+        spinner.succeed(chalk.dim('Benchmark complete'));
+        checkRow('CPU hash workload', `${benchmarkResult.cpuHashMs}ms`);
+        checkRow('Matrix calculation', `${benchmarkResult.matrixMs}ms`);
+    }
+    console.log();
+    // Network
+    let network;
+    {
+        const spinner = ora({ text: 'Testing network', color: 'green' }).start();
+        network = await getNetworkInfo(apiUrl);
+        spinner.succeed(chalk.dim('Network check'));
+        checkRow('Latency', network.latencyMs !== null ? `${network.latencyMs}ms` : 'Could not measure', network.latencyMs !== null);
+        if (network.downloadMbps !== null) {
+            checkRow('Download estimate', `${network.downloadMbps} Mbps`);
+        }
+    }
+    console.log();
+    line();
+    console.log();
+    // Calculate scores
+    const gpuScore = calculateGpuScore({
+        gpuName: gpu.name,
+        vramGb: gpu.vramGb,
+        cpuCores: system.cpuCores,
+        ramGb: system.ramGb,
+        cudaAvailable: gpu.cudaAvailable,
+        dockerAvailable: docker.available,
+        dockerGpuRuntime: docker.gpuRuntime,
+    });
+    const runtimeScore = calculateRuntimeScore({
+        gpuName: gpu.name,
+        vramGb: gpu.vramGb,
+        cpuCores: system.cpuCores,
+        ramGb: system.ramGb,
+        cudaAvailable: gpu.cudaAvailable,
+        dockerAvailable: docker.available,
+        dockerGpuRuntime: docker.gpuRuntime,
+    });
+    const networkScore = calculateNetworkScore(network.latencyMs);
+    const inferenceScore = calculateInferenceScore(system.cpuCores, system.ramGb, benchmarkResult.totalMs, gpu.name);
+    const stabilityScore = calculateStabilityScore(system.cpuCores, system.ramGb);
+    const finalScore = calculateFinalScore({
+        gpuScore,
+        runtimeScore,
+        networkScore,
+        inferenceScore,
+        stabilityScore,
+    });
+    const grade = getGrade(finalScore);
+    console.log(chalk.bold(' Score breakdown'));
+    console.log();
+    scoreBar('GPU Capability      (30%)', gpuScore);
+    scoreBar('Runtime Readiness   (20%)', runtimeScore);
+    scoreBar('Performance         (20%)', inferenceScore);
+    scoreBar('Network             (15%)', networkScore);
+    scoreBar('Stability           (15%)', stabilityScore);
+    console.log();
+    const gradeColor = finalScore >= 85 ? chalk.green : finalScore >= 70 ? chalk.yellow : chalk.red;
+    console.log(` ${chalk.dim('Final Score')}  ${gradeColor.bold(`${finalScore}/100`)}  ${gradeColor(`[${grade}]`)}`);
+    console.log();
+    line();
+    console.log();
+    // Build report
+    const report = buildReport({
+        reportVersion: '1.0.0',
+        providerWallet,
+        resourceName,
+        resourceType,
+        idleGatewayUrl,
+        system,
+        gpu,
+        docker,
+        network,
+        scores: { gpuScore, runtimeScore, networkScore, inferenceScore, stabilityScore, finalScore, grade },
+        benchmarkMs: benchmarkResult.totalMs,
+        cliVersion: CLI_VERSION,
+    });
+    // Save locally
+    const localPath = saveReportLocally(report);
+    console.log(chalk.dim(` Report saved locally: ${localPath}`));
+    console.log();
+    // Upload
+    const uploadSpinner = ora({ text: `Uploading to ${apiUrl}`, color: 'green' }).start();
+    try {
+        const res = await fetch(`${apiUrl}/api/reports/upload`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(report),
+            signal: AbortSignal.timeout(30000),
+        });
+        const json = await res.json();
+        if (!res.ok) {
+            uploadSpinner.fail('Upload failed');
+            console.error(chalk.red(` ✗ Server error: ${JSON.stringify(json)}`));
+            console.log(chalk.dim(` Your report was saved locally: ${localPath}`));
+            console.log(chalk.dim(` You can upload it later with: idlebench upload ${localPath}`));
+            return;
+        }
+        uploadSpinner.succeed('Report uploaded');
+        console.log();
+        console.log(chalk.bold(' Benchmark complete.'));
+        console.log();
+        console.log(chalk.dim('  Score:           '), chalk.white.bold(`${finalScore}/100`));
+        console.log(chalk.dim('  Grade:           '), gradeColor.bold(grade));
+        console.log(chalk.dim('  Public URL:      '), chalk.cyan(String(json.publicUrl)));
+        console.log(chalk.dim('  Local report:    '), chalk.dim(localPath));
+        console.log();
+        console.log(chalk.dim(' Attach the badge to your IDLE listing or GitHub README:'));
+        console.log(chalk.dim(` Badge URL: ${apiUrl}/api/badge/${json.resourceId}`));
+        console.log();
+    }
+    catch (err) {
+        uploadSpinner.fail('Upload failed — network error');
+        console.error(chalk.red(` ✗ ${err instanceof Error ? err.message : err}`));
+        console.log();
+        console.log(chalk.dim(` Your report was saved locally: ${localPath}`));
+        console.log(chalk.dim(` Upload later with: idlebench upload ${localPath}`));
+    }
+}

package/dist/commands/upload.d.ts

@@ -0,0 +1,4 @@
+export declare function runUpload(filePath: string, options: {
+    apiUrl?: string;
+}): Promise<void>;
+//# sourceMappingURL=upload.d.ts.map

package/dist/commands/upload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../../src/commands/upload.ts"],"names":[],"mappings":"AAqCA,wBAAsB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,iBA2D7E"}

package/dist/commands/upload.js

@@ -0,0 +1,88 @@
+import { readFileSync } from 'fs';
+import chalk from 'chalk';
+import ora from 'ora';
+import { fetch } from 'undici';
+import { z } from 'zod';
+const ReportSchema = z.object({
+    reportVersion: z.string(),
+    providerWallet: z.string(),
+    resourceName: z.string(),
+    resourceType: z.string(),
+    system: z.object({
+        os: z.string(),
+        arch: z.string(),
+        cpuModel: z.string(),
+        cpuCores: z.number(),
+        ramGb: z.number(),
+    }),
+    gpu: z.object({
+        cudaAvailable: z.boolean(),
+    }).passthrough(),
+    runtime: z.object({
+        dockerAvailable: z.boolean(),
+        dockerGpuRuntime: z.boolean(),
+    }).passthrough(),
+    network: z.object({}).passthrough(),
+    scores: z.object({
+        finalScore: z.number(),
+        grade: z.string(),
+    }).passthrough(),
+    metadata: z.object({
+        createdAt: z.string(),
+        cliVersion: z.string(),
+    }),
+    reportHash: z.string(),
+});
+export async function runUpload(filePath, options) {
+    const apiUrl = (options.apiUrl ?? 'https://idlebench.com').replace(/\/$/, '');
+    console.log();
+    console.log(chalk.bold(' IdleBench Upload'));
+    console.log(chalk.dim(` Uploading: ${filePath}`));
+    console.log();
+    let rawJson;
+    let reportData;
+    try {
+        rawJson = readFileSync(filePath, 'utf-8');
+        reportData = JSON.parse(rawJson);
+    }
+    catch (err) {
+        console.error(chalk.red(' ✗ Could not read report file:'), filePath);
+        if (err instanceof Error)
+            console.error(chalk.dim(`   ${err.message}`));
+        process.exit(1);
+    }
+    const parsed = ReportSchema.safeParse(reportData);
+    if (!parsed.success) {
+        console.error(chalk.red(' ✗ Invalid report format:'));
+        console.error(chalk.dim(JSON.stringify(parsed.error.flatten(), null, 2)));
+        process.exit(1);
+    }
+    const spinner = ora({ text: 'Uploading to IdleBench...', color: 'green' }).start();
+    try {
+        const res = await fetch(`${apiUrl}/api/reports/upload`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: rawJson,
+            signal: AbortSignal.timeout(30000),
+        });
+        const json = await res.json();
+        if (!res.ok) {
+            spinner.fail('Upload failed');
+            console.error(chalk.red(` ✗ ${JSON.stringify(json)}`));
+            process.exit(1);
+        }
+        spinner.succeed('Report uploaded');
+        console.log();
+        console.log(chalk.bold(' Upload complete'));
+        console.log();
+        console.log(chalk.dim('  Score:      '), chalk.white(`${json.score}/100`));
+        console.log(chalk.dim('  Grade:      '), chalk.white(String(json.grade)));
+        console.log(chalk.dim('  Public URL: '), chalk.cyan(String(json.publicUrl)));
+        console.log();
+    }
+    catch (err) {
+        spinner.fail('Upload failed');
+        console.error(chalk.red(' ✗ Network error:'), err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}