@olane/os 0.7.1

package/dist/src/o-olane-os/o-os.js

@@ -0,0 +1,207 @@
+import { OlaneOSSystemStatus } from './enum/o-os.status-enum.js';
+import touch from 'touch';
+import { readFile } from 'fs/promises';
+import { oLeaderNode } from '@olane/o-leader';
+import { oAddress, oObject } from '@olane/o-core';
+import { NodeType } from '@olane/o-core';
+import { initCommonTools } from '@olane/o-tools-common';
+import { initRegistryTools } from '@olane/o-tool-registry';
+import { ConfigManager } from '../utils/config.js';
+import { oLaneTool } from '@olane/o-lane';
+import { oLaneStorage } from '@olane/o-storage';
+import { oNodeAddress } from '@olane/o-node';
+export class OlaneOS extends oObject {
+    constructor(config) {
+        super();
+        this.leaders = []; // clones of leader for scale
+        this.nodes = []; // clones of node for scale
+        this.rootLeader = null; // the root leader node
+        this.roundRobinIndex = 0;
+        this.config = config;
+    }
+    entryNode() {
+        const node = this.nodes[this.roundRobinIndex];
+        this.roundRobinIndex = (this.roundRobinIndex + 1) % this.nodes.length;
+        return node;
+    }
+    addLeader(leader) {
+        this.leaders.push(leader);
+        if (!this.rootLeader) {
+            this.rootLeader = leader;
+        }
+    }
+    async addNode(node) {
+        if (this.status !== OlaneOSSystemStatus.RUNNING) {
+            throw new Error('OS instance is not running, cannot add node');
+        }
+        // TODO: how do we handle multiple leaders?
+        // TODO: how do we handle multiple nodes?
+        if (this.nodes.length === 0) {
+            throw new Error('No non-leader nodes found, cannot add node');
+        }
+        const selection = this.entryNode();
+        selection.addChildNode(node);
+        await selection.start();
+        const parent = this.entryNode();
+        parent.addChildNode(node);
+    }
+    async loadConfig() {
+        // TODO make this a promise based function
+        if (this.config.configFilePath) {
+            try {
+                await touch(this.config.configFilePath);
+                this.logger.debug('Config file path: ' + this.config.configFilePath);
+                // let's load the config
+                const config = await readFile(this.config.configFilePath, 'utf8');
+                this.logger.debug('Config file contents: ' + config);
+                if (config?.length === 0) {
+                    // no contents, let's create a new config
+                    throw new Error('No config file found, cannot start OS instance');
+                }
+                const json = JSON.parse(config);
+                this.logger.debug('Config file parsed: ' + json);
+                const osConfig = json.oNetworkConfig;
+                this.config = {
+                    ...osConfig,
+                    nodes: (osConfig.nodes || []).map((node) => ({
+                        ...node,
+                        address: new oNodeAddress(node.address.value),
+                    })),
+                    network: {
+                        ...osConfig.network,
+                        port: osConfig.network?.port || 4999,
+                    },
+                    configFilePath: this.config.configFilePath, // persist the config file path
+                };
+            }
+            catch (error) {
+                this.logger.error('Failed to initialize config folder', error);
+                throw new Error('Failed to initialize config folder');
+            }
+        }
+        else {
+            this.logger.warn('No config file path provided, using default config');
+        }
+    }
+    async getOSInstanceName() {
+        if (this.config.configFilePath) {
+            const osConfig = await ConfigManager.getOSConfigFromPath(this.config.configFilePath);
+            return osConfig?.name;
+        }
+    }
+    async startNodes(type) {
+        this.logger.debug('Starting nodes');
+        if (!this.config.nodes || this.config.nodes?.length === 0) {
+            throw new Error('No nodes found in config, cannot start OS instance');
+        }
+        const filtered = this.config.nodes.filter((node) => node.type === type);
+        const osInstanceName = await this.getOSInstanceName();
+        // check the config for any leaders
+        for (const node of filtered) {
+            if (node.type === NodeType.LEADER) {
+                this.logger.debug('Starting leader: ' + node.address.toString());
+                const leaderNode = new oLeaderNode({
+                    ...node,
+                    systemName: osInstanceName,
+                });
+                if (!this.rootLeader) {
+                    this.rootLeader = leaderNode;
+                }
+                await leaderNode.start();
+                await initCommonTools(leaderNode);
+                this.leaders.push(leaderNode);
+            }
+            else {
+                this.logger.debug('Starting non-leader node: ' + node.address.toString());
+                const commonNode = new oLaneTool({
+                    ...node,
+                    address: node.address,
+                    leader: this.rootLeader?.address || null,
+                    parent: this.rootLeader?.address || null,
+                });
+                await commonNode.start();
+                this.rootLeader?.addChildNode(commonNode);
+                const olaneStorage = new oLaneStorage({
+                    name: 'lane-storage',
+                    parent: commonNode.address,
+                    leader: this.rootLeader?.address || null,
+                });
+                await olaneStorage.start();
+                commonNode.addChildNode(olaneStorage);
+                await initCommonTools(commonNode);
+                await initRegistryTools(commonNode);
+                this.nodes.push(commonNode);
+            }
+        }
+    }
+    async runSavedPlans() {
+        const plans = Array.from(new Set(this.config?.lanes || []));
+        for (const plan of plans) {
+            this.logger.debug('Running saved plan: ' + plan);
+            await this.use(new oAddress(plan), {
+                method: 'use',
+            });
+        }
+    }
+    async use(oAddress, params) {
+        const entryNode = this.entryNode();
+        if (!entryNode) {
+            throw new Error('Entry node not found');
+        }
+        this.logger.debug('Using address: ' + oAddress.toString());
+        return entryNode.use(oAddress, params);
+    }
+    async start() {
+        this.logger.debug('Starting OS instance');
+        this.status = OlaneOSSystemStatus.STARTING;
+        // initialize config folder
+        await this.loadConfig();
+        this.logger.debug('OS instance config loaded');
+        // start leaders (and consequentially, the rest of the OS instance)
+        await this.startNodes(NodeType.LEADER);
+        this.logger.debug('Leaders started...');
+        await this.startNodes(NodeType.NODE);
+        this.logger.debug('Nodes started...');
+        await this.runSavedPlans();
+        this.logger.debug('Saved plans run...');
+        this.logger.debug('OS instance started...');
+        // index the OS instance
+        if (!this.config.noIndexNetwork) {
+            await this.use(oAddress.leader(), {
+                method: 'index_network',
+                params: {},
+            });
+        }
+        this.status = OlaneOSSystemStatus.RUNNING;
+        return {
+            peerId: this.rootLeader?.peerId.toString() || '',
+            transports: this.rootLeader?.transports || [],
+        };
+    }
+    async stop() {
+        this.logger.debug('Stopping OS instance');
+        this.status = OlaneOSSystemStatus.STOPPING;
+        const stopPromises = [];
+        try {
+            if (!this.rootLeader) {
+                throw new Error('Root leader not found');
+            }
+            stopPromises.push(this.rootLeader.stop());
+            // Wait for all stop operations to complete
+            await Promise.all(stopPromises);
+            this.logger.debug('OS instance stopped successfully');
+        }
+        catch (error) {
+            this.logger.error('Error while stopping OS instance:', error);
+        }
+        finally {
+            this.status = OlaneOSSystemStatus.STOPPED;
+            this.roundRobinIndex = 0;
+        }
+    }
+    async restart() {
+        this.logger.debug('Restarting OS instance');
+        await this.stop();
+        await this.start();
+    }
+}

