.gitea/workflows/deploy.yml

@@ -0,0 +1,43 @@
+name: Plant Growing Automation
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  deploy:
+    runs-on: pigrow
+
+    steps:
+      - name: Checkout code
+        run: |
+          cd ~/apps/grow
+          git fetch
+          git checkout main
+          git pull origin main
+          - name: Install dependencies
+        run: |
+          cd ~/apps/grow
+          if [ -f package-lock.json ] || [ -f package.json ]; then
+            echo "Installing npm dependencies..."
+            npm install
+          else
+            echo "No Node.js project found (missing package.json)"
+            exit 1
+          fi
+
+
+      - name: Stop existing screen session, if running
+        run: |
+          if screen -list | grep -q "grow_server"; then
+            echo "Stopping existing screen session..."
+            screen -S grow_server -X quit
+          fi
+
+      - name: Start server in screen session
+        run: |
+          cd ~/apps/grow
+
+          setsid screen -dmS grow_server bash -c 'HTTP_PORT=8080 WS_PORT=3003 npm start >server.log 2>&1'
+          echo "Server started in detached screen session"

.gitignore

@@ -0,0 +1,3 @@
+venv/*
+node_modules/*
+dist/*

package.json

@@ -0,0 +1,23 @@
+{
+  "dependencies": {
+    "@roamhq/wrtc": "0.8.0",
+    "node-pre-gyp": "^0.17.0",
+    "ws": "^8.18.0",
+    "sass": "1.86.3"
+  },
+  "scripts": {
+    "build:scss": "npx sass src/static/css:dist/static/css",
+    "copy:html": "cp src/static/index.html dist/static",
+    "build:js:fe": "npx tsc src/static/js/*.ts --outDir dist/static/js",
+    "build:js:be": "npx tsc --skipLibCheck src/*.ts --outDir dist",
+    "build": "npm run build:js:fe && npm run build:js:be && npm run build:scss && npm run copy:html",
+    "start": "npm run build && node dist/server.js",
+    "dev": "npm run build && npx ts-node src/server.ts"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "@types/ws": "^8.5.13",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.2"
+  }
+}

src/http.ts

@@ -0,0 +1,84 @@
+import * as http from "http";
+import * as fs from "fs";
+import * as path from "path";
+
+
+export default class HttpServer {
+
+    private httpServer: http.Server;
+    private port: number;
+    private root: string;
+    // public constructor(port: number, root: string, tune: (ch: string, adp?: number) => void, getChannels: ()=>string[], getSignal: (adapter:number)=>object) {
+
+    public constructor(port: number, root: string) {
+        this.port = port;
+        this.root = root;
+        this.httpServer = http.createServer((req, res) => {
+            let status: number = 404;
+            let body: any = "";
+            const url = new URL(req.url, `http://${req.headers.host}`);
+            const pathname = path.normalize(url.pathname);
+
+            if (pathname.startsWith('/api/')) {
+                const query = pathname.split('/');
+                const api = query[2];
+                switch (req.method) {
+                    case "GET":
+                        switch (api) {
+                            case "list":
+                                // body = JSON.stringify(getChannels());
+                                status = 200;
+                                break;
+                            case "signal":
+                                const adapter = parseInt(url.searchParams.get('adapter'));
+                                // body = JSON.stringify(getSignal(adapter));
+                                status = 200;
+                                break;
+
+                        }
+                        break;
+                    case "PUT":
+                        switch (api) {
+                            case "tune":
+                                const channel = decodeURIComponent(query[3]);
+                                const adapter = parseInt(url.searchParams.get('adapter'));
+                                // tune(channel, adapter);
+                                status = 202;
+                                break;
+     
+                        }
+
+                }
+            }
+            else if (req.method === 'GET') {
+                const filePath = path.join(root, path.extname(pathname) === '' ? pathname + "/index.html" : pathname);
+                try {
+                    body = fs.readFileSync(filePath);
+                    status = 200;
+                }
+                catch (err) {
+                    body = "Invalid File"
+                }
+            }
+            else {
+                body = "Invalid Request"
+            }
+            res.writeHead(status);
+            res.end(body);
+
+        });
+    }
+    public start() {
+        this.httpServer.listen(this.port, () => {
+            console.log(`Serving ${this.root} at http://localhost:${this.port}`);
+        });
+    }
+
+
+
+
+
+
+
+}
+

src/server.ts

@@ -0,0 +1,54 @@
+import HttpServer from './http';
+import VideoSocket from './ws';
+
+const HTTP_PORT = process.env.HTTP_PORT ? parseInt(process.env.HTTP_PORT, 10) : 8080;
+const WS_PORT = process.env.WS_PORT ? parseInt(process.env.WS_PORT, 10) : 3003;
+const STATIC_ROOT = process.cwd() + "/dist/static";
+const TV_DEV_0 = process.env.TV_DEV_0 ?? '/dev/video0'
+
+// const zap = new Zap();
+
+
+// const tune = (reqChannel: string, reqAdapter?: number) => {
+//     const adapter = reqAdapter === 0 || reqAdapter === 1 ? reqAdapter : 0;
+//     zap.zapTo(reqChannel, adapter).then((zap: IZap) => {
+//         console.log(`Tuned ${zap.adapter} to ${zap.channel}`)
+//     }).catch((err: Error) => {
+//         console.error(err.message);
+//     });
+// }
+
+// const getChannels = () =>
+//     zap.getChannels();
+
+// const getSignal = (adapter: number) =>
+//     zap.getSignal(adapter)
+
+const httpServer = new HttpServer(HTTP_PORT, STATIC_ROOT);
+const videoSocket = new VideoSocket(WS_PORT, TV_DEV_0);
+
+httpServer.start();
+
+
+process.stdin.setEncoding("utf8");
+process.stdin.resume();
+
+console.log("Menu:");
+
+process.stdin.on("data", async (data: string) => {
+    const input = data.trim();
+    console.log(`Received: "${input}"`);
+    // await zap.zapTo(input).then((zap: IZap) => {
+    //     console.log(`Tuned ${zap.adapter} to ${zap.channel}`)
+
+    // }).catch((err: Error) => {
+    //     console.error(err.message);
+    // });
+
+});
+
+
+
+
+
+

src/static/css/styes.scss

@@ -0,0 +1,60 @@
+$background-color: #c7c7c7;
+$primary-color: #333;
+$secondary-color: #d11414;
+$text-color: #123455;
+
+body {
+    font-family: sans-serif;
+    background-color: $background-color;
+    header {
+        nav {
+            ul {
+                display: flex;
+                list-style: none;
+                gap: 1em;
+                li {
+
+                }
+            }
+            a {
+                &:hover {}
+            }
+        }
+    }
+
+    main {
+        display: flex;
+        flex-direction: column;
+        text-align: center;
+        align-items: center;
+        justify-content: center;
+        h1 {}
+
+        p {}
+        img {
+            width: 20em;
+            border-radius: 50%;
+        }
+        .content{
+            display: flex;
+            flex-direction: row;
+            gap: 1em;
+            .player{
+
+                .channel-group{
+                    display: flex;
+                    align-self: center;
+                    justify-self: center;
+                }
+            }
+        }
+        
+    }
+
+
+    footer {
+        text-align: center;
+        // background: #eee;
+        padding: 1em;
+    }
+}

src/static/index.html

@@ -0,0 +1,29 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <title>WebRTC Stream</title>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <link rel="stylesheet" href="css/index.css" />
+</head>
+
+<body>
+  <header></header>
+  <main>
+    <h1>Video streams</h1>
+    <h2>WebRTC</h2>
+    <div class="content">
+      <div class="player">
+        <video id="video0" autoplay playsinline controls></video>
+        <div id="channel-container-0" class="channel-group"></div>
+      </div>
+
+
+  </main>
+  </div>
+
+  <script src="js/video.js"></script>
+</body>
+
+</html>

src/static/js/video.ts

@@ -0,0 +1,46 @@
+const isSecure = window.location.protocol === 'https:';
+const host = window.location.hostname;
+const ws0builder = isSecure ? `wss://${host}/ws3` : `ws://${host}:3003`;
+const ws0 = new WebSocket(ws0builder);
+const config  = {
+  iceServers: [
+    {
+      urls: ['stun:dwestgate.us:3478','turn:dwestgate.us:3478?transport=udp'],
+      username: 'webrtcuser',
+      credential: 'webrtccred'
+    }
+  ]
+};
+const pc0 = new RTCPeerConnection(config);
+const video0 = document.getElementById('video0') as HTMLVideoElement;
+
+
+pc0.ontrack = (event) => {
+  console.log("Received track event", event.streams);
+  video0.srcObject = event.streams[0];
+};
+
+pc0.onicecandidate = ({ candidate }) => {
+  if (candidate) {
+    ws0.send(JSON.stringify({ type: 'ice-candidate', data: candidate }));
+  }
+};
+
+ws0.onopen = async () => {
+  pc0.addTransceiver('video', { direction: 'recvonly' });
+  pc0.addTransceiver('audio', { direction: 'recvonly' })
+  const offer = await pc0.createOffer();
+  await pc0.setLocalDescription(offer);
+  ws0.send(JSON.stringify({ type: 'offer', data: offer }));
+}
+
+ws0.onmessage = async (message) => {
+  const msg = JSON.parse(message.data);
+  if (msg.type === 'answer') {
+    await pc0.setRemoteDescription(msg.data);
+  }
+  else if (msg.type === 'ice-candidate') {
+    await pc0.addIceCandidate(msg.data);
+  }
+};
+

src/ws.ts

@@ -0,0 +1,208 @@
+import { MediaStream, MediaStreamTrack, nonstandard, RTCPeerConnection } from '@roamhq/wrtc';
+import { ChildProcessWithoutNullStreams, spawn } from 'child_process';
+import * as ws from 'ws';
+
+// Constants
+const WIDTH = 640; // Video width
+const HEIGHT = 480; // Video height
+const FRAME_SIZE = WIDTH * HEIGHT * 1.5; // YUV420P frame size
+
+export default class VideoSocket {
+    videoDevice: string;
+    public constructor(port: number, videoDevice) {
+        this.videoDevice = videoDevice
+        const ffmpegProcess = this.startFFmpeg();
+        const videoTrack = this.createVideoTrack(ffmpegProcess);
+        const audioTrack = this.createAudioTrack(ffmpegProcess);
+
+
+        // ffmpegProcess.stdio[2].on('data', data => {
+        //     console.log("stdio[2] ",data.toString())
+        // })
+
+        // WebSocket signaling server
+        const wss = new ws.WebSocketServer({ port });
+
+        wss.on('connection', async (ws: ws.WebSocket) => {
+            const peerConnection: RTCPeerConnection = this.createPeerConnection(videoTrack, audioTrack);
+
+            ws.on('message', async (message: Buffer) => {
+                const { type, data } = JSON.parse(message.toString());
+
+                if (type == 'offer') {
+                    await peerConnection.setRemoteDescription(data);
+                    const answer = await peerConnection.createAnswer();
+                    await peerConnection.setLocalDescription(answer);
+                    ws.send(JSON.stringify({ type: 'answer', data: peerConnection.localDescription }));
+                }
+
+                if (type === 'ice-candidate') {
+                    await peerConnection.addIceCandidate(data);
+                }
+
+            });
+
+            peerConnection.oniceconnectionstatechange = () => {
+                if (peerConnection.iceConnectionState === 'failed') {
+                    console.error('ICE connection failed');
+                }
+            };
+
+
+            // Send ICE candidates to the client
+            peerConnection.onicecandidate = ({ candidate }) => {
+                if (candidate) {
+                    ws.send(JSON.stringify({ type: 'ice-candidate', data: candidate }));
+                }
+            };
+
+            ws.on('close', () => {
+                console.log('Client disconnected');
+                peerConnection.close();
+            });
+        });
+    }
+
+    // Function to start FFmpeg and capture raw video
+    startFFmpeg = (): ChildProcessWithoutNullStreams => {
+        const p = spawn('ffmpeg', [
+            '-loglevel', 'debug',
+            '-i', this.videoDevice,
+
+            // Video
+            '-map', '0:v:0',
+            '-vf', `scale=${WIDTH}:${HEIGHT}`,
+            '-vcodec', 'rawvideo',
+            '-pix_fmt', 'yuv420p',
+            '-f', 'rawvideo',
+
+            //quality
+            '-fflags', '+discardcorrupt',
+            '-err_detect', 'ignore_err',
+            '-analyzeduration', '100M',
+            '-probesize', '100M',
+
+            'pipe:3',
+
+            // Audio
+            // '-map', '0:a:0',
+            // // '-acodec', 'pcm_s16le',
+            // '-ac', '1',
+            // '-ar', '48000',
+            // '-f', 'alsa',
+            // 'pipe:4'
+
+        ], {
+            stdio: ['ignore', 'pipe', 'pipe', 'pipe'/*, 'pipe'*/]
+        });
+        process.on('SIGINT', () => {
+            console.log('🔻 Server shutting down...');
+            p.kill('SIGINT');
+            process.exit(0);
+        });
+
+        process.on('SIGTERM', () => {
+            console.log('🔻 SIGTERM received');
+            p.kill('SIGTERM');
+            process.exit(0);
+        });
+        process.on('exit', () => {
+            p.kill('SIGHUP'); //this one
+            p.kill('SIGTERM');
+        });
+        return p;
+    }
+
+
+    createVideoTrack = (ffmpegProcess: ChildProcessWithoutNullStreams) => {
+        let videoBuffer = Buffer.alloc(0);
+        const videoSource = new nonstandard.RTCVideoSource();
+        const videoStream = ffmpegProcess.stdio[3]; // pipe:3
+        // Start FFmpeg and pipe video frames to the source
+        videoStream.on('data', (chunk: Buffer) => {
+            videoBuffer = Buffer.concat([videoBuffer, chunk]);
+            if (videoBuffer.length > FRAME_SIZE * 2) {
+                console.warn('Video buffer overrun — possible freeze trigger');
+            }
+            while (videoBuffer.length >= FRAME_SIZE) {
+                const frameData = videoBuffer.slice(0, FRAME_SIZE);
+                videoBuffer = videoBuffer.slice(FRAME_SIZE);
+                const frame: nonstandard.RTCVideoFrame = {
+                    width: WIDTH,
+                    height: HEIGHT,
+                    data: new Uint8Array(frameData),
+                }
+                videoSource.onFrame(frame);
+            }
+        });
+
+        videoStream.on('exit', (code) => {
+            console.log(`FFmpeg exited with code ${code}`);
+        });
+        return videoSource.createTrack();
+
+    }
+
+    createAudioTrack = (ffmpegProcess: ChildProcessWithoutNullStreams) => {
+        let audioBuffer = Buffer.alloc(0);
+        const audioSource = new nonstandard.RTCAudioSource();
+        const audioStream = ffmpegProcess.stdio[4]; // pipe:4
+        // --- AUDIO handling ---
+        const AUDIO_FRAME_SIZE = 480 * 2; // 480 samples * 2 bytes (s16le)
+
+        /*
+        audioStream.on('data', (chunk: Buffer) => {
+            audioBuffer = Buffer.concat([audioBuffer, chunk]);
+            while (audioBuffer.length >= AUDIO_FRAME_SIZE) {
+                const frameData = audioBuffer.slice(0, AUDIO_FRAME_SIZE);
+                audioBuffer = audioBuffer.slice(AUDIO_FRAME_SIZE);
+                const samples = new Int16Array(480);
+                for (let i = 0; i < 480; i++) {
+                    samples[i] = frameData.readInt16LE(i * 2);
+                }
+                audioSource.onData({
+                    samples,
+                    sampleRate: 48000,
+                    bitsPerSample: 16,
+                    channelCount: 1,
+                    numberOfFrames: 480
+                });
+            }
+        });
+
+        audioStream.on('data', (data: Buffer) => {
+            // console.error('FFmpeg Error:', data.toString());
+        });
+
+        audioStream.on('exit', (code) => {
+            console.log(`FFmpeg exited with code ${code}`);
+        });
+        */
+        return audioSource.createTrack();
+    }
+
+    createPeerConnection = (videoTrack: MediaStreamTrack, audioTrack: MediaStreamTrack): RTCPeerConnection => {
+        const peerConnection = new RTCPeerConnection({
+            iceServers: [
+                {
+                    urls: 'stun:192.168.0.3:3478'
+                },
+                {
+                    urls: 'turn:192.168.0.3:3478?transport=udp',
+                    username: 'webrtcuser',
+                    credential: 'webrtccred'
+                }
+            ]
+        });
+        const stream = new MediaStream()
+        stream.addTrack(videoTrack)
+        stream.addTrack(audioTrack);
+        peerConnection.addTrack(videoTrack, stream);
+        peerConnection.addTrack(audioTrack, stream);
+        return peerConnection;
+    }
+
+}
+
+
+

tsconfig.json

@@ -0,0 +1,116 @@
+{
+  "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": "ES2020", /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "lib": [
+      "esnext",
+      "ES2020",
+      "DOM"
+    ], /* 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": false, /* 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. */
+    // "types": ["node", "webrtc"],
+    // "typeRoots": ["./node_modules/@types"],
+    // "typeRoots": ["./node_modules/@types/webrtc"],                                  /* 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. */
+    // "rewriteRelativeImportExtensions": true,          /* Rewrite '.ts', '.tsx', '.mts', and '.cts' file extensions in relative import paths to their JavaScript equivalent in output files. */
+    // "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. */
+    // "noUncheckedSideEffectImports": true,             /* Check side effect 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. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "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": "dist",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "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": false, /* 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. */
+    /* 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. */
+    // "isolatedDeclarations": true,                     /* Require sufficient annotation on exports so other tools can trivially generate declaration files. */
+    "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": false, /* 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. */
+    // "strictBuiltinIteratorReturn": true,              /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */
+    // "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"],
+  "exclude": [
+    "node_modules","./node_modules/@roamhq/wrtc"
+  ]
+  //   "include": [
+  //  "./src", "./types"
+  //   ]
+}