graphai 0.0.1

package/.eslintrc.js

@@ -0,0 +1,49 @@
+module.exports = {
+    "env": {
+        "es2021": true,
+        "node": true
+    },
+    "extends": [
+        "eslint:recommended",
+        "plugin:@typescript-eslint/recommended"
+    ],
+    "overrides": [
+        {
+            "env": {
+                "node": true
+            },
+            "files": [
+                ".eslintrc.{js,cjs}"
+            ],
+            "parserOptions": {
+                "sourceType": "script"
+            }
+        }
+    ],
+    "parser": "@typescript-eslint/parser",
+    "parserOptions": {
+        "ecmaVersion": "latest",
+        "sourceType": "module"
+    },
+    "plugins": [
+        "@typescript-eslint"
+    ],
+    "rules": {
+        "indent": [
+            "error",
+            2
+        ],
+        "linebreak-style": [
+            "error",
+            "unix"
+        ],
+        "quotes": [
+            "error",
+            "double"
+        ],
+        "semi": [
+            "error",
+            "always"
+        ]
+    }
+};

package/.prettierrc

@@ -0,0 +1,3 @@
+{
+  "printWidth": 160
+}

package/README.md

@@ -0,0 +1 @@
+# dataflow

package/lib/file_utils.d.ts

@@ -0,0 +1,3 @@
+export declare const readManifestData: (file: string) => any;
+export declare const readJsonManifest: (fileName: string) => any;
+export declare const readYamlManifest: (fileName: string) => any;

package/lib/file_utils.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readYamlManifest = exports.readJsonManifest = exports.readManifestData = void 0;
+const fs_1 = __importDefault(require("fs"));
+const yaml_1 = __importDefault(require("yaml"));
+const readManifestData = (file) => {
+    if (file.endsWith(".yaml") || file.endsWith(".yml")) {
+        return (0, exports.readYamlManifest)(file);
+    }
+    if (file.endsWith(".json")) {
+        return (0, exports.readJsonManifest)(file);
+    }
+    throw new Error("No file exists " + file);
+};
+exports.readManifestData = readManifestData;
+const readJsonManifest = (fileName) => {
+    const manifest_file = fs_1.default.readFileSync(fileName, "utf8");
+    const manifest = JSON.parse(manifest_file);
+    return manifest;
+};
+exports.readJsonManifest = readJsonManifest;
+const readYamlManifest = (fileName) => {
+    const manifest_file = fs_1.default.readFileSync(fileName, "utf8");
+    const manifest = yaml_1.default.parse(manifest_file);
+    return manifest;
+};
+exports.readYamlManifest = readYamlManifest;

package/lib/flow.d.ts

@@ -0,0 +1,51 @@
+export declare enum NodeState {
+    Waiting = 0,
+    Executing = 1,
+    Failed = 2,
+    Completed = 3
+}
+type NodeData = {
+    inputs: undefined | Array<string>;
+    params: any;
+    retry: undefined | number;
+};
+type FlowData = {
+    nodes: Record<string, NodeData>;
+};
+export declare enum FlowCommand {
+    Log = 0,
+    Execute = 1,
+    OnComplete = 2
+}
+type FlowCallback = (params: Record<string, any>) => void;
+declare class Node {
+    key: string;
+    inputs: Array<string>;
+    pendings: Set<string>;
+    params: any;
+    waitlist: Set<string>;
+    state: NodeState;
+    result: Record<string, any>;
+    retryLimit: number;
+    retryCount: number;
+    constructor(key: string, data: NodeData);
+    asString(): string;
+    complete(result: Record<string, any>, nodes: Record<string, Node>, graph: Graph): void;
+    reportError(result: Record<string, any>, nodes: Record<string, Node>, graph: Graph): void;
+    removePending(key: string, graph: Graph): void;
+    payload(graph: Graph): Record<string, any>;
+    executeIfReady(graph: Graph): void;
+}
+export declare class Graph {
+    nodes: Record<string, Node>;
+    callback: FlowCallback;
+    private runningNodes;
+    constructor(data: FlowData, callback: FlowCallback);
+    asString(): string;
+    run(): void;
+    feed(key: string, result: Record<string, any>): void;
+    reportError(key: string, result: Record<string, any>): void;
+    add(node: Node): void;
+    remove(node: Node): void;
+}
+export {};