package/dist/src/utils/config.d.ts

@@ -0,0 +1,35 @@
+import { OlaneOSSystemStatus } from '../o-olane-os/enum/o-os.status-enum.js';
+import { OlaneOSConfig } from '../o-olane-os/index.js';
+export interface OlaneOSInstanceConfig {
+    name: string;
+    version: string;
+    description: string;
+    port: number;
+    status: OlaneOSSystemStatus;
+    path?: string;
+    createdAt?: string;
+    pid?: number;
+    peerId?: string;
+    transports?: string[];
+    oNetworkConfig?: OlaneOSConfig;
+}
+export interface CLIConfig {
+    instancesPath: string;
+}
+export declare const CONFIG_FILE_NAME = "config.json";
+export declare class ConfigManager {
+    private static configPath;
+    private static instancesPath;
+    private static configFile;
+    static initialize(): Promise<void>;
+    static getDefaultConfig(): CLIConfig;
+    static getConfig(): Promise<CLIConfig>;
+    static saveConfig(config: Partial<CLIConfig>): Promise<void>;
+    static writeConfig(config: Partial<CLIConfig>): Promise<void>;
+    static getOSConfigFromPath(path: string): Promise<OlaneOSInstanceConfig | null>;
+    static getOSConfig(name: string): Promise<OlaneOSInstanceConfig | null>;
+    static saveOSConfig(config: OlaneOSInstanceConfig): Promise<void>;
+    static listOSInstances(): Promise<OlaneOSInstanceConfig[]>;
+    static deleteOSInstance(name: string): Promise<void>;
+}
+//# sourceMappingURL=config.d.ts.map

package/dist/src/utils/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/utils/config.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAEvD,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,mBAAmB,CAAC;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,cAAc,CAAC,EAAE,aAAa,CAAC;CAChC;AAED,MAAM,WAAW,SAAS;IACxB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,eAAO,MAAM,gBAAgB,gBAAgB,CAAC;AAE9C,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAC,UAAU,CAAuB;IAChD,OAAO,CAAC,MAAM,CAAC,aAAa,CAAyB;IACrD,OAAO,CAAC,MAAM,CAAC,UAAU,CAAuB;WAEnC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IASxC,MAAM,CAAC,gBAAgB,IAAI,SAAS;WAMvB,SAAS,IAAI,OAAO,CAAC,SAAS,CAAC;WAM/B,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;WAOrD,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;WAItD,mBAAmB,CAC9B,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC;WAO3B,WAAW,CACtB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC;WAY3B,YAAY,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;WAQ1D,eAAe,IAAI,OAAO,CAAC,qBAAqB,EAAE,CAAC;WAuBnD,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAM3D"}

package/dist/src/utils/config.js

@@ -0,0 +1,82 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { DEFAULT_CONFIG_PATH, DEFAULT_INSTANCE_PATH, DEFAULT_CONFIG_FILE, } from '@olane/o-core';
+export const CONFIG_FILE_NAME = 'config.json';
+export class ConfigManager {
+    static async initialize() {
+        await fs.ensureDir(ConfigManager.configPath);
+        await fs.ensureDir(ConfigManager.instancesPath);
+        if (!(await fs.pathExists(ConfigManager.configFile))) {
+            await this.writeConfig(this.getDefaultConfig());
+        }
+    }
+    static getDefaultConfig() {
+        return {
+            instancesPath: ConfigManager.instancesPath,
+        };
+    }
+    static async getConfig() {
+        await this.initialize();
+        const config = await fs.readJson(ConfigManager.configFile);
+        return { ...this.getDefaultConfig(), ...config };
+    }
+    static async saveConfig(config) {
+        await this.initialize();
+        const currentConfig = await this.getConfig();
+        const newConfig = { ...currentConfig, ...config };
+        await this.writeConfig(newConfig);
+    }
+    static async writeConfig(config) {
+        await fs.writeJson(ConfigManager.configFile, config, { spaces: 2 });
+    }
+    static async getOSConfigFromPath(path) {
+        if (await fs.pathExists(path)) {
+            return await fs.readJson(path);
+        }
+        return null;
+    }
+    static async getOSConfig(name) {
+        const configPath = path.join(ConfigManager.instancesPath, name, CONFIG_FILE_NAME);
+        if (await fs.pathExists(configPath)) {
+            return await fs.readJson(configPath);
+        }
+        return null;
+    }
+    static async saveOSConfig(config) {
+        const osPath = path.join(ConfigManager.instancesPath, config.name);
+        await fs.ensureDir(osPath);
+        await fs.writeJson(path.join(osPath, CONFIG_FILE_NAME), config, {
+            spaces: 2,
+        });
+    }
+    static async listOSInstances() {
+        try {
+            await this.initialize();
+            const osInstances = [];
+            const osInstanceNames = await fs.readdir(ConfigManager.instancesPath);
+            for (const osInstanceName of osInstanceNames) {
+                const config = await this.getOSConfig(osInstanceName);
+                if (config) {
+                    osInstances.push(config);
+                }
+            }
+            return osInstances;
+        }
+        catch (error) {
+            // if the default path for config does not exist, return an empty array
+            if (error instanceof Error && error.message.includes('ENOENT')) {
+                return [];
+            }
+            throw error;
+        }
+    }
+    static async deleteOSInstance(name) {
+        const osInstancePath = path.join(ConfigManager.instancesPath, name);
+        if (await fs.pathExists(osInstancePath)) {
+            await fs.remove(osInstancePath);
+        }
+    }
+}
+ConfigManager.configPath = DEFAULT_CONFIG_PATH;
+ConfigManager.instancesPath = DEFAULT_INSTANCE_PATH;
+ConfigManager.configFile = DEFAULT_CONFIG_FILE;