package/lib/flow.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Graph = exports.FlowCommand = exports.NodeState = void 0;
+var NodeState;
+(function (NodeState) {
+    NodeState[NodeState["Waiting"] = 0] = "Waiting";
+    NodeState[NodeState["Executing"] = 1] = "Executing";
+    NodeState[NodeState["Failed"] = 2] = "Failed";
+    NodeState[NodeState["Completed"] = 3] = "Completed";
+})(NodeState || (exports.NodeState = NodeState = {}));
+var FlowCommand;
+(function (FlowCommand) {
+    FlowCommand[FlowCommand["Log"] = 0] = "Log";
+    FlowCommand[FlowCommand["Execute"] = 1] = "Execute";
+    FlowCommand[FlowCommand["OnComplete"] = 2] = "OnComplete";
+})(FlowCommand || (exports.FlowCommand = FlowCommand = {}));
+class Node {
+    constructor(key, data) {
+        this.key = key;
+        this.inputs = data.inputs ?? [];
+        this.pendings = new Set(this.inputs);
+        this.params = data.params;
+        this.waitlist = new Set();
+        this.state = NodeState.Waiting;
+        this.result = {};
+        this.retryLimit = data.retry ?? 0;
+        this.retryCount = 0;
+    }
+    asString() {
+        return `${this.key}: ${this.state} ${[...this.waitlist]}`;
+    }
+    complete(result, nodes, graph) {
+        this.state = NodeState.Completed;
+        this.result = result;
+        this.waitlist.forEach(key => {
+            const node = nodes[key];
+            node.removePending(this.key, graph);
+        });
+        graph.remove(this);
+    }
+    reportError(result, nodes, graph) {
+        this.state = NodeState.Failed;
+        this.result = result;
+        if (this.retryCount < this.retryLimit) {
+            this.retryCount++;
+            this.state = NodeState.Executing;
+            graph.callback({ cmd: FlowCommand.Execute, node: this.key, params: this.params, retry: this.retryCount, payload: this.payload(graph) });
+        }
+        else {
+            graph.remove(this);
+        }
+    }
+    removePending(key, graph) {
+        this.pendings.delete(key);
+        this.executeIfReady(graph);
+    }
+    payload(graph) {
+        const foo = {};
+        return this.inputs.reduce((payload, key) => {
+            payload[key] = graph.nodes[key].result;
+            return payload;
+        }, foo);
+    }
+    executeIfReady(graph) {
+        if (this.pendings.size == 0) {
+            this.state = NodeState.Executing;
+            graph.add(this);
+            graph.callback({ cmd: FlowCommand.Execute, node: this.key, params: this.params, retry: 0, payload: this.payload(graph) });
+        }
+    }
+}
+class Graph {
+    constructor(data, callback) {
+        this.callback = callback;
+        this.runningNodes = new Set();
+        const foo = {}; // HACK: Work around
+        this.nodes = Object.keys(data.nodes).reduce((nodes, key) => {
+            nodes[key] = new Node(key, data.nodes[key]);
+            return nodes;
+        }, foo);
+        // Generate the waitlist for each node
+        Object.keys(this.nodes).forEach(key => {
+            const node = this.nodes[key];
+            node.pendings.forEach(pending => {
+                const node2 = this.nodes[pending];
+                node2.waitlist.add(key);
+            });
+        });
+    }
+    asString() {
+        return Object.keys(this.nodes).map((key) => { return this.nodes[key].asString(); }).join('\n');
+    }
+    run() {
+        // Nodes without pending data should run immediately.
+        Object.keys(this.nodes).forEach(key => {
+            const node = this.nodes[key];
+            node.executeIfReady(this);
+        });
+    }
+    feed(key, result) {
+        const node = this.nodes[key];
+        node.complete(result, this.nodes, this);
+    }
+    reportError(key, result) {
+        const node = this.nodes[key];
+        node.reportError(result, this.nodes, this);
+    }
+    add(node) {
+        this.runningNodes.add(node.key);
+    }
+    remove(node) {
+        this.runningNodes.delete(node.key);
+        if (this.runningNodes.size == 0) {
+            this.callback({ cmd: FlowCommand.OnComplete });
+        }
+    }
+}
+exports.Graph = Graph;

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+import { Graph } from "./flow";
+export { Graph };

package/lib/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Graph = void 0;
+const flow_1 = require("./flow");
+Object.defineProperty(exports, "Graph", { enumerable: true, get: function () { return flow_1.Graph; } });

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "graphai",
+  "version": "0.0.1",
+  "description": "Asynchronous data flow execution engine to make it simple to build LLM apps.",
+  "main": "lib/index.js",
+  "scripts": {
+    "build": "tsc",
+    "eslint": "eslint --fix --ext src/**/*.{ts} tests/**/*.ts",
+    "format": "prettier --write '{src,tests}/**/*.ts'",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/snakajima/dataflow"
+  },
+  "author": "Satoshi Nakajima",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/snakajima/dataflow/issues"
+  },
+  "homepage": "https://github.com/snakajima/dataflow#readme",
+  "devDependencies": {
+    "@types/node": "^20.8.7",
+    "@typescript-eslint/eslint-plugin": "^6.8.0",
+    "@typescript-eslint/parser": "^6.8.0",
+    "eslint": "^7.32.0 || ^8.2.0",
+    "eslint-plugin-import": "^2.25.2",
+    "prettier": "^3.0.3",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.2.2"
+  },
+  "dependencies": {
+    "openai": "^4.12.4",
+    "yaml": "^2.3.3"
+  },
+  "types": "./lib/index.d.ts",
+  "directories": {
+    "lib": "lib",
+    "test": "tests"
+  }
+}

package/src/file_utils.ts

@@ -0,0 +1,24 @@
+import fs from "fs";
+import YAML from "yaml";
+
+export const readManifestData = (file: string) => {
+  if (file.endsWith(".yaml") || file.endsWith(".yml")) {
+    return readYamlManifest(file);
+  }
+  if (file.endsWith(".json")) {
+    return readJsonManifest(file);
+  }
+  throw new Error("No file exists " + file);
+};
+
+export const readJsonManifest = (fileName: string) => {
+  const manifest_file = fs.readFileSync(fileName, "utf8");
+  const manifest = JSON.parse(manifest_file);
+  return manifest;
+};
+
+export const readYamlManifest = (fileName: string) => {
+  const manifest_file = fs.readFileSync(fileName, "utf8");
+  const manifest = YAML.parse(manifest_file);
+  return manifest;
+};

package/src/flow.ts