package/dist/test/basic/basic-usage.spec.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=basic-usage.spec.d.ts.map

package/dist/test/basic/basic-usage.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic-usage.spec.d.ts","sourceRoot":"","sources":["../../../test/basic/basic-usage.spec.ts"],"names":[],"mappings":""}

package/dist/test/basic/basic-usage.spec.js

@@ -0,0 +1,115 @@
+"use strict";
+// import { oAddress, NodeState } from '@olane/o-core';
+// import { expect } from 'chai';
+// import dotenv from 'dotenv';
+// import { defaultOSInstance } from '../utils/os.default.js';
+// import { OlaneOSSystemStatus } from '../../src/o-olane-os/enum/o-os.status-enum.js';
+// dotenv.config();
+// const network = defaultOSInstance;
+// describe('basic-usage @initialize', async () => {
+//   it('should be able to startup the network', async () => {
+//     await network.start();
+//     expect(network.status).to.equal(OlaneOSSystemStatus.RUNNING);
+//   });
+//   // disabled for now, to avoid unecessary indexing costs
+//   // it('should be able to index the network', async () => {
+//   //   const entryNode = network.entryNode();
+//   //   expect(entryNode).to.exist;
+//   //   expect(entryNode.state).to.equal(NodeState.RUNNING);
+//   //   const response = await entryNode.use(new oAddress('o://leader'), {
+//   //     method: 'index_network',
+//   //     params: {},
+//   //   });
+//   //   const data = response.result.data;
+//   //   expect(data).to.exist;
+//   //   expect(data.error).to.be.undefined;
+//   //   expect(data.message).to.equal('Network indexed!');
+//   // });
+//   it('should be able to use olane remote services', async () => {
+//     const entryNode = network.entryNode();
+//     expect(entryNode).to.exist;
+//     expect(entryNode.state).to.equal(NodeState.RUNNING);
+//     // configure the intelligence tool
+//     // await entryNode.use(new oAddress('o://intelligence'), {
+//     //   method: 'configure',
+//     //   params: {
+//     //     modelProvider: 'anthropic',
+//     //     hostingProvider: 'olane',
+//     //     accessToken: 'test',
+//     //     address: 'o://leader/intelligence',
+//     //   },
+//     // });
+//     // use the intelligence tool
+//     const response2 = await entryNode.use(new oAddress('o://perplexity'), {
+//       method: 'completion',
+//       params: {
+//         model: 'sonar',
+//         messages: [
+//           {
+//             role: 'user',
+//             content: 'What is the weather in Tokyo?',
+//           },
+//         ],
+//       },
+//     });
+//     console.log(response2.result.data);
+//   });
+// });
+// // describe('olane network usage', async () => {
+// //   it('should be able to use the olane network', async () => {
+// //     // let's dial the other network
+// //     const response = await network.use(
+// //       new oAddress('o://leader', [
+// //         multiaddr('/dns4/leader.olane.com/tcp/4000/tls/ws'),
+// //       ]),
+// //       {
+// //         method: 'intent',
+// //         params: {
+// //           intent: 'What can I do?',
+// //         },
+// //       },
+// //     );
+// //     console.log(response.result.data);
+// //   });
+// // });
+// // describe('external-networks', async () => {
+// //   it('should be able to use an external network', async () => {
+// //     const network2 = new oNetwork({
+// //       // configFilePath: path.join(os.homedir(), '.olane', 'config.json'),
+// //       nodes: [
+// //         {
+// //           type: NodeType.LEADER,
+// //           address: new oAddress('o://leader'),
+// //           leader: null,
+// //           parent: null,
+// //         },
+// //         {
+// //           type: NodeType.NODE,
+// //           address: new oAddress('o://node2'),
+// //           leader: null,
+// //           parent: null,
+// //         },
+// //       ],
+// //       plans: [],
+// //       noIndexNetwork: true,
+// //     });
+// //     await network2.start();
+// //     expect(network2.status).to.equal(NetworkStatus.RUNNING);
+// //     // let's dial the other network
+// //     await network2.use(
+// //       new oAddress('o://leader', [
+// //         ...(network?.rootLeader?.address.libp2pTransports || []),
+// //       ]),
+// //       {
+// //         method: 'index_network',
+// //         params: {},
+// //       },
+// //     );
+// //   });
+// // });
+// describe('basic-usage @stop-network', async () => {
+//   it('should be able to stop the network', async () => {
+//     await network.stop();
+//     expect(network.status).to.equal(OlaneOSSystemStatus.STOPPED);
+//   });
+// });