@@ -0,0 +1,152 @@
+export enum NodeState {
+  Waiting,
+  Executing,
+  Failed,
+  Completed
+}
+
+type NodeData = {
+  inputs: undefined | Array<string>;
+  params: any; // Application specific parameters
+  retry: undefined | number;
+}
+
+type FlowData = {
+  nodes: Record<string, NodeData>;
+};
+
+export enum FlowCommand {
+  Log,
+  Execute,
+  OnComplete
+}
+
+type FlowCallback = (params: Record<string, any>) => void;
+
+class Node {
+  public key: string;
+  public inputs: Array<string>;
+  public pendings: Set<string>;
+  public params: any;
+  public waitlist: Set<string>;
+  public state: NodeState;
+  public result: Record<string, any>;
+  public retryLimit: number;
+  public retryCount: number;
+  constructor(key: string, data: NodeData) {
+    this.key = key;
+    this.inputs = data.inputs ?? [];
+    this.pendings = new Set(this.inputs);
+    this.params = data.params;
+    this.waitlist = new Set<string>();
+    this.state = NodeState.Waiting;
+    this.result = {};
+    this.retryLimit = data.retry ?? 0;
+    this.retryCount = 0;
+  }
+
+  public asString() {
+    return `${this.key}: ${this.state} ${[...this.waitlist]}`    
+  }
+
+  public complete(result: Record<string, any>, nodes: Record<string, Node>, graph: Graph) {
+    this.state = NodeState.Completed;
+    this.result = result;
+    this.waitlist.forEach(key => {
+      const node = nodes[key];
+      node.removePending(this.key, graph);
+    });
+    graph.remove(this);
+  }
+
+  public reportError(result: Record<string, any>, nodes: Record<string, Node>, graph: Graph) {
+    this.state = NodeState.Failed;
+    this.result = result;
+    if (this.retryCount < this.retryLimit) {
+      this.retryCount++;
+      this.state = NodeState.Executing;
+      graph.callback({cmd: FlowCommand.Execute, node: this.key, params: this.params, retry: this.retryCount, payload: this.payload(graph) });
+    } else {
+      graph.remove(this);
+    }
+  }
+
+  public removePending(key: string, graph: Graph) {
+    this.pendings.delete(key);
+    this.executeIfReady(graph);
+  }
+
+  public payload(graph: Graph) {
+    const foo: Record<string, any> = {};
+    return this.inputs.reduce((payload, key) => {
+      payload[key] = graph.nodes[key].result;       
+      return payload;
+    }, foo);    
+  }
+
+  public executeIfReady(graph: Graph) {
+    if (this.pendings.size == 0) {
+      this.state = NodeState.Executing;
+      graph.add(this);
+      graph.callback({cmd: FlowCommand.Execute, node: this.key, params: this.params, retry: 0, payload: this.payload(graph) });
+    }
+  }
+}
+
+export class Graph {
+  public nodes: Record<string, Node>
+  public callback: FlowCallback;
+  private runningNodes: Set<string>;
+
+  constructor(data: FlowData, callback: FlowCallback) {
+    this.callback = callback;
+    this.runningNodes = new Set<string>();
+    const foo: Record<string, Node> = {}; // HACK: Work around
+    this.nodes = Object.keys(data.nodes).reduce((nodes, key) => {
+      nodes[key] = new Node(key, data.nodes[key]);
+      return nodes;
+    }, foo);
+
+    // Generate the waitlist for each node
+    Object.keys(this.nodes).forEach(key => {
+      const node = this.nodes[key];
+      node.pendings.forEach(pending => {
+        const node2 = this.nodes[pending]
+        node2.waitlist.add(key);
+      });
+    });
+  }
+
+  public asString() {
+    return Object.keys(this.nodes).map((key) => { return this.nodes[key].asString() }).join('\n');
+  }
+
+  public run() {
+    // Nodes without pending data should run immediately.
+    Object.keys(this.nodes).forEach(key => {
+      const node = this.nodes[key];
+      node.executeIfReady(this);
+    });
+  }
+
+  public feed(key: string, result: Record<string, any>) {
+    const node = this.nodes[key];
+    node.complete(result, this.nodes, this);
+  }
+
+  public reportError(key: string, result: Record<string, any>) {
+    const node = this.nodes[key];
+    node.reportError(result, this.nodes, this);
+  }
+
+  public add(node: Node) {
+    this.runningNodes.add(node.key);
+  }
+
+  public remove(node: Node) {
+    this.runningNodes.delete(node.key);
+    if (this.runningNodes.size == 0) {
+      this.callback({cmd: FlowCommand.OnComplete});
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+import { Graph } from "./flow";
+
+export { Graph };

package/tests/graphs/sample1.yml

@@ -0,0 +1,19 @@
+nodes:
+  node1:
+    params:
+      delay: 500
+  node2:
+    params:
+      delay: 100
+  node3:
+    params:
+      delay: 500
+    inputs: [node1, node2]
+  node4:
+    params:
+      delay: 100
+    inputs: [node3]
+  node5:
+    params:
+      delay: 500
+    inputs: [node2, node4]

package/tests/graphs/sample2.yml

@@ -0,0 +1,17 @@
+nodes:
+  node1:
+    params:
+      delay: 500
+  node2:
+    params:
+      delay: 100
+  node3:
+    params:
+      delay: 500
+      fail: true
+    inputs: [node1, node2]
+    retry: 2
+  node4:
+    params:
+      delay: 100
+    inputs: [node3]

package/tests/sample_flow.ts

@@ -0,0 +1,39 @@
+import path from "path";
+import { Graph, FlowCommand } from "../src/flow";
+
+import { readManifestData } from "../src/file_utils";
+
+const test = async (file: string) => {
+  const file_path = path.resolve(__dirname) + file;
+  const graph_data = readManifestData(file_path);
+  return new Promise((resolve, reject) => {
+    const graph = new Graph(graph_data, async (params) => {
+      if (params.cmd == FlowCommand.Execute) {
+          const node = params.node;
+          console.log("executing", node, params.params, params.payload)
+          setTimeout(() => {
+            if (params.params.fail && params.retry < 2) {
+              const result = { [node]:"failed" };
+              console.log("failed", node, result, params.retry)
+              graph.reportError(node, result);
+            } else {
+              const result = { [node]:"output" };
+              console.log("completing", node, result)
+              graph.feed(node, result)
+            }
+          }, params.params.delay);
+      } else if (params.cmd == FlowCommand.OnComplete) {
+        resolve(graph);
+      }
+    });
+    graph.run();
+  });
+}
+
+const main = async () => {
+  await test("/graphs/sample1.yml");
+  console.log("COMPLETE 1");
+  await test("/graphs/sample2.yml");
+  console.log("COMPLETE 2");
+};
+main();

package/tsconfig.json

@@ -0,0 +1,110 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "es2021",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    "rootDir": "./src/",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "./lib",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  },
+  "include": ["src"]
+}