package/dist/test/basic/resolvers.spec.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=resolvers.spec.d.ts.map

package/dist/test/basic/resolvers.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvers.spec.d.ts","sourceRoot":"","sources":["../../../test/basic/resolvers.spec.ts"],"names":[],"mappings":""}

package/dist/test/basic/resolvers.spec.js

@@ -0,0 +1,36 @@
+"use strict";
+// import { oAddress, NodeState } from '@olane/o-core';
+// import { expect } from 'chai';
+// import dotenv from 'dotenv';
+// import { defaultOSInstance } from '../utils/os.default.js';
+// import { OlaneOSSystemStatus } from '../../src/o-olane-os/enum/o-os.status-enum.js';
+// dotenv.config();
+// const network = defaultOSInstance;
+// describe('basic-usage @initialize', async () => {
+//   it('should be able to startup the network', async () => {
+//     await network.start();
+//     expect(network.status).to.equal(OlaneOSSystemStatus.RUNNING);
+//   });
+//   it('should be able to handshake with a method address', async () => {
+//     const entryNode = network.entryNode();
+//     expect(entryNode).to.exist;
+//     expect(entryNode.state).to.equal(NodeState.RUNNING);
+//     // configure the intelligence tool
+//     const response = await entryNode.use(
+//       new oAddress('o://leader/node/mcp/validate_url'),
+//       {
+//         method: 'handshake',
+//         params: {
+//           intent: 'Validate the URL of an MCP server',
+//         },
+//       },
+//     );
+//     console.log(response.result.data);
+//   });
+// });
+// describe('basic-usage @stop-network', async () => {
+//   it('should be able to stop the network', async () => {
+//     await network.stop();
+//     expect(network.status).to.equal(OlaneOSSystemStatus.STOPPED);
+//   });
+// });

package/dist/test/benchmarks/benchmark.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=benchmark.spec.d.ts.map

package/dist/test/benchmarks/benchmark.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmark.spec.d.ts","sourceRoot":"","sources":["../../../test/benchmarks/benchmark.spec.ts"],"names":[],"mappings":""}

package/dist/test/benchmarks/benchmark.spec.js

@@ -0,0 +1,65 @@
+import dotenv from 'dotenv';
+import { expect } from 'chai';
+import { defaultOSInstance } from '../utils/os.default.js';
+import { OlaneOSSystemStatus } from '../../src/o-olane-os/enum/o-os.status-enum.js';
+import { oAddress } from '@olane/o-core';
+import { GITHUB_TEST_CASES } from './github/github.test-cases.js';
+dotenv.config();
+const olaneOSInstance = defaultOSInstance;
+describe('basic-usage @initialize', async () => {
+    it('should be able to startup the OS instance', async () => {
+        await olaneOSInstance.start();
+        expect(olaneOSInstance.status).to.equal(OlaneOSSystemStatus.RUNNING);
+    });
+});
+// describe('intelligence @configure-intelligence', async () => {
+//   it('should be able to set the intelligence preference to ollama', async () => {
+//     await network.use(new oAddress('o://memory'), {
+//       method: 'put',
+//       params: {
+//         key: 'intelligence-preference',
+//         value: 'o://ollama',
+//       },
+//     });
+//   });
+// });
+describe('o-mcp github-benchmarks', () => {
+    // it('should be able to create a branch', async () => {
+    //   const response = await network.use(new oAddress('o://leader'), {
+    //     method: 'intent',
+    //     params: {
+    //       intent: `Create a branch called "test-branch" in the repo "travel-planner-app"`,
+    //     },
+    //   });
+    //   console.log(response.result.data);
+    // }, 300_000);
+    it('should be able to test github benchmarks', async () => {
+        const response = await olaneOSInstance.use(oAddress.leader(), {
+            method: 'intent',
+            params: {
+                intent: `Add the MCP server https://api.githubcopilot.com/mcp/ use the headers "Authorization: Bearer ${process.env.GITHUB_API_KEY}"`,
+            },
+        });
+        console.log('Setup MCP server response:');
+        console.log(response.result.data);
+        for (const testCase of GITHUB_TEST_CASES) {
+            console.log(testCase.input);
+            const handshakeResponse = await olaneOSInstance.use(oAddress.leader(), {
+                method: 'intent',
+                params: {
+                    intent: testCase.input,
+                },
+            });
+            console.log(`Finished with ${handshakeResponse.result.data.cycles} cycles`);
+            console.log(handshakeResponse.result.data);
+            // const result = await testCase.output;
+            // expect(result).to.contain(testCase.output.contains);
+        }
+    }, 300000);
+});
+describe('basic-usage @stop-network', async () => {
+    it('should be able to stop the network', async () => {
+        await olaneOSInstance.stop();
+        expect(olaneOSInstance.status).to.equal(OlaneOSSystemStatus.STOPPED);
+    });
+});

package/dist/test/benchmarks/github/github.test-cases.d.ts

@@ -0,0 +1,3 @@
+import { TestCase } from '../interfaces/test-case.interface';
+export declare const GITHUB_TEST_CASES: TestCase[];
+//# sourceMappingURL=github.test-cases.d.ts.map

package/dist/test/benchmarks/github/github.test-cases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github.test-cases.d.ts","sourceRoot":"","sources":["../../../../test/benchmarks/github/github.test-cases.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mCAAmC,CAAC;AAE7D,eAAO,MAAM,iBAAiB,EAAE,QAAQ,EAgPvC,CAAC"}