Add files using upload-large-folder tool

backend/node_modules/.bin/giget

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+import { relative } from 'node:path';
+import { defineCommand, runMain } from 'citty';
+import { consola } from 'consola';
+import { d as downloadTemplate, s as startShell } from './shared/giget.OCaTp9b-.mjs';
+import 'node:fs/promises';
+import 'node:fs';
+import 'assert';
+import 'path';
+import 'events';
+import 'stream';
+import 'string_decoder';
+import 'buffer';
+import 'zlib';
+import 'process';
+import 'fs';
+import 'util';
+import 'crypto';
+import 'pathe';
+import 'defu';
+import 'nypm';
+import 'node:stream';
+import 'node:child_process';
+import 'node:os';
+import 'node:util';
+import 'node-fetch-native/proxy';
+
+const name = "giget";
+const version = "2.0.0";
+const description = "Download templates and git repositories with pleasure!";
+const pkg = {
+	name: name,
+	version: version,
+	description: description};
+
+const mainCommand = defineCommand({
+  meta: {
+    name: pkg.name,
+    version: pkg.version,
+    description: pkg.description
+  },
+  args: {
+    // TODO: Make it `-t` in the next major version
+    template: {
+      type: "positional",
+      description: "Template name or a a URI describing provider, repository, subdir, and branch/ref"
+    },
+    dir: {
+      type: "positional",
+      description: "A relative or absolute path where to extract the template",
+      required: false
+    },
+    auth: {
+      type: "string",
+      description: "Custom Authorization token to use for downloading template. (Can be overriden with `GIGET_AUTH` environment variable)"
+    },
+    cwd: {
+      type: "string",
+      description: "Set current working directory to resolve dirs relative to it"
+    },
+    force: {
+      type: "boolean",
+      description: "Clone to existing directory even if exists"
+    },
+    forceClean: {
+      type: "boolean",
+      description: "Remove any existing directory or file recusively before cloning"
+    },
+    offline: {
+      type: "boolean",
+      description: "o not attempt to download and use cached version"
+    },
+    preferOffline: {
+      type: "boolean",
+      description: "Use cache if exists otherwise try to download"
+    },
+    shell: {
+      type: "boolean",
+      description: "Open a new shell with current working "
+    },
+    install: {
+      type: "boolean",
+      description: "Install dependencies after cloning"
+    },
+    verbose: {
+      type: "boolean",
+      description: "Show verbose debugging info"
+    }
+  },
+  run: async ({ args }) => {
+    if (args.verbose) {
+      process.env.DEBUG = process.env.DEBUG || "true";
+    }
+    const r = await downloadTemplate(args.template, {
+      dir: args.dir,
+      force: args.force,
+      forceClean: args.forceClean,
+      offline: args.offline,
+      preferOffline: args.preferOffline,
+      auth: args.auth,
+      install: args.install
+    });
+    const _from = r.name || r.url;
+    const _to = relative(process.cwd(), r.dir) || "./";
+    consola.log(`\u2728 Successfully cloned \`${_from}\` to \`${_to}\`
+`);
+    if (args.shell) {
+      startShell(r.dir);
+    }
+  }
+});
+runMain(mainCommand);

backend/node_modules/c12/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Pooya Parsa <pooya@pi0.io>
+
+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.

backend/node_modules/c12/README.md

@@ -0,0 +1,467 @@
+# ⚙️ c12
+
+<!-- automd:badges color=yellow codecov -->
+
+[![npm version](https://img.shields.io/npm/v/c12?color=yellow)](https://npmjs.com/package/c12)
+[![npm downloads](https://img.shields.io/npm/dm/c12?color=yellow)](https://npm.chart.dev/c12)
+[![codecov](https://img.shields.io/codecov/c/gh/unjs/c12?color=yellow)](https://codecov.io/gh/unjs/c12)
+
+<!-- /automd -->
+
+c12 (pronounced as /siːtwelv/, like c-twelve) is a smart configuration loader.
+
+## ✅ Features
+
+- `.js`, `.ts`, `.mjs`, `.cjs`, `.mts`, `.cts` `.json` config loader with [unjs/jiti](https://jiti.unjs.io)
+- `.jsonc`, `.json5`, `.yaml`, `.yml`, `.toml` config loader with [unjs/confbox](https://confbox.unjs.io)
+- `.config/` directory support following [config dir proposal](https://github.com/pi0/config-dir)
+- `.rc` config support with [unjs/rc9](https://github.com/unjs/rc9)
+- `.env` support with [dotenv](https://www.npmjs.com/package/dotenv)
+- Multiple sources merged with [unjs/defu](https://github.com/unjs/defu)
+- Reads config from the nearest `package.json` file
+- [Extends configurations](https://github.com/unjs/c12#extending-configuration) from multiple local or git sources
+- Overwrite with [environment-specific configuration](#environment-specific-configuration)
+- Config watcher with auto-reload and HMR support
+- Create or update configuration files with [magicast](https://github.com/unjs/magicast)
+
+## 🦴 Used by
+
+- [Nuxt](https://nuxt.com/)
+- [Nitro](https://nitro.build/)
+- [Unbuild](https://unbuild.unjs.io)
+- [Automd](https://automd.unjs.io)
+- [Changelogen](https://changelogen.unjs.io)
+- [RemixKit](https://github.com/jrestall/remix-kit)
+- [Hey API](https://github.com/hey-api/openapi-ts)
+- [kysely-ctl](https://github.com/kysely-org/kysely-ctl)
+
+## Usage
+
+Install package:
+
+<!-- automd:pm-install -->
+
+```sh
+# ✨ Auto-detect
+npx nypm install c12
+
+# npm
+npm install c12
+
+# yarn
+yarn add c12
+
+# pnpm
+pnpm install c12
+
+# bun
+bun install c12
+
+# deno
+deno install c12
+```
+
+<!-- /automd -->
+
+Import:
+
+```js
+// ESM import
+import { loadConfig, watchConfig } from "c12";
+
+// or using dynamic import
+const { loadConfig, watchConfig } = await import("c12");
+```
+
+Load configuration:
+
+```js
+// Get loaded config
+const { config } = await loadConfig({});
+
+// Get resolved config and extended layers
+const { config, configFile, layers } = await loadConfig({});
+```
+
+## Loading priority
+
+c12 merged config sources with [unjs/defu](https://github.com/unjs/defu) by below order:
+
+1. Config overrides passed by options
+2. Config file in CWD
+3. RC file in CWD
+4. Global RC file in the user's home directory
+5. Config from `package.json`
+6. Default config passed by options
+7. Extended config layers
+
+## Options
+
+### `cwd`
+
+Resolve configuration from this working directory. The default is `process.cwd()`
+
+### `name`
+
+Configuration base name. The default is `config`.
+
+### `configFile`
+
+Configuration file name without extension. Default is generated from `name` (f.e., if `name` is `foo`, the config file will be => `foo.config`).
+
+### `rcFile`
+
+RC Config file name. Default is generated from `name` (name=foo => `.foorc`).
+
+Set to `false` to disable loading RC config.
+
+### `globalRC`
+
+Load RC config from the workspace directory and the user's home directory. Only enabled when `rcFile` is provided. Set to `false` to disable this functionality.
+
+### `dotenv`
+
+Loads `.env` file if enabled. It is disabled by default.
+
+### `packageJson`
+
+Loads config from nearest `package.json` file. It is disabled by default.
+
+If `true` value is passed, c12 uses `name` field from `package.json`.
+
+You can also pass either a string or an array of strings as a value to use those fields.
+
+### `defaults`
+
+Specify default configuration. It has the **lowest** priority and is applied **after extending** config.
+
+### `defaultConfig`
+
+Specify default configuration. It is applied **before** extending config.
+
+### `overrides`
+
+Specify override configuration. It has the **highest** priority and is applied **before extending** config.
+
+### `omit$Keys`
+
+Exclude environment-specific and built-in keys start with `$` in the resolved config. The default is `false`.
+
+### `jiti`
+
+Custom [unjs/jiti](https://github.com/unjs/jiti) instance used to import configuration files.
+
+### `jitiOptions`
+
+Custom [unjs/jiti](https://github.com/unjs/jiti) options to import configuration files.
+
+### `giget`
+
+Options passed to [unjs/giget](https://github.com/unjs/giget) when extending layer from git source.
+
+### `merger`
+
+Custom options merger function. Default is [defu](https://github.com/unjs/defu).
+
+**Note:** Custom merge function should deeply merge options with arguments high -> low priority.
+
+### `envName`
+
+Environment name used for [environment specific configuration](#environment-specific-configuration).
+
+The default is `process.env.NODE_ENV`. You can set `envName` to `false` or an empty string to disable the feature.
+
+### `resolve`
+
+You can define a custom function that resolves the config.
+
+
+## Extending configuration
+
+If resolved config contains a `extends` key, it will be used to extend the configuration.
+
+Extending can be nested and each layer can extend from one base or more.
+
+The final config is merged result of extended options and user options with [unjs/defu](https://github.com/unjs/defu).
+
+Each item in extends is a string that can be either an absolute or relative path to the current config file pointing to a config file for extending or the directory containing the config file.
+If it starts with either `github:`, `gitlab:`, `bitbucket:`, or `https:`, c12 automatically clones it.
+
+For custom merging strategies, you can directly access each layer with `layers` property.
+
+**Example:**
+
+```js
+// config.ts
+export default {
+  colors: {
+    primary: "user_primary",
+  },
+  extends: ["./theme"],
+};
+```
+
+```js
+// config.dev.ts
+export default {
+  dev: true,
+};
+```
+
+```js
+// theme/config.ts
+export default {
+  extends: "../base",
+  colors: {
+    primary: "theme_primary",
+    secondary: "theme_secondary",
+  },
+};
+```
+
+```js
+// base/config.ts
+export default {
+  colors: {
+    primary: "base_primary",
+    text: "base_text",
+  },
+};
+```
+
+The loaded configuration would look like this:
+
+```js
+const config = {
+  dev: true,
+  colors: {
+    primary: "user_primary",
+    secondary: "theme_secondary",
+    text: "base_text",
+  },
+};
+```
+
+Layers:
+
+```js
+[
+  {
+    config: {
+      /* theme config */
+    },
+    configFile: "/path/to/theme/config.ts",
+    cwd: "/path/to/theme ",
+  },
+  {
+    config: {
+      /* base  config */
+    },
+    configFile: "/path/to/base/config.ts",
+    cwd: "/path/to/base",
+  },
+  {
+    config: {
+      /* dev   config */
+    },
+    configFile: "/path/to/config.dev.ts",
+    cwd: "/path/",
+  },
+];
+```
+
+## Extending config layer from remote sources
+
+You can also extend configuration from remote sources such as npm or github.
+
+In the repo, there should be a `config.ts` (or `config.{name}.ts`) file to be considered as a valid config layer.
+
+**Example:** Extend from a github repository
+
+```js
+// config.ts
+export default {
+  extends: "gh:user/repo",
+};
+```
+
+**Example:** Extend from a github repository with branch and subpath
+
+```js
+// config.ts
+export default {
+  extends: "gh:user/repo/theme#dev",
+};
+```
+
+**Example:** Extend a private repository and install dependencies:
+
+```js
+// config.ts
+export default {
+  extends: ["gh:user/repo", { auth: process.env.GITHUB_TOKEN, install: true }],
+};
+```
+
+You can pass more options to `giget: {}` in layer config or disable it by setting it to `false`.
+
+Refer to [unjs/giget](https://giget.unjs.io) for more information.
+
+## Environment-specific configuration
+
+Users can define environment-specific configuration using these config keys:
+
+- `$test: {...}`
+- `$development: {...}`
+- `$production: {...}`
+- `$env: { [env]: {...} }`
+
+c12 tries to match [`envName`](#envname) and override environment config if specified.
+
+**Note:** Environment will be applied when extending each configuration layer. This way layers can provide environment-specific configuration.
+
+**Example:**
+
+```js
+export default {
+  // Default configuration
+  logLevel: "info",
+
+  // Environment overrides
+  $test: { logLevel: "silent" },
+  $development: { logLevel: "warning" },
+  $production: { logLevel: "error" },
+  $env: {
+    staging: { logLevel: "debug" },
+  },
+};
+```
+
+## Watching configuration
+
+you can use `watchConfig` instead of `loadConfig` to load config and watch for changes, add and removals in all expected configuration paths and auto reload with new config.
+
+### Lifecycle hooks
+
+- `onWatch`: This function is always called when config is updated, added, or removed before attempting to reload the config.
+- `acceptHMR`: By implementing this function, you can compare old and new functions and return `true` if a full reload is not needed.
+- `onUpdate`: This function is always called after the new config is updated. If `acceptHMR` returns true, it will be skipped.
+
+```ts
+import { watchConfig } from "c12";
+
+const config = watchConfig({
+  cwd: ".",
+  // chokidarOptions: {}, // Default is { ignoreInitial: true }
+  // debounce: 200 // Default is 100. You can set it to false to disable debounced watcher
+  onWatch: (event) => {
+    console.log("[watcher]", event.type, event.path);
+  },
+  acceptHMR({ oldConfig, newConfig, getDiff }) {
+    const diff = getDiff();
+    if (diff.length === 0) {
+      console.log("No config changed detected!");
+      return true; // No changes!
+    }
+  },
+  onUpdate({ oldConfig, newConfig, getDiff }) {
+    const diff = getDiff();
+    console.log("Config updated:\n" + diff.map((i) => i.toJSON()).join("\n"));
+  },
+});
+
+console.log("watching config files:", config.watchingFiles);
+console.log("initial config", config.config);
+
+// Stop watcher when not needed anymore
+// await config.unwatch();
+```
+
+## Updating config
+
+> [!NOTE]
+> This feature is experimental
+
+Update or create a new configuration files.
+
+Add `magicast` peer dependency:
+
+<!-- automd:pm-install name="magicast" dev -->
+
+```sh
+# ✨ Auto-detect
+npx nypm install -D magicast
+
+# npm
+npm install -D magicast
+
+# yarn
+yarn add -D magicast
+
+# pnpm
+pnpm install -D magicast
+
+# bun
+bun install -D magicast
+
+# deno
+deno install --dev magicast
+```
+
+<!-- /automd -->
+
+Import util from `c12/update`
+
+```js
+const { configFile, created } = await updateConfig({
+  cwd: ".",
+  configFile: "foo.config",
+  onCreate: ({ configFile }) => {
+    // You can prompt user if wants to create a new config file and return false to cancel
+    console.log(`Creating new config file in ${configFile}...`);
+    return "export default { test: true }";
+  },
+  onUpdate: (config) => {
+    // You can update the config contents just like an object
+    config.test2 = false;
+  },
+});
+
+console.log(`Config file ${created ? "created" : "updated"} in ${configFile}`);
+```
+
+## Contribution
+
+<details>
+  <summary>Local development</summary>
+
+- Clone this repository
+- Install the latest LTS version of [Node.js](https://nodejs.org/en/)
+- Enable [Corepack](https://github.com/nodejs/corepack) using `corepack enable`
+- Install dependencies using `pnpm install`
+- Run tests using `pnpm dev` or `pnpm test`
+
+</details>
+
+<!-- /automd -->
+
+## License
+
+<!-- automd:contributors license=MIT author="pi0" -->
+
+Published under the [MIT](https://github.com/unjs/c12/blob/main/LICENSE) license.
+Made by [@pi0](https://github.com/pi0) and [community](https://github.com/unjs/c12/graphs/contributors) 💛
+<br><br>
+<a href="https://github.com/unjs/c12/graphs/contributors">
+<img src="https://contrib.rocks/image?repo=unjs/c12" />
+</a>
+
+<!-- /automd -->
+
+<!-- automd:with-automd -->
+
+---
+
+_🤖 auto updated with [automd](https://automd.unjs.io)_
+
+<!-- /automd -->

backend/node_modules/c12/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "c12",
+  "version": "3.1.0",
+  "description": "Smart Config Loader",
+  "repository": "unjs/c12",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./update": {
+      "types": "./dist/update.d.mts",
+      "default": "./dist/update.mjs"
+    }
+  },
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "automd && unbuild",
+    "dev": "vitest dev",
+    "lint": "eslint . && prettier -c src test",
+    "lint:fix": "eslint . --fix && prettier -w src test",
+    "prepack": "unbuild",
+    "release": "pnpm build && pnpm test && changelogen --release --push --publish",
+    "test": "pnpm lint && vitest run --coverage && pnpm test:types",
+    "test:types": "tsc --noEmit"
+  },
+  "dependencies": {
+    "chokidar": "^4.0.3",
+    "confbox": "^0.2.2",
+    "defu": "^6.1.4",
+    "dotenv": "^16.6.1",
+    "exsolve": "^1.0.7",
+    "giget": "^2.0.0",
+    "jiti": "^2.4.2",
+    "ohash": "^2.0.11",
+    "pathe": "^2.0.3",
+    "perfect-debounce": "^1.0.0",
+    "pkg-types": "^2.2.0",
+    "rc9": "^2.1.2"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.13",
+    "@vitest/coverage-v8": "^3.2.4",
+    "automd": "^0.4.0",
+    "changelogen": "^0.6.2",
+    "eslint": "^9.31.0",
+    "eslint-config-unjs": "^0.5.0",
+    "expect-type": "^1.2.2",
+    "magicast": "^0.3.5",
+    "prettier": "^3.6.2",
+    "typescript": "^5.8.3",
+    "unbuild": "^3.5.0",
+    "vitest": "^3.2.4"
+  },
+  "peerDependencies": {
+    "magicast": "^0.3.5"
+  },
+  "peerDependenciesMeta": {
+    "magicast": {
+      "optional": true
+    }
+  },
+  "packageManager": "pnpm@10.13.1"
+}

backend/node_modules/chokidar/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2012 Paul Miller (https://paulmillr.com), Elan Shanker
+
+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.

backend/node_modules/chokidar/README.md

@@ -0,0 +1,305 @@
+# Chokidar [![Weekly downloads](https://img.shields.io/npm/dw/chokidar.svg)](https://github.com/paulmillr/chokidar)
+
+> Minimal and efficient cross-platform file watching library
+
+## Why?
+
+There are many reasons to prefer Chokidar to raw fs.watch / fs.watchFile in 2024:
+
+- Events are properly reported
+    - macOS events report filenames
+    - events are not reported twice
+    - changes are reported as add / change / unlink instead of useless `rename`
+- Atomic writes are supported, using `atomic` option
+    - Some file editors use them
+- Chunked writes are supported, using `awaitWriteFinish` option
+    - Large files are commonly written in chunks
+- File / dir filtering is supported
+- Symbolic links are supported
+- Recursive watching is always supported, instead of partial when using raw events
+    - Includes a way to limit recursion depth
+
+Chokidar relies on the Node.js core `fs` module, but when using
+`fs.watch` and `fs.watchFile` for watching, it normalizes the events it
+receives, often checking for truth by getting file stats and/or dir contents.
+The `fs.watch`-based implementation is the default, which
+avoids polling and keeps CPU usage down. Be advised that chokidar will initiate
+watchers recursively for everything within scope of the paths that have been
+specified, so be judicious about not wasting system resources by watching much
+more than needed. For some cases, `fs.watchFile`, which utilizes polling and uses more resources, is used.
+
+Made for [Brunch](https://brunch.io/) in 2012,
+it is now used in [~30 million repositories](https://www.npmjs.com/browse/depended/chokidar) and
+has proven itself in production environments.
+
+**Sep 2024 update:** v4 is out! It decreases dependency count from 13 to 1, removes
+support for globs, adds support for ESM / Common.js modules, and bumps minimum node.js version from v8 to v14.
+Check out [upgrading](#upgrading).
+
+## Getting started
+
+Install with npm:
+
+```sh
+npm install chokidar
+```
+
+Use it in your code:
+
+```javascript
+import chokidar from 'chokidar';
+
+// One-liner for current directory
+chokidar.watch('.').on('all', (event, path) => {
+  console.log(event, path);
+});
+
+
+// Extended options
+// ----------------
+
+// Initialize watcher.
+const watcher = chokidar.watch('file, dir, or array', {
+  ignored: (path, stats) => stats?.isFile() && !path.endsWith('.js'), // only watch js files
+  persistent: true
+});
+
+// Something to use when events are received.
+const log = console.log.bind(console);
+// Add event listeners.
+watcher
+  .on('add', path => log(`File ${path} has been added`))
+  .on('change', path => log(`File ${path} has been changed`))
+  .on('unlink', path => log(`File ${path} has been removed`));
+
+// More possible events.
+watcher
+  .on('addDir', path => log(`Directory ${path} has been added`))
+  .on('unlinkDir', path => log(`Directory ${path} has been removed`))
+  .on('error', error => log(`Watcher error: ${error}`))
+  .on('ready', () => log('Initial scan complete. Ready for changes'))
+  .on('raw', (event, path, details) => { // internal
+    log('Raw event info:', event, path, details);
+  });
+
+// 'add', 'addDir' and 'change' events also receive stat() results as second
+// argument when available: https://nodejs.org/api/fs.html#fs_class_fs_stats
+watcher.on('change', (path, stats) => {
+  if (stats) console.log(`File ${path} changed size to ${stats.size}`);
+});
+
+// Watch new files.
+watcher.add('new-file');
+watcher.add(['new-file-2', 'new-file-3']);
+
+// Get list of actual paths being watched on the filesystem
+let watchedPaths = watcher.getWatched();
+
+// Un-watch some files.
+await watcher.unwatch('new-file');
+
+// Stop watching. The method is async!
+await watcher.close().then(() => console.log('closed'));
+
+// Full list of options. See below for descriptions.
+// Do not use this example!
+chokidar.watch('file', {
+  persistent: true,
+
+  // ignore .txt files
+  ignored: (file) => file.endsWith('.txt'),
+  // watch only .txt files
+  // ignored: (file, _stats) => _stats?.isFile() && !file.endsWith('.txt'),
+
+  awaitWriteFinish: true, // emit single event when chunked writes are completed
+  atomic: true, // emit proper events when "atomic writes" (mv _tmp file) are used
+
+  // The options also allow specifying custom intervals in ms
+  // awaitWriteFinish: {
+  //   stabilityThreshold: 2000,
+  //   pollInterval: 100
+  // },
+  // atomic: 100,
+
+  interval: 100,
+  binaryInterval: 300,
+
+  cwd: '.',
+  depth: 99,
+
+  followSymlinks: true,
+  ignoreInitial: false,
+  ignorePermissionErrors: false,
+  usePolling: false,
+  alwaysStat: false,
+});
+
+```
+
+`chokidar.watch(paths, [options])`
+
+* `paths` (string or array of strings). Paths to files, dirs to be watched
+recursively.
+* `options` (object) Options object as defined below:
+
+#### Persistence
+
+* `persistent` (default: `true`). Indicates whether the process
+should continue to run as long as files are being watched.
+
+#### Path filtering
+
+* `ignored` function, regex, or path. Defines files/paths to be ignored.
+The whole relative or absolute path is tested, not just filename. If a function with two arguments
+is provided, it gets called twice per path - once with a single argument (the path), second
+time with two arguments (the path and the
+[`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats)
+object of that path).
+* `ignoreInitial` (default: `false`). If set to `false` then `add`/`addDir` events are also emitted for matching paths while
+instantiating the watching as chokidar discovers these file paths (before the `ready` event).
+* `followSymlinks` (default: `true`). When `false`, only the
+symlinks themselves will be watched for changes instead of following
+the link references and bubbling events through the link's path.
+* `cwd` (no default). The base directory from which watch `paths` are to be
+derived. Paths emitted with events will be relative to this.
+
+#### Performance
+
+* `usePolling` (default: `false`).
+Whether to use fs.watchFile (backed by polling), or fs.watch. If polling
+leads to high CPU utilization, consider setting this to `false`. It is
+typically necessary to **set this to `true` to successfully watch files over
+a network**, and it may be necessary to successfully watch files in other
+non-standard situations. Setting to `true` explicitly on MacOS overrides the
+`useFsEvents` default. You may also set the CHOKIDAR_USEPOLLING env variable
+to true (1) or false (0) in order to override this option.
+* _Polling-specific settings_ (effective when `usePolling: true`)
+  * `interval` (default: `100`). Interval of file system polling, in milliseconds. You may also
+    set the CHOKIDAR_INTERVAL env variable to override this option.
+  * `binaryInterval` (default: `300`). Interval of file system
+  polling for binary files.
+  ([see list of binary extensions](https://github.com/sindresorhus/binary-extensions/blob/master/binary-extensions.json))
+* `alwaysStat` (default: `false`). If relying upon the
+[`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats)
+object that may get passed with `add`, `addDir`, and `change` events, set
+this to `true` to ensure it is provided even in cases where it wasn't
+already available from the underlying watch events.
+* `depth` (default: `undefined`). If set, limits how many levels of
+subdirectories will be traversed.
+* `awaitWriteFinish` (default: `false`).
+By default, the `add` event will fire when a file first appears on disk, before
+the entire file has been written. Furthermore, in some cases some `change`
+events will be emitted while the file is being written. In some cases,
+especially when watching for large files there will be a need to wait for the
+write operation to finish before responding to a file creation or modification.
+Setting `awaitWriteFinish` to `true` (or a truthy value) will poll file size,
+holding its `add` and `change` events until the size does not change for a
+configurable amount of time. The appropriate duration setting is heavily
+dependent on the OS and hardware. For accurate detection this parameter should
+be relatively high, making file watching much less responsive.
+Use with caution.
+  * *`options.awaitWriteFinish` can be set to an object in order to adjust
+  timing params:*
+  * `awaitWriteFinish.stabilityThreshold` (default: 2000). Amount of time in
+  milliseconds for a file size to remain constant before emitting its event.
+  * `awaitWriteFinish.pollInterval` (default: 100). File size polling interval, in milliseconds.
+
+#### Errors
+
+* `ignorePermissionErrors` (default: `false`). Indicates whether to watch files
+that don't have read permissions if possible. If watching fails due to `EPERM`
+or `EACCES` with this set to `true`, the errors will be suppressed silently.
+* `atomic` (default: `true` if `useFsEvents` and `usePolling` are `false`).
+Automatically filters out artifacts that occur when using editors that use
+"atomic writes" instead of writing directly to the source file. If a file is
+re-added within 100 ms of being deleted, Chokidar emits a `change` event
+rather than `unlink` then `add`. If the default of 100 ms does not work well
+for you, you can override it by setting `atomic` to a custom value, in
+milliseconds.
+
+### Methods & Events
+
+`chokidar.watch()` produces an instance of `FSWatcher`. Methods of `FSWatcher`:
+
+* `.add(path / paths)`: Add files, directories for tracking.
+Takes an array of strings or just one string.
+* `.on(event, callback)`: Listen for an FS event.
+Available events: `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `ready`,
+`raw`, `error`.
+Additionally `all` is available which gets emitted with the underlying event
+name and path for every event other than `ready`, `raw`, and `error`.  `raw` is internal, use it carefully.
+* `.unwatch(path / paths)`: Stop watching files or directories.
+Takes an array of strings or just one string.
+* `.close()`: **async** Removes all listeners from watched files. Asynchronous, returns Promise. Use with `await` to ensure bugs don't happen.
+* `.getWatched()`: Returns an object representing all the paths on the file
+system being watched by this `FSWatcher` instance. The object's keys are all the
+directories (using absolute paths unless the `cwd` option was used), and the
+values are arrays of the names of the items contained in each directory.
+
+### CLI
+
+Check out third party [chokidar-cli](https://github.com/open-cli-tools/chokidar-cli),
+which allows to execute a command on each change, or get a stdio stream of change events.
+
+## Troubleshooting
+
+Sometimes, Chokidar runs out of file handles, causing `EMFILE` and `ENOSP` errors:
+
+* `bash: cannot set terminal process group (-1): Inappropriate ioctl for device bash: no job control in this shell`
+* `Error: watch /home/ ENOSPC`
+
+There are two things that can cause it.
+
+1. Exhausted file handles for generic fs operations
+    - Can be solved by using [graceful-fs](https://www.npmjs.com/package/graceful-fs),
+      which can monkey-patch native `fs` module used by chokidar: `let fs = require('fs'); let grfs = require('graceful-fs'); grfs.gracefulify(fs);`
+    - Can also be solved by tuning OS: `echo fs.inotify.max_user_watches=524288 | sudo tee -a /etc/sysctl.conf && sudo sysctl -p`.
+2. Exhausted file handles for `fs.watch`
+    - Can't seem to be solved by graceful-fs or OS tuning
+    - It's possible to start using `usePolling: true`, which will switch backend to resource-intensive `fs.watchFile`
+
+All fsevents-related issues (`WARN optional dep failed`, `fsevents is not a constructor`) are solved by upgrading to v4+.
+
+## Changelog
+
+- **v4 (Sep 2024):** remove glob support and bundled fsevents. Decrease dependency count from 13 to 1. Rewrite in typescript. Bumps minimum node.js requirement to v14+
+- **v3 (Apr 2019):** massive CPU & RAM consumption improvements; reduces deps / package size by a factor of 17x and bumps Node.js requirement to v8.16+.
+- **v2 (Dec 2017):** globs are now posix-style-only. Tons of bugfixes.
+- **v1 (Apr 2015):** glob support, symlink support, tons of bugfixes. Node 0.8+ is supported
+- **v0.1 (Apr 2012):** Initial release, extracted from [Brunch](https://github.com/brunch/brunch/blob/9847a065aea300da99bd0753f90354cde9de1261/src/helpers.coffee#L66)
+
+### Upgrading
+
+If you've used globs before and want do replicate the functionality with v4:
+
+```js
+// v3
+chok.watch('**/*.js');
+chok.watch("./directory/**/*");
+
+// v4
+chok.watch('.', {
+  ignored: (path, stats) => stats?.isFile() && !path.endsWith('.js'), // only watch js files
+});
+chok.watch('./directory');
+
+// other way
+import { glob } from 'node:fs/promises';
+const watcher = watch(await Array.fromAsync(glob('**/*.js')));
+
+// unwatching
+// v3
+chok.unwatch('**/*.js');
+// v4
+chok.unwatch(await glob('**/*.js'));
+```
+
+## Also
+
+Why was chokidar named this way? What's the meaning behind it?
+
+>Chowkidar is a transliteration of a Hindi word meaning 'watchman, gatekeeper', चौकीदार. This ultimately comes from Sanskrit _ चतुष्क_ (crossway, quadrangle, consisting-of-four). This word is also used in other languages like Urdu as (چوکیدار) which is widely used in Pakistan and India. 
+
+## License
+
+MIT (c) Paul Miller (<https://paulmillr.com>), see [LICENSE](LICENSE) file.

backend/node_modules/chokidar/handler.d.ts

@@ -0,0 +1,90 @@
+import type { WatchEventType, Stats, FSWatcher as NativeFsWatcher } from 'fs';
+import type { FSWatcher, WatchHelper, Throttler } from './index.js';
+import type { EntryInfo } from 'readdirp';
+export type Path = string;
+export declare const STR_DATA = "data";
+export declare const STR_END = "end";
+export declare const STR_CLOSE = "close";
+export declare const EMPTY_FN: () => void;
+export declare const IDENTITY_FN: (val: unknown) => unknown;
+export declare const isWindows: boolean;
+export declare const isMacos: boolean;
+export declare const isLinux: boolean;
+export declare const isFreeBSD: boolean;
+export declare const isIBMi: boolean;
+export declare const EVENTS: {
+    readonly ALL: "all";
+    readonly READY: "ready";
+    readonly ADD: "add";
+    readonly CHANGE: "change";
+    readonly ADD_DIR: "addDir";
+    readonly UNLINK: "unlink";
+    readonly UNLINK_DIR: "unlinkDir";
+    readonly RAW: "raw";
+    readonly ERROR: "error";
+};
+export type EventName = (typeof EVENTS)[keyof typeof EVENTS];
+export type FsWatchContainer = {
+    listeners: (path: string) => void | Set<any>;
+    errHandlers: (err: unknown) => void | Set<any>;
+    rawEmitters: (ev: WatchEventType, path: string, opts: unknown) => void | Set<any>;
+    watcher: NativeFsWatcher;
+    watcherUnusable?: boolean;
+};
+export interface WatchHandlers {
+    listener: (path: string) => void;
+    errHandler: (err: unknown) => void;
+    rawEmitter: (ev: WatchEventType, path: string, opts: unknown) => void;
+}
+/**
+ * @mixin
+ */
+export declare class NodeFsHandler {
+    fsw: FSWatcher;
+    _boundHandleError: (error: unknown) => void;
+    constructor(fsW: FSWatcher);
+    /**
+     * Watch file for changes with fs_watchFile or fs_watch.
+     * @param path to file or dir
+     * @param listener on fs change
+     * @returns closer for the watcher instance
+     */
+    _watchWithNodeFs(path: string, listener: (path: string, newStats?: any) => void | Promise<void>): (() => void) | undefined;
+    /**
+     * Watch a file and emit add event if warranted.
+     * @returns closer for the watcher instance
+     */
+    _handleFile(file: Path, stats: Stats, initialAdd: boolean): (() => void) | undefined;
+    /**
+     * Handle symlinks encountered while reading a dir.
+     * @param entry returned by readdirp
+     * @param directory path of dir being read
+     * @param path of this item
+     * @param item basename of this item
+     * @returns true if no more processing is needed for this entry.
+     */
+    _handleSymlink(entry: EntryInfo, directory: string, path: Path, item: string): Promise<boolean | undefined>;
+    _handleRead(directory: string, initialAdd: boolean, wh: WatchHelper, target: Path, dir: Path, depth: number, throttler: Throttler): Promise<unknown> | undefined;
+    /**
+     * Read directory to add / remove files from `@watched` list and re-read it on change.
+     * @param dir fs path
+     * @param stats
+     * @param initialAdd
+     * @param depth relative to user-supplied path
+     * @param target child path targeted for watch
+     * @param wh Common watch helpers for this path
+     * @param realpath
+     * @returns closer for the watcher instance.
+     */
+    _handleDir(dir: string, stats: Stats, initialAdd: boolean, depth: number, target: string, wh: WatchHelper, realpath: string): Promise<(() => void) | undefined>;
+    /**
+     * Handle added file, directory, or glob pattern.
+     * Delegates call to _handleFile / _handleDir after checks.
+     * @param path to file or ir
+     * @param initialAdd was the file added at watch instantiation?
+     * @param priorWh depth relative to user-supplied path
+     * @param depth Child path actually targeted for watch
+     * @param target Child path actually targeted for watch
+     */
+    _addToNodeFs(path: string, initialAdd: boolean, priorWh: WatchHelper | undefined, depth: number, target?: string): Promise<string | false | undefined>;
+}

backend/node_modules/chokidar/handler.js

@@ -0,0 +1,635 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeFsHandler = exports.EVENTS = exports.isIBMi = exports.isFreeBSD = exports.isLinux = exports.isMacos = exports.isWindows = exports.IDENTITY_FN = exports.EMPTY_FN = exports.STR_CLOSE = exports.STR_END = exports.STR_DATA = void 0;
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const sysPath = require("path");
+const os_1 = require("os");
+exports.STR_DATA = 'data';
+exports.STR_END = 'end';
+exports.STR_CLOSE = 'close';
+const EMPTY_FN = () => { };
+exports.EMPTY_FN = EMPTY_FN;
+const IDENTITY_FN = (val) => val;
+exports.IDENTITY_FN = IDENTITY_FN;
+const pl = process.platform;
+exports.isWindows = pl === 'win32';
+exports.isMacos = pl === 'darwin';
+exports.isLinux = pl === 'linux';
+exports.isFreeBSD = pl === 'freebsd';
+exports.isIBMi = (0, os_1.type)() === 'OS400';
+exports.EVENTS = {
+    ALL: 'all',
+    READY: 'ready',
+    ADD: 'add',
+    CHANGE: 'change',
+    ADD_DIR: 'addDir',
+    UNLINK: 'unlink',
+    UNLINK_DIR: 'unlinkDir',
+    RAW: 'raw',
+    ERROR: 'error',
+};
+const EV = exports.EVENTS;
+const THROTTLE_MODE_WATCH = 'watch';
+const statMethods = { lstat: promises_1.lstat, stat: promises_1.stat };
+const KEY_LISTENERS = 'listeners';
+const KEY_ERR = 'errHandlers';
+const KEY_RAW = 'rawEmitters';
+const HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
+// prettier-ignore
+const binaryExtensions = new Set([
+    '3dm', '3ds', '3g2', '3gp', '7z', 'a', 'aac', 'adp', 'afdesign', 'afphoto', 'afpub', 'ai',
+    'aif', 'aiff', 'alz', 'ape', 'apk', 'appimage', 'ar', 'arj', 'asf', 'au', 'avi',
+    'bak', 'baml', 'bh', 'bin', 'bk', 'bmp', 'btif', 'bz2', 'bzip2',
+    'cab', 'caf', 'cgm', 'class', 'cmx', 'cpio', 'cr2', 'cur', 'dat', 'dcm', 'deb', 'dex', 'djvu',
+    'dll', 'dmg', 'dng', 'doc', 'docm', 'docx', 'dot', 'dotm', 'dra', 'DS_Store', 'dsk', 'dts',
+    'dtshd', 'dvb', 'dwg', 'dxf',
+    'ecelp4800', 'ecelp7470', 'ecelp9600', 'egg', 'eol', 'eot', 'epub', 'exe',
+    'f4v', 'fbs', 'fh', 'fla', 'flac', 'flatpak', 'fli', 'flv', 'fpx', 'fst', 'fvt',
+    'g3', 'gh', 'gif', 'graffle', 'gz', 'gzip',
+    'h261', 'h263', 'h264', 'icns', 'ico', 'ief', 'img', 'ipa', 'iso',
+    'jar', 'jpeg', 'jpg', 'jpgv', 'jpm', 'jxr', 'key', 'ktx',
+    'lha', 'lib', 'lvp', 'lz', 'lzh', 'lzma', 'lzo',
+    'm3u', 'm4a', 'm4v', 'mar', 'mdi', 'mht', 'mid', 'midi', 'mj2', 'mka', 'mkv', 'mmr', 'mng',
+    'mobi', 'mov', 'movie', 'mp3',
+    'mp4', 'mp4a', 'mpeg', 'mpg', 'mpga', 'mxu',
+    'nef', 'npx', 'numbers', 'nupkg',
+    'o', 'odp', 'ods', 'odt', 'oga', 'ogg', 'ogv', 'otf', 'ott',
+    'pages', 'pbm', 'pcx', 'pdb', 'pdf', 'pea', 'pgm', 'pic', 'png', 'pnm', 'pot', 'potm',
+    'potx', 'ppa', 'ppam',
+    'ppm', 'pps', 'ppsm', 'ppsx', 'ppt', 'pptm', 'pptx', 'psd', 'pya', 'pyc', 'pyo', 'pyv',
+    'qt',
+    'rar', 'ras', 'raw', 'resources', 'rgb', 'rip', 'rlc', 'rmf', 'rmvb', 'rpm', 'rtf', 'rz',
+    's3m', 's7z', 'scpt', 'sgi', 'shar', 'snap', 'sil', 'sketch', 'slk', 'smv', 'snk', 'so',
+    'stl', 'suo', 'sub', 'swf',
+    'tar', 'tbz', 'tbz2', 'tga', 'tgz', 'thmx', 'tif', 'tiff', 'tlz', 'ttc', 'ttf', 'txz',
+    'udf', 'uvh', 'uvi', 'uvm', 'uvp', 'uvs', 'uvu',
+    'viv', 'vob',
+    'war', 'wav', 'wax', 'wbmp', 'wdp', 'weba', 'webm', 'webp', 'whl', 'wim', 'wm', 'wma',
+    'wmv', 'wmx', 'woff', 'woff2', 'wrm', 'wvx',
+    'xbm', 'xif', 'xla', 'xlam', 'xls', 'xlsb', 'xlsm', 'xlsx', 'xlt', 'xltm', 'xltx', 'xm',
+    'xmind', 'xpi', 'xpm', 'xwd', 'xz',
+    'z', 'zip', 'zipx',
+]);
+const isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
+// TODO: emit errors properly. Example: EMFILE on Macos.
+const foreach = (val, fn) => {
+    if (val instanceof Set) {
+        val.forEach(fn);
+    }
+    else {
+        fn(val);
+    }
+};
+const addAndConvert = (main, prop, item) => {
+    let container = main[prop];
+    if (!(container instanceof Set)) {
+        main[prop] = container = new Set([container]);
+    }
+    container.add(item);
+};
+const clearItem = (cont) => (key) => {
+    const set = cont[key];
+    if (set instanceof Set) {
+        set.clear();
+    }
+    else {
+        delete cont[key];
+    }
+};
+const delFromSet = (main, prop, item) => {
+    const container = main[prop];
+    if (container instanceof Set) {
+        container.delete(item);
+    }
+    else if (container === item) {
+        delete main[prop];
+    }
+};
+const isEmptySet = (val) => (val instanceof Set ? val.size === 0 : !val);
+const FsWatchInstances = new Map();
+/**
+ * Instantiates the fs_watch interface
+ * @param path to be watched
+ * @param options to be passed to fs_watch
+ * @param listener main event handler
+ * @param errHandler emits info about errors
+ * @param emitRaw emits raw event data
+ * @returns {NativeFsWatcher}
+ */
+function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
+    const handleEvent = (rawEvent, evPath) => {
+        listener(path);
+        emitRaw(rawEvent, evPath, { watchedPath: path });
+        // emit based on events occurring for files from a directory's watcher in
+        // case the file's watcher misses it (and rely on throttling to de-dupe)
+        if (evPath && path !== evPath) {
+            fsWatchBroadcast(sysPath.resolve(path, evPath), KEY_LISTENERS, sysPath.join(path, evPath));
+        }
+    };
+    try {
+        return (0, fs_1.watch)(path, {
+            persistent: options.persistent,
+        }, handleEvent);
+    }
+    catch (error) {
+        errHandler(error);
+        return undefined;
+    }
+}
+/**
+ * Helper for passing fs_watch event data to a collection of listeners
+ * @param fullPath absolute path bound to fs_watch instance
+ */
+const fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
+    const cont = FsWatchInstances.get(fullPath);
+    if (!cont)
+        return;
+    foreach(cont[listenerType], (listener) => {
+        listener(val1, val2, val3);
+    });
+};
+/**
+ * Instantiates the fs_watch interface or binds listeners
+ * to an existing one covering the same file system entry
+ * @param path
+ * @param fullPath absolute path
+ * @param options to be passed to fs_watch
+ * @param handlers container for event listener functions
+ */
+const setFsWatchListener = (path, fullPath, options, handlers) => {
+    const { listener, errHandler, rawEmitter } = handlers;
+    let cont = FsWatchInstances.get(fullPath);
+    let watcher;
+    if (!options.persistent) {
+        watcher = createFsWatchInstance(path, options, listener, errHandler, rawEmitter);
+        if (!watcher)
+            return;
+        return watcher.close.bind(watcher);
+    }
+    if (cont) {
+        addAndConvert(cont, KEY_LISTENERS, listener);
+        addAndConvert(cont, KEY_ERR, errHandler);
+        addAndConvert(cont, KEY_RAW, rawEmitter);
+    }
+    else {
+        watcher = createFsWatchInstance(path, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, // no need to use broadcast here
+        fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+        if (!watcher)
+            return;
+        watcher.on(EV.ERROR, async (error) => {
+            const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+            if (cont)
+                cont.watcherUnusable = true; // documented since Node 10.4.1
+            // Workaround for https://github.com/joyent/node/issues/4337
+            if (exports.isWindows && error.code === 'EPERM') {
+                try {
+                    const fd = await (0, promises_1.open)(path, 'r');
+                    await fd.close();
+                    broadcastErr(error);
+                }
+                catch (err) {
+                    // do nothing
+                }
+            }
+            else {
+                broadcastErr(error);
+            }
+        });
+        cont = {
+            listeners: listener,
+            errHandlers: errHandler,
+            rawEmitters: rawEmitter,
+            watcher,
+        };
+        FsWatchInstances.set(fullPath, cont);
+    }
+    // const index = cont.listeners.indexOf(listener);
+    // removes this instance's listeners and closes the underlying fs_watch
+    // instance if there are no more listeners left
+    return () => {
+        delFromSet(cont, KEY_LISTENERS, listener);
+        delFromSet(cont, KEY_ERR, errHandler);
+        delFromSet(cont, KEY_RAW, rawEmitter);
+        if (isEmptySet(cont.listeners)) {
+            // Check to protect against issue gh-730.
+            // if (cont.watcherUnusable) {
+            cont.watcher.close();
+            // }
+            FsWatchInstances.delete(fullPath);
+            HANDLER_KEYS.forEach(clearItem(cont));
+            // @ts-ignore
+            cont.watcher = undefined;
+            Object.freeze(cont);
+        }
+    };
+};
+// fs_watchFile helpers
+// object to hold per-process fs_watchFile instances
+// (may be shared across chokidar FSWatcher instances)
+const FsWatchFileInstances = new Map();
+/**
+ * Instantiates the fs_watchFile interface or binds listeners
+ * to an existing one covering the same file system entry
+ * @param path to be watched
+ * @param fullPath absolute path
+ * @param options options to be passed to fs_watchFile
+ * @param handlers container for event listener functions
+ * @returns closer
+ */
+const setFsWatchFileListener = (path, fullPath, options, handlers) => {
+    const { listener, rawEmitter } = handlers;
+    let cont = FsWatchFileInstances.get(fullPath);
+    // let listeners = new Set();
+    // let rawEmitters = new Set();
+    const copts = cont && cont.options;
+    if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+        // "Upgrade" the watcher to persistence or a quicker interval.
+        // This creates some unlikely edge case issues if the user mixes
+        // settings in a very weird way, but solving for those cases
+        // doesn't seem worthwhile for the added complexity.
+        // listeners = cont.listeners;
+        // rawEmitters = cont.rawEmitters;
+        (0, fs_1.unwatchFile)(fullPath);
+        cont = undefined;
+    }
+    if (cont) {
+        addAndConvert(cont, KEY_LISTENERS, listener);
+        addAndConvert(cont, KEY_RAW, rawEmitter);
+    }
+    else {
+        // TODO
+        // listeners.add(listener);
+        // rawEmitters.add(rawEmitter);
+        cont = {
+            listeners: listener,
+            rawEmitters: rawEmitter,
+            options,
+            watcher: (0, fs_1.watchFile)(fullPath, options, (curr, prev) => {
+                foreach(cont.rawEmitters, (rawEmitter) => {
+                    rawEmitter(EV.CHANGE, fullPath, { curr, prev });
+                });
+                const currmtime = curr.mtimeMs;
+                if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+                    foreach(cont.listeners, (listener) => listener(path, curr));
+                }
+            }),
+        };
+        FsWatchFileInstances.set(fullPath, cont);
+    }
+    // const index = cont.listeners.indexOf(listener);
+    // Removes this instance's listeners and closes the underlying fs_watchFile
+    // instance if there are no more listeners left.
+    return () => {
+        delFromSet(cont, KEY_LISTENERS, listener);
+        delFromSet(cont, KEY_RAW, rawEmitter);
+        if (isEmptySet(cont.listeners)) {
+            FsWatchFileInstances.delete(fullPath);
+            (0, fs_1.unwatchFile)(fullPath);
+            cont.options = cont.watcher = undefined;
+            Object.freeze(cont);
+        }
+    };
+};
+/**
+ * @mixin
+ */
+class NodeFsHandler {
+    constructor(fsW) {
+        this.fsw = fsW;
+        this._boundHandleError = (error) => fsW._handleError(error);
+    }
+    /**
+     * Watch file for changes with fs_watchFile or fs_watch.
+     * @param path to file or dir
+     * @param listener on fs change
+     * @returns closer for the watcher instance
+     */
+    _watchWithNodeFs(path, listener) {
+        const opts = this.fsw.options;
+        const directory = sysPath.dirname(path);
+        const basename = sysPath.basename(path);
+        const parent = this.fsw._getWatchedDir(directory);
+        parent.add(basename);
+        const absolutePath = sysPath.resolve(path);
+        const options = {
+            persistent: opts.persistent,
+        };
+        if (!listener)
+            listener = exports.EMPTY_FN;
+        let closer;
+        if (opts.usePolling) {
+            const enableBin = opts.interval !== opts.binaryInterval;
+            options.interval = enableBin && isBinaryPath(basename) ? opts.binaryInterval : opts.interval;
+            closer = setFsWatchFileListener(path, absolutePath, options, {
+                listener,
+                rawEmitter: this.fsw._emitRaw,
+            });
+        }
+        else {
+            closer = setFsWatchListener(path, absolutePath, options, {
+                listener,
+                errHandler: this._boundHandleError,
+                rawEmitter: this.fsw._emitRaw,
+            });
+        }
+        return closer;
+    }
+    /**
+     * Watch a file and emit add event if warranted.
+     * @returns closer for the watcher instance
+     */
+    _handleFile(file, stats, initialAdd) {
+        if (this.fsw.closed) {
+            return;
+        }
+        const dirname = sysPath.dirname(file);
+        const basename = sysPath.basename(file);
+        const parent = this.fsw._getWatchedDir(dirname);
+        // stats is always present
+        let prevStats = stats;
+        // if the file is already being watched, do nothing
+        if (parent.has(basename))
+            return;
+        const listener = async (path, newStats) => {
+            if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
+                return;
+            if (!newStats || newStats.mtimeMs === 0) {
+                try {
+                    const newStats = await (0, promises_1.stat)(file);
+                    if (this.fsw.closed)
+                        return;
+                    // Check that change event was not fired because of changed only accessTime.
+                    const at = newStats.atimeMs;
+                    const mt = newStats.mtimeMs;
+                    if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+                        this.fsw._emit(EV.CHANGE, file, newStats);
+                    }
+                    if ((exports.isMacos || exports.isLinux || exports.isFreeBSD) && prevStats.ino !== newStats.ino) {
+                        this.fsw._closeFile(path);
+                        prevStats = newStats;
+                        const closer = this._watchWithNodeFs(file, listener);
+                        if (closer)
+                            this.fsw._addPathCloser(path, closer);
+                    }
+                    else {
+                        prevStats = newStats;
+                    }
+                }
+                catch (error) {
+                    // Fix issues where mtime is null but file is still present
+                    this.fsw._remove(dirname, basename);
+                }
+                // add is about to be emitted if file not already tracked in parent
+            }
+            else if (parent.has(basename)) {
+                // Check that change event was not fired because of changed only accessTime.
+                const at = newStats.atimeMs;
+                const mt = newStats.mtimeMs;
+                if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+                    this.fsw._emit(EV.CHANGE, file, newStats);
+                }
+                prevStats = newStats;
+            }
+        };
+        // kick off the watcher
+        const closer = this._watchWithNodeFs(file, listener);
+        // emit an add event if we're supposed to
+        if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+            if (!this.fsw._throttle(EV.ADD, file, 0))
+                return;
+            this.fsw._emit(EV.ADD, file, stats);
+        }
+        return closer;
+    }
+    /**
+     * Handle symlinks encountered while reading a dir.
+     * @param entry returned by readdirp
+     * @param directory path of dir being read
+     * @param path of this item
+     * @param item basename of this item
+     * @returns true if no more processing is needed for this entry.
+     */
+    async _handleSymlink(entry, directory, path, item) {
+        if (this.fsw.closed) {
+            return;
+        }
+        const full = entry.fullPath;
+        const dir = this.fsw._getWatchedDir(directory);
+        if (!this.fsw.options.followSymlinks) {
+            // watch symlink directly (don't follow) and detect changes
+            this.fsw._incrReadyCount();
+            let linkPath;
+            try {
+                linkPath = await (0, promises_1.realpath)(path);
+            }
+            catch (e) {
+                this.fsw._emitReady();
+                return true;
+            }
+            if (this.fsw.closed)
+                return;
+            if (dir.has(item)) {
+                if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+                    this.fsw._symlinkPaths.set(full, linkPath);
+                    this.fsw._emit(EV.CHANGE, path, entry.stats);
+                }
+            }
+            else {
+                dir.add(item);
+                this.fsw._symlinkPaths.set(full, linkPath);
+                this.fsw._emit(EV.ADD, path, entry.stats);
+            }
+            this.fsw._emitReady();
+            return true;
+        }
+        // don't follow the same symlink more than once
+        if (this.fsw._symlinkPaths.has(full)) {
+            return true;
+        }
+        this.fsw._symlinkPaths.set(full, true);
+    }
+    _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+        // Normalize the directory name on Windows
+        directory = sysPath.join(directory, '');
+        throttler = this.fsw._throttle('readdir', directory, 1000);
+        if (!throttler)
+            return;
+        const previous = this.fsw._getWatchedDir(wh.path);
+        const current = new Set();
+        let stream = this.fsw._readdirp(directory, {
+            fileFilter: (entry) => wh.filterPath(entry),
+            directoryFilter: (entry) => wh.filterDir(entry),
+        });
+        if (!stream)
+            return;
+        stream
+            .on(exports.STR_DATA, async (entry) => {
+            if (this.fsw.closed) {
+                stream = undefined;
+                return;
+            }
+            const item = entry.path;
+            let path = sysPath.join(directory, item);
+            current.add(item);
+            if (entry.stats.isSymbolicLink() &&
+                (await this._handleSymlink(entry, directory, path, item))) {
+                return;
+            }
+            if (this.fsw.closed) {
+                stream = undefined;
+                return;
+            }
+            // Files that present in current directory snapshot
+            // but absent in previous are added to watch list and
+            // emit `add` event.
+            if (item === target || (!target && !previous.has(item))) {
+                this.fsw._incrReadyCount();
+                // ensure relativeness of path is preserved in case of watcher reuse
+                path = sysPath.join(dir, sysPath.relative(dir, path));
+                this._addToNodeFs(path, initialAdd, wh, depth + 1);
+            }
+        })
+            .on(EV.ERROR, this._boundHandleError);
+        return new Promise((resolve, reject) => {
+            if (!stream)
+                return reject();
+            stream.once(exports.STR_END, () => {
+                if (this.fsw.closed) {
+                    stream = undefined;
+                    return;
+                }
+                const wasThrottled = throttler ? throttler.clear() : false;
+                resolve(undefined);
+                // Files that absent in current directory snapshot
+                // but present in previous emit `remove` event
+                // and are removed from @watched[directory].
+                previous
+                    .getChildren()
+                    .filter((item) => {
+                    return item !== directory && !current.has(item);
+                })
+                    .forEach((item) => {
+                    this.fsw._remove(directory, item);
+                });
+                stream = undefined;
+                // one more time for any missed in case changes came in extremely quickly
+                if (wasThrottled)
+                    this._handleRead(directory, false, wh, target, dir, depth, throttler);
+            });
+        });
+    }
+    /**
+     * Read directory to add / remove files from `@watched` list and re-read it on change.
+     * @param dir fs path
+     * @param stats
+     * @param initialAdd
+     * @param depth relative to user-supplied path
+     * @param target child path targeted for watch
+     * @param wh Common watch helpers for this path
+     * @param realpath
+     * @returns closer for the watcher instance.
+     */
+    async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
+        const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
+        const tracked = parentDir.has(sysPath.basename(dir));
+        if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+            this.fsw._emit(EV.ADD_DIR, dir, stats);
+        }
+        // ensure dir is tracked (harmless if redundant)
+        parentDir.add(sysPath.basename(dir));
+        this.fsw._getWatchedDir(dir);
+        let throttler;
+        let closer;
+        const oDepth = this.fsw.options.depth;
+        if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath)) {
+            if (!target) {
+                await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+                if (this.fsw.closed)
+                    return;
+            }
+            closer = this._watchWithNodeFs(dir, (dirPath, stats) => {
+                // if current directory is removed, do nothing
+                if (stats && stats.mtimeMs === 0)
+                    return;
+                this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+            });
+        }
+        return closer;
+    }
+    /**
+     * Handle added file, directory, or glob pattern.
+     * Delegates call to _handleFile / _handleDir after checks.
+     * @param path to file or ir
+     * @param initialAdd was the file added at watch instantiation?
+     * @param priorWh depth relative to user-supplied path
+     * @param depth Child path actually targeted for watch
+     * @param target Child path actually targeted for watch
+     */
+    async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
+        const ready = this.fsw._emitReady;
+        if (this.fsw._isIgnored(path) || this.fsw.closed) {
+            ready();
+            return false;
+        }
+        const wh = this.fsw._getWatchHelpers(path);
+        if (priorWh) {
+            wh.filterPath = (entry) => priorWh.filterPath(entry);
+            wh.filterDir = (entry) => priorWh.filterDir(entry);
+        }
+        // evaluate what is at the path we're being asked to watch
+        try {
+            const stats = await statMethods[wh.statMethod](wh.watchPath);
+            if (this.fsw.closed)
+                return;
+            if (this.fsw._isIgnored(wh.watchPath, stats)) {
+                ready();
+                return false;
+            }
+            const follow = this.fsw.options.followSymlinks;
+            let closer;
+            if (stats.isDirectory()) {
+                const absPath = sysPath.resolve(path);
+                const targetPath = follow ? await (0, promises_1.realpath)(path) : path;
+                if (this.fsw.closed)
+                    return;
+                closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+                if (this.fsw.closed)
+                    return;
+                // preserve this symlink's target path
+                if (absPath !== targetPath && targetPath !== undefined) {
+                    this.fsw._symlinkPaths.set(absPath, targetPath);
+                }
+            }
+            else if (stats.isSymbolicLink()) {
+                const targetPath = follow ? await (0, promises_1.realpath)(path) : path;
+                if (this.fsw.closed)
+                    return;
+                const parent = sysPath.dirname(wh.watchPath);
+                this.fsw._getWatchedDir(parent).add(wh.watchPath);
+                this.fsw._emit(EV.ADD, wh.watchPath, stats);
+                closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
+                if (this.fsw.closed)
+                    return;
+                // preserve this symlink's target path
+                if (targetPath !== undefined) {
+                    this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath);
+                }
+            }
+            else {
+                closer = this._handleFile(wh.watchPath, stats, initialAdd);
+            }
+            ready();
+            if (closer)
+                this.fsw._addPathCloser(path, closer);
+            return false;
+        }
+        catch (error) {
+            if (this.fsw._handleError(error)) {
+                ready();
+                return path;
+            }
+        }
+    }
+}
+exports.NodeFsHandler = NodeFsHandler;

backend/node_modules/chokidar/index.d.ts

@@ -0,0 +1,215 @@
+/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
+import { Stats } from 'fs';
+import { EventEmitter } from 'events';
+import { ReaddirpStream, ReaddirpOptions, EntryInfo } from 'readdirp';
+import { NodeFsHandler, EventName, Path, EVENTS as EV, WatchHandlers } from './handler.js';
+type AWF = {
+    stabilityThreshold: number;
+    pollInterval: number;
+};
+type BasicOpts = {
+    persistent: boolean;
+    ignoreInitial: boolean;
+    followSymlinks: boolean;
+    cwd?: string;
+    usePolling: boolean;
+    interval: number;
+    binaryInterval: number;
+    alwaysStat?: boolean;
+    depth?: number;
+    ignorePermissionErrors: boolean;
+    atomic: boolean | number;
+};
+export type Throttler = {
+    timeoutObject: NodeJS.Timeout;
+    clear: () => void;
+    count: number;
+};
+export type ChokidarOptions = Partial<BasicOpts & {
+    ignored: Matcher | Matcher[];
+    awaitWriteFinish: boolean | Partial<AWF>;
+}>;
+export type FSWInstanceOptions = BasicOpts & {
+    ignored: Matcher[];
+    awaitWriteFinish: false | AWF;
+};
+export type ThrottleType = 'readdir' | 'watch' | 'add' | 'remove' | 'change';
+export type EmitArgs = [path: Path, stats?: Stats];
+export type EmitErrorArgs = [error: Error, stats?: Stats];
+export type EmitArgsWithName = [event: EventName, ...EmitArgs];
+export type MatchFunction = (val: string, stats?: Stats) => boolean;
+export interface MatcherObject {
+    path: string;
+    recursive?: boolean;
+}
+export type Matcher = string | RegExp | MatchFunction | MatcherObject;
+/**
+ * Directory entry.
+ */
+declare class DirEntry {
+    path: Path;
+    _removeWatcher: (dir: string, base: string) => void;
+    items: Set<Path>;
+    constructor(dir: Path, removeWatcher: (dir: string, base: string) => void);
+    add(item: string): void;
+    remove(item: string): Promise<void>;
+    has(item: string): boolean | undefined;
+    getChildren(): string[];
+    dispose(): void;
+}
+export declare class WatchHelper {
+    fsw: FSWatcher;
+    path: string;
+    watchPath: string;
+    fullWatchPath: string;
+    dirParts: string[][];
+    followSymlinks: boolean;
+    statMethod: 'stat' | 'lstat';
+    constructor(path: string, follow: boolean, fsw: FSWatcher);
+    entryPath(entry: EntryInfo): Path;
+    filterPath(entry: EntryInfo): boolean;
+    filterDir(entry: EntryInfo): boolean;
+}
+export interface FSWatcherKnownEventMap {
+    [EV.READY]: [];
+    [EV.RAW]: Parameters<WatchHandlers['rawEmitter']>;
+    [EV.ERROR]: Parameters<WatchHandlers['errHandler']>;
+    [EV.ALL]: [event: EventName, ...EmitArgs];
+}
+export type FSWatcherEventMap = FSWatcherKnownEventMap & {
+    [k in Exclude<EventName, keyof FSWatcherKnownEventMap>]: EmitArgs;
+};
+/**
+ * Watches files & directories for changes. Emitted events:
+ * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
+ *
+ *     new FSWatcher()
+ *       .add(directories)
+ *       .on('add', path => log('File', path, 'was added'))
+ */
+export declare class FSWatcher extends EventEmitter<FSWatcherEventMap> {
+    closed: boolean;
+    options: FSWInstanceOptions;
+    _closers: Map<string, Array<any>>;
+    _ignoredPaths: Set<Matcher>;
+    _throttled: Map<ThrottleType, Map<any, any>>;
+    _streams: Set<ReaddirpStream>;
+    _symlinkPaths: Map<Path, string | boolean>;
+    _watched: Map<string, DirEntry>;
+    _pendingWrites: Map<string, any>;
+    _pendingUnlinks: Map<string, EmitArgsWithName>;
+    _readyCount: number;
+    _emitReady: () => void;
+    _closePromise?: Promise<void>;
+    _userIgnored?: MatchFunction;
+    _readyEmitted: boolean;
+    _emitRaw: WatchHandlers['rawEmitter'];
+    _boundRemove: (dir: string, item: string) => void;
+    _nodeFsHandler: NodeFsHandler;
+    constructor(_opts?: ChokidarOptions);
+    _addIgnoredPath(matcher: Matcher): void;
+    _removeIgnoredPath(matcher: Matcher): void;
+    /**
+     * Adds paths to be watched on an existing FSWatcher instance.
+     * @param paths_ file or file list. Other arguments are unused
+     */
+    add(paths_: Path | Path[], _origAdd?: string, _internal?: boolean): FSWatcher;
+    /**
+     * Close watchers or start ignoring events from specified paths.
+     */
+    unwatch(paths_: Path | Path[]): FSWatcher;
+    /**
+     * Close watchers and remove all listeners from watched paths.
+     */
+    close(): Promise<void>;
+    /**
+     * Expose list of watched paths
+     * @returns for chaining
+     */
+    getWatched(): Record<string, string[]>;
+    emitWithAll(event: EventName, args: EmitArgs): void;
+    /**
+     * Normalize and emit events.
+     * Calling _emit DOES NOT MEAN emit() would be called!
+     * @param event Type of event
+     * @param path File or directory path
+     * @param stats arguments to be passed with event
+     * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+     */
+    _emit(event: EventName, path: Path, stats?: Stats): Promise<this | undefined>;
+    /**
+     * Common handler for errors
+     * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+     */
+    _handleError(error: Error): Error | boolean;
+    /**
+     * Helper utility for throttling
+     * @param actionType type being throttled
+     * @param path being acted upon
+     * @param timeout duration of time to suppress duplicate actions
+     * @returns tracking object or false if action should be suppressed
+     */
+    _throttle(actionType: ThrottleType, path: Path, timeout: number): Throttler | false;
+    _incrReadyCount(): number;
+    /**
+     * Awaits write operation to finish.
+     * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+     * @param path being acted upon
+     * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+     * @param event
+     * @param awfEmit Callback to be called when ready for event to be emitted.
+     */
+    _awaitWriteFinish(path: Path, threshold: number, event: EventName, awfEmit: (err?: Error, stat?: Stats) => void): void;
+    /**
+     * Determines whether user has asked to ignore this path.
+     */
+    _isIgnored(path: Path, stats?: Stats): boolean;
+    _isntIgnored(path: Path, stat?: Stats): boolean;
+    /**
+     * Provides a set of common helpers and properties relating to symlink handling.
+     * @param path file or directory pattern being watched
+     */
+    _getWatchHelpers(path: Path): WatchHelper;
+    /**
+     * Provides directory tracking objects
+     * @param directory path of the directory
+     */
+    _getWatchedDir(directory: string): DirEntry;
+    /**
+     * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+     */
+    _hasReadPermissions(stats: Stats): boolean;
+    /**
+     * Handles emitting unlink events for
+     * files and directories, and via recursion, for
+     * files and directories within directories that are unlinked
+     * @param directory within which the following item is located
+     * @param item      base path of item/directory
+     */
+    _remove(directory: string, item: string, isDirectory?: boolean): void;
+    /**
+     * Closes all watchers for a path
+     */
+    _closePath(path: Path): void;
+    /**
+     * Closes only file-specific watchers
+     */
+    _closeFile(path: Path): void;
+    _addPathCloser(path: Path, closer: () => void): void;
+    _readdirp(root: Path, opts?: Partial<ReaddirpOptions>): ReaddirpStream | undefined;
+}
+/**
+ * Instantiates watcher with paths to be tracked.
+ * @param paths file / directory paths
+ * @param options opts, such as `atomic`, `awaitWriteFinish`, `ignored`, and others
+ * @returns an instance of FSWatcher for chaining.
+ * @example
+ * const watcher = watch('.').on('all', (event, path) => { console.log(event, path); });
+ * watch('.', { atomic: true, awaitWriteFinish: true, ignored: (f, stats) => stats?.isFile() && !f.endsWith('.js') })
+ */
+export declare function watch(paths: string | string[], options?: ChokidarOptions): FSWatcher;
+declare const _default: {
+    watch: typeof watch;
+    FSWatcher: typeof FSWatcher;
+};
+export default _default;

backend/node_modules/chokidar/index.js

@@ -0,0 +1,804 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FSWatcher = exports.WatchHelper = void 0;
+exports.watch = watch;
+/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const events_1 = require("events");
+const sysPath = require("path");
+const readdirp_1 = require("readdirp");
+const handler_js_1 = require("./handler.js");
+const SLASH = '/';
+const SLASH_SLASH = '//';
+const ONE_DOT = '.';
+const TWO_DOTS = '..';
+const STRING_TYPE = 'string';
+const BACK_SLASH_RE = /\\/g;
+const DOUBLE_SLASH_RE = /\/\//;
+const DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+const REPLACER_RE = /^\.[/\\]/;
+function arrify(item) {
+    return Array.isArray(item) ? item : [item];
+}
+const isMatcherObject = (matcher) => typeof matcher === 'object' && matcher !== null && !(matcher instanceof RegExp);
+function createPattern(matcher) {
+    if (typeof matcher === 'function')
+        return matcher;
+    if (typeof matcher === 'string')
+        return (string) => matcher === string;
+    if (matcher instanceof RegExp)
+        return (string) => matcher.test(string);
+    if (typeof matcher === 'object' && matcher !== null) {
+        return (string) => {
+            if (matcher.path === string)
+                return true;
+            if (matcher.recursive) {
+                const relative = sysPath.relative(matcher.path, string);
+                if (!relative) {
+                    return false;
+                }
+                return !relative.startsWith('..') && !sysPath.isAbsolute(relative);
+            }
+            return false;
+        };
+    }
+    return () => false;
+}
+function normalizePath(path) {
+    if (typeof path !== 'string')
+        throw new Error('string expected');
+    path = sysPath.normalize(path);
+    path = path.replace(/\\/g, '/');
+    let prepend = false;
+    if (path.startsWith('//'))
+        prepend = true;
+    const DOUBLE_SLASH_RE = /\/\//;
+    while (path.match(DOUBLE_SLASH_RE))
+        path = path.replace(DOUBLE_SLASH_RE, '/');
+    if (prepend)
+        path = '/' + path;
+    return path;
+}
+function matchPatterns(patterns, testString, stats) {
+    const path = normalizePath(testString);
+    for (let index = 0; index < patterns.length; index++) {
+        const pattern = patterns[index];
+        if (pattern(path, stats)) {
+            return true;
+        }
+    }
+    return false;
+}
+function anymatch(matchers, testString) {
+    if (matchers == null) {
+        throw new TypeError('anymatch: specify first argument');
+    }
+    // Early cache for matchers.
+    const matchersArray = arrify(matchers);
+    const patterns = matchersArray.map((matcher) => createPattern(matcher));
+    if (testString == null) {
+        return (testString, stats) => {
+            return matchPatterns(patterns, testString, stats);
+        };
+    }
+    return matchPatterns(patterns, testString);
+}
+const unifyPaths = (paths_) => {
+    const paths = arrify(paths_).flat();
+    if (!paths.every((p) => typeof p === STRING_TYPE)) {
+        throw new TypeError(`Non-string provided as watch path: ${paths}`);
+    }
+    return paths.map(normalizePathToUnix);
+};
+// If SLASH_SLASH occurs at the beginning of path, it is not replaced
+//     because "//StoragePC/DrivePool/Movies" is a valid network path
+const toUnix = (string) => {
+    let str = string.replace(BACK_SLASH_RE, SLASH);
+    let prepend = false;
+    if (str.startsWith(SLASH_SLASH)) {
+        prepend = true;
+    }
+    while (str.match(DOUBLE_SLASH_RE)) {
+        str = str.replace(DOUBLE_SLASH_RE, SLASH);
+    }
+    if (prepend) {
+        str = SLASH + str;
+    }
+    return str;
+};
+// Our version of upath.normalize
+// TODO: this is not equal to path-normalize module - investigate why
+const normalizePathToUnix = (path) => toUnix(sysPath.normalize(toUnix(path)));
+// TODO: refactor
+const normalizeIgnored = (cwd = '') => (path) => {
+    if (typeof path === 'string') {
+        return normalizePathToUnix(sysPath.isAbsolute(path) ? path : sysPath.join(cwd, path));
+    }
+    else {
+        return path;
+    }
+};
+const getAbsolutePath = (path, cwd) => {
+    if (sysPath.isAbsolute(path)) {
+        return path;
+    }
+    return sysPath.join(cwd, path);
+};
+const EMPTY_SET = Object.freeze(new Set());
+/**
+ * Directory entry.
+ */
+class DirEntry {
+    constructor(dir, removeWatcher) {
+        this.path = dir;
+        this._removeWatcher = removeWatcher;
+        this.items = new Set();
+    }
+    add(item) {
+        const { items } = this;
+        if (!items)
+            return;
+        if (item !== ONE_DOT && item !== TWO_DOTS)
+            items.add(item);
+    }
+    async remove(item) {
+        const { items } = this;
+        if (!items)
+            return;
+        items.delete(item);
+        if (items.size > 0)
+            return;
+        const dir = this.path;
+        try {
+            await (0, promises_1.readdir)(dir);
+        }
+        catch (err) {
+            if (this._removeWatcher) {
+                this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir));
+            }
+        }
+    }
+    has(item) {
+        const { items } = this;
+        if (!items)
+            return;
+        return items.has(item);
+    }
+    getChildren() {
+        const { items } = this;
+        if (!items)
+            return [];
+        return [...items.values()];
+    }
+    dispose() {
+        this.items.clear();
+        this.path = '';
+        this._removeWatcher = handler_js_1.EMPTY_FN;
+        this.items = EMPTY_SET;
+        Object.freeze(this);
+    }
+}
+const STAT_METHOD_F = 'stat';
+const STAT_METHOD_L = 'lstat';
+class WatchHelper {
+    constructor(path, follow, fsw) {
+        this.fsw = fsw;
+        const watchPath = path;
+        this.path = path = path.replace(REPLACER_RE, '');
+        this.watchPath = watchPath;
+        this.fullWatchPath = sysPath.resolve(watchPath);
+        this.dirParts = [];
+        this.dirParts.forEach((parts) => {
+            if (parts.length > 1)
+                parts.pop();
+        });
+        this.followSymlinks = follow;
+        this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+    }
+    entryPath(entry) {
+        return sysPath.join(this.watchPath, sysPath.relative(this.watchPath, entry.fullPath));
+    }
+    filterPath(entry) {
+        const { stats } = entry;
+        if (stats && stats.isSymbolicLink())
+            return this.filterDir(entry);
+        const resolvedPath = this.entryPath(entry);
+        // TODO: what if stats is undefined? remove !
+        return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+    }
+    filterDir(entry) {
+        return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+    }
+}
+exports.WatchHelper = WatchHelper;
+/**
+ * Watches files & directories for changes. Emitted events:
+ * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
+ *
+ *     new FSWatcher()
+ *       .add(directories)
+ *       .on('add', path => log('File', path, 'was added'))
+ */
+class FSWatcher extends events_1.EventEmitter {
+    // Not indenting methods for history sake; for now.
+    constructor(_opts = {}) {
+        super();
+        this.closed = false;
+        this._closers = new Map();
+        this._ignoredPaths = new Set();
+        this._throttled = new Map();
+        this._streams = new Set();
+        this._symlinkPaths = new Map();
+        this._watched = new Map();
+        this._pendingWrites = new Map();
+        this._pendingUnlinks = new Map();
+        this._readyCount = 0;
+        this._readyEmitted = false;
+        const awf = _opts.awaitWriteFinish;
+        const DEF_AWF = { stabilityThreshold: 2000, pollInterval: 100 };
+        const opts = {
+            // Defaults
+            persistent: true,
+            ignoreInitial: false,
+            ignorePermissionErrors: false,
+            interval: 100,
+            binaryInterval: 300,
+            followSymlinks: true,
+            usePolling: false,
+            // useAsync: false,
+            atomic: true, // NOTE: overwritten later (depends on usePolling)
+            ..._opts,
+            // Change format
+            ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+            awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === 'object' ? { ...DEF_AWF, ...awf } : false,
+        };
+        // Always default to polling on IBM i because fs.watch() is not available on IBM i.
+        if (handler_js_1.isIBMi)
+            opts.usePolling = true;
+        // Editor atomic write normalization enabled by default with fs.watch
+        if (opts.atomic === undefined)
+            opts.atomic = !opts.usePolling;
+        // opts.atomic = typeof _opts.atomic === 'number' ? _opts.atomic : 100;
+        // Global override. Useful for developers, who need to force polling for all
+        // instances of chokidar, regardless of usage / dependency depth
+        const envPoll = process.env.CHOKIDAR_USEPOLLING;
+        if (envPoll !== undefined) {
+            const envLower = envPoll.toLowerCase();
+            if (envLower === 'false' || envLower === '0')
+                opts.usePolling = false;
+            else if (envLower === 'true' || envLower === '1')
+                opts.usePolling = true;
+            else
+                opts.usePolling = !!envLower;
+        }
+        const envInterval = process.env.CHOKIDAR_INTERVAL;
+        if (envInterval)
+            opts.interval = Number.parseInt(envInterval, 10);
+        // This is done to emit ready only once, but each 'add' will increase that?
+        let readyCalls = 0;
+        this._emitReady = () => {
+            readyCalls++;
+            if (readyCalls >= this._readyCount) {
+                this._emitReady = handler_js_1.EMPTY_FN;
+                this._readyEmitted = true;
+                // use process.nextTick to allow time for listener to be bound
+                process.nextTick(() => this.emit(handler_js_1.EVENTS.READY));
+            }
+        };
+        this._emitRaw = (...args) => this.emit(handler_js_1.EVENTS.RAW, ...args);
+        this._boundRemove = this._remove.bind(this);
+        this.options = opts;
+        this._nodeFsHandler = new handler_js_1.NodeFsHandler(this);
+        // You’re frozen when your heart’s not open.
+        Object.freeze(opts);
+    }
+    _addIgnoredPath(matcher) {
+        if (isMatcherObject(matcher)) {
+            // return early if we already have a deeply equal matcher object
+            for (const ignored of this._ignoredPaths) {
+                if (isMatcherObject(ignored) &&
+                    ignored.path === matcher.path &&
+                    ignored.recursive === matcher.recursive) {
+                    return;
+                }
+            }
+        }
+        this._ignoredPaths.add(matcher);
+    }
+    _removeIgnoredPath(matcher) {
+        this._ignoredPaths.delete(matcher);
+        // now find any matcher objects with the matcher as path
+        if (typeof matcher === 'string') {
+            for (const ignored of this._ignoredPaths) {
+                // TODO (43081j): make this more efficient.
+                // probably just make a `this._ignoredDirectories` or some
+                // such thing.
+                if (isMatcherObject(ignored) && ignored.path === matcher) {
+                    this._ignoredPaths.delete(ignored);
+                }
+            }
+        }
+    }
+    // Public methods
+    /**
+     * Adds paths to be watched on an existing FSWatcher instance.
+     * @param paths_ file or file list. Other arguments are unused
+     */
+    add(paths_, _origAdd, _internal) {
+        const { cwd } = this.options;
+        this.closed = false;
+        this._closePromise = undefined;
+        let paths = unifyPaths(paths_);
+        if (cwd) {
+            paths = paths.map((path) => {
+                const absPath = getAbsolutePath(path, cwd);
+                // Check `path` instead of `absPath` because the cwd portion can't be a glob
+                return absPath;
+            });
+        }
+        paths.forEach((path) => {
+            this._removeIgnoredPath(path);
+        });
+        this._userIgnored = undefined;
+        if (!this._readyCount)
+            this._readyCount = 0;
+        this._readyCount += paths.length;
+        Promise.all(paths.map(async (path) => {
+            const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, undefined, 0, _origAdd);
+            if (res)
+                this._emitReady();
+            return res;
+        })).then((results) => {
+            if (this.closed)
+                return;
+            results.forEach((item) => {
+                if (item)
+                    this.add(sysPath.dirname(item), sysPath.basename(_origAdd || item));
+            });
+        });
+        return this;
+    }
+    /**
+     * Close watchers or start ignoring events from specified paths.
+     */
+    unwatch(paths_) {
+        if (this.closed)
+            return this;
+        const paths = unifyPaths(paths_);
+        const { cwd } = this.options;
+        paths.forEach((path) => {
+            // convert to absolute path unless relative path already matches
+            if (!sysPath.isAbsolute(path) && !this._closers.has(path)) {
+                if (cwd)
+                    path = sysPath.join(cwd, path);
+                path = sysPath.resolve(path);
+            }
+            this._closePath(path);
+            this._addIgnoredPath(path);
+            if (this._watched.has(path)) {
+                this._addIgnoredPath({
+                    path,
+                    recursive: true,
+                });
+            }
+            // reset the cached userIgnored anymatch fn
+            // to make ignoredPaths changes effective
+            this._userIgnored = undefined;
+        });
+        return this;
+    }
+    /**
+     * Close watchers and remove all listeners from watched paths.
+     */
+    close() {
+        if (this._closePromise) {
+            return this._closePromise;
+        }
+        this.closed = true;
+        // Memory management.
+        this.removeAllListeners();
+        const closers = [];
+        this._closers.forEach((closerList) => closerList.forEach((closer) => {
+            const promise = closer();
+            if (promise instanceof Promise)
+                closers.push(promise);
+        }));
+        this._streams.forEach((stream) => stream.destroy());
+        this._userIgnored = undefined;
+        this._readyCount = 0;
+        this._readyEmitted = false;
+        this._watched.forEach((dirent) => dirent.dispose());
+        this._closers.clear();
+        this._watched.clear();
+        this._streams.clear();
+        this._symlinkPaths.clear();
+        this._throttled.clear();
+        this._closePromise = closers.length
+            ? Promise.all(closers).then(() => undefined)
+            : Promise.resolve();
+        return this._closePromise;
+    }
+    /**
+     * Expose list of watched paths
+     * @returns for chaining
+     */
+    getWatched() {
+        const watchList = {};
+        this._watched.forEach((entry, dir) => {
+            const key = this.options.cwd ? sysPath.relative(this.options.cwd, dir) : dir;
+            const index = key || ONE_DOT;
+            watchList[index] = entry.getChildren().sort();
+        });
+        return watchList;
+    }
+    emitWithAll(event, args) {
+        this.emit(event, ...args);
+        if (event !== handler_js_1.EVENTS.ERROR)
+            this.emit(handler_js_1.EVENTS.ALL, event, ...args);
+    }
+    // Common helpers
+    // --------------
+    /**
+     * Normalize and emit events.
+     * Calling _emit DOES NOT MEAN emit() would be called!
+     * @param event Type of event
+     * @param path File or directory path
+     * @param stats arguments to be passed with event
+     * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+     */
+    async _emit(event, path, stats) {
+        if (this.closed)
+            return;
+        const opts = this.options;
+        if (handler_js_1.isWindows)
+            path = sysPath.normalize(path);
+        if (opts.cwd)
+            path = sysPath.relative(opts.cwd, path);
+        const args = [path];
+        if (stats != null)
+            args.push(stats);
+        const awf = opts.awaitWriteFinish;
+        let pw;
+        if (awf && (pw = this._pendingWrites.get(path))) {
+            pw.lastChange = new Date();
+            return this;
+        }
+        if (opts.atomic) {
+            if (event === handler_js_1.EVENTS.UNLINK) {
+                this._pendingUnlinks.set(path, [event, ...args]);
+                setTimeout(() => {
+                    this._pendingUnlinks.forEach((entry, path) => {
+                        this.emit(...entry);
+                        this.emit(handler_js_1.EVENTS.ALL, ...entry);
+                        this._pendingUnlinks.delete(path);
+                    });
+                }, typeof opts.atomic === 'number' ? opts.atomic : 100);
+                return this;
+            }
+            if (event === handler_js_1.EVENTS.ADD && this._pendingUnlinks.has(path)) {
+                event = handler_js_1.EVENTS.CHANGE;
+                this._pendingUnlinks.delete(path);
+            }
+        }
+        if (awf && (event === handler_js_1.EVENTS.ADD || event === handler_js_1.EVENTS.CHANGE) && this._readyEmitted) {
+            const awfEmit = (err, stats) => {
+                if (err) {
+                    event = handler_js_1.EVENTS.ERROR;
+                    args[0] = err;
+                    this.emitWithAll(event, args);
+                }
+                else if (stats) {
+                    // if stats doesn't exist the file must have been deleted
+                    if (args.length > 1) {
+                        args[1] = stats;
+                    }
+                    else {
+                        args.push(stats);
+                    }
+                    this.emitWithAll(event, args);
+                }
+            };
+            this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
+            return this;
+        }
+        if (event === handler_js_1.EVENTS.CHANGE) {
+            const isThrottled = !this._throttle(handler_js_1.EVENTS.CHANGE, path, 50);
+            if (isThrottled)
+                return this;
+        }
+        if (opts.alwaysStat &&
+            stats === undefined &&
+            (event === handler_js_1.EVENTS.ADD || event === handler_js_1.EVENTS.ADD_DIR || event === handler_js_1.EVENTS.CHANGE)) {
+            const fullPath = opts.cwd ? sysPath.join(opts.cwd, path) : path;
+            let stats;
+            try {
+                stats = await (0, promises_1.stat)(fullPath);
+            }
+            catch (err) {
+                // do nothing
+            }
+            // Suppress event when fs_stat fails, to avoid sending undefined 'stat'
+            if (!stats || this.closed)
+                return;
+            args.push(stats);
+        }
+        this.emitWithAll(event, args);
+        return this;
+    }
+    /**
+     * Common handler for errors
+     * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+     */
+    _handleError(error) {
+        const code = error && error.code;
+        if (error &&
+            code !== 'ENOENT' &&
+            code !== 'ENOTDIR' &&
+            (!this.options.ignorePermissionErrors || (code !== 'EPERM' && code !== 'EACCES'))) {
+            this.emit(handler_js_1.EVENTS.ERROR, error);
+        }
+        return error || this.closed;
+    }
+    /**
+     * Helper utility for throttling
+     * @param actionType type being throttled
+     * @param path being acted upon
+     * @param timeout duration of time to suppress duplicate actions
+     * @returns tracking object or false if action should be suppressed
+     */
+    _throttle(actionType, path, timeout) {
+        if (!this._throttled.has(actionType)) {
+            this._throttled.set(actionType, new Map());
+        }
+        const action = this._throttled.get(actionType);
+        if (!action)
+            throw new Error('invalid throttle');
+        const actionPath = action.get(path);
+        if (actionPath) {
+            actionPath.count++;
+            return false;
+        }
+        // eslint-disable-next-line prefer-const
+        let timeoutObject;
+        const clear = () => {
+            const item = action.get(path);
+            const count = item ? item.count : 0;
+            action.delete(path);
+            clearTimeout(timeoutObject);
+            if (item)
+                clearTimeout(item.timeoutObject);
+            return count;
+        };
+        timeoutObject = setTimeout(clear, timeout);
+        const thr = { timeoutObject, clear, count: 0 };
+        action.set(path, thr);
+        return thr;
+    }
+    _incrReadyCount() {
+        return this._readyCount++;
+    }
+    /**
+     * Awaits write operation to finish.
+     * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+     * @param path being acted upon
+     * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+     * @param event
+     * @param awfEmit Callback to be called when ready for event to be emitted.
+     */
+    _awaitWriteFinish(path, threshold, event, awfEmit) {
+        const awf = this.options.awaitWriteFinish;
+        if (typeof awf !== 'object')
+            return;
+        const pollInterval = awf.pollInterval;
+        let timeoutHandler;
+        let fullPath = path;
+        if (this.options.cwd && !sysPath.isAbsolute(path)) {
+            fullPath = sysPath.join(this.options.cwd, path);
+        }
+        const now = new Date();
+        const writes = this._pendingWrites;
+        function awaitWriteFinishFn(prevStat) {
+            (0, fs_1.stat)(fullPath, (err, curStat) => {
+                if (err || !writes.has(path)) {
+                    if (err && err.code !== 'ENOENT')
+                        awfEmit(err);
+                    return;
+                }
+                const now = Number(new Date());
+                if (prevStat && curStat.size !== prevStat.size) {
+                    writes.get(path).lastChange = now;
+                }
+                const pw = writes.get(path);
+                const df = now - pw.lastChange;
+                if (df >= threshold) {
+                    writes.delete(path);
+                    awfEmit(undefined, curStat);
+                }
+                else {
+                    timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+                }
+            });
+        }
+        if (!writes.has(path)) {
+            writes.set(path, {
+                lastChange: now,
+                cancelWait: () => {
+                    writes.delete(path);
+                    clearTimeout(timeoutHandler);
+                    return event;
+                },
+            });
+            timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+        }
+    }
+    /**
+     * Determines whether user has asked to ignore this path.
+     */
+    _isIgnored(path, stats) {
+        if (this.options.atomic && DOT_RE.test(path))
+            return true;
+        if (!this._userIgnored) {
+            const { cwd } = this.options;
+            const ign = this.options.ignored;
+            const ignored = (ign || []).map(normalizeIgnored(cwd));
+            const ignoredPaths = [...this._ignoredPaths];
+            const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
+            this._userIgnored = anymatch(list, undefined);
+        }
+        return this._userIgnored(path, stats);
+    }
+    _isntIgnored(path, stat) {
+        return !this._isIgnored(path, stat);
+    }
+    /**
+     * Provides a set of common helpers and properties relating to symlink handling.
+     * @param path file or directory pattern being watched
+     */
+    _getWatchHelpers(path) {
+        return new WatchHelper(path, this.options.followSymlinks, this);
+    }
+    // Directory helpers
+    // -----------------
+    /**
+     * Provides directory tracking objects
+     * @param directory path of the directory
+     */
+    _getWatchedDir(directory) {
+        const dir = sysPath.resolve(directory);
+        if (!this._watched.has(dir))
+            this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+        return this._watched.get(dir);
+    }
+    // File helpers
+    // ------------
+    /**
+     * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+     */
+    _hasReadPermissions(stats) {
+        if (this.options.ignorePermissionErrors)
+            return true;
+        return Boolean(Number(stats.mode) & 0o400);
+    }
+    /**
+     * Handles emitting unlink events for
+     * files and directories, and via recursion, for
+     * files and directories within directories that are unlinked
+     * @param directory within which the following item is located
+     * @param item      base path of item/directory
+     */
+    _remove(directory, item, isDirectory) {
+        // if what is being deleted is a directory, get that directory's paths
+        // for recursive deleting and cleaning of watched object
+        // if it is not a directory, nestedDirectoryChildren will be empty array
+        const path = sysPath.join(directory, item);
+        const fullPath = sysPath.resolve(path);
+        isDirectory =
+            isDirectory != null ? isDirectory : this._watched.has(path) || this._watched.has(fullPath);
+        // prevent duplicate handling in case of arriving here nearly simultaneously
+        // via multiple paths (such as _handleFile and _handleDir)
+        if (!this._throttle('remove', path, 100))
+            return;
+        // if the only watched file is removed, watch for its return
+        if (!isDirectory && this._watched.size === 1) {
+            this.add(directory, item, true);
+        }
+        // This will create a new entry in the watched object in either case
+        // so we got to do the directory check beforehand
+        const wp = this._getWatchedDir(path);
+        const nestedDirectoryChildren = wp.getChildren();
+        // Recursively remove children directories / files.
+        nestedDirectoryChildren.forEach((nested) => this._remove(path, nested));
+        // Check if item was on the watched list and remove it
+        const parent = this._getWatchedDir(directory);
+        const wasTracked = parent.has(item);
+        parent.remove(item);
+        // Fixes issue #1042 -> Relative paths were detected and added as symlinks
+        // (https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L612),
+        // but never removed from the map in case the path was deleted.
+        // This leads to an incorrect state if the path was recreated:
+        // https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L553
+        if (this._symlinkPaths.has(fullPath)) {
+            this._symlinkPaths.delete(fullPath);
+        }
+        // If we wait for this file to be fully written, cancel the wait.
+        let relPath = path;
+        if (this.options.cwd)
+            relPath = sysPath.relative(this.options.cwd, path);
+        if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+            const event = this._pendingWrites.get(relPath).cancelWait();
+            if (event === handler_js_1.EVENTS.ADD)
+                return;
+        }
+        // The Entry will either be a directory that just got removed
+        // or a bogus entry to a file, in either case we have to remove it
+        this._watched.delete(path);
+        this._watched.delete(fullPath);
+        const eventName = isDirectory ? handler_js_1.EVENTS.UNLINK_DIR : handler_js_1.EVENTS.UNLINK;
+        if (wasTracked && !this._isIgnored(path))
+            this._emit(eventName, path);
+        // Avoid conflicts if we later create another file with the same name
+        this._closePath(path);
+    }
+    /**
+     * Closes all watchers for a path
+     */
+    _closePath(path) {
+        this._closeFile(path);
+        const dir = sysPath.dirname(path);
+        this._getWatchedDir(dir).remove(sysPath.basename(path));
+    }
+    /**
+     * Closes only file-specific watchers
+     */
+    _closeFile(path) {
+        const closers = this._closers.get(path);
+        if (!closers)
+            return;
+        closers.forEach((closer) => closer());
+        this._closers.delete(path);
+    }
+    _addPathCloser(path, closer) {
+        if (!closer)
+            return;
+        let list = this._closers.get(path);
+        if (!list) {
+            list = [];
+            this._closers.set(path, list);
+        }
+        list.push(closer);
+    }
+    _readdirp(root, opts) {
+        if (this.closed)
+            return;
+        const options = { type: handler_js_1.EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
+        let stream = (0, readdirp_1.readdirp)(root, options);
+        this._streams.add(stream);
+        stream.once(handler_js_1.STR_CLOSE, () => {
+            stream = undefined;
+        });
+        stream.once(handler_js_1.STR_END, () => {
+            if (stream) {
+                this._streams.delete(stream);
+                stream = undefined;
+            }
+        });
+        return stream;
+    }
+}
+exports.FSWatcher = FSWatcher;
+/**
+ * Instantiates watcher with paths to be tracked.
+ * @param paths file / directory paths
+ * @param options opts, such as `atomic`, `awaitWriteFinish`, `ignored`, and others
+ * @returns an instance of FSWatcher for chaining.
+ * @example
+ * const watcher = watch('.').on('all', (event, path) => { console.log(event, path); });
+ * watch('.', { atomic: true, awaitWriteFinish: true, ignored: (f, stats) => stats?.isFile() && !f.endsWith('.js') })
+ */
+function watch(paths, options = {}) {
+    const watcher = new FSWatcher(options);
+    watcher.add(paths);
+    return watcher;
+}
+exports.default = { watch, FSWatcher };

backend/node_modules/chokidar/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "chokidar",
+  "description": "Minimal and efficient cross-platform file watching library",
+  "version": "4.0.3",
+  "homepage": "https://github.com/paulmillr/chokidar",
+  "author": "Paul Miller (https://paulmillr.com)",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "handler.js",
+    "handler.d.ts",
+    "esm"
+  ],
+  "main": "./index.js",
+  "module": "./esm/index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./index.js"
+    },
+    "./handler.js": {
+      "import": "./esm/handler.js",
+      "require": "./handler.js"
+    }
+  },
+  "dependencies": {
+    "readdirp": "^4.0.1"
+  },
+  "devDependencies": {
+    "@paulmillr/jsbt": "0.2.1",
+    "@types/node": "20.14.8",
+    "chai": "4.3.4",
+    "prettier": "3.1.1",
+    "rimraf": "5.0.5",
+    "sinon": "12.0.1",
+    "sinon-chai": "3.7.0",
+    "typescript": "5.5.2",
+    "upath": "2.0.1"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">= 14.16.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/paulmillr/chokidar.git"
+  },
+  "bugs": {
+    "url": "https://github.com/paulmillr/chokidar/issues"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc && tsc -p tsconfig.esm.json",
+    "lint": "prettier --check src",
+    "format": "prettier --write src",
+    "test": "node --test"
+  },
+  "keywords": [
+    "fs",
+    "watch",
+    "watchFile",
+    "watcher",
+    "watching",
+    "file",
+    "fsevents"
+  ],
+  "funding": "https://paulmillr.com/funding/"
+}

backend/node_modules/dotenv/CHANGELOG.md

@@ -0,0 +1,520 @@
+# Changelog
+
+All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+
+## [Unreleased](https://github.com/motdotla/dotenv/compare/v16.6.1...master)
+
+## [16.6.1](https://github.com/motdotla/dotenv/compare/v16.6.0...v16.6.1) (2025-06-27)
+
+### Changed
+
+- Default `quiet` to true – hiding the runtime log message ([#874](https://github.com/motdotla/dotenv/pull/874))
+- NOTICE: 17.0.0 will be released with quiet defaulting to false. Use `config({ quiet: true })` to suppress.
+- And check out the new [dotenvx](https://github.com/dotenvx/dotenvx). As coding workflows evolve and agents increasingly handle secrets, encrypted .env files offer a much safer way to deploy both agents and code together with secure secrets. Simply switch `require('dotenv').config()` for `require('@dotenvx/dotenvx').config()`.
+
+## [16.6.0](https://github.com/motdotla/dotenv/compare/v16.5.0...v16.6.0) (2025-06-26)
+
+### Added
+
+- Default log helpful message `[dotenv@16.6.0] injecting env (1) from .env` ([#870](https://github.com/motdotla/dotenv/pull/870))
+- Use `{ quiet: true }` to suppress
+- Aligns dotenv more closely with [dotenvx](https://github.com/dotenvx/dotenvx).
+
+## [16.5.0](https://github.com/motdotla/dotenv/compare/v16.4.7...v16.5.0) (2025-04-07)
+
+### Added
+
+- 🎉 Added new sponsor [Graphite](https://graphite.dev/?utm_source=github&utm_medium=repo&utm_campaign=dotenv) - *the AI developer productivity platform helping teams on GitHub ship higher quality software, faster*.
+
+> [!TIP]
+> **[Become a sponsor](https://github.com/sponsors/motdotla)**
+> 
+> The dotenvx README is viewed thousands of times DAILY on GitHub and NPM.
+> Sponsoring dotenv is a great way to get in front of developers and give back to the developer community at the same time.
+
+### Changed
+
+- Remove `_log` method. Use `_debug` [#862](https://github.com/motdotla/dotenv/pull/862)
+
+## [16.4.7](https://github.com/motdotla/dotenv/compare/v16.4.6...v16.4.7) (2024-12-03)
+
+### Changed
+
+- Ignore `.tap` folder when publishing. (oops, sorry about that everyone. - @motdotla) [#848](https://github.com/motdotla/dotenv/pull/848)
+
+## [16.4.6](https://github.com/motdotla/dotenv/compare/v16.4.5...v16.4.6) (2024-12-02)
+
+### Changed
+
+- Clean up stale dev dependencies [#847](https://github.com/motdotla/dotenv/pull/847)
+- Various README updates clarifying usage and alternative solutions using [dotenvx](https://github.com/dotenvx/dotenvx)
+
+## [16.4.5](https://github.com/motdotla/dotenv/compare/v16.4.4...v16.4.5) (2024-02-19)
+
+### Changed
+
+- 🐞 Fix recent regression when using `path` option. return to historical behavior: do not attempt to auto find `.env` if `path` set. (regression was introduced in `16.4.3`) [#814](https://github.com/motdotla/dotenv/pull/814)
+
+## [16.4.4](https://github.com/motdotla/dotenv/compare/v16.4.3...v16.4.4) (2024-02-13)
+
+### Changed
+
+- 🐞 Replaced chaining operator `?.` with old school `&&` (fixing node 12 failures) [#812](https://github.com/motdotla/dotenv/pull/812)
+
+## [16.4.3](https://github.com/motdotla/dotenv/compare/v16.4.2...v16.4.3) (2024-02-12)
+
+### Changed
+
+- Fixed processing of multiple files in `options.path` [#805](https://github.com/motdotla/dotenv/pull/805)
+
+## [16.4.2](https://github.com/motdotla/dotenv/compare/v16.4.1...v16.4.2) (2024-02-10)
+
+### Changed
+
+- Changed funding link in package.json to [`dotenvx.com`](https://dotenvx.com)
+
+## [16.4.1](https://github.com/motdotla/dotenv/compare/v16.4.0...v16.4.1) (2024-01-24)
+
+- Patch support for array as `path` option [#797](https://github.com/motdotla/dotenv/pull/797)
+
+## [16.4.0](https://github.com/motdotla/dotenv/compare/v16.3.2...v16.4.0) (2024-01-23)
+
+- Add `error.code` to error messages around `.env.vault` decryption handling [#795](https://github.com/motdotla/dotenv/pull/795)
+- Add ability to find `.env.vault` file when filename(s) passed as an array [#784](https://github.com/motdotla/dotenv/pull/784)
+
+## [16.3.2](https://github.com/motdotla/dotenv/compare/v16.3.1...v16.3.2) (2024-01-18)
+
+### Added
+
+- Add debug message when no encoding set [#735](https://github.com/motdotla/dotenv/pull/735)
+
+### Changed
+
+- Fix output typing for `populate` [#792](https://github.com/motdotla/dotenv/pull/792)
+- Use subarray instead of slice [#793](https://github.com/motdotla/dotenv/pull/793)
+
+## [16.3.1](https://github.com/motdotla/dotenv/compare/v16.3.0...v16.3.1) (2023-06-17)
+
+### Added
+
+- Add missing type definitions for `processEnv` and `DOTENV_KEY` options. [#756](https://github.com/motdotla/dotenv/pull/756)
+
+## [16.3.0](https://github.com/motdotla/dotenv/compare/v16.2.0...v16.3.0) (2023-06-16)
+
+### Added
+
+- Optionally pass `DOTENV_KEY` to options rather than relying on `process.env.DOTENV_KEY`. Defaults to `process.env.DOTENV_KEY` [#754](https://github.com/motdotla/dotenv/pull/754)
+
+## [16.2.0](https://github.com/motdotla/dotenv/compare/v16.1.4...v16.2.0) (2023-06-15)
+
+### Added
+
+- Optionally write to your own target object rather than `process.env`. Defaults to `process.env`. [#753](https://github.com/motdotla/dotenv/pull/753)
+- Add import type URL to types file [#751](https://github.com/motdotla/dotenv/pull/751)
+
+## [16.1.4](https://github.com/motdotla/dotenv/compare/v16.1.3...v16.1.4) (2023-06-04)
+
+### Added
+
+- Added `.github/` to `.npmignore` [#747](https://github.com/motdotla/dotenv/pull/747)
+
+## [16.1.3](https://github.com/motdotla/dotenv/compare/v16.1.2...v16.1.3) (2023-05-31)
+
+### Removed
+
+- Removed `browser` keys for `path`, `os`, and `crypto` in package.json. These were set to false incorrectly as of 16.1. Instead, if using dotenv on the front-end make sure to include polyfills for `path`, `os`, and `crypto`. [node-polyfill-webpack-plugin](https://github.com/Richienb/node-polyfill-webpack-plugin) provides these.
+
+## [16.1.2](https://github.com/motdotla/dotenv/compare/v16.1.1...v16.1.2) (2023-05-31)
+
+### Changed
+
+- Exposed private function `_configDotenv` as `configDotenv`. [#744](https://github.com/motdotla/dotenv/pull/744)
+
+## [16.1.1](https://github.com/motdotla/dotenv/compare/v16.1.0...v16.1.1) (2023-05-30)
+
+### Added
+
+- Added type definition for `decrypt` function
+
+### Changed
+
+- Fixed `{crypto: false}` in `packageJson.browser`
+
+## [16.1.0](https://github.com/motdotla/dotenv/compare/v16.0.3...v16.1.0) (2023-05-30)
+
+### Added
+
+- Add `populate` convenience method [#733](https://github.com/motdotla/dotenv/pull/733)
+- Accept URL as path option [#720](https://github.com/motdotla/dotenv/pull/720)
+- Add dotenv to `npm fund` command
+- Spanish language README [#698](https://github.com/motdotla/dotenv/pull/698)
+- Add `.env.vault` support. 🎉 ([#730](https://github.com/motdotla/dotenv/pull/730))
+
+ℹ️ `.env.vault` extends the `.env` file format standard with a localized encrypted vault file. Package it securely with your production code deploys. It's cloud agnostic so that you can deploy your secrets anywhere – without [risky third-party integrations](https://techcrunch.com/2023/01/05/circleci-breach/). [read more](https://github.com/motdotla/dotenv#-deploying)
+
+### Changed
+
+- Fixed "cannot resolve 'fs'" error on tools like Replit [#693](https://github.com/motdotla/dotenv/pull/693)
+
+## [16.0.3](https://github.com/motdotla/dotenv/compare/v16.0.2...v16.0.3) (2022-09-29)
+
+### Changed
+
+- Added library version to debug logs ([#682](https://github.com/motdotla/dotenv/pull/682))
+
+## [16.0.2](https://github.com/motdotla/dotenv/compare/v16.0.1...v16.0.2) (2022-08-30)
+
+### Added
+
+- Export `env-options.js` and `cli-options.js` in package.json for use with downstream [dotenv-expand](https://github.com/motdotla/dotenv-expand) module
+
+## [16.0.1](https://github.com/motdotla/dotenv/compare/v16.0.0...v16.0.1) (2022-05-10)
+
+### Changed
+
+- Minor README clarifications
+- Development ONLY: updated devDependencies as recommended for development only security risks ([#658](https://github.com/motdotla/dotenv/pull/658))
+
+## [16.0.0](https://github.com/motdotla/dotenv/compare/v15.0.1...v16.0.0) (2022-02-02)
+
+### Added
+
+- _Breaking:_ Backtick support 🎉 ([#615](https://github.com/motdotla/dotenv/pull/615))
+
+If you had values containing the backtick character, please quote those values with either single or double quotes.
+
+## [15.0.1](https://github.com/motdotla/dotenv/compare/v15.0.0...v15.0.1) (2022-02-02)
+
+### Changed
+
+- Properly parse empty single or double quoted values 🐞 ([#614](https://github.com/motdotla/dotenv/pull/614))
+
+## [15.0.0](https://github.com/motdotla/dotenv/compare/v14.3.2...v15.0.0) (2022-01-31)
+
+`v15.0.0` is a major new release with some important breaking changes.
+
+### Added
+
+- _Breaking:_ Multiline parsing support (just works. no need for the flag.)
+
+### Changed
+
+- _Breaking:_ `#` marks the beginning of a comment (UNLESS the value is wrapped in quotes. Please update your `.env` files to wrap in quotes any values containing `#`. For example: `SECRET_HASH="something-with-a-#-hash"`).
+
+..Understandably, (as some teams have noted) this is tedious to do across the entire team. To make it less tedious, we recommend using [dotenv cli](https://github.com/dotenv-org/cli) going forward. It's an optional plugin that will keep your `.env` files in sync between machines, environments, or team members.
+
+### Removed
+
+- _Breaking:_ Remove multiline option (just works out of the box now. no need for the flag.)
+
+## [14.3.2](https://github.com/motdotla/dotenv/compare/v14.3.1...v14.3.2) (2022-01-25)
+
+### Changed
+
+- Preserve backwards compatibility on values containing `#` 🐞 ([#603](https://github.com/motdotla/dotenv/pull/603))
+
+## [14.3.1](https://github.com/motdotla/dotenv/compare/v14.3.0...v14.3.1) (2022-01-25)
+
+### Changed
+
+- Preserve backwards compatibility on exports by re-introducing the prior in-place exports 🐞 ([#606](https://github.com/motdotla/dotenv/pull/606))
+
+## [14.3.0](https://github.com/motdotla/dotenv/compare/v14.2.0...v14.3.0) (2022-01-24)
+
+### Added
+
+- Add `multiline` option 🎉 ([#486](https://github.com/motdotla/dotenv/pull/486))
+
+## [14.2.0](https://github.com/motdotla/dotenv/compare/v14.1.1...v14.2.0) (2022-01-17)
+
+### Added
+
+- Add `dotenv_config_override` cli option
+- Add `DOTENV_CONFIG_OVERRIDE` command line env option
+
+## [14.1.1](https://github.com/motdotla/dotenv/compare/v14.1.0...v14.1.1) (2022-01-17)
+
+### Added
+
+- Add React gotcha to FAQ on README
+
+## [14.1.0](https://github.com/motdotla/dotenv/compare/v14.0.1...v14.1.0) (2022-01-17)
+
+### Added
+
+- Add `override` option 🎉 ([#595](https://github.com/motdotla/dotenv/pull/595))
+
+## [14.0.1](https://github.com/motdotla/dotenv/compare/v14.0.0...v14.0.1) (2022-01-16)
+
+### Added
+
+- Log error on failure to load `.env` file ([#594](https://github.com/motdotla/dotenv/pull/594))
+
+## [14.0.0](https://github.com/motdotla/dotenv/compare/v13.0.1...v14.0.0) (2022-01-16)
+
+### Added
+
+- _Breaking:_ Support inline comments for the parser 🎉 ([#568](https://github.com/motdotla/dotenv/pull/568))
+
+## [13.0.1](https://github.com/motdotla/dotenv/compare/v13.0.0...v13.0.1) (2022-01-16)
+
+### Changed
+
+* Hide comments and newlines from debug output ([#404](https://github.com/motdotla/dotenv/pull/404))
+
+## [13.0.0](https://github.com/motdotla/dotenv/compare/v12.0.4...v13.0.0) (2022-01-16)
+
+### Added
+
+* _Breaking:_ Add type file for `config.js` ([#539](https://github.com/motdotla/dotenv/pull/539))
+
+## [12.0.4](https://github.com/motdotla/dotenv/compare/v12.0.3...v12.0.4) (2022-01-16)
+
+### Changed
+
+* README updates
+* Minor order adjustment to package json format
+
+## [12.0.3](https://github.com/motdotla/dotenv/compare/v12.0.2...v12.0.3) (2022-01-15)
+
+### Changed
+
+* Simplified jsdoc for consistency across editors
+
+## [12.0.2](https://github.com/motdotla/dotenv/compare/v12.0.1...v12.0.2) (2022-01-15)
+
+### Changed
+
+* Improve embedded jsdoc type documentation
+
+## [12.0.1](https://github.com/motdotla/dotenv/compare/v12.0.0...v12.0.1) (2022-01-15)
+
+### Changed
+
+* README updates and clarifications
+
+## [12.0.0](https://github.com/motdotla/dotenv/compare/v11.0.0...v12.0.0) (2022-01-15)
+
+### Removed
+
+- _Breaking:_ drop support for Flow static type checker ([#584](https://github.com/motdotla/dotenv/pull/584))
+
+### Changed
+
+- Move types/index.d.ts to lib/main.d.ts ([#585](https://github.com/motdotla/dotenv/pull/585))
+- Typescript cleanup ([#587](https://github.com/motdotla/dotenv/pull/587))
+- Explicit typescript inclusion in package.json ([#566](https://github.com/motdotla/dotenv/pull/566))
+
+## [11.0.0](https://github.com/motdotla/dotenv/compare/v10.0.0...v11.0.0) (2022-01-11)
+
+### Changed
+
+- _Breaking:_ drop support for Node v10 ([#558](https://github.com/motdotla/dotenv/pull/558))
+- Patch debug option ([#550](https://github.com/motdotla/dotenv/pull/550))
+
+## [10.0.0](https://github.com/motdotla/dotenv/compare/v9.0.2...v10.0.0) (2021-05-20)
+
+### Added
+
+- Add generic support to parse function
+- Allow for import "dotenv/config.js"
+- Add support to resolve home directory in path via ~
+
+## [9.0.2](https://github.com/motdotla/dotenv/compare/v9.0.1...v9.0.2) (2021-05-10)
+
+### Changed
+
+- Support windows newlines with debug mode
+
+## [9.0.1](https://github.com/motdotla/dotenv/compare/v9.0.0...v9.0.1) (2021-05-08)
+
+### Changed
+
+- Updates to README
+
+## [9.0.0](https://github.com/motdotla/dotenv/compare/v8.6.0...v9.0.0) (2021-05-05)
+
+### Changed
+
+- _Breaking:_ drop support for Node v8
+
+## [8.6.0](https://github.com/motdotla/dotenv/compare/v8.5.1...v8.6.0) (2021-05-05)
+
+### Added
+
+- define package.json in exports
+
+## [8.5.1](https://github.com/motdotla/dotenv/compare/v8.5.0...v8.5.1) (2021-05-05)
+
+### Changed
+
+- updated dev dependencies via npm audit
+
+## [8.5.0](https://github.com/motdotla/dotenv/compare/v8.4.0...v8.5.0) (2021-05-05)
+
+### Added
+
+- allow for `import "dotenv/config"`
+
+## [8.4.0](https://github.com/motdotla/dotenv/compare/v8.3.0...v8.4.0) (2021-05-05)
+
+### Changed
+
+- point to exact types file to work with VS Code
+
+## [8.3.0](https://github.com/motdotla/dotenv/compare/v8.2.0...v8.3.0) (2021-05-05)
+
+### Changed
+
+- _Breaking:_ drop support for Node v8 (mistake to be released as minor bump. later bumped to 9.0.0. see above.)
+
+## [8.2.0](https://github.com/motdotla/dotenv/compare/v8.1.0...v8.2.0) (2019-10-16)
+
+### Added
+
+- TypeScript types
+
+## [8.1.0](https://github.com/motdotla/dotenv/compare/v8.0.0...v8.1.0) (2019-08-18)
+
+### Changed
+
+- _Breaking:_ drop support for Node v6 ([#392](https://github.com/motdotla/dotenv/issues/392))
+
+# [8.0.0](https://github.com/motdotla/dotenv/compare/v7.0.0...v8.0.0) (2019-05-02)
+
+### Changed
+
+- _Breaking:_ drop support for Node v6 ([#302](https://github.com/motdotla/dotenv/issues/392))
+
+## [7.0.0] - 2019-03-12
+
+### Fixed
+
+- Fix removing unbalanced quotes ([#376](https://github.com/motdotla/dotenv/pull/376))
+
+### Removed
+
+- Removed `load` alias for `config` for consistency throughout code and documentation.
+
+## [6.2.0] - 2018-12-03
+
+### Added
+
+- Support preload configuration via environment variables ([#351](https://github.com/motdotla/dotenv/issues/351))
+
+## [6.1.0] - 2018-10-08
+
+### Added
+
+- `debug` option for `config` and `parse` methods will turn on logging
+
+## [6.0.0] - 2018-06-02
+
+### Changed
+
+- _Breaking:_ drop support for Node v4 ([#304](https://github.com/motdotla/dotenv/pull/304))
+
+## [5.0.0] - 2018-01-29
+
+### Added
+
+- Testing against Node v8 and v9
+- Documentation on trim behavior of values
+- Documentation on how to use with `import`
+
+### Changed
+
+- _Breaking_: default `path` is now `path.resolve(process.cwd(), '.env')`
+- _Breaking_: does not write over keys already in `process.env` if the key has a falsy value
+- using `const` and `let` instead of `var`
+
+### Removed
+
+- Testing against Node v7
+
+## [4.0.0] - 2016-12-23
+
+### Changed
+
+- Return Object with parsed content or error instead of false ([#165](https://github.com/motdotla/dotenv/pull/165)).
+
+### Removed
+
+- `verbose` option removed in favor of returning result.
+
+## [3.0.0] - 2016-12-20
+
+### Added
+
+- `verbose` option will log any error messages. Off by default.
+- parses email addresses correctly
+- allow importing config method directly in ES6
+
+### Changed
+
+- Suppress error messages by default ([#154](https://github.com/motdotla/dotenv/pull/154))
+- Ignoring more files for NPM to make package download smaller
+
+### Fixed
+
+- False positive test due to case-sensitive variable ([#124](https://github.com/motdotla/dotenv/pull/124))
+
+### Removed
+
+- `silent` option removed in favor of `verbose`
+
+## [2.0.0] - 2016-01-20
+
+### Added
+
+- CHANGELOG to ["make it easier for users and contributors to see precisely what notable changes have been made between each release"](http://keepachangelog.com/). Linked to from README
+- LICENSE to be more explicit about what was defined in `package.json`. Linked to from README
+- Testing nodejs v4 on travis-ci
+- added examples of how to use dotenv in different ways
+- return parsed object on success rather than boolean true
+
+### Changed
+
+- README has shorter description not referencing ruby gem since we don't have or want feature parity
+
+### Removed
+
+- Variable expansion and escaping so environment variables are encouraged to be fully orthogonal
+
+## [1.2.0] - 2015-06-20
+
+### Added
+
+- Preload hook to require dotenv without including it in your code
+
+### Changed
+
+- clarified license to be "BSD-2-Clause" in `package.json`
+
+### Fixed
+
+- retain spaces in string vars
+
+## [1.1.0] - 2015-03-31
+
+### Added
+
+- Silent option to silence `console.log` when `.env` missing
+
+## [1.0.0] - 2015-03-13
+
+### Removed
+
+- support for multiple `.env` files. should always use one `.env` file for the current environment
+
+[7.0.0]: https://github.com/motdotla/dotenv/compare/v6.2.0...v7.0.0
+[6.2.0]: https://github.com/motdotla/dotenv/compare/v6.1.0...v6.2.0
+[6.1.0]: https://github.com/motdotla/dotenv/compare/v6.0.0...v6.1.0
+[6.0.0]: https://github.com/motdotla/dotenv/compare/v5.0.0...v6.0.0
+[5.0.0]: https://github.com/motdotla/dotenv/compare/v4.0.0...v5.0.0
+[4.0.0]: https://github.com/motdotla/dotenv/compare/v3.0.0...v4.0.0
+[3.0.0]: https://github.com/motdotla/dotenv/compare/v2.0.0...v3.0.0
+[2.0.0]: https://github.com/motdotla/dotenv/compare/v1.2.0...v2.0.0
+[1.2.0]: https://github.com/motdotla/dotenv/compare/v1.1.0...v1.2.0
+[1.1.0]: https://github.com/motdotla/dotenv/compare/v1.0.0...v1.1.0
+[1.0.0]: https://github.com/motdotla/dotenv/compare/v0.4.0...v1.0.0

backend/node_modules/dotenv/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2015, Scott Motte
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

backend/node_modules/dotenv/README-es.md

@@ -0,0 +1,411 @@
+<div align="center">
+🎉 announcing <a href="https://github.com/dotenvx/dotenvx">dotenvx</a>. <em>run anywhere, multi-environment, encrypted envs</em>.
+</div>
+
+&nbsp;
+
+<div align="center">
+
+<p>
+  <sup>
+    <a href="https://github.com/sponsors/motdotla">Dotenv es apoyado por la comunidad.</a>
+  </sup>
+</p>
+<sup>Gracias espaciales a:</sup>
+<br>
+<br>
+
+<a href="https://graphite.dev/?utm_source=github&utm_medium=repo&utm_campaign=dotenv"><img src="https://res.cloudinary.com/dotenv-org/image/upload/v1744035073/graphite_lgsrl8.gif" width="240" alt="Graphite" /></a>
+
+<a href="https://graphite.dev/?utm_source=github&utm_medium=repo&utm_campaign=dotenv">
+  <b>Graphite is the AI developer productivity platform helping teams on GitHub ship higher quality software, faster.</b>
+</a>
+<hr>
+</div>
+
+# dotenv [![NPM version](https://img.shields.io/npm/v/dotenv.svg?style=flat-square)](https://www.npmjs.com/package/dotenv)
+
+<img src="https://raw.githubusercontent.com/motdotla/dotenv/master/dotenv.svg" alt="dotenv" align="right" width="200" />
+
+Dotenv es un módulo de dependencia cero que carga las variables de entorno desde un archivo `.env` en [`process.env`](https://nodejs.org/docs/latest/api/process.html#process_process_env). El almacenamiento de la configuración del entorno separado del código está basado en la metodología [The Twelve-Factor App](http://12factor.net/config).
+
+[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/feross/standard)
+[![LICENSE](https://img.shields.io/github/license/motdotla/dotenv.svg)](LICENSE)
+
+## Instalación
+
+```bash
+# instalación local (recomendado)
+npm install dotenv --save
+```
+
+O installación con yarn? `yarn add dotenv`
+
+## Uso
+
+Cree un archivo `.env` en la raíz de su proyecto:
+
+```dosini
+S3_BUCKET="YOURS3BUCKET"
+SECRET_KEY="YOURSECRETKEYGOESHERE"
+```
+
+Tan prónto como sea posible en su aplicación, importe y configure dotenv:
+
+```javascript
+require('dotenv').config()
+console.log(process.env) // elimine esto después que haya confirmado que esta funcionando
+```
+
+.. o usa ES6?
+
+```javascript
+import * as dotenv from 'dotenv' // vea en https://github.com/motdotla/dotenv#como-uso-dotenv-con-import
+// REVISAR LINK DE REFERENCIA DE IMPORTACIÓN
+dotenv.config()
+import express from 'express'
+```
+
+Eso es todo. `process.env` ahora tiene las claves y los valores que definiste en tu archivo `.env`:
+
+```javascript
+require('dotenv').config()
+
+...
+
+s3.getBucketCors({Bucket: process.env.S3_BUCKET}, function(err, data) {})
+```
+
+### Valores multilínea
+
+Si necesita variables de varias líneas, por ejemplo, claves privadas, ahora se admiten en la versión (`>= v15.0.0`) con saltos de línea:
+
+```dosini
+PRIVATE_KEY="-----BEGIN RSA PRIVATE KEY-----
+...
+Kh9NV...
+...
+-----END RSA PRIVATE KEY-----"
+```
+
+Alternativamente, puede usar comillas dobles y usar el carácter `\n`:
+
+```dosini
+PRIVATE_KEY="-----BEGIN RSA PRIVATE KEY-----\nKh9NV...\n-----END RSA PRIVATE KEY-----\n"
+```
+
+### Comentarios
+
+Los comentarios pueden ser agregados en tu archivo o en la misma línea:
+
+```dosini
+# This is a comment
+SECRET_KEY=YOURSECRETKEYGOESHERE # comment
+SECRET_HASH="something-with-a-#-hash"
+```
+
+Los comentarios comienzan donde existe un `#`, entonces, si su valor contiene un `#`, enciérrelo entre comillas. Este es un cambio importante desde la versión `>= v15.0.0` en adelante.
+
+### Análisis
+
+El motor que analiza el contenido de su archivo que contiene variables de entorno está disponible para su uso. Este Acepta una Cadena o un Búfer y devolverá un Objeto con las claves y los valores analizados.
+
+```javascript
+const dotenv = require('dotenv')
+const buf = Buffer.from('BASICO=basico')
+const config = dotenv.parse(buf) // devolverá un objeto
+console.log(typeof config, config) // objeto { BASICO : 'basico' }
+```
+
+### Precarga
+
+Puede usar el `--require` (`-r`) [opción de línea de comando](https://nodejs.org/api/cli.html#-r---require-module) para precargar dotenv. Al hacer esto, no necesita requerir ni cargar dotnev en el código de su aplicación.
+
+```bash
+$ node -r dotenv/config tu_script.js
+```
+
+Las opciones de configuración a continuación se admiten como argumentos de línea de comandos en el formato `dotenv_config_<option>=value`
+
+```bash
+$ node -r dotenv/config tu_script.js dotenv_config_path=/custom/path/to/.env dotenv_config_debug=true
+```
+
+Además, puede usar variables de entorno para establecer opciones de configuración. Los argumentos de línea de comandos precederán a estos.
+
+```bash
+$ DOTENV_CONFIG_<OPTION>=value node -r dotenv/config tu_script.js
+```
+
+```bash
+$ DOTENV_CONFIG_ENCODING=latin1 DOTENV_CONFIG_DEBUG=true node -r dotenv/config tu_script.js dotenv_config_path=/custom/path/to/.env
+```
+
+### Expansión Variable
+
+Necesitaras agregar el valor de otro variable en una de sus variables? Usa [dotenv-expand](https://github.com/motdotla/dotenv-expand).
+
+## Ejemplos
+
+Vea [ejemplos](https://github.com/dotenv-org/examples) sobre el uso de dotenv con varios frameworks, lenguajes y configuraciones.
+
+* [nodejs](https://github.com/dotenv-org/examples/tree/master/dotenv-nodejs)
+* [nodejs (depurar en)](https://github.com/dotenv-org/examples/tree/master/dotenv-nodejs-debug)
+* [nodejs (anular en)](https://github.com/dotenv-org/examples/tree/master/dotenv-nodejs-override)
+* [esm](https://github.com/dotenv-org/examples/tree/master/dotenv-esm)
+* [esm (precarga)](https://github.com/dotenv-org/examples/tree/master/dotenv-esm-preload)
+* [typescript](https://github.com/dotenv-org/examples/tree/master/dotenv-typescript)
+* [typescript parse](https://github.com/dotenv-org/examples/tree/master/dotenv-typescript-parse)
+* [typescript config](https://github.com/dotenv-org/examples/tree/master/dotenv-typescript-config)
+* [webpack](https://github.com/dotenv-org/examples/tree/master/dotenv-webpack)
+* [webpack (plugin)](https://github.com/dotenv-org/examples/tree/master/dotenv-webpack2)
+* [react](https://github.com/dotenv-org/examples/tree/master/dotenv-react)
+* [react (typescript)](https://github.com/dotenv-org/examples/tree/master/dotenv-react-typescript)
+* [express](https://github.com/dotenv-org/examples/tree/master/dotenv-express)
+* [nestjs](https://github.com/dotenv-org/examples/tree/master/dotenv-nestjs)
+
+## Documentación
+
+Dotenv expone dos funciones:
+
+* `configuración`
+* `analizar`
+
+### Configuración
+
+`Configuración` leerá su archivo `.env`, analizará el contenido, lo asignará a [`process.env`](https://nodejs.org/docs/latest/api/process.html#process_process_env),
+y devolverá un Objeto con una clave `parsed` que contiene el contenido cargado o una clave `error` si falla.
+
+```js
+const result = dotenv.config()
+
+if (result.error) {
+  throw result.error
+}
+
+console.log(result.parsed)
+```
+
+Adicionalmente, puede pasar opciones a `configuracion`.
+
+#### Opciones
+
+##### Ruta
+
+Por defecto: `path.resolve(process.cwd(), '.env')`
+
+Especifique una ruta personalizada si el archivo que contiene las variables de entorno se encuentra localizado en otro lugar.
+
+```js
+require('dotenv').config({ path: '/personalizado/ruta/a/.env' })
+```
+
+##### Codificación
+
+Por defecto: `utf8`
+
+Especifique la codificación del archivo que contiene las variables de entorno.
+
+```js
+require('dotenv').config({ encoding: 'latin1' })
+```
+
+##### Depurar
+
+Por defecto: `false`
+
+Active el registro de ayuda para depurar por qué ciertas claves o valores no se inician como lo esperabas.
+
+```js
+require('dotenv').config({ debug: process.env.DEBUG })
+```
+
+##### Anular
+
+Por defecto: `false`
+
+Anule cualquier variable de entorno que ya se haya configurada en su maquina con los valores de su archivo .env.
+
+```js
+require('dotenv').config({ override: true })
+```
+
+### Analizar
+
+El motor que analiza el contenido del archivo que contiene las variables de entorno está disponible para su uso. Acepta una Cadena o un Búfer y retornará un objecto con los valores analizados.
+
+```js
+const dotenv = require('dotenv')
+const buf = Buffer.from('BASICO=basico')
+const config = dotenv.parse(buf) // devolverá un objeto
+console.log(typeof config, config) // objeto { BASICO : 'basico' }
+```
+
+#### Opciones
+
+##### Depurar
+
+Por defecto: `false`
+
+Active el registro de ayuda para depurar por qué ciertas claves o valores no se inician como lo esperabas.
+
+```js
+const dotenv = require('dotenv')
+const buf = Buffer.from('hola mundo')
+const opt = { debug: true }
+const config = dotenv.parse(buf, opt)
+// espere por un mensaje de depuración porque el búfer no esta listo KEY=VAL
+```
+
+## FAQ
+
+### ¿Por qué el archivo `.env` no carga mis variables de entorno correctamente?
+
+Lo más probable es que su archivo `.env` no esté en el lugar correcto. [Vea este stack overflow](https://stackoverflow.com/questions/42335016/dotenv-file-is-not-loading-environment-variables).
+
+Active el modo de depuración y vuelva a intentarlo...
+
+```js
+require('dotenv').config({ debug: true })
+```
+
+Recibirá un error apropiado en su consola.
+
+### ¿Debo confirmar mi archivo `.env`?
+
+No. Recomendamos **enfáticamente** no enviar su archivo `.env` a la versión de control. Solo debe incluir los valores especificos del entorno, como la base de datos, contraseñas o claves API.
+
+### ¿Debería tener multiples archivos `.env`?
+
+No. Recomendamos **enfáticamente** no tener un archivo `.env` "principal" y un archivo `.env` de "entorno" como `.env.test`. Su configuración debe variar entre implementaciones y no debe compartir valores entre entornos.
+
+> En una Aplicación de Doce Factores, las variables de entorno son controles diferenciados, cada uno totalmente independiente a otras variables de entorno. Nunca se agrupan como "entornos", sino que se gestionan de manera independiente para cada despliegue. Este es un modelo que se escala sin problemas a medida que la aplicación se expande de forma natural en más despliegues a lo largo de su vida.
+>
+> – [La Apliación de los Doce Factores](https://12factor.net/es/)
+
+### ¿Qué reglas sigue el motor de análisis?
+
+El motor de análisis actualmente admite las siguientes reglas:
+
+- `BASICO=basico` se convierte en `{BASICO: 'basico'}`
+- las líneas vacías se saltan
+- las líneas que comienzan con `#` se tratan como comentarios
+- `#` marca el comienzo de un comentario (a menos que el valor esté entre comillas)
+- valores vacíos se convierten en cadenas vacías (`VACIO=` se convierte en `{VACIO: ''}`)
+- las comillas internas se mantienen (piensa en JSON) (`JSON={"foo": "bar"}` se convierte en `{JSON:"{\"foo\": \"bar\"}"`)
+- los espacios en blanco se eliminan de ambos extremos de los valores no citanos (aprende más en [`trim`](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/String/Trim)) (`FOO=  algo ` se convierte en `{FOO: 'algo'}`)
+- los valores entre comillas simples y dobles se escapan (`CITA_SIMPLE='citado'` se convierte en `{CITA_SIMPLE: "citado"}`)
+- los valores entre comillas simples y dobles mantienen los espacios en blanco en ambos extremos  (`FOO="  algo  "` se convierte en `{FOO: '  algo  '}`)
+- los valores entre comillas dobles expanden nuevas líneas (`MULTILINEA="nueva\nlínea"` se convierte en
+
+```
+{MULTILINEA: 'nueva
+línea'}
+```
+
+- se admite la comilla simple invertida (`` SIGNO_ACENTO=`Esto tiene comillas 'simples' y "dobles" en su interior.` ``)
+
+### ¿Qué sucede con las variables de entorno que ya estaban configuradas?
+
+Por defecto, nunca modificaremos ninguna variable de entorno que ya haya sido establecida. En particular, si hay una variable en su archivo `.env` que colisiona con una que ya existe en su entorno, entonces esa variable se omitirá.
+
+Si por el contrario, quieres anular `process.env` utiliza la opción `override`.
+
+```javascript
+require('dotenv').config({ override: true })
+```
+
+### ¿Por qué mis variables de entorno no aparecen para React?
+
+Su código React se ejecuta en Webpack, donde el módulo `fs` o incluso el propio `process` global no son accesibles fuera-de-la-caja. El módulo `process.env` sólo puede ser inyectado a través de la configuración de Webpack.
+
+Si estás usando [`react-scripts`](https://www.npmjs.com/package/react-scripts), el cual se distribuye a través de [`create-react-app`](https://create-react-app.dev/), tiene dotenv incorporado pero con una singularidad. Escriba sus variables de entorno con `REACT_APP_`. Vea [este stack overflow](https://stackoverflow.com/questions/42182577/is-it-possible-to-use-dotenv-in-a-react-project) para más detalles.
+
+Si estás utilizando otros frameworks (por ejemplo, Next.js, Gatsby...), debes consultar su documentación para saber cómo injectar variables de entorno en el cliente.
+
+### ¿Puedo personalizar/escribir plugins para dotenv?
+
+Sí! `dotenv.config()` devuelve un objeto que representa el archivo `.env` analizado. Esto te da todo lo que necesitas para poder establecer valores en `process.env`. Por ejemplo:
+
+```js
+const dotenv = require('dotenv')
+const variableExpansion = require('dotenv-expand')
+const miEnv = dotenv.config()
+variableExpansion(miEnv)
+```
+
+### Cómo uso dotnev con `import`?
+
+Simplemente..
+
+```javascript
+// index.mjs (ESM)
+import * as dotenv from 'dotenv' // vea https://github.com/motdotla/dotenv#como-uso-dotenv-con-import
+dotenv.config()
+import express from 'express'
+```
+
+Un poco de historia...
+
+> Cuando se ejecuta un módulo que contiene una sentencia `import`, los módulos que importa serán cargados primero, y luego se ejecuta cada bloque del módulo en un recorrido en profundidad del gráfico de dependencias, evitando los ciclos al saltarse todo lo que ya se ha ejecutado.
+>
+> – [ES6 en Profundidad: Módulos](https://hacks.mozilla.org/2015/08/es6-in-depth-modules/)
+
+¿Qué significa esto en lenguaje sencillo? Significa que se podrías pensar que lo siguiente funcionaría pero no lo hará.
+
+```js
+// notificarError.mjs
+import { Cliente } from 'mejor-servicio-para-notificar-error'
+
+export default new Client(process.env.CLAVE_API)
+
+// index.mjs
+import dotenv from 'dotenv'
+dotenv.config()
+
+import notificarError from './notificarError.mjs'
+notificarError.report(new Error('ejemplo documentado'))
+```
+
+`process.env.CLAVE_API` será vacio.
+
+En su lugar, el código anterior debe ser escrito como...
+
+```js
+// notificarError.mjs
+import { Cliente } from 'mejor-servicio-para-notificar-errores'
+
+export default new Client(process.env.CLAVE_API)
+
+// index.mjs
+import * as dotenv from 'dotenv'
+dotenv.config()
+
+import notificarError from './notificarError.mjs'
+notificarError.report(new Error('ejemplo documentado'))
+```
+
+¿Esto tiene algo de sentido? Esto es poco poco intuitivo, pero es como funciona la importación de módulos en ES6. Aquí hay un ejemplo [ejemplo práctico de esta trampa](https://github.com/dotenv-org/examples/tree/master/dotenv-es6-import-pitfall).
+
+Existen dos arternativas a este planteamiento:
+
+1. Precarga dotenv: `node --require dotenv/config index.js` (_Nota: no es necesario usar `import` dotenv con este método_)
+2. Cree un archivo separado que ejecutará `config` primero como se describe en [este comentario #133](https://github.com/motdotla/dotenv/issues/133#issuecomment-255298822)
+
+### ¿Qué pasa con la expansión de variable?
+
+Prueba [dotenv-expand](https://github.com/motdotla/dotenv-expand)
+
+## Guía de contribución
+
+Vea [CONTRIBUTING.md](CONTRIBUTING.md)
+
+## REGISTRO DE CAMBIOS
+
+Vea [CHANGELOG.md](CHANGELOG.md)
+
+## ¿Quiénes utilizan dotenv?
+
+[Estos módulos npm dependen de él.](https://www.npmjs.com/browse/depended/dotenv)
+
+Los proyectos que lo amplían suelen utilizar la [palabra clave "dotenv" en npm](https://www.npmjs.com/search?q=keywords:dotenv).

backend/node_modules/dotenv/README.md

@@ -0,0 +1,645 @@
+<div align="center">
+🎉 announcing <a href="https://github.com/dotenvx/dotenvx">dotenvx</a>. <em>run anywhere, multi-environment, encrypted envs</em>.
+</div>
+
+&nbsp;
+
+<div align="center">
+
+**Special thanks to [our sponsors](https://github.com/sponsors/motdotla)**
+
+<br>
+<a href="https://graphite.dev/?utm_source=github&utm_medium=repo&utm_campaign=dotenv"><img src="https://res.cloudinary.com/dotenv-org/image/upload/v1744035073/graphite_lgsrl8.gif" width="240" alt="Graphite" /></a>
+<br>
+<a href="https://graphite.dev/?utm_source=github&utm_medium=repo&utm_campaign=dotenv">
+  <b>Graphite is the AI developer productivity platform helping teams on GitHub ship higher quality software, faster.</b>
+</a>
+<hr>
+</div>
+
+# dotenv [![NPM version](https://img.shields.io/npm/v/dotenv.svg?style=flat-square)](https://www.npmjs.com/package/dotenv)
+
+<img src="https://raw.githubusercontent.com/motdotla/dotenv/master/dotenv.svg" alt="dotenv" align="right" width="200" />
+
+Dotenv is a zero-dependency module that loads environment variables from a `.env` file into [`process.env`](https://nodejs.org/docs/latest/api/process.html#process_process_env). Storing configuration in the environment separate from code is based on [The Twelve-Factor App](https://12factor.net/config) methodology.
+
+[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/feross/standard)
+[![LICENSE](https://img.shields.io/github/license/motdotla/dotenv.svg)](LICENSE)
+[![codecov](https://codecov.io/gh/motdotla/dotenv-expand/graph/badge.svg?token=pawWEyaMfg)](https://codecov.io/gh/motdotla/dotenv-expand)
+
+* [🌱 Install](#-install)
+* [🏗️ Usage (.env)](#%EF%B8%8F-usage)
+* [🌴 Multiple Environments 🆕](#-manage-multiple-environments)
+* [🚀 Deploying (encryption) 🆕](#-deploying)
+* [📚 Examples](#-examples)
+* [📖 Docs](#-documentation)
+* [❓ FAQ](#-faq)
+* [⏱️ Changelog](./CHANGELOG.md)
+
+## 🌱 Install
+
+```bash
+npm install dotenv --save
+```
+
+You can also use an npm-compatible package manager like yarn, bun or pnpm:
+
+```bash
+yarn add dotenv
+```
+```bash
+bun add dotenv
+```
+```bash
+pnpm add dotenv
+```
+
+## 🏗️ Usage
+
+<a href="https://www.youtube.com/watch?v=YtkZR0NFd1g">
+<div align="right">
+<img src="https://img.youtube.com/vi/YtkZR0NFd1g/hqdefault.jpg" alt="how to use dotenv video tutorial" align="right" width="330" />
+<img src="https://simpleicons.vercel.app/youtube/ff0000" alt="youtube/@dotenvorg" align="right" width="24" />
+</div>
+</a>
+
+Create a `.env` file in the root of your project (if using a monorepo structure like `apps/backend/app.js`, put it in the root of the folder where your `app.js` process runs):
+
+```dosini
+S3_BUCKET="YOURS3BUCKET"
+SECRET_KEY="YOURSECRETKEYGOESHERE"
+```
+
+As early as possible in your application, import and configure dotenv:
+
+```javascript
+require('dotenv').config()
+console.log(process.env) // remove this after you've confirmed it is working
+```
+
+.. [or using ES6?](#how-do-i-use-dotenv-with-import)
+
+```javascript
+import 'dotenv/config'
+```
+
+That's it. `process.env` now has the keys and values you defined in your `.env` file:
+
+```javascript
+require('dotenv').config()
+// or import 'dotenv/config' if you're using ES6
+
+...
+
+s3.getBucketCors({Bucket: process.env.S3_BUCKET}, function(err, data) {})
+```
+
+### Multiline values
+
+If you need multiline variables, for example private keys, those are now supported (`>= v15.0.0`) with line breaks:
+
+```dosini
+PRIVATE_KEY="-----BEGIN RSA PRIVATE KEY-----
+...
+Kh9NV...
+...
+-----END RSA PRIVATE KEY-----"
+```
+
+Alternatively, you can double quote strings and use the `\n` character:
+
+```dosini
+PRIVATE_KEY="-----BEGIN RSA PRIVATE KEY-----\nKh9NV...\n-----END RSA PRIVATE KEY-----\n"
+```
+
+### Comments
+
+Comments may be added to your file on their own line or inline:
+
+```dosini
+# This is a comment
+SECRET_KEY=YOURSECRETKEYGOESHERE # comment
+SECRET_HASH="something-with-a-#-hash"
+```
+
+Comments begin where a `#` exists, so if your value contains a `#` please wrap it in quotes. This is a breaking change from `>= v15.0.0` and on.
+
+### Parsing
+
+The engine which parses the contents of your file containing environment variables is available to use. It accepts a String or Buffer and will return an Object with the parsed keys and values.
+
+```javascript
+const dotenv = require('dotenv')
+const buf = Buffer.from('BASIC=basic')
+const config = dotenv.parse(buf) // will return an object
+console.log(typeof config, config) // object { BASIC : 'basic' }
+```
+
+### Preload
+
+> Note: Consider using [`dotenvx`](https://github.com/dotenvx/dotenvx) instead of preloading. I am now doing (and recommending) so.
+>
+> It serves the same purpose (you do not need to require and load dotenv), adds better debugging, and works with ANY language, framework, or platform. – [motdotla](https://github.com/motdotla)
+
+You can use the `--require` (`-r`) [command line option](https://nodejs.org/api/cli.html#-r---require-module) to preload dotenv. By doing this, you do not need to require and load dotenv in your application code.
+
+```bash
+$ node -r dotenv/config your_script.js
+```
+
+The configuration options below are supported as command line arguments in the format `dotenv_config_<option>=value`
+
+```bash
+$ node -r dotenv/config your_script.js dotenv_config_path=/custom/path/to/.env dotenv_config_debug=true
+```
+
+Additionally, you can use environment variables to set configuration options. Command line arguments will precede these.
+
+```bash
+$ DOTENV_CONFIG_<OPTION>=value node -r dotenv/config your_script.js
+```
+
+```bash
+$ DOTENV_CONFIG_ENCODING=latin1 DOTENV_CONFIG_DEBUG=true node -r dotenv/config your_script.js dotenv_config_path=/custom/path/to/.env
+```
+
+### Variable Expansion
+
+You need to add the value of another variable in one of your variables? Use [dotenv-expand](https://github.com/motdotla/dotenv-expand).
+
+### Command Substitution
+
+Use [dotenvx](https://github.com/dotenvx/dotenvx) to use command substitution.
+
+Add the output of a command to one of your variables in your .env file.
+
+```ini
+# .env
+DATABASE_URL="postgres://$(whoami)@localhost/my_database"
+```
+```js
+// index.js
+console.log('DATABASE_URL', process.env.DATABASE_URL)
+```
+```sh
+$ dotenvx run --debug -- node index.js
+[dotenvx@0.14.1] injecting env (1) from .env
+DATABASE_URL postgres://yourusername@localhost/my_database
+```
+
+### Syncing
+
+You need to keep `.env` files in sync between machines, environments, or team members? Use [dotenvx](https://github.com/dotenvx/dotenvx) to encrypt your `.env` files and safely include them in source control. This still subscribes to the twelve-factor app rules by generating a decryption key separate from code.
+
+### Multiple Environments
+
+Use [dotenvx](https://github.com/dotenvx/dotenvx) to generate `.env.ci`, `.env.production` files, and more.
+
+### Deploying
+
+You need to deploy your secrets in a cloud-agnostic manner? Use [dotenvx](https://github.com/dotenvx/dotenvx) to generate a private decryption key that is set on your production server.
+
+## 🌴 Manage Multiple Environments
+
+Use [dotenvx](https://github.com/dotenvx/dotenvx)
+
+Run any environment locally. Create a `.env.ENVIRONMENT` file and use `--env-file` to load it. It's straightforward, yet flexible.
+
+```bash
+$ echo "HELLO=production" > .env.production
+$ echo "console.log('Hello ' + process.env.HELLO)" > index.js
+
+$ dotenvx run --env-file=.env.production -- node index.js
+Hello production
+> ^^
+```
+
+or with multiple .env files
+
+```bash
+$ echo "HELLO=local" > .env.local
+$ echo "HELLO=World" > .env
+$ echo "console.log('Hello ' + process.env.HELLO)" > index.js
+
+$ dotenvx run --env-file=.env.local --env-file=.env -- node index.js
+Hello local
+```
+
+[more environment examples](https://dotenvx.com/docs/quickstart/environments)
+
+## 🚀 Deploying
+
+Use [dotenvx](https://github.com/dotenvx/dotenvx).
+
+Add encryption to your `.env` files with a single command. Pass the `--encrypt` flag.
+
+```
+$ dotenvx set HELLO Production --encrypt -f .env.production
+$ echo "console.log('Hello ' + process.env.HELLO)" > index.js
+
+$ DOTENV_PRIVATE_KEY_PRODUCTION="<.env.production private key>" dotenvx run -- node index.js
+[dotenvx] injecting env (2) from .env.production
+Hello Production
+```
+
+[learn more](https://github.com/dotenvx/dotenvx?tab=readme-ov-file#encryption)
+
+## 📚 Examples
+
+See [examples](https://github.com/dotenv-org/examples) of using dotenv with various frameworks, languages, and configurations.
+
+* [nodejs](https://github.com/dotenv-org/examples/tree/master/usage/dotenv-nodejs)
+* [nodejs (debug on)](https://github.com/dotenv-org/examples/tree/master/usage/dotenv-nodejs-debug)
+* [nodejs (override on)](https://github.com/dotenv-org/examples/tree/master/usage/dotenv-nodejs-override)
+* [nodejs (processEnv override)](https://github.com/dotenv-org/examples/tree/master/usage/dotenv-custom-target)
+* [esm](https://github.com/dotenv-org/examples/tree/master/usage/dotenv-esm)
+* [esm (preload)](https://github.com/dotenv-org/examples/tree/master/usage/dotenv-esm-preload)
+* [typescript](https://github.com/dotenv-org/examples/tree/master/usage/dotenv-typescript)
+* [typescript parse](https://github.com/dotenv-org/examples/tree/master/usage/dotenv-typescript-parse)
+* [typescript config](https://github.com/dotenv-org/examples/tree/master/usage/dotenv-typescript-config)
+* [webpack](https://github.com/dotenv-org/examples/tree/master/usage/dotenv-webpack)
+* [webpack (plugin)](https://github.com/dotenv-org/examples/tree/master/usage/dotenv-webpack2)
+* [react](https://github.com/dotenv-org/examples/tree/master/usage/dotenv-react)
+* [react (typescript)](https://github.com/dotenv-org/examples/tree/master/usage/dotenv-react-typescript)
+* [express](https://github.com/dotenv-org/examples/tree/master/usage/dotenv-express)
+* [nestjs](https://github.com/dotenv-org/examples/tree/master/usage/dotenv-nestjs)
+* [fastify](https://github.com/dotenv-org/examples/tree/master/usage/dotenv-fastify)
+
+## 📖 Documentation
+
+Dotenv exposes four functions:
+
+* `config`
+* `parse`
+* `populate`
+* `decrypt`
+
+### Config
+
+`config` will read your `.env` file, parse the contents, assign it to
+[`process.env`](https://nodejs.org/docs/latest/api/process.html#process_process_env),
+and return an Object with a `parsed` key containing the loaded content or an `error` key if it failed.
+
+```js
+const result = dotenv.config()
+
+if (result.error) {
+  throw result.error
+}
+
+console.log(result.parsed)
+```
+
+You can additionally, pass options to `config`.
+
+#### Options
+
+##### path
+
+Default: `path.resolve(process.cwd(), '.env')`
+
+Specify a custom path if your file containing environment variables is located elsewhere.
+
+```js
+require('dotenv').config({ path: '/custom/path/to/.env' })
+```
+
+By default, `config` will look for a file called .env in the current working directory.
+
+Pass in multiple files as an array, and they will be parsed in order and combined with `process.env` (or `option.processEnv`, if set). The first value set for a variable will win, unless the `options.override` flag is set, in which case the last value set will win.  If a value already exists in `process.env` and the `options.override` flag is NOT set, no changes will be made to that value. 
+
+```js  
+require('dotenv').config({ path: ['.env.local', '.env'] })
+```
+
+##### encoding
+
+Default: `utf8`
+
+Specify the encoding of your file containing environment variables.
+
+```js
+require('dotenv').config({ encoding: 'latin1' })
+```
+
+##### debug
+
+Default: `false`
+
+Turn on logging to help debug why certain keys or values are not being set as you expect.
+
+```js
+require('dotenv').config({ debug: process.env.DEBUG })
+```
+
+##### override
+
+Default: `false`
+
+Override any environment variables that have already been set on your machine with values from your .env file(s). If multiple files have been provided in `option.path` the override will also be used as each file is combined with the next. Without `override` being set, the first value wins. With `override` set the last value wins. 
+
+```js
+require('dotenv').config({ override: true })
+```
+
+##### processEnv
+
+Default: `process.env`
+
+Specify an object to write your environment variables to. Defaults to `process.env` environment variables.
+
+```js
+const myObject = {}
+require('dotenv').config({ processEnv: myObject })
+
+console.log(myObject) // values from .env
+console.log(process.env) // this was not changed or written to
+```
+
+### Parse
+
+The engine which parses the contents of your file containing environment
+variables is available to use. It accepts a String or Buffer and will return
+an Object with the parsed keys and values.
+
+```js
+const dotenv = require('dotenv')
+const buf = Buffer.from('BASIC=basic')
+const config = dotenv.parse(buf) // will return an object
+console.log(typeof config, config) // object { BASIC : 'basic' }
+```
+
+#### Options
+
+##### debug
+
+Default: `false`
+
+Turn on logging to help debug why certain keys or values are not being set as you expect.
+
+```js
+const dotenv = require('dotenv')
+const buf = Buffer.from('hello world')
+const opt = { debug: true }
+const config = dotenv.parse(buf, opt)
+// expect a debug message because the buffer is not in KEY=VAL form
+```
+
+### Populate
+
+The engine which populates the contents of your .env file to `process.env` is available for use. It accepts a target, a source, and options. This is useful for power users who want to supply their own objects.
+
+For example, customizing the source:
+
+```js
+const dotenv = require('dotenv')
+const parsed = { HELLO: 'world' }
+
+dotenv.populate(process.env, parsed)
+
+console.log(process.env.HELLO) // world
+```
+
+For example, customizing the source AND target:
+
+```js
+const dotenv = require('dotenv')
+const parsed = { HELLO: 'universe' }
+const target = { HELLO: 'world' } // empty object
+
+dotenv.populate(target, parsed, { override: true, debug: true })
+
+console.log(target) // { HELLO: 'universe' }
+```
+
+#### options
+
+##### Debug
+
+Default: `false`
+
+Turn on logging to help debug why certain keys or values are not being populated as you expect.
+
+##### override
+
+Default: `false`
+
+Override any environment variables that have already been set.
+
+## ❓ FAQ
+
+### Why is the `.env` file not loading my environment variables successfully?
+
+Most likely your `.env` file is not in the correct place. [See this stack overflow](https://stackoverflow.com/questions/42335016/dotenv-file-is-not-loading-environment-variables).
+
+Turn on debug mode and try again..
+
+```js
+require('dotenv').config({ debug: true })
+```
+
+You will receive a helpful error outputted to your console.
+
+### Should I commit my `.env` file?
+
+No. We **strongly** recommend against committing your `.env` file to version
+control. It should only include environment-specific values such as database
+passwords or API keys. Your production database should have a different
+password than your development database.
+
+### Should I have multiple `.env` files?
+
+We recommend creating one `.env` file per environment. Use `.env` for local/development, `.env.production` for production and so on. This still follows the twelve factor principles as each is attributed individually to its own environment. Avoid custom set ups that work in inheritance somehow (`.env.production` inherits values form `.env` for example). It is better to duplicate values if necessary across each `.env.environment` file.
+
+> In a twelve-factor app, env vars are granular controls, each fully orthogonal to other env vars. They are never grouped together as “environments”, but instead are independently managed for each deploy. This is a model that scales up smoothly as the app naturally expands into more deploys over its lifetime.
+>
+> – [The Twelve-Factor App](http://12factor.net/config)
+
+### What rules does the parsing engine follow?
+
+The parsing engine currently supports the following rules:
+
+- `BASIC=basic` becomes `{BASIC: 'basic'}`
+- empty lines are skipped
+- lines beginning with `#` are treated as comments
+- `#` marks the beginning of a comment (unless when the value is wrapped in quotes)
+- empty values become empty strings (`EMPTY=` becomes `{EMPTY: ''}`)
+- inner quotes are maintained (think JSON) (`JSON={"foo": "bar"}` becomes `{JSON:"{\"foo\": \"bar\"}"`)
+- whitespace is removed from both ends of unquoted values (see more on [`trim`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim)) (`FOO=  some value  ` becomes `{FOO: 'some value'}`)
+- single and double quoted values are escaped (`SINGLE_QUOTE='quoted'` becomes `{SINGLE_QUOTE: "quoted"}`)
+- single and double quoted values maintain whitespace from both ends (`FOO="  some value  "` becomes `{FOO: '  some value  '}`)
+- double quoted values expand new lines (`MULTILINE="new\nline"` becomes
+
+```
+{MULTILINE: 'new
+line'}
+```
+
+- backticks are supported (`` BACKTICK_KEY=`This has 'single' and "double" quotes inside of it.` ``)
+
+### What happens to environment variables that were already set?
+
+By default, we will never modify any environment variables that have already been set. In particular, if there is a variable in your `.env` file which collides with one that already exists in your environment, then that variable will be skipped.
+
+If instead, you want to override `process.env` use the `override` option.
+
+```javascript
+require('dotenv').config({ override: true })
+```
+
+### How come my environment variables are not showing up for React?
+
+Your React code is run in Webpack, where the `fs` module or even the `process` global itself are not accessible out-of-the-box. `process.env` can only be injected through Webpack configuration.
+
+If you are using [`react-scripts`](https://www.npmjs.com/package/react-scripts), which is distributed through [`create-react-app`](https://create-react-app.dev/), it has dotenv built in but with a quirk. Preface your environment variables with `REACT_APP_`. See [this stack overflow](https://stackoverflow.com/questions/42182577/is-it-possible-to-use-dotenv-in-a-react-project) for more details.
+
+If you are using other frameworks (e.g. Next.js, Gatsby...), you need to consult their documentation for how to inject environment variables into the client.
+
+### Can I customize/write plugins for dotenv?
+
+Yes! `dotenv.config()` returns an object representing the parsed `.env` file. This gives you everything you need to continue setting values on `process.env`. For example:
+
+```js
+const dotenv = require('dotenv')
+const variableExpansion = require('dotenv-expand')
+const myEnv = dotenv.config()
+variableExpansion(myEnv)
+```
+
+### How do I use dotenv with `import`?
+
+Simply..
+
+```javascript
+// index.mjs (ESM)
+import 'dotenv/config' // see https://github.com/motdotla/dotenv#how-do-i-use-dotenv-with-import
+import express from 'express'
+```
+
+A little background..
+
+> When you run a module containing an `import` declaration, the modules it imports are loaded first, then each module body is executed in a depth-first traversal of the dependency graph, avoiding cycles by skipping anything already executed.
+>
+> – [ES6 In Depth: Modules](https://hacks.mozilla.org/2015/08/es6-in-depth-modules/)
+
+What does this mean in plain language? It means you would think the following would work but it won't.
+
+`errorReporter.mjs`:
+```js
+class Client {
+  constructor (apiKey) {
+    console.log('apiKey', apiKey)
+
+    this.apiKey = apiKey
+  }
+}
+
+export default new Client(process.env.API_KEY)
+```
+`index.mjs`:
+```js
+// Note: this is INCORRECT and will not work
+import * as dotenv from 'dotenv'
+dotenv.config()
+
+import errorReporter from './errorReporter.mjs' // process.env.API_KEY will be blank!
+```
+
+`process.env.API_KEY` will be blank.
+
+Instead, `index.mjs` should be written as..
+
+```js
+import 'dotenv/config'
+
+import errorReporter from './errorReporter.mjs'
+```
+
+Does that make sense? It's a bit unintuitive, but it is how importing of ES6 modules work. Here is a [working example of this pitfall](https://github.com/dotenv-org/examples/tree/master/usage/dotenv-es6-import-pitfall).
+
+There are two alternatives to this approach:
+
+1. Preload dotenv: `node --require dotenv/config index.js` (_Note: you do not need to `import` dotenv with this approach_)
+2. Create a separate file that will execute `config` first as outlined in [this comment on #133](https://github.com/motdotla/dotenv/issues/133#issuecomment-255298822)
+
+### Why am I getting the error `Module not found: Error: Can't resolve 'crypto|os|path'`?
+
+You are using dotenv on the front-end and have not included a polyfill. Webpack < 5 used to include these for you. Do the following:
+
+```bash
+npm install node-polyfill-webpack-plugin
+```
+
+Configure your `webpack.config.js` to something like the following.
+
+```js
+require('dotenv').config()
+
+const path = require('path');
+const webpack = require('webpack')
+
+const NodePolyfillPlugin = require('node-polyfill-webpack-plugin')
+
+module.exports = {
+  mode: 'development',
+  entry: './src/index.ts',
+  output: {
+    filename: 'bundle.js',
+    path: path.resolve(__dirname, 'dist'),
+  },
+  plugins: [
+    new NodePolyfillPlugin(),
+    new webpack.DefinePlugin({
+      'process.env': {
+        HELLO: JSON.stringify(process.env.HELLO)
+      }
+    }),
+  ]
+};
+```
+
+Alternatively, just use [dotenv-webpack](https://github.com/mrsteele/dotenv-webpack) which does this and more behind the scenes for you.
+
+### What about variable expansion?
+
+Try [dotenv-expand](https://github.com/motdotla/dotenv-expand)
+
+### What about syncing and securing .env files?
+
+Use [dotenvx](https://github.com/dotenvx/dotenvx)
+
+### What if I accidentally commit my `.env` file to code?
+
+Remove it, [remove git history](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/removing-sensitive-data-from-a-repository) and then install the [git pre-commit hook](https://github.com/dotenvx/dotenvx#pre-commit) to prevent this from ever happening again. 
+
+```
+brew install dotenvx/brew/dotenvx
+dotenvx precommit --install
+```
+
+### How can I prevent committing my `.env` file to a Docker build?
+
+Use the [docker prebuild hook](https://dotenvx.com/docs/features/prebuild).
+
+```bash
+# Dockerfile
+...
+RUN curl -fsS https://dotenvx.sh/ | sh
+...
+RUN dotenvx prebuild
+CMD ["dotenvx", "run", "--", "node", "index.js"]
+```
+
+## Contributing Guide
+
+See [CONTRIBUTING.md](CONTRIBUTING.md)
+
+## CHANGELOG
+
+See [CHANGELOG.md](CHANGELOG.md)
+
+## Who's using dotenv?
+
+[These npm modules depend on it.](https://www.npmjs.com/browse/depended/dotenv)
+
+Projects that expand it often use the [keyword "dotenv" on npm](https://www.npmjs.com/search?q=keywords:dotenv).

backend/node_modules/dotenv/SECURITY.md

@@ -0,0 +1 @@
+Please report any security vulnerabilities to security@dotenvx.com. 

backend/node_modules/dotenv/config.d.ts

@@ -0,0 +1 @@
+export {};

backend/node_modules/dotenv/config.js

@@ -0,0 +1,9 @@
+(function () {
+  require('./lib/main').config(
+    Object.assign(
+      {},
+      require('./lib/env-options'),
+      require('./lib/cli-options')(process.argv)
+    )
+  )
+})()

backend/node_modules/dotenv/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "dotenv",
+  "version": "16.6.1",
+  "description": "Loads environment variables from .env file",
+  "main": "lib/main.js",
+  "types": "lib/main.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/main.d.ts",
+      "require": "./lib/main.js",
+      "default": "./lib/main.js"
+    },
+    "./config": "./config.js",
+    "./config.js": "./config.js",
+    "./lib/env-options": "./lib/env-options.js",
+    "./lib/env-options.js": "./lib/env-options.js",
+    "./lib/cli-options": "./lib/cli-options.js",
+    "./lib/cli-options.js": "./lib/cli-options.js",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "dts-check": "tsc --project tests/types/tsconfig.json",
+    "lint": "standard",
+    "pretest": "npm run lint && npm run dts-check",
+    "test": "tap run --allow-empty-coverage --disable-coverage --timeout=60000",
+    "test:coverage": "tap run --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
+    "prerelease": "npm test",
+    "release": "standard-version"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/motdotla/dotenv.git"
+  },
+  "homepage": "https://github.com/motdotla/dotenv#readme",
+  "funding": "https://dotenvx.com",
+  "keywords": [
+    "dotenv",
+    "env",
+    ".env",
+    "environment",
+    "variables",
+    "config",
+    "settings"
+  ],
+  "readmeFilename": "README.md",
+  "license": "BSD-2-Clause",
+  "devDependencies": {
+    "@types/node": "^18.11.3",
+    "decache": "^4.6.2",
+    "sinon": "^14.0.1",
+    "standard": "^17.0.0",
+    "standard-version": "^9.5.0",
+    "tap": "^19.2.0",
+    "typescript": "^4.8.4"
+  },
+  "engines": {
+    "node": ">=12"
+  },
+  "browser": {
+    "fs": false
+  }
+}

backend/node_modules/effect/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Effectful Technologies Inc
+
+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.

backend/node_modules/effect/README.md

@@ -0,0 +1,53 @@
+# `effect` Core Package
+
+The `effect` package is the heart of the Effect framework, providing robust primitives for managing side effects, ensuring type safety, and supporting concurrency in your TypeScript applications.
+
+## Requirements
+
+- **TypeScript 5.4 or Newer:**
+  Ensure you are using a compatible TypeScript version.
+
+- **Strict Type-Checking:**
+  The `strict` flag must be enabled in your `tsconfig.json`. For example:
+
+  ```json
+  {
+    "compilerOptions": {
+      "strict": true
+      // ...other options
+    }
+  }
+  ```
+
+## Installation
+
+Install the core package using your preferred package manager. For example, with npm:
+
+```bash
+npm install effect
+```
+
+## Documentation
+
+- **Website:**
+  For detailed information and usage examples, visit the [Effect website](https://www.effect.website/).
+
+- **API Reference:**
+  For a complete API reference of the core package `effect`, see the [Effect API documentation](https://effect-ts.github.io/effect/).
+
+## Overview of Effect Modules
+
+The `effect` package provides a collection of modules designed for functional programming in TypeScript. Below is a brief overview of the core modules:
+
+| Module   | Description                                                                                                                |
+| -------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Effect   | The core abstraction for managing side effects, concurrency, and error handling in a structured way.                       |
+| Context  | A lightweight dependency injection mechanism that enables passing services through computations without direct references. |
+| Layer    | A system for managing dependencies, allowing for modular and composable resource allocation.                               |
+| Fiber    | Lightweight virtual threads with resource-safe cancellation capabilities, enabling many features in Effect.                |
+| Stream   | A powerful abstraction for handling asynchronous, event-driven data processing.                                            |
+| Schedule | A module for defining retry and repeat policies with composable schedules.                                                 |
+| Scope    | Manages the lifecycle of resources, ensuring proper acquisition and release.                                               |
+| Schema   | A powerful library for defining, validating, and transforming structured data with type-safe encoding and decoding.        |
+
+For a comparison between `effect/Schema` and `zod`, see [Schema vs Zod](https://github.com/Effect-TS/effect/tree/main/packages/effect/schema-vs-zod.md).

backend/node_modules/effect/package.json

@@ -0,0 +1,1451 @@
+{
+  "name": "effect",
+  "version": "3.21.0",
+  "description": "The missing standard library for TypeScript, for writing production-grade software.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Effect-TS/effect.git",
+    "directory": "packages/effect"
+  },
+  "sideEffects": [],
+  "homepage": "https://effect.website",
+  "dependencies": {
+    "@standard-schema/spec": "^1.0.0",
+    "fast-check": "^3.23.1"
+  },
+  "publishConfig": {
+    "provenance": true
+  },
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/dts/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/dts/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/cjs/index.js"
+    },
+    "./.index": {
+      "types": "./dist/dts/.index.d.ts",
+      "import": "./dist/esm/.index.js",
+      "default": "./dist/cjs/.index.js"
+    },
+    "./Arbitrary": {
+      "types": "./dist/dts/Arbitrary.d.ts",
+      "import": "./dist/esm/Arbitrary.js",
+      "default": "./dist/cjs/Arbitrary.js"
+    },
+    "./Array": {
+      "types": "./dist/dts/Array.d.ts",
+      "import": "./dist/esm/Array.js",
+      "default": "./dist/cjs/Array.js"
+    },
+    "./BigDecimal": {
+      "types": "./dist/dts/BigDecimal.d.ts",
+      "import": "./dist/esm/BigDecimal.js",
+      "default": "./dist/cjs/BigDecimal.js"
+    },
+    "./BigInt": {
+      "types": "./dist/dts/BigInt.d.ts",
+      "import": "./dist/esm/BigInt.js",
+      "default": "./dist/cjs/BigInt.js"
+    },
+    "./Boolean": {
+      "types": "./dist/dts/Boolean.d.ts",
+      "import": "./dist/esm/Boolean.js",
+      "default": "./dist/cjs/Boolean.js"
+    },
+    "./Brand": {
+      "types": "./dist/dts/Brand.d.ts",
+      "import": "./dist/esm/Brand.js",
+      "default": "./dist/cjs/Brand.js"
+    },
+    "./Cache": {
+      "types": "./dist/dts/Cache.d.ts",
+      "import": "./dist/esm/Cache.js",
+      "default": "./dist/cjs/Cache.js"
+    },
+    "./Cause": {
+      "types": "./dist/dts/Cause.d.ts",
+      "import": "./dist/esm/Cause.js",
+      "default": "./dist/cjs/Cause.js"
+    },
+    "./Channel": {
+      "types": "./dist/dts/Channel.d.ts",
+      "import": "./dist/esm/Channel.js",
+      "default": "./dist/cjs/Channel.js"
+    },
+    "./ChildExecutorDecision": {
+      "types": "./dist/dts/ChildExecutorDecision.d.ts",
+      "import": "./dist/esm/ChildExecutorDecision.js",
+      "default": "./dist/cjs/ChildExecutorDecision.js"
+    },
+    "./Chunk": {
+      "types": "./dist/dts/Chunk.d.ts",
+      "import": "./dist/esm/Chunk.js",
+      "default": "./dist/cjs/Chunk.js"
+    },
+    "./Clock": {
+      "types": "./dist/dts/Clock.d.ts",
+      "import": "./dist/esm/Clock.js",
+      "default": "./dist/cjs/Clock.js"
+    },
+    "./Config": {
+      "types": "./dist/dts/Config.d.ts",
+      "import": "./dist/esm/Config.js",
+      "default": "./dist/cjs/Config.js"
+    },
+    "./ConfigError": {
+      "types": "./dist/dts/ConfigError.d.ts",
+      "import": "./dist/esm/ConfigError.js",
+      "default": "./dist/cjs/ConfigError.js"
+    },
+    "./ConfigProvider": {
+      "types": "./dist/dts/ConfigProvider.d.ts",
+      "import": "./dist/esm/ConfigProvider.js",
+      "default": "./dist/cjs/ConfigProvider.js"
+    },
+    "./ConfigProviderPathPatch": {
+      "types": "./dist/dts/ConfigProviderPathPatch.d.ts",
+      "import": "./dist/esm/ConfigProviderPathPatch.js",
+      "default": "./dist/cjs/ConfigProviderPathPatch.js"
+    },
+    "./Console": {
+      "types": "./dist/dts/Console.d.ts",
+      "import": "./dist/esm/Console.js",
+      "default": "./dist/cjs/Console.js"
+    },
+    "./Context": {
+      "types": "./dist/dts/Context.d.ts",
+      "import": "./dist/esm/Context.js",
+      "default": "./dist/cjs/Context.js"
+    },
+    "./Cron": {
+      "types": "./dist/dts/Cron.d.ts",
+      "import": "./dist/esm/Cron.js",
+      "default": "./dist/cjs/Cron.js"
+    },
+    "./Data": {
+      "types": "./dist/dts/Data.d.ts",
+      "import": "./dist/esm/Data.js",
+      "default": "./dist/cjs/Data.js"
+    },
+    "./DateTime": {
+      "types": "./dist/dts/DateTime.d.ts",
+      "import": "./dist/esm/DateTime.js",
+      "default": "./dist/cjs/DateTime.js"
+    },
+    "./DefaultServices": {
+      "types": "./dist/dts/DefaultServices.d.ts",
+      "import": "./dist/esm/DefaultServices.js",
+      "default": "./dist/cjs/DefaultServices.js"
+    },
+    "./Deferred": {
+      "types": "./dist/dts/Deferred.d.ts",
+      "import": "./dist/esm/Deferred.js",
+      "default": "./dist/cjs/Deferred.js"
+    },
+    "./Differ": {
+      "types": "./dist/dts/Differ.d.ts",
+      "import": "./dist/esm/Differ.js",
+      "default": "./dist/cjs/Differ.js"
+    },
+    "./Duration": {
+      "types": "./dist/dts/Duration.d.ts",
+      "import": "./dist/esm/Duration.js",
+      "default": "./dist/cjs/Duration.js"
+    },
+    "./Effect": {
+      "types": "./dist/dts/Effect.d.ts",
+      "import": "./dist/esm/Effect.js",
+      "default": "./dist/cjs/Effect.js"
+    },
+    "./Effectable": {
+      "types": "./dist/dts/Effectable.d.ts",
+      "import": "./dist/esm/Effectable.js",
+      "default": "./dist/cjs/Effectable.js"
+    },
+    "./Either": {
+      "types": "./dist/dts/Either.d.ts",
+      "import": "./dist/esm/Either.js",
+      "default": "./dist/cjs/Either.js"
+    },
+    "./Encoding": {
+      "types": "./dist/dts/Encoding.d.ts",
+      "import": "./dist/esm/Encoding.js",
+      "default": "./dist/cjs/Encoding.js"
+    },
+    "./Equal": {
+      "types": "./dist/dts/Equal.d.ts",
+      "import": "./dist/esm/Equal.js",
+      "default": "./dist/cjs/Equal.js"
+    },
+    "./Equivalence": {
+      "types": "./dist/dts/Equivalence.d.ts",
+      "import": "./dist/esm/Equivalence.js",
+      "default": "./dist/cjs/Equivalence.js"
+    },
+    "./ExecutionPlan": {
+      "types": "./dist/dts/ExecutionPlan.d.ts",
+      "import": "./dist/esm/ExecutionPlan.js",
+      "default": "./dist/cjs/ExecutionPlan.js"
+    },
+    "./ExecutionStrategy": {
+      "types": "./dist/dts/ExecutionStrategy.d.ts",
+      "import": "./dist/esm/ExecutionStrategy.js",
+      "default": "./dist/cjs/ExecutionStrategy.js"
+    },
+    "./Exit": {
+      "types": "./dist/dts/Exit.d.ts",
+      "import": "./dist/esm/Exit.js",
+      "default": "./dist/cjs/Exit.js"
+    },
+    "./FastCheck": {
+      "types": "./dist/dts/FastCheck.d.ts",
+      "import": "./dist/esm/FastCheck.js",
+      "default": "./dist/cjs/FastCheck.js"
+    },
+    "./Fiber": {
+      "types": "./dist/dts/Fiber.d.ts",
+      "import": "./dist/esm/Fiber.js",
+      "default": "./dist/cjs/Fiber.js"
+    },
+    "./FiberHandle": {
+      "types": "./dist/dts/FiberHandle.d.ts",
+      "import": "./dist/esm/FiberHandle.js",
+      "default": "./dist/cjs/FiberHandle.js"
+    },
+    "./FiberId": {
+      "types": "./dist/dts/FiberId.d.ts",
+      "import": "./dist/esm/FiberId.js",
+      "default": "./dist/cjs/FiberId.js"
+    },
+    "./FiberMap": {
+      "types": "./dist/dts/FiberMap.d.ts",
+      "import": "./dist/esm/FiberMap.js",
+      "default": "./dist/cjs/FiberMap.js"
+    },
+    "./FiberRef": {
+      "types": "./dist/dts/FiberRef.d.ts",
+      "import": "./dist/esm/FiberRef.js",
+      "default": "./dist/cjs/FiberRef.js"
+    },
+    "./FiberRefs": {
+      "types": "./dist/dts/FiberRefs.d.ts",
+      "import": "./dist/esm/FiberRefs.js",
+      "default": "./dist/cjs/FiberRefs.js"
+    },
+    "./FiberRefsPatch": {
+      "types": "./dist/dts/FiberRefsPatch.d.ts",
+      "import": "./dist/esm/FiberRefsPatch.js",
+      "default": "./dist/cjs/FiberRefsPatch.js"
+    },
+    "./FiberSet": {
+      "types": "./dist/dts/FiberSet.d.ts",
+      "import": "./dist/esm/FiberSet.js",
+      "default": "./dist/cjs/FiberSet.js"
+    },
+    "./FiberStatus": {
+      "types": "./dist/dts/FiberStatus.d.ts",
+      "import": "./dist/esm/FiberStatus.js",
+      "default": "./dist/cjs/FiberStatus.js"
+    },
+    "./Function": {
+      "types": "./dist/dts/Function.d.ts",
+      "import": "./dist/esm/Function.js",
+      "default": "./dist/cjs/Function.js"
+    },
+    "./GlobalValue": {
+      "types": "./dist/dts/GlobalValue.d.ts",
+      "import": "./dist/esm/GlobalValue.js",
+      "default": "./dist/cjs/GlobalValue.js"
+    },
+    "./Graph": {
+      "types": "./dist/dts/Graph.d.ts",
+      "import": "./dist/esm/Graph.js",
+      "default": "./dist/cjs/Graph.js"
+    },
+    "./GroupBy": {
+      "types": "./dist/dts/GroupBy.d.ts",
+      "import": "./dist/esm/GroupBy.js",
+      "default": "./dist/cjs/GroupBy.js"
+    },
+    "./HKT": {
+      "types": "./dist/dts/HKT.d.ts",
+      "import": "./dist/esm/HKT.js",
+      "default": "./dist/cjs/HKT.js"
+    },
+    "./Hash": {
+      "types": "./dist/dts/Hash.d.ts",
+      "import": "./dist/esm/Hash.js",
+      "default": "./dist/cjs/Hash.js"
+    },
+    "./HashMap": {
+      "types": "./dist/dts/HashMap.d.ts",
+      "import": "./dist/esm/HashMap.js",
+      "default": "./dist/cjs/HashMap.js"
+    },
+    "./HashRing": {
+      "types": "./dist/dts/HashRing.d.ts",
+      "import": "./dist/esm/HashRing.js",
+      "default": "./dist/cjs/HashRing.js"
+    },
+    "./HashSet": {
+      "types": "./dist/dts/HashSet.d.ts",
+      "import": "./dist/esm/HashSet.js",
+      "default": "./dist/cjs/HashSet.js"
+    },
+    "./Inspectable": {
+      "types": "./dist/dts/Inspectable.d.ts",
+      "import": "./dist/esm/Inspectable.js",
+      "default": "./dist/cjs/Inspectable.js"
+    },
+    "./Iterable": {
+      "types": "./dist/dts/Iterable.d.ts",
+      "import": "./dist/esm/Iterable.js",
+      "default": "./dist/cjs/Iterable.js"
+    },
+    "./JSONSchema": {
+      "types": "./dist/dts/JSONSchema.d.ts",
+      "import": "./dist/esm/JSONSchema.js",
+      "default": "./dist/cjs/JSONSchema.js"
+    },
+    "./KeyedPool": {
+      "types": "./dist/dts/KeyedPool.d.ts",
+      "import": "./dist/esm/KeyedPool.js",
+      "default": "./dist/cjs/KeyedPool.js"
+    },
+    "./Layer": {
+      "types": "./dist/dts/Layer.d.ts",
+      "import": "./dist/esm/Layer.js",
+      "default": "./dist/cjs/Layer.js"
+    },
+    "./LayerMap": {
+      "types": "./dist/dts/LayerMap.d.ts",
+      "import": "./dist/esm/LayerMap.js",
+      "default": "./dist/cjs/LayerMap.js"
+    },
+    "./List": {
+      "types": "./dist/dts/List.d.ts",
+      "import": "./dist/esm/List.js",
+      "default": "./dist/cjs/List.js"
+    },
+    "./LogLevel": {
+      "types": "./dist/dts/LogLevel.d.ts",
+      "import": "./dist/esm/LogLevel.js",
+      "default": "./dist/cjs/LogLevel.js"
+    },
+    "./LogSpan": {
+      "types": "./dist/dts/LogSpan.d.ts",
+      "import": "./dist/esm/LogSpan.js",
+      "default": "./dist/cjs/LogSpan.js"
+    },
+    "./Logger": {
+      "types": "./dist/dts/Logger.d.ts",
+      "import": "./dist/esm/Logger.js",
+      "default": "./dist/cjs/Logger.js"
+    },
+    "./Mailbox": {
+      "types": "./dist/dts/Mailbox.d.ts",
+      "import": "./dist/esm/Mailbox.js",
+      "default": "./dist/cjs/Mailbox.js"
+    },
+    "./ManagedRuntime": {
+      "types": "./dist/dts/ManagedRuntime.d.ts",
+      "import": "./dist/esm/ManagedRuntime.js",
+      "default": "./dist/cjs/ManagedRuntime.js"
+    },
+    "./Match": {
+      "types": "./dist/dts/Match.d.ts",
+      "import": "./dist/esm/Match.js",
+      "default": "./dist/cjs/Match.js"
+    },
+    "./MergeDecision": {
+      "types": "./dist/dts/MergeDecision.d.ts",
+      "import": "./dist/esm/MergeDecision.js",
+      "default": "./dist/cjs/MergeDecision.js"
+    },
+    "./MergeState": {
+      "types": "./dist/dts/MergeState.d.ts",
+      "import": "./dist/esm/MergeState.js",
+      "default": "./dist/cjs/MergeState.js"
+    },
+    "./MergeStrategy": {
+      "types": "./dist/dts/MergeStrategy.d.ts",
+      "import": "./dist/esm/MergeStrategy.js",
+      "default": "./dist/cjs/MergeStrategy.js"
+    },
+    "./Metric": {
+      "types": "./dist/dts/Metric.d.ts",
+      "import": "./dist/esm/Metric.js",
+      "default": "./dist/cjs/Metric.js"
+    },
+    "./MetricBoundaries": {
+      "types": "./dist/dts/MetricBoundaries.d.ts",
+      "import": "./dist/esm/MetricBoundaries.js",
+      "default": "./dist/cjs/MetricBoundaries.js"
+    },
+    "./MetricHook": {
+      "types": "./dist/dts/MetricHook.d.ts",
+      "import": "./dist/esm/MetricHook.js",
+      "default": "./dist/cjs/MetricHook.js"
+    },
+    "./MetricKey": {
+      "types": "./dist/dts/MetricKey.d.ts",
+      "import": "./dist/esm/MetricKey.js",
+      "default": "./dist/cjs/MetricKey.js"
+    },
+    "./MetricKeyType": {
+      "types": "./dist/dts/MetricKeyType.d.ts",
+      "import": "./dist/esm/MetricKeyType.js",
+      "default": "./dist/cjs/MetricKeyType.js"
+    },
+    "./MetricLabel": {
+      "types": "./dist/dts/MetricLabel.d.ts",
+      "import": "./dist/esm/MetricLabel.js",
+      "default": "./dist/cjs/MetricLabel.js"
+    },
+    "./MetricPair": {
+      "types": "./dist/dts/MetricPair.d.ts",
+      "import": "./dist/esm/MetricPair.js",
+      "default": "./dist/cjs/MetricPair.js"
+    },
+    "./MetricPolling": {
+      "types": "./dist/dts/MetricPolling.d.ts",
+      "import": "./dist/esm/MetricPolling.js",
+      "default": "./dist/cjs/MetricPolling.js"
+    },
+    "./MetricRegistry": {
+      "types": "./dist/dts/MetricRegistry.d.ts",
+      "import": "./dist/esm/MetricRegistry.js",
+      "default": "./dist/cjs/MetricRegistry.js"
+    },
+    "./MetricState": {
+      "types": "./dist/dts/MetricState.d.ts",
+      "import": "./dist/esm/MetricState.js",
+      "default": "./dist/cjs/MetricState.js"
+    },
+    "./Micro": {
+      "types": "./dist/dts/Micro.d.ts",
+      "import": "./dist/esm/Micro.js",
+      "default": "./dist/cjs/Micro.js"
+    },
+    "./ModuleVersion": {
+      "types": "./dist/dts/ModuleVersion.d.ts",
+      "import": "./dist/esm/ModuleVersion.js",
+      "default": "./dist/cjs/ModuleVersion.js"
+    },
+    "./MutableHashMap": {
+      "types": "./dist/dts/MutableHashMap.d.ts",
+      "import": "./dist/esm/MutableHashMap.js",
+      "default": "./dist/cjs/MutableHashMap.js"
+    },
+    "./MutableHashSet": {
+      "types": "./dist/dts/MutableHashSet.d.ts",
+      "import": "./dist/esm/MutableHashSet.js",
+      "default": "./dist/cjs/MutableHashSet.js"
+    },
+    "./MutableList": {
+      "types": "./dist/dts/MutableList.d.ts",
+      "import": "./dist/esm/MutableList.js",
+      "default": "./dist/cjs/MutableList.js"
+    },
+    "./MutableQueue": {
+      "types": "./dist/dts/MutableQueue.d.ts",
+      "import": "./dist/esm/MutableQueue.js",
+      "default": "./dist/cjs/MutableQueue.js"
+    },
+    "./MutableRef": {
+      "types": "./dist/dts/MutableRef.d.ts",
+      "import": "./dist/esm/MutableRef.js",
+      "default": "./dist/cjs/MutableRef.js"
+    },
+    "./NonEmptyIterable": {
+      "types": "./dist/dts/NonEmptyIterable.d.ts",
+      "import": "./dist/esm/NonEmptyIterable.js",
+      "default": "./dist/cjs/NonEmptyIterable.js"
+    },
+    "./Number": {
+      "types": "./dist/dts/Number.d.ts",
+      "import": "./dist/esm/Number.js",
+      "default": "./dist/cjs/Number.js"
+    },
+    "./Option": {
+      "types": "./dist/dts/Option.d.ts",
+      "import": "./dist/esm/Option.js",
+      "default": "./dist/cjs/Option.js"
+    },
+    "./Order": {
+      "types": "./dist/dts/Order.d.ts",
+      "import": "./dist/esm/Order.js",
+      "default": "./dist/cjs/Order.js"
+    },
+    "./Ordering": {
+      "types": "./dist/dts/Ordering.d.ts",
+      "import": "./dist/esm/Ordering.js",
+      "default": "./dist/cjs/Ordering.js"
+    },
+    "./ParseResult": {
+      "types": "./dist/dts/ParseResult.d.ts",
+      "import": "./dist/esm/ParseResult.js",
+      "default": "./dist/cjs/ParseResult.js"
+    },
+    "./PartitionedSemaphore": {
+      "types": "./dist/dts/PartitionedSemaphore.d.ts",
+      "import": "./dist/esm/PartitionedSemaphore.js",
+      "default": "./dist/cjs/PartitionedSemaphore.js"
+    },
+    "./Pipeable": {
+      "types": "./dist/dts/Pipeable.d.ts",
+      "import": "./dist/esm/Pipeable.js",
+      "default": "./dist/cjs/Pipeable.js"
+    },
+    "./Pool": {
+      "types": "./dist/dts/Pool.d.ts",
+      "import": "./dist/esm/Pool.js",
+      "default": "./dist/cjs/Pool.js"
+    },
+    "./Predicate": {
+      "types": "./dist/dts/Predicate.d.ts",
+      "import": "./dist/esm/Predicate.js",
+      "default": "./dist/cjs/Predicate.js"
+    },
+    "./Pretty": {
+      "types": "./dist/dts/Pretty.d.ts",
+      "import": "./dist/esm/Pretty.js",
+      "default": "./dist/cjs/Pretty.js"
+    },
+    "./PrimaryKey": {
+      "types": "./dist/dts/PrimaryKey.d.ts",
+      "import": "./dist/esm/PrimaryKey.js",
+      "default": "./dist/cjs/PrimaryKey.js"
+    },
+    "./PubSub": {
+      "types": "./dist/dts/PubSub.d.ts",
+      "import": "./dist/esm/PubSub.js",
+      "default": "./dist/cjs/PubSub.js"
+    },
+    "./Queue": {
+      "types": "./dist/dts/Queue.d.ts",
+      "import": "./dist/esm/Queue.js",
+      "default": "./dist/cjs/Queue.js"
+    },
+    "./Random": {
+      "types": "./dist/dts/Random.d.ts",
+      "import": "./dist/esm/Random.js",
+      "default": "./dist/cjs/Random.js"
+    },
+    "./RateLimiter": {
+      "types": "./dist/dts/RateLimiter.d.ts",
+      "import": "./dist/esm/RateLimiter.js",
+      "default": "./dist/cjs/RateLimiter.js"
+    },
+    "./RcMap": {
+      "types": "./dist/dts/RcMap.d.ts",
+      "import": "./dist/esm/RcMap.js",
+      "default": "./dist/cjs/RcMap.js"
+    },
+    "./RcRef": {
+      "types": "./dist/dts/RcRef.d.ts",
+      "import": "./dist/esm/RcRef.js",
+      "default": "./dist/cjs/RcRef.js"
+    },
+    "./Readable": {
+      "types": "./dist/dts/Readable.d.ts",
+      "import": "./dist/esm/Readable.js",
+      "default": "./dist/cjs/Readable.js"
+    },
+    "./Record": {
+      "types": "./dist/dts/Record.d.ts",
+      "import": "./dist/esm/Record.js",
+      "default": "./dist/cjs/Record.js"
+    },
+    "./RedBlackTree": {
+      "types": "./dist/dts/RedBlackTree.d.ts",
+      "import": "./dist/esm/RedBlackTree.js",
+      "default": "./dist/cjs/RedBlackTree.js"
+    },
+    "./Redacted": {
+      "types": "./dist/dts/Redacted.d.ts",
+      "import": "./dist/esm/Redacted.js",
+      "default": "./dist/cjs/Redacted.js"
+    },
+    "./Ref": {
+      "types": "./dist/dts/Ref.d.ts",
+      "import": "./dist/esm/Ref.js",
+      "default": "./dist/cjs/Ref.js"
+    },
+    "./RegExp": {
+      "types": "./dist/dts/RegExp.d.ts",
+      "import": "./dist/esm/RegExp.js",
+      "default": "./dist/cjs/RegExp.js"
+    },
+    "./Reloadable": {
+      "types": "./dist/dts/Reloadable.d.ts",
+      "import": "./dist/esm/Reloadable.js",
+      "default": "./dist/cjs/Reloadable.js"
+    },
+    "./Request": {
+      "types": "./dist/dts/Request.d.ts",
+      "import": "./dist/esm/Request.js",
+      "default": "./dist/cjs/Request.js"
+    },
+    "./RequestBlock": {
+      "types": "./dist/dts/RequestBlock.d.ts",
+      "import": "./dist/esm/RequestBlock.js",
+      "default": "./dist/cjs/RequestBlock.js"
+    },
+    "./RequestResolver": {
+      "types": "./dist/dts/RequestResolver.d.ts",
+      "import": "./dist/esm/RequestResolver.js",
+      "default": "./dist/cjs/RequestResolver.js"
+    },
+    "./Resource": {
+      "types": "./dist/dts/Resource.d.ts",
+      "import": "./dist/esm/Resource.js",
+      "default": "./dist/cjs/Resource.js"
+    },
+    "./Runtime": {
+      "types": "./dist/dts/Runtime.d.ts",
+      "import": "./dist/esm/Runtime.js",
+      "default": "./dist/cjs/Runtime.js"
+    },
+    "./RuntimeFlags": {
+      "types": "./dist/dts/RuntimeFlags.d.ts",
+      "import": "./dist/esm/RuntimeFlags.js",
+      "default": "./dist/cjs/RuntimeFlags.js"
+    },
+    "./RuntimeFlagsPatch": {
+      "types": "./dist/dts/RuntimeFlagsPatch.d.ts",
+      "import": "./dist/esm/RuntimeFlagsPatch.js",
+      "default": "./dist/cjs/RuntimeFlagsPatch.js"
+    },
+    "./STM": {
+      "types": "./dist/dts/STM.d.ts",
+      "import": "./dist/esm/STM.js",
+      "default": "./dist/cjs/STM.js"
+    },
+    "./Schedule": {
+      "types": "./dist/dts/Schedule.d.ts",
+      "import": "./dist/esm/Schedule.js",
+      "default": "./dist/cjs/Schedule.js"
+    },
+    "./ScheduleDecision": {
+      "types": "./dist/dts/ScheduleDecision.d.ts",
+      "import": "./dist/esm/ScheduleDecision.js",
+      "default": "./dist/cjs/ScheduleDecision.js"
+    },
+    "./ScheduleInterval": {
+      "types": "./dist/dts/ScheduleInterval.d.ts",
+      "import": "./dist/esm/ScheduleInterval.js",
+      "default": "./dist/cjs/ScheduleInterval.js"
+    },
+    "./ScheduleIntervals": {
+      "types": "./dist/dts/ScheduleIntervals.d.ts",
+      "import": "./dist/esm/ScheduleIntervals.js",
+      "default": "./dist/cjs/ScheduleIntervals.js"
+    },
+    "./Scheduler": {
+      "types": "./dist/dts/Scheduler.d.ts",
+      "import": "./dist/esm/Scheduler.js",
+      "default": "./dist/cjs/Scheduler.js"
+    },
+    "./Schema": {
+      "types": "./dist/dts/Schema.d.ts",
+      "import": "./dist/esm/Schema.js",
+      "default": "./dist/cjs/Schema.js"
+    },
+    "./SchemaAST": {
+      "types": "./dist/dts/SchemaAST.d.ts",
+      "import": "./dist/esm/SchemaAST.js",
+      "default": "./dist/cjs/SchemaAST.js"
+    },
+    "./Scope": {
+      "types": "./dist/dts/Scope.d.ts",
+      "import": "./dist/esm/Scope.js",
+      "default": "./dist/cjs/Scope.js"
+    },
+    "./ScopedCache": {
+      "types": "./dist/dts/ScopedCache.d.ts",
+      "import": "./dist/esm/ScopedCache.js",
+      "default": "./dist/cjs/ScopedCache.js"
+    },
+    "./ScopedRef": {
+      "types": "./dist/dts/ScopedRef.d.ts",
+      "import": "./dist/esm/ScopedRef.js",
+      "default": "./dist/cjs/ScopedRef.js"
+    },
+    "./Secret": {
+      "types": "./dist/dts/Secret.d.ts",
+      "import": "./dist/esm/Secret.js",
+      "default": "./dist/cjs/Secret.js"
+    },
+    "./SingleProducerAsyncInput": {
+      "types": "./dist/dts/SingleProducerAsyncInput.d.ts",
+      "import": "./dist/esm/SingleProducerAsyncInput.js",
+      "default": "./dist/cjs/SingleProducerAsyncInput.js"
+    },
+    "./Sink": {
+      "types": "./dist/dts/Sink.d.ts",
+      "import": "./dist/esm/Sink.js",
+      "default": "./dist/cjs/Sink.js"
+    },
+    "./SortedMap": {
+      "types": "./dist/dts/SortedMap.d.ts",
+      "import": "./dist/esm/SortedMap.js",
+      "default": "./dist/cjs/SortedMap.js"
+    },
+    "./SortedSet": {
+      "types": "./dist/dts/SortedSet.d.ts",
+      "import": "./dist/esm/SortedSet.js",
+      "default": "./dist/cjs/SortedSet.js"
+    },
+    "./Stream": {
+      "types": "./dist/dts/Stream.d.ts",
+      "import": "./dist/esm/Stream.js",
+      "default": "./dist/cjs/Stream.js"
+    },
+    "./StreamEmit": {
+      "types": "./dist/dts/StreamEmit.d.ts",
+      "import": "./dist/esm/StreamEmit.js",
+      "default": "./dist/cjs/StreamEmit.js"
+    },
+    "./StreamHaltStrategy": {
+      "types": "./dist/dts/StreamHaltStrategy.d.ts",
+      "import": "./dist/esm/StreamHaltStrategy.js",
+      "default": "./dist/cjs/StreamHaltStrategy.js"
+    },
+    "./Streamable": {
+      "types": "./dist/dts/Streamable.d.ts",
+      "import": "./dist/esm/Streamable.js",
+      "default": "./dist/cjs/Streamable.js"
+    },
+    "./String": {
+      "types": "./dist/dts/String.d.ts",
+      "import": "./dist/esm/String.js",
+      "default": "./dist/cjs/String.js"
+    },
+    "./Struct": {
+      "types": "./dist/dts/Struct.d.ts",
+      "import": "./dist/esm/Struct.js",
+      "default": "./dist/cjs/Struct.js"
+    },
+    "./Subscribable": {
+      "types": "./dist/dts/Subscribable.d.ts",
+      "import": "./dist/esm/Subscribable.js",
+      "default": "./dist/cjs/Subscribable.js"
+    },
+    "./SubscriptionRef": {
+      "types": "./dist/dts/SubscriptionRef.d.ts",
+      "import": "./dist/esm/SubscriptionRef.js",
+      "default": "./dist/cjs/SubscriptionRef.js"
+    },
+    "./Supervisor": {
+      "types": "./dist/dts/Supervisor.d.ts",
+      "import": "./dist/esm/Supervisor.js",
+      "default": "./dist/cjs/Supervisor.js"
+    },
+    "./Symbol": {
+      "types": "./dist/dts/Symbol.d.ts",
+      "import": "./dist/esm/Symbol.js",
+      "default": "./dist/cjs/Symbol.js"
+    },
+    "./SynchronizedRef": {
+      "types": "./dist/dts/SynchronizedRef.d.ts",
+      "import": "./dist/esm/SynchronizedRef.js",
+      "default": "./dist/cjs/SynchronizedRef.js"
+    },
+    "./TArray": {
+      "types": "./dist/dts/TArray.d.ts",
+      "import": "./dist/esm/TArray.js",
+      "default": "./dist/cjs/TArray.js"
+    },
+    "./TDeferred": {
+      "types": "./dist/dts/TDeferred.d.ts",
+      "import": "./dist/esm/TDeferred.js",
+      "default": "./dist/cjs/TDeferred.js"
+    },
+    "./TMap": {
+      "types": "./dist/dts/TMap.d.ts",
+      "import": "./dist/esm/TMap.js",
+      "default": "./dist/cjs/TMap.js"
+    },
+    "./TPriorityQueue": {
+      "types": "./dist/dts/TPriorityQueue.d.ts",
+      "import": "./dist/esm/TPriorityQueue.js",
+      "default": "./dist/cjs/TPriorityQueue.js"
+    },
+    "./TPubSub": {
+      "types": "./dist/dts/TPubSub.d.ts",
+      "import": "./dist/esm/TPubSub.js",
+      "default": "./dist/cjs/TPubSub.js"
+    },
+    "./TQueue": {
+      "types": "./dist/dts/TQueue.d.ts",
+      "import": "./dist/esm/TQueue.js",
+      "default": "./dist/cjs/TQueue.js"
+    },
+    "./TRandom": {
+      "types": "./dist/dts/TRandom.d.ts",
+      "import": "./dist/esm/TRandom.js",
+      "default": "./dist/cjs/TRandom.js"
+    },
+    "./TReentrantLock": {
+      "types": "./dist/dts/TReentrantLock.d.ts",
+      "import": "./dist/esm/TReentrantLock.js",
+      "default": "./dist/cjs/TReentrantLock.js"
+    },
+    "./TRef": {
+      "types": "./dist/dts/TRef.d.ts",
+      "import": "./dist/esm/TRef.js",
+      "default": "./dist/cjs/TRef.js"
+    },
+    "./TSemaphore": {
+      "types": "./dist/dts/TSemaphore.d.ts",
+      "import": "./dist/esm/TSemaphore.js",
+      "default": "./dist/cjs/TSemaphore.js"
+    },
+    "./TSet": {
+      "types": "./dist/dts/TSet.d.ts",
+      "import": "./dist/esm/TSet.js",
+      "default": "./dist/cjs/TSet.js"
+    },
+    "./TSubscriptionRef": {
+      "types": "./dist/dts/TSubscriptionRef.d.ts",
+      "import": "./dist/esm/TSubscriptionRef.js",
+      "default": "./dist/cjs/TSubscriptionRef.js"
+    },
+    "./Take": {
+      "types": "./dist/dts/Take.d.ts",
+      "import": "./dist/esm/Take.js",
+      "default": "./dist/cjs/Take.js"
+    },
+    "./TestAnnotation": {
+      "types": "./dist/dts/TestAnnotation.d.ts",
+      "import": "./dist/esm/TestAnnotation.js",
+      "default": "./dist/cjs/TestAnnotation.js"
+    },
+    "./TestAnnotationMap": {
+      "types": "./dist/dts/TestAnnotationMap.d.ts",
+      "import": "./dist/esm/TestAnnotationMap.js",
+      "default": "./dist/cjs/TestAnnotationMap.js"
+    },
+    "./TestAnnotations": {
+      "types": "./dist/dts/TestAnnotations.d.ts",
+      "import": "./dist/esm/TestAnnotations.js",
+      "default": "./dist/cjs/TestAnnotations.js"
+    },
+    "./TestClock": {
+      "types": "./dist/dts/TestClock.d.ts",
+      "import": "./dist/esm/TestClock.js",
+      "default": "./dist/cjs/TestClock.js"
+    },
+    "./TestConfig": {
+      "types": "./dist/dts/TestConfig.d.ts",
+      "import": "./dist/esm/TestConfig.js",
+      "default": "./dist/cjs/TestConfig.js"
+    },
+    "./TestContext": {
+      "types": "./dist/dts/TestContext.d.ts",
+      "import": "./dist/esm/TestContext.js",
+      "default": "./dist/cjs/TestContext.js"
+    },
+    "./TestLive": {
+      "types": "./dist/dts/TestLive.d.ts",
+      "import": "./dist/esm/TestLive.js",
+      "default": "./dist/cjs/TestLive.js"
+    },
+    "./TestServices": {
+      "types": "./dist/dts/TestServices.d.ts",
+      "import": "./dist/esm/TestServices.js",
+      "default": "./dist/cjs/TestServices.js"
+    },
+    "./TestSized": {
+      "types": "./dist/dts/TestSized.d.ts",
+      "import": "./dist/esm/TestSized.js",
+      "default": "./dist/cjs/TestSized.js"
+    },
+    "./Tracer": {
+      "types": "./dist/dts/Tracer.d.ts",
+      "import": "./dist/esm/Tracer.js",
+      "default": "./dist/cjs/Tracer.js"
+    },
+    "./Trie": {
+      "types": "./dist/dts/Trie.d.ts",
+      "import": "./dist/esm/Trie.js",
+      "default": "./dist/cjs/Trie.js"
+    },
+    "./Tuple": {
+      "types": "./dist/dts/Tuple.d.ts",
+      "import": "./dist/esm/Tuple.js",
+      "default": "./dist/cjs/Tuple.js"
+    },
+    "./Types": {
+      "types": "./dist/dts/Types.d.ts",
+      "import": "./dist/esm/Types.js",
+      "default": "./dist/cjs/Types.js"
+    },
+    "./Unify": {
+      "types": "./dist/dts/Unify.d.ts",
+      "import": "./dist/esm/Unify.js",
+      "default": "./dist/cjs/Unify.js"
+    },
+    "./UpstreamPullRequest": {
+      "types": "./dist/dts/UpstreamPullRequest.d.ts",
+      "import": "./dist/esm/UpstreamPullRequest.js",
+      "default": "./dist/cjs/UpstreamPullRequest.js"
+    },
+    "./UpstreamPullStrategy": {
+      "types": "./dist/dts/UpstreamPullStrategy.d.ts",
+      "import": "./dist/esm/UpstreamPullStrategy.js",
+      "default": "./dist/cjs/UpstreamPullStrategy.js"
+    },
+    "./Utils": {
+      "types": "./dist/dts/Utils.d.ts",
+      "import": "./dist/esm/Utils.js",
+      "default": "./dist/cjs/Utils.js"
+    },
+    "./index": {
+      "types": "./dist/dts/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/cjs/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".index": [
+        "./dist/dts/.index.d.ts"
+      ],
+      "Arbitrary": [
+        "./dist/dts/Arbitrary.d.ts"
+      ],
+      "Array": [
+        "./dist/dts/Array.d.ts"
+      ],
+      "BigDecimal": [
+        "./dist/dts/BigDecimal.d.ts"
+      ],
+      "BigInt": [
+        "./dist/dts/BigInt.d.ts"
+      ],
+      "Boolean": [
+        "./dist/dts/Boolean.d.ts"
+      ],
+      "Brand": [
+        "./dist/dts/Brand.d.ts"
+      ],
+      "Cache": [
+        "./dist/dts/Cache.d.ts"
+      ],
+      "Cause": [
+        "./dist/dts/Cause.d.ts"
+      ],
+      "Channel": [
+        "./dist/dts/Channel.d.ts"
+      ],
+      "ChildExecutorDecision": [
+        "./dist/dts/ChildExecutorDecision.d.ts"
+      ],
+      "Chunk": [
+        "./dist/dts/Chunk.d.ts"
+      ],
+      "Clock": [
+        "./dist/dts/Clock.d.ts"
+      ],
+      "Config": [
+        "./dist/dts/Config.d.ts"
+      ],
+      "ConfigError": [
+        "./dist/dts/ConfigError.d.ts"
+      ],
+      "ConfigProvider": [
+        "./dist/dts/ConfigProvider.d.ts"
+      ],
+      "ConfigProviderPathPatch": [
+        "./dist/dts/ConfigProviderPathPatch.d.ts"
+      ],
+      "Console": [
+        "./dist/dts/Console.d.ts"
+      ],
+      "Context": [
+        "./dist/dts/Context.d.ts"
+      ],
+      "Cron": [
+        "./dist/dts/Cron.d.ts"
+      ],
+      "Data": [
+        "./dist/dts/Data.d.ts"
+      ],
+      "DateTime": [
+        "./dist/dts/DateTime.d.ts"
+      ],
+      "DefaultServices": [
+        "./dist/dts/DefaultServices.d.ts"
+      ],
+      "Deferred": [
+        "./dist/dts/Deferred.d.ts"
+      ],
+      "Differ": [
+        "./dist/dts/Differ.d.ts"
+      ],
+      "Duration": [
+        "./dist/dts/Duration.d.ts"
+      ],
+      "Effect": [
+        "./dist/dts/Effect.d.ts"
+      ],
+      "Effectable": [
+        "./dist/dts/Effectable.d.ts"
+      ],
+      "Either": [
+        "./dist/dts/Either.d.ts"
+      ],
+      "Encoding": [
+        "./dist/dts/Encoding.d.ts"
+      ],
+      "Equal": [
+        "./dist/dts/Equal.d.ts"
+      ],
+      "Equivalence": [
+        "./dist/dts/Equivalence.d.ts"
+      ],
+      "ExecutionPlan": [
+        "./dist/dts/ExecutionPlan.d.ts"
+      ],
+      "ExecutionStrategy": [
+        "./dist/dts/ExecutionStrategy.d.ts"
+      ],
+      "Exit": [
+        "./dist/dts/Exit.d.ts"
+      ],
+      "FastCheck": [
+        "./dist/dts/FastCheck.d.ts"
+      ],
+      "Fiber": [
+        "./dist/dts/Fiber.d.ts"
+      ],
+      "FiberHandle": [
+        "./dist/dts/FiberHandle.d.ts"
+      ],
+      "FiberId": [
+        "./dist/dts/FiberId.d.ts"
+      ],
+      "FiberMap": [
+        "./dist/dts/FiberMap.d.ts"
+      ],
+      "FiberRef": [
+        "./dist/dts/FiberRef.d.ts"
+      ],
+      "FiberRefs": [
+        "./dist/dts/FiberRefs.d.ts"
+      ],
+      "FiberRefsPatch": [
+        "./dist/dts/FiberRefsPatch.d.ts"
+      ],
+      "FiberSet": [
+        "./dist/dts/FiberSet.d.ts"
+      ],
+      "FiberStatus": [
+        "./dist/dts/FiberStatus.d.ts"
+      ],
+      "Function": [
+        "./dist/dts/Function.d.ts"
+      ],
+      "GlobalValue": [
+        "./dist/dts/GlobalValue.d.ts"
+      ],
+      "Graph": [
+        "./dist/dts/Graph.d.ts"
+      ],
+      "GroupBy": [
+        "./dist/dts/GroupBy.d.ts"
+      ],
+      "HKT": [
+        "./dist/dts/HKT.d.ts"
+      ],
+      "Hash": [
+        "./dist/dts/Hash.d.ts"
+      ],
+      "HashMap": [
+        "./dist/dts/HashMap.d.ts"
+      ],
+      "HashRing": [
+        "./dist/dts/HashRing.d.ts"
+      ],
+      "HashSet": [
+        "./dist/dts/HashSet.d.ts"
+      ],
+      "Inspectable": [
+        "./dist/dts/Inspectable.d.ts"
+      ],
+      "Iterable": [
+        "./dist/dts/Iterable.d.ts"
+      ],
+      "JSONSchema": [
+        "./dist/dts/JSONSchema.d.ts"
+      ],
+      "KeyedPool": [
+        "./dist/dts/KeyedPool.d.ts"
+      ],
+      "Layer": [
+        "./dist/dts/Layer.d.ts"
+      ],
+      "LayerMap": [
+        "./dist/dts/LayerMap.d.ts"
+      ],
+      "List": [
+        "./dist/dts/List.d.ts"
+      ],
+      "LogLevel": [
+        "./dist/dts/LogLevel.d.ts"
+      ],
+      "LogSpan": [
+        "./dist/dts/LogSpan.d.ts"
+      ],
+      "Logger": [
+        "./dist/dts/Logger.d.ts"
+      ],
+      "Mailbox": [
+        "./dist/dts/Mailbox.d.ts"
+      ],
+      "ManagedRuntime": [
+        "./dist/dts/ManagedRuntime.d.ts"
+      ],
+      "Match": [
+        "./dist/dts/Match.d.ts"
+      ],
+      "MergeDecision": [
+        "./dist/dts/MergeDecision.d.ts"
+      ],
+      "MergeState": [
+        "./dist/dts/MergeState.d.ts"
+      ],
+      "MergeStrategy": [
+        "./dist/dts/MergeStrategy.d.ts"
+      ],
+      "Metric": [
+        "./dist/dts/Metric.d.ts"
+      ],
+      "MetricBoundaries": [
+        "./dist/dts/MetricBoundaries.d.ts"
+      ],
+      "MetricHook": [
+        "./dist/dts/MetricHook.d.ts"
+      ],
+      "MetricKey": [
+        "./dist/dts/MetricKey.d.ts"
+      ],
+      "MetricKeyType": [
+        "./dist/dts/MetricKeyType.d.ts"
+      ],
+      "MetricLabel": [
+        "./dist/dts/MetricLabel.d.ts"
+      ],
+      "MetricPair": [
+        "./dist/dts/MetricPair.d.ts"
+      ],
+      "MetricPolling": [
+        "./dist/dts/MetricPolling.d.ts"
+      ],
+      "MetricRegistry": [
+        "./dist/dts/MetricRegistry.d.ts"
+      ],
+      "MetricState": [
+        "./dist/dts/MetricState.d.ts"
+      ],
+      "Micro": [
+        "./dist/dts/Micro.d.ts"
+      ],
+      "ModuleVersion": [
+        "./dist/dts/ModuleVersion.d.ts"
+      ],
+      "MutableHashMap": [
+        "./dist/dts/MutableHashMap.d.ts"
+      ],
+      "MutableHashSet": [
+        "./dist/dts/MutableHashSet.d.ts"
+      ],
+      "MutableList": [
+        "./dist/dts/MutableList.d.ts"
+      ],
+      "MutableQueue": [
+        "./dist/dts/MutableQueue.d.ts"
+      ],
+      "MutableRef": [
+        "./dist/dts/MutableRef.d.ts"
+      ],
+      "NonEmptyIterable": [
+        "./dist/dts/NonEmptyIterable.d.ts"
+      ],
+      "Number": [
+        "./dist/dts/Number.d.ts"
+      ],
+      "Option": [
+        "./dist/dts/Option.d.ts"
+      ],
+      "Order": [
+        "./dist/dts/Order.d.ts"
+      ],
+      "Ordering": [
+        "./dist/dts/Ordering.d.ts"
+      ],
+      "ParseResult": [
+        "./dist/dts/ParseResult.d.ts"
+      ],
+      "PartitionedSemaphore": [
+        "./dist/dts/PartitionedSemaphore.d.ts"
+      ],
+      "Pipeable": [
+        "./dist/dts/Pipeable.d.ts"
+      ],
+      "Pool": [
+        "./dist/dts/Pool.d.ts"
+      ],
+      "Predicate": [
+        "./dist/dts/Predicate.d.ts"
+      ],
+      "Pretty": [
+        "./dist/dts/Pretty.d.ts"
+      ],
+      "PrimaryKey": [
+        "./dist/dts/PrimaryKey.d.ts"
+      ],
+      "PubSub": [
+        "./dist/dts/PubSub.d.ts"
+      ],
+      "Queue": [
+        "./dist/dts/Queue.d.ts"
+      ],
+      "Random": [
+        "./dist/dts/Random.d.ts"
+      ],
+      "RateLimiter": [
+        "./dist/dts/RateLimiter.d.ts"
+      ],
+      "RcMap": [
+        "./dist/dts/RcMap.d.ts"
+      ],
+      "RcRef": [
+        "./dist/dts/RcRef.d.ts"
+      ],
+      "Readable": [
+        "./dist/dts/Readable.d.ts"
+      ],
+      "Record": [
+        "./dist/dts/Record.d.ts"
+      ],
+      "RedBlackTree": [
+        "./dist/dts/RedBlackTree.d.ts"
+      ],
+      "Redacted": [
+        "./dist/dts/Redacted.d.ts"
+      ],
+      "Ref": [
+        "./dist/dts/Ref.d.ts"
+      ],
+      "RegExp": [
+        "./dist/dts/RegExp.d.ts"
+      ],
+      "Reloadable": [
+        "./dist/dts/Reloadable.d.ts"
+      ],
+      "Request": [
+        "./dist/dts/Request.d.ts"
+      ],
+      "RequestBlock": [
+        "./dist/dts/RequestBlock.d.ts"
+      ],
+      "RequestResolver": [
+        "./dist/dts/RequestResolver.d.ts"
+      ],
+      "Resource": [
+        "./dist/dts/Resource.d.ts"
+      ],
+      "Runtime": [
+        "./dist/dts/Runtime.d.ts"
+      ],
+      "RuntimeFlags": [
+        "./dist/dts/RuntimeFlags.d.ts"
+      ],
+      "RuntimeFlagsPatch": [
+        "./dist/dts/RuntimeFlagsPatch.d.ts"
+      ],
+      "STM": [
+        "./dist/dts/STM.d.ts"
+      ],
+      "Schedule": [
+        "./dist/dts/Schedule.d.ts"
+      ],
+      "ScheduleDecision": [
+        "./dist/dts/ScheduleDecision.d.ts"
+      ],
+      "ScheduleInterval": [
+        "./dist/dts/ScheduleInterval.d.ts"
+      ],
+      "ScheduleIntervals": [
+        "./dist/dts/ScheduleIntervals.d.ts"
+      ],
+      "Scheduler": [
+        "./dist/dts/Scheduler.d.ts"
+      ],
+      "Schema": [
+        "./dist/dts/Schema.d.ts"
+      ],
+      "SchemaAST": [
+        "./dist/dts/SchemaAST.d.ts"
+      ],
+      "Scope": [
+        "./dist/dts/Scope.d.ts"
+      ],
+      "ScopedCache": [
+        "./dist/dts/ScopedCache.d.ts"
+      ],
+      "ScopedRef": [
+        "./dist/dts/ScopedRef.d.ts"
+      ],
+      "Secret": [
+        "./dist/dts/Secret.d.ts"
+      ],
+      "SingleProducerAsyncInput": [
+        "./dist/dts/SingleProducerAsyncInput.d.ts"
+      ],
+      "Sink": [
+        "./dist/dts/Sink.d.ts"
+      ],
+      "SortedMap": [
+        "./dist/dts/SortedMap.d.ts"
+      ],
+      "SortedSet": [
+        "./dist/dts/SortedSet.d.ts"
+      ],
+      "Stream": [
+        "./dist/dts/Stream.d.ts"
+      ],
+      "StreamEmit": [
+        "./dist/dts/StreamEmit.d.ts"
+      ],
+      "StreamHaltStrategy": [
+        "./dist/dts/StreamHaltStrategy.d.ts"
+      ],
+      "Streamable": [
+        "./dist/dts/Streamable.d.ts"
+      ],
+      "String": [
+        "./dist/dts/String.d.ts"
+      ],
+      "Struct": [
+        "./dist/dts/Struct.d.ts"
+      ],
+      "Subscribable": [
+        "./dist/dts/Subscribable.d.ts"
+      ],
+      "SubscriptionRef": [
+        "./dist/dts/SubscriptionRef.d.ts"
+      ],
+      "Supervisor": [
+        "./dist/dts/Supervisor.d.ts"
+      ],
+      "Symbol": [
+        "./dist/dts/Symbol.d.ts"
+      ],
+      "SynchronizedRef": [
+        "./dist/dts/SynchronizedRef.d.ts"
+      ],
+      "TArray": [
+        "./dist/dts/TArray.d.ts"
+      ],
+      "TDeferred": [
+        "./dist/dts/TDeferred.d.ts"
+      ],
+      "TMap": [
+        "./dist/dts/TMap.d.ts"
+      ],
+      "TPriorityQueue": [
+        "./dist/dts/TPriorityQueue.d.ts"
+      ],
+      "TPubSub": [
+        "./dist/dts/TPubSub.d.ts"
+      ],
+      "TQueue": [
+        "./dist/dts/TQueue.d.ts"
+      ],
+      "TRandom": [
+        "./dist/dts/TRandom.d.ts"
+      ],
+      "TReentrantLock": [
+        "./dist/dts/TReentrantLock.d.ts"
+      ],
+      "TRef": [
+        "./dist/dts/TRef.d.ts"
+      ],
+      "TSemaphore": [
+        "./dist/dts/TSemaphore.d.ts"
+      ],
+      "TSet": [
+        "./dist/dts/TSet.d.ts"
+      ],
+      "TSubscriptionRef": [
+        "./dist/dts/TSubscriptionRef.d.ts"
+      ],
+      "Take": [
+        "./dist/dts/Take.d.ts"
+      ],
+      "TestAnnotation": [
+        "./dist/dts/TestAnnotation.d.ts"
+      ],
+      "TestAnnotationMap": [
+        "./dist/dts/TestAnnotationMap.d.ts"
+      ],
+      "TestAnnotations": [
+        "./dist/dts/TestAnnotations.d.ts"
+      ],
+      "TestClock": [
+        "./dist/dts/TestClock.d.ts"
+      ],
+      "TestConfig": [
+        "./dist/dts/TestConfig.d.ts"
+      ],
+      "TestContext": [
+        "./dist/dts/TestContext.d.ts"
+      ],
+      "TestLive": [
+        "./dist/dts/TestLive.d.ts"
+      ],
+      "TestServices": [
+        "./dist/dts/TestServices.d.ts"
+      ],
+      "TestSized": [
+        "./dist/dts/TestSized.d.ts"
+      ],
+      "Tracer": [
+        "./dist/dts/Tracer.d.ts"
+      ],
+      "Trie": [
+        "./dist/dts/Trie.d.ts"
+      ],
+      "Tuple": [
+        "./dist/dts/Tuple.d.ts"
+      ],
+      "Types": [
+        "./dist/dts/Types.d.ts"
+      ],
+      "Unify": [
+        "./dist/dts/Unify.d.ts"
+      ],
+      "UpstreamPullRequest": [
+        "./dist/dts/UpstreamPullRequest.d.ts"
+      ],
+      "UpstreamPullStrategy": [
+        "./dist/dts/UpstreamPullStrategy.d.ts"
+      ],
+      "Utils": [
+        "./dist/dts/Utils.d.ts"
+      ],
+      "index": [
+        "./dist/dts/index.d.ts"
+      ]
+    }
+  }
+}

backend/node_modules/giget/LICENSE

@@ -0,0 +1,184 @@
+MIT License
+
+Copyright (c) Pooya Parsa <pooya@pi0.io>
+
+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.
+
+---
+
+Third party bundled dependencies
+
+- https://github.com/isaacs/node-tar
+- https://github.com/isaacs/fs-minipass
+
+"""
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+""""
+
+- https://github.com/isaacs/minipass
+
+"""
+The ISC License
+
+Copyright (c) 2017-2023 npm, Inc., Isaac Z. Schlueter, and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+"""
+
+- https://github.com/isaacs/minizlib
+
+"""
+Minizlib was created by Isaac Z. Schlueter.
+It is a derivative work of the Node.js project.
+
+"""
+Copyright (c) 2017-2023 Isaac Z. Schlueter and Contributors
+Copyright (c) 2017-2023 Node.js contributors. All rights reserved.
+Copyright (c) 2017-2023 Joyent, Inc. and other Node contributors. All rights reserved.
+
+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.
+"""
+
+- https://github.com/isaacs/node-mkdirp
+
+"""
+Copyright (c) 2011-2023 James Halliday (mail@substack.net) and Isaac Z. Schlueter (i@izs.me)
+
+This project is free software released under the MIT license:
+
+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.
+"""
+
+- https://github.com/isaacs/yallist/blob/main/LICENSE.md
+- https://github.com/isaacs/chownr/blob/main/LICENSE.md
+
+"""
+
+# Blue Oak Model License
+
+Version 1.0.0
+
+## Purpose
+
+This license gives everyone as much permission to work with
+this software as possible, while protecting contributors
+from liability.
+
+## Acceptance
+
+In order to receive this license, you must agree to its
+rules. The rules of this license are both obligations
+under that agreement and conditions to your license.
+You must not do anything with this software that triggers
+a rule that you cannot or will not follow.
+
+## Copyright
+
+Each contributor licenses you to do everything with this
+software that would otherwise infringe that contributor's
+copyright in it.
+
+## Notices
+
+You must ensure that everyone who gets a copy of
+any part of this software from you, with or without
+changes, also gets the text of this license or a link to
+<https://blueoakcouncil.org/license/1.0.0>.
+
+## Excuse
+
+If anyone notifies you in writing that you have not
+complied with [Notices](#notices), you can keep your
+license by taking all practical steps to comply within 30
+days after the notice. If you do not do so, your license
+ends immediately.
+
+## Patent
+
+Each contributor licenses you to do everything with this
+software that would otherwise infringe any patent claims
+they can license or become able to license.
+
+## Reliability
+
+No contributor can revoke this license.
+
+## No Liability
+
+**_As far as the law allows, this software comes as is,
+without any warranty or condition, and no contributor
+will be liable to anyone for any damages related to this
+software or this license, under any kind of legal claim._**
+"""

backend/node_modules/giget/README.md

@@ -0,0 +1,248 @@
+# giget
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![Codecov][codecov-src]][codecov-href]
+
+> Download templates and git repositories with pleasure!
+
+## Features
+
+✨ Support popular git providers (GitHub, GitLab, Bitbucket, Sourcehut) out of the box.
+
+✨ Built-in and custom [template registry](#template-registry).
+
+✨ Fast cloning using tarball gzip without depending on local `git` and `tar`.
+
+✨ Works online and offline with disk cache support.
+
+✨ Custom template provider support with programmatic usage.
+
+✨ Support extracting with a sub dir.
+
+✨ Authorization support to download private templates
+
+✨ Optionally install dependencies after clone using [unjs/nypm](https://github.com/unjs/nypm)
+
+✨ HTTP proxy support and native fetch via [unjs/node-fetch-native](https://github.com/unjs/node-fetch-native)
+
+## Usage (CLI)
+
+```bash
+npx giget@latest <template> [<dir>] [...options]
+```
+
+### Arguments
+
+- **template**: Template name or a URI describing provider, repository, sub dir, and branch/ref. (See [Examples](#examples))
+- **dir**: A relative or absolute path where to extract the template.
+
+### Options
+
+- `--force`: Clone to existing directory even if exists.
+- `--offline`: Do not attempt to download and use the cached version.
+- `--prefer-offline`: Use cache if exists otherwise try to download.
+- `--force-clean`: ⚠️ Remove any existing directory or file recursively before cloning.
+- `--shell`: ⚠️ Open a new shell with the current working directory in cloned dir. (Experimental).
+- `--registry`: URL to a custom registry. (Can be overridden with `GIGET_REGISTRY` environment variable).
+- `--no-registry`: Disable registry lookup and functionality.
+- `--verbose`: Show verbose debugging info.
+- `--cwd`: Set the current working directory to resolve dirs relative to it.
+- `--auth`: Custom Authorization token to use for downloading template. (Can be overridden with `GIGET_AUTH` environment variable).
+- `--install`: Install dependencies after cloning using [unjs/nypm](https://github.com/unjs/nypm).
+
+### Examples
+
+```sh
+# Clone nuxt starter from giget template registry
+npx giget@latest nuxt
+
+# Clone the main branch of github.com/unjs/template to unjs-template directory
+npx giget@latest gh:unjs/template
+
+# Clone to myProject directory
+npx giget@latest gh:unjs/template myProject
+
+# Clone dev branch
+npx giget@latest gh:unjs/template#dev
+
+# Clone /test directory from main branch
+npx giget@latest gh:unjs/template/test
+
+# Clone from gitlab
+npx giget@latest gitlab:unjs/template
+
+# Clone from bitbucket
+npx giget@latest bitbucket:unjs/template
+
+# Clone from sourcehut
+npx giget@latest sourcehut:pi0/unjs-template
+
+# Clone from https URL (tarball)
+npx giget@latest https://api.github.com/repos/unjs/template/tarball/main
+
+# Clone from https URL (JSON)
+npx giget@latest https://raw.githubusercontent.com/unjs/giget/main/templates/unjs.json
+```
+
+## Template Registry
+
+Giget has a built-in HTTP registry system for resolving templates. This way you can support template name shortcuts and meta-data. The default registry is served from [unjs/giget/templates](./templates/).
+
+If you want to add your template to the built-in registry, just drop a PR to add it to the [./templates](./templates) directory. Slugs are added on a first-come first-served basis but this might change in the future.
+
+### Custom Registry
+
+A custom registry should provide an endpoint with the dynamic path `/:template.json` that returns a JSON response with keys the same as [custom providers](#custom-providers).
+
+- `name`: (required) Name of the template.
+- `tar` (required) Link to the tar download link.
+- `defaultDir`: (optional) Default cloning directory.
+- `url`: (optional) Webpage of the template.
+- `subdir`: (optional) Directory inside the tar file.
+- `headers`: (optional) Custom headers to send while downloading template.
+
+Because of the simplicity, you can even use a GitHub repository as a template registry but also you can build something more powerful by bringing your own API.
+
+## Usage (Programmatic)
+
+Install package:
+
+```sh
+# npm
+npm install giget
+
+# yarn
+yarn install giget
+
+# pnpm
+pnpm install giget
+```
+
+Import:
+
+```js
+// ESM
+import { downloadTemplate } from "giget";
+
+// CommonJS
+const { downloadTemplate } = require("giget");
+```
+
+### `downloadTemplate(source, options?)`
+
+**Example:**
+
+```js
+const { source, dir } = await downloadTemplate("github:unjs/template");
+```
+
+**Options:**
+
+- `source`: (string) Input source in format of `[provider]:repo[/subpath][#ref]`.
+- `options`: (object) Options are usually inferred from the input string. You can customize them.
+  - `dir`: (string) Destination directory to clone to. If not provided, `user-name` will be used relative to the current directory.
+  - `provider`: (string) Either `github`, `gitlab`, `bitbucket` or `sourcehut`. The default is `github`.
+  - `force`: (boolean) Extract to the existing dir even if already exists.
+  - `forceClean`: (boolean) ⚠️ Clean up any existing directory or file before cloning.
+  - `offline`: (boolean) Do not attempt to download and use the cached version.
+  - `preferOffline`: (boolean) Use cache if exists otherwise try to download.
+  - `providers`: (object) A map from provider name to custom providers. Can be used to override built-ins too.
+  - `registry`: (string or false) Set to `false` to disable registry. Set to a URL string (without trailing slash) for custom registry. (Can be overridden with `GIGET_REGISTRY` environment variable).
+  - `cwd`: (string) Current working directory to resolve dirs relative to it.
+  - `auth`: (string) Custom Authorization token to use for downloading template. (Can be overridden with `GIGET_AUTH` environment variable).
+
+**Return value:**
+
+The return value is a promise that resolves to the resolved template.
+
+- `dir`: (string) Path to extracted dir.
+- `source`: (string) Normalized version of the input source without provider.
+- [other provider template keys]
+  - `url`: (string) URL of the repository that can be opened in the browser. Useful for logging.
+
+## Custom Providers
+
+Using the programmatic method, you can make your custom template providers.
+
+```ts
+import type { TemplateProvider } from "giget";
+
+const rainbow: TemplateProvider = async (input, { auth }) => {
+  return {
+    name: "rainbow",
+    version: input,
+    headers: { authorization: auth },
+    url: `https://rainbow.template/?variant=${input}`,
+    tar: `https://rainbow.template/dl/rainbow.${input}.tar.gz`,
+  };
+};
+
+const { source, dir } = await downloadTemplate("rainbow:one", {
+  providers: { rainbow },
+});
+```
+
+### Custom Registry Providers
+
+You can define additional [custom registry](#custom-registry) providers using `registryProvider` utility and register to `providers`.
+
+```ts
+import { registryProvider } from "giget";
+
+const themes = registryProvider(
+  "https://raw.githubusercontent.com/unjs/giget/main/templates",
+);
+
+const { source, dir } = await downloadTemplate("themes:test", {
+  providers: { themes },
+});
+```
+
+## Providing token for private repositories
+
+For private repositories and sources, you might need a token. In order to provide it, using CLI, you can use `--auth`, using programmatic API using `auth` option and in both modes also it is possible to use `GIGET_AUTH` environment variable to set it. The value will be set in `Authorization: Bearer ...` header by default.
+
+**Note:** For github private repository access with Fine-grained access tokens, you need to give **Contents** and **Metadata** repository permissions.
+
+### GitHub Actions
+
+If your project depends on a private GitHub repository, you need to add the access token as a secret. Please see GitHub Actions docs on [creating secrets for a repository](https://docs.github.com/en/actions/security-for-github-actions/security-guides/using-secrets-in-github-actions#creating-secrets-for-a-repository). In your workflow, refer to the token as shown in the example below:
+
+```yml
+- name: Install packages
+  run: npm ci
+  env:
+    GIGET_AUTH: ${{ secrets.GIGET_AUTH }}
+```
+
+
+## Related projects
+
+Giget wouldn't be possible without inspiration from former projects. In comparison, giget does not depend on any local command which increases stability and performance and supports custom template providers, auth, and many more features out of the box.
+
+- https://github.com/samsonjs/gitter
+- https://github.com/tiged/tiged
+- https://github.com/Rich-Harris/degit
+
+## 💻 Development
+
+- Clone this repository
+- Enable [Corepack](https://github.com/nodejs/corepack) using `corepack enable` (use `npm i -g corepack` for Node.js < 16.10)
+- Install dependencies using `pnpm install`
+- Run interactive tests using `pnpm dev`
+
+## License
+
+Made with 💛
+
+Published under [MIT License](./LICENSE).
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/giget?style=flat&colorA=18181B&colorB=F0DB4F
+[npm-version-href]: https://npmjs.com/package/giget
+[npm-downloads-src]: https://img.shields.io/npm/dm/giget?style=flat&colorA=18181B&colorB=F0DB4F
+[npm-downloads-href]: https://npmjs.com/package/giget
+[codecov-src]: https://img.shields.io/codecov/c/gh/unjs/giget/main?style=flat&colorA=18181B&colorB=F0DB4F
+[codecov-href]: https://codecov.io/gh/unjs/giget

backend/node_modules/giget/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "giget",
+  "version": "2.0.0",
+  "description": "Download templates and git repositories with pleasure!",
+  "repository": "unjs/giget",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "types": "./dist/index.d.mts",
+  "bin": {
+    "giget": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "unbuild",
+    "dev": "vitest dev",
+    "giget": "jiti ./src/cli.ts",
+    "lint": "eslint . && prettier -c src test",
+    "lint:fix": "eslint . --fix && prettier -w src test",
+    "prepack": "unbuild",
+    "play": "pnpm giget --force-clean --verbose unjs .tmp/clone",
+    "release": "pnpm test && changelogen --release && npm publish && git push --follow-tags",
+    "test": "pnpm lint && vitest run --coverage"
+  },
+  "dependencies": {
+    "citty": "^0.1.6",
+    "consola": "^3.4.0",
+    "defu": "^6.1.4",
+    "node-fetch-native": "^1.6.6",
+    "nypm": "^0.6.0",
+    "pathe": "^2.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.5",
+    "@types/tar": "^6.1.13",
+    "@vitest/coverage-v8": "^3.0.7",
+    "changelogen": "^0.5.7",
+    "esbuild": "^0.25.0",
+    "eslint": "^9.21.0",
+    "eslint-config-unjs": "^0.4.2",
+    "jiti": "^2.4.2",
+    "prettier": "^3.5.2",
+    "tar": "^6.2.1",
+    "typescript": "^5.7.3",
+    "unbuild": "^3.3.1",
+    "vitest": "^3.0.7"
+  },
+  "packageManager": "pnpm@10.5.0",
+  "pnpm": {
+    "patchedDependencies": {
+      "tar": "patches/tar.patch"
+    }
+  }
+}

backend/node_modules/perfect-debounce/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Pooya Parsa <pooya@pi0.io>
+
+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.

backend/node_modules/perfect-debounce/README.md

@@ -0,0 +1,92 @@
+# perfect-debounce
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![Github Actions][github-actions-src]][github-actions-href]
+[![Codecov][codecov-src]][codecov-href]
+
+> An improved debounce function with Promise support.
+
+- Well tested debounce implementation
+- Native Promise support
+- Avoid duplicate calls while promise is being resolved
+- Configurable `trailing` and `leading` behavior
+
+## Usage
+
+Install package:
+
+```sh
+# npm
+npm install perfect-debounce
+
+# yarn
+yarn add perfect-debounce
+
+# pnpm
+pnpm add perfect-debounce
+```
+
+Import:
+
+```js
+// ESM
+import { debounce } from 'perfect-debounce'
+
+// CommonJS
+const { debounce } = require('perfect-debounce')
+```
+
+Debounce function:
+
+```js
+const debounced = debounce(async () => {
+  // Some heavy stuff
+}, 25)
+```
+
+When calling `debounced`, it will wait at least for `25ms` as configured before actually calling our function. This helps to avoid multiple calls.
+
+To avoid initial wait, we can set `leading: true` option. It will cause function to be immediately called if there is no other call:
+
+```js
+const debounced = debounce(async () => {
+  // Some heavy stuff
+}, 25, { leading: true })
+```
+
+If executing async function takes longer than debounce value, duplicate calls will be still prevented a last call will happen. To disable this behavior, we can set `trailing: false` option:
+
+```js
+const debounced = debounce(async () => {
+  // Some heavy stuff
+}, 25, { trailing: false })
+```
+
+## 💻 Development
+
+- Clone this repository
+- Enable [Corepack](https://github.com/nodejs/corepack) using `corepack enable` (use `npm i -g corepack` for Node.js < 16.10)
+- Install dependencies using `pnpm install`
+- Run interactive tests using `pnpm dev`
+
+## License
+
+Made with 💛
+
+Based on [sindresorhus/p-debounce](https://github.com/sindresorhus/p-debounce).
+
+Published under [MIT License](./LICENSE).
+
+<!-- Badges -->
+[npm-version-src]: https://img.shields.io/npm/v/perfect-debounce?style=flat-square
+[npm-version-href]: https://npmjs.com/package/perfect-debounce
+
+[npm-downloads-src]: https://img.shields.io/npm/dm/perfect-debounce?style=flat-square
+[npm-downloads-href]: https://npmjs.com/package/perfect-debounce
+
+[github-actions-src]: https://img.shields.io/github/workflow/status/unjs/perfect-debounce/ci/main?style=flat-square
+[github-actions-href]: https://github.com/unjs/perfect-debounce/actions?query=workflow%3Aci
+
+[codecov-src]: https://img.shields.io/codecov/c/gh/unjs/perfect-debounce/main?style=flat-square
+[codecov-href]: https://codecov.io/gh/unjs/perfect-debounce

backend/node_modules/perfect-debounce/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "perfect-debounce",
+  "version": "1.0.0",
+  "description": "",
+  "repository": "unjs/perfect-debounce",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "unbuild",
+    "dev": "vitest dev",
+    "lint": "eslint --ext .ts,.js,.mjs,.cjs . && prettier --check src test",
+    "lint:fix": "eslint --ext .ts,.js,.mjs,.cjs . --fix && prettier -w src test",
+    "release": "pnpm test && pnpm build && changelogen --release --push && npm publish",
+    "test": "vitest run --coverage"
+  },
+  "devDependencies": {
+    "@types/node": "^18.16.3",
+    "@vitest/coverage-c8": "^0.31.0",
+    "changelogen": "^0.5.3",
+    "eslint": "^8.39.0",
+    "eslint-config-unjs": "^0.1.0",
+    "in-range": "^3.0.0",
+    "prettier": "^2.8.8",
+    "time-span": "^5.1.0",
+    "typescript": "^5.0.4",
+    "unbuild": "^1.2.1",
+    "vitest": "^0.31.0"
+  },
+  "packageManager": "pnpm@8.4.0"
+}

backend/node_modules/prisma/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

backend/node_modules/prisma/README.md

@@ -0,0 +1,86 @@
+<div align="center">
+  <h1>Prisma</h1>
+  <a href="https://www.npmjs.com/package/prisma"><img src="https://img.shields.io/npm/v/prisma.svg?style=flat" /></a>
+  <a href="https://github.com/prisma/prisma/blob/main/CONTRIBUTING.md"><img src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg" /></a>
+  <a href="https://github.com/prisma/prisma/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-Apache%202-blue" /></a>
+  <a href="https://pris.ly/discord"><img alt="Discord" src="https://img.shields.io/discord/937751382725886062?label=Discord"></a>
+  <br />
+  <br />
+  <a href="https://www.prisma.io/docs/getting-started/quickstart">Quickstart</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://www.prisma.io/">Website</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://www.prisma.io/docs/">Docs</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://github.com/prisma/prisma-examples/">Examples</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://www.prisma.io/blog">Blog</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://pris.ly/discord">Discord</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://twitter.com/prisma">Twitter</a>
+  <br />
+  <hr />
+</div>
+
+## What is Prisma?
+
+Prisma is a **next-generation ORM** that consists of these tools:
+
+- [**Prisma Client**](https://www.prisma.io/docs/concepts/components/prisma-client): Auto-generated and type-safe query builder for Node.js & TypeScript
+- [**Prisma Migrate**](https://www.prisma.io/docs/concepts/components/prisma-migrate): Declarative data modeling & migration system
+- [**Prisma Studio**](https://github.com/prisma/studio): GUI to view and edit data in your database
+
+Prisma Client can be used in _any_ Node.js or TypeScript backend application (including serverless applications and microservices). This can be a [REST API](https://www.prisma.io/docs/concepts/overview/prisma-in-your-stack/rest), a [GraphQL API](https://www.prisma.io/docs/concepts/overview/prisma-in-your-stack/graphql) a gRPC API, or anything else that needs a database.
+
+**If you need a database to use with Prisma ORM, check out [Prisma Postgres](https://www.prisma.io/docs/getting-started/quickstart-prismaPostgres?utm_source=npm&utm_medium=readme) or if you are looking for our MCP Server, head [here](https://github.com/prisma/mcp).**
+
+## Getting started
+
+The fastest way to get started with Prisma is by following the [**Quickstart (5 min)**](https://pris.ly/quickstart).
+
+The Quickstart is based on a preconfigured SQLite database. You can also get started with your own database (PostgreSQL and MySQL) by following one of these guides:
+
+- [Add Prisma to an existing project](https://www.prisma.io/docs/getting-started/setup-prisma/add-to-existing-project/relational-databases-typescript-postgresql)
+- [Set up a new project with Prisma from scratch](https://www.prisma.io/docs/getting-started/setup-prisma/start-from-scratch/relational-databases-typescript-postgresql)
+
+## Community
+
+Prisma has a large and supportive [community](https://www.prisma.io/community) of enthusiastic application developers. You can join us on [Discord](https://pris.ly/discord) and here on [GitHub](https://github.com/prisma/prisma/discussions).
+
+## Security
+
+If you have a security issue to report, please contact us at [security@prisma.io](mailto:security@prisma.io?subject=[GitHub]%20Prisma%202%20Security%20Report%20).
+
+## Support
+
+### Ask a question about Prisma
+
+You can ask questions and initiate [discussions](https://github.com/prisma/prisma/discussions/) about Prisma-related topics in the `prisma` repository on GitHub.
+
+👉 [**Ask a question**](https://github.com/prisma/prisma/discussions/new)
+
+### Create a bug report for Prisma
+
+If you see an error message or run into an issue, please make sure to create a bug report! You can find [best practices for creating bug reports](https://www.prisma.io/docs/guides/other/troubleshooting-orm/creating-bug-reports) (like including additional debugging output) in the docs.
+
+👉 [**Create bug report**](https://pris.ly/prisma-prisma-bug-report)
+
+### Submit a feature request
+
+If Prisma currently doesn't have a certain feature, be sure to check out the [roadmap](https://www.prisma.io/docs/more/roadmap) to see if this is already planned for the future.
+
+If the feature on the roadmap is linked to a GitHub issue, please make sure to leave a +1 on the issue and ideally a comment with your thoughts about the feature!
+
+👉 [**Submit feature request**](https://github.com/prisma/prisma/issues/new?assignees=&labels=&template=feature_request.md&title=)
+
+## Contributing
+
+Refer to our [contribution guidelines](https://github.com/prisma/prisma/blob/main/CONTRIBUTING.md) and [Code of Conduct for contributors](https://github.com/prisma/prisma/blob/main/CODE_OF_CONDUCT.md).
+
+## Tests Status
+
+- Prisma Tests Status:  
+  [![CI](https://github.com/prisma/prisma/actions/workflows/test.yml/badge.svg)](https://github.com/prisma/prisma/actions/workflows/test.yml)
+- Ecosystem Tests Status:  
+  [![Actions Status](https://github.com/prisma/ecosystem-tests/workflows/test/badge.svg)](https://github.com/prisma/ecosystem-tests/actions)

backend/node_modules/prisma/config.d.ts

@@ -0,0 +1 @@
+export { defineConfig, env, type PrismaConfig, type PrismaConfigInternal } from '@prisma/config';

backend/node_modules/prisma/config.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var config_exports = {};
+__export(config_exports, {
+  defineConfig: () => import_config.defineConfig,
+  env: () => import_config.env
+});
+module.exports = __toCommonJS(config_exports);
+var import_config = require("@prisma/config");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineConfig,
+  env
+});

backend/node_modules/prisma/package.json

@@ -0,0 +1,180 @@
+{
+  "version": "6.19.3",
+  "name": "prisma",
+  "description": "Prisma is an open-source database toolkit. It includes a JavaScript/TypeScript ORM for Node.js, migrations and a modern GUI to view and edit the data in your database. You can use Prisma in new projects or add it to an existing one.",
+  "keywords": [
+    "CLI",
+    "ORM",
+    "Prisma",
+    "Prisma CLI",
+    "prisma2",
+    "database",
+    "db",
+    "JavaScript",
+    "JS",
+    "TypeScript",
+    "TS",
+    "SQL",
+    "SQLite",
+    "pg",
+    "Postgres",
+    "PostgreSQL",
+    "CockroachDB",
+    "MySQL",
+    "MariaDB",
+    "MSSQL",
+    "SQL Server",
+    "SQLServer",
+    "MongoDB",
+    "MCP"
+  ],
+  "main": "build/index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prisma/prisma.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://www.prisma.io",
+  "author": "Tim Suchanek <suchanek@prisma.io>",
+  "bugs": "https://github.com/prisma/prisma/issues",
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=18.18"
+  },
+  "prisma": {
+    "prismaCommit": "727a61ae916846267a98358d103b3e8a2afebd45"
+  },
+  "files": [
+    "README.md",
+    "build",
+    "config.js",
+    "config.d.ts",
+    "dist/cli/src/types.d.ts",
+    "install",
+    "runtime/*.js",
+    "runtime/*.d.ts",
+    "runtime/utils",
+    "runtime/dist",
+    "runtime/llhttp",
+    "prisma-client",
+    "preinstall",
+    "scripts/preinstall-entry.js"
+  ],
+  "pkg": {
+    "assets": [
+      "build/**/*",
+      "runtime/**/*",
+      "prisma-client/**/*",
+      "node_modules/@prisma/engines/**/*",
+      "node_modules/@prisma/engines/*"
+    ]
+  },
+  "bin": {
+    "prisma": "build/index.js"
+  },
+  "types": "./dist/cli/src/types.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "require": {
+        "types": "./dist/cli/src/types.d.ts",
+        "default": "./build/types.js"
+      },
+      "import": {
+        "types": "./dist/cli/src/types.d.ts",
+        "default": "./build/types.js"
+      },
+      "default": "./build/types.js"
+    },
+    "./config": {
+      "require": {
+        "types": "./config.d.ts",
+        "default": "./config.js"
+      },
+      "import": {
+        "types": "./config.d.ts",
+        "default": "./config.js"
+      },
+      "default": "./config.js"
+    },
+    "./build/index.js": {
+      "require": {
+        "types": "./dist/cli/src/types.d.ts",
+        "default": "./build/index.js"
+      },
+      "default": "./build/index.js"
+    }
+  },
+  "devDependencies": {
+    "@inquirer/prompts": "7.3.3",
+    "@libsql/client": "0.8.1",
+    "@modelcontextprotocol/sdk": "1.13.2",
+    "@opentelemetry/api": "1.9.0",
+    "@opentelemetry/context-async-hooks": "2.1.0",
+    "@opentelemetry/sdk-trace-base": "2.1.0",
+    "@prisma/mini-proxy": "0.9.5",
+    "@prisma/studio": "0.511.0",
+    "@prisma/studio-server": "0.511.0",
+    "@swc/core": "1.11.5",
+    "@swc/jest": "0.2.37",
+    "@types/fs-extra": "11.0.4",
+    "@types/jest": "29.5.14",
+    "@types/node": "18.19.76",
+    "async-listen": "3.1.0",
+    "checkpoint-client": "1.1.33",
+    "chokidar": "4.0.3",
+    "env-paths": "2.2.1",
+    "execa": "5.1.1",
+    "fs-extra": "11.3.0",
+    "get-port": "7.1.0",
+    "jest": "29.7.0",
+    "jest-junit": "16.0.0",
+    "kleur": "4.1.5",
+    "line-replace": "2.0.1",
+    "log-update": "6.1.0",
+    "node-fetch": "3.3.2",
+    "npm-packlist": "5.1.3",
+    "open": "7.4.2",
+    "package-up": "5.0.0",
+    "resolve-pkg": "2.0.0",
+    "ts-pattern": "5.6.2",
+    "typescript": "5.4.5",
+    "xdg-app-paths": "8.3.0",
+    "zod": "3.24.2",
+    "@prisma/adapter-libsql": "6.19.3",
+    "@prisma/client-generator-registry": "6.19.3",
+    "@prisma/client": "6.19.3",
+    "@prisma/debug": "6.19.3",
+    "@prisma/dmmf": "6.19.3",
+    "@prisma/driver-adapter-utils": "6.19.3",
+    "@prisma/fetch-engine": "6.19.3",
+    "@prisma/internals": "6.19.3",
+    "@prisma/generator": "6.19.3",
+    "@prisma/get-platform": "6.19.3",
+    "@prisma/migrate": "6.19.3"
+  },
+  "dependencies": {
+    "@prisma/engines": "6.19.3",
+    "@prisma/config": "6.19.3"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.1.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
+  "sideEffects": false,
+  "scripts": {
+    "prisma": "tsx src/bin.ts",
+    "platform": "tsx src/bin.ts platform --early-access",
+    "pm": "tsx src/bin.ts platform --early-access",
+    "dev": "DEV=true tsx helpers/build.ts",
+    "build": "tsx helpers/build.ts",
+    "test": "dotenv -e ../../.db.env -- tsx helpers/run-tests.ts",
+    "test:platform": "dotenv -e ../../.db.env -- tsx helpers/run-tests.ts src/platform",
+    "tsc": "tsc -d -p tsconfig.build.json",
+    "preinstall": "node scripts/preinstall-entry.js"
+  }
+}

backend/node_modules/readdirp/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2012-2019 Thorsten Lorenz, Paul Miller (https://paulmillr.com)
+
+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.

backend/node_modules/readdirp/README.md

@@ -0,0 +1,120 @@
+# readdirp [![Weekly downloads](https://img.shields.io/npm/dw/readdirp.svg)](https://github.com/paulmillr/readdirp)
+
+Recursive version of fs.readdir. Exposes a **stream API** (with small RAM & CPU footprint) and a **promise API**.
+
+```sh
+npm install readdirp
+jsr add jsr:@paulmillr/readdirp
+```
+
+```javascript
+// Use streams to achieve small RAM & CPU footprint.
+// 1) Streams example with for-await.
+import readdirp from 'readdirp';
+for await (const entry of readdirp('.')) {
+  const {path} = entry;
+  console.log(`${JSON.stringify({path})}`);
+}
+
+// 2) Streams example, non for-await.
+// Print out all JS files along with their size within the current folder & subfolders.
+import readdirp from 'readdirp';
+readdirp('.', {alwaysStat: true, fileFilter: (f) => f.basename.endsWith('.js')})
+  .on('data', (entry) => {
+    const {path, stats: {size}} = entry;
+    console.log(`${JSON.stringify({path, size})}`);
+  })
+  // Optionally call stream.destroy() in `warn()` in order to abort and cause 'close' to be emitted
+  .on('warn', error => console.error('non-fatal error', error))
+  .on('error', error => console.error('fatal error', error))
+  .on('end', () => console.log('done'));
+
+// 3) Promise example. More RAM and CPU than streams / for-await.
+import { readdirpPromise } from 'readdirp';
+const files = await readdirpPromise('.');
+console.log(files.map(file => file.path));
+
+// Other options.
+import readdirp from 'readdirp';
+readdirp('test', {
+  fileFilter: (f) => f.basename.endsWith('.js'),
+  directoryFilter: (d) => d.basename !== '.git',
+  // directoryFilter: (di) => di.basename.length === 9
+  type: 'files_directories',
+  depth: 1
+});
+```
+
+## API
+
+`const stream = readdirp(root[, options])` — **Stream API**
+
+- Reads given root recursively and returns a `stream` of [entry infos](#entryinfo)
+- Optionally can be used like `for await (const entry of stream)` with node.js 10+ (`asyncIterator`).
+- `on('data', (entry) => {})` [entry info](#entryinfo) for every file / dir.
+- `on('warn', (error) => {})` non-fatal `Error` that prevents a file / dir from being processed. Example: inaccessible to the user.
+- `on('error', (error) => {})` fatal `Error` which also ends the stream. Example: illegal options where passed.
+- `on('end')` — we are done. Called when all entries were found and no more will be emitted.
+- `on('close')` — stream is destroyed via `stream.destroy()`.
+  Could be useful if you want to manually abort even on a non fatal error.
+  At that point the stream is no longer `readable` and no more entries, warning or errors are emitted
+- To learn more about streams, consult the very detailed [nodejs streams documentation](https://nodejs.org/api/stream.html)
+  or the [stream-handbook](https://github.com/substack/stream-handbook)
+
+`const entries = await readdirp.promise(root[, options])` — **Promise API**. Returns a list of [entry infos](#entryinfo).
+
+First argument is awalys `root`, path in which to start reading and recursing into subdirectories.
+
+### options
+
+- `fileFilter`: filter to include or exclude files
+    - **Function**: a function that takes an entry info as a parameter and returns true to include or false to exclude the entry
+- `directoryFilter`: filter to include/exclude directories found and to recurse into. Directories that do not pass a filter will not be recursed into.
+- `depth: 5`: depth at which to stop recursing even if more subdirectories are found
+- `type: 'files'`: determines if data events on the stream should be emitted for `'files'` (default), `'directories'`, `'files_directories'`, or `'all'`. Setting to `'all'` will also include entries for other types of file descriptors like character devices, unix sockets and named pipes.
+- `alwaysStat: false`: always return `stats` property for every file. Default is `false`, readdirp will return `Dirent` entries. Setting it to `true` can double readdir execution time - use it only when you need file `size`, `mtime` etc. Cannot be enabled on node <10.10.0.
+- `lstat: false`: include symlink entries in the stream along with files. When `true`, `fs.lstat` would be used instead of `fs.stat`
+
+### `EntryInfo`
+
+Has the following properties:
+
+- `path: 'assets/javascripts/react.js'`: path to the file/directory (relative to given root)
+- `fullPath: '/Users/dev/projects/app/assets/javascripts/react.js'`: full path to the file/directory found
+- `basename: 'react.js'`: name of the file/directory
+- `dirent: fs.Dirent`: built-in [dir entry object](https://nodejs.org/api/fs.html#fs_class_fs_dirent) - only with `alwaysStat: false`
+- `stats: fs.Stats`: built in [stat object](https://nodejs.org/api/fs.html#fs_class_fs_stats) - only with `alwaysStat: true`
+
+## Changelog
+
+- 4.0 (Aug 25, 2024) rewritten in typescript, producing hybrid common.js / esm module.
+    - Remove glob support and all dependencies
+    - Make sure you're using `let {readdirp} = require('readdirp')` in common.js
+- 3.5 (Oct 13, 2020) disallows recursive directory-based symlinks.
+  Before, it could have entered infinite loop.
+- 3.4 (Mar 19, 2020) adds support for directory-based symlinks.
+- 3.3 (Dec 6, 2019) stabilizes RAM consumption and enables perf management with `highWaterMark` option. Fixes race conditions related to `for-await` looping.
+- 3.2 (Oct 14, 2019) improves performance by 250% and makes streams implementation more idiomatic.
+- 3.1 (Jul 7, 2019) brings `bigint` support to `stat` output on Windows. This is backwards-incompatible for some cases. Be careful. It you use it incorrectly, you'll see "TypeError: Cannot mix BigInt and other types, use explicit conversions".
+- 3.0 brings huge performance improvements and stream backpressure support.
+- Upgrading 2.x to 3.x:
+    - Signature changed from `readdirp(options)` to `readdirp(root, options)`
+    - Replaced callback API with promise API.
+    - Renamed `entryType` option to `type`
+    - Renamed `entryType: 'both'` to `'files_directories'`
+    - `EntryInfo`
+        - Renamed `stat` to `stats`
+            - Emitted only when `alwaysStat: true`
+            - `dirent` is emitted instead of `stats` by default with `alwaysStat: false`
+        - Renamed `name` to `basename`
+        - Removed `parentDir` and `fullParentDir` properties
+- Supported node.js versions:
+    - 4.x: node 14+
+    - 3.x: node 8+
+    - 2.x: node 0.6+
+
+## License
+
+Copyright (c) 2012-2019 Thorsten Lorenz, Paul Miller (<https://paulmillr.com>)
+
+MIT License, see [LICENSE](LICENSE) file.

backend/node_modules/readdirp/index.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReaddirpStream = exports.EntryTypes = void 0;
+exports.readdirp = readdirp;
+exports.readdirpPromise = readdirpPromise;
+const promises_1 = require("node:fs/promises");
+const node_stream_1 = require("node:stream");
+const node_path_1 = require("node:path");
+exports.EntryTypes = {
+    FILE_TYPE: 'files',
+    DIR_TYPE: 'directories',
+    FILE_DIR_TYPE: 'files_directories',
+    EVERYTHING_TYPE: 'all',
+};
+const defaultOptions = {
+    root: '.',
+    fileFilter: (_entryInfo) => true,
+    directoryFilter: (_entryInfo) => true,
+    type: exports.EntryTypes.FILE_TYPE,
+    lstat: false,
+    depth: 2147483648,
+    alwaysStat: false,
+    highWaterMark: 4096,
+};
+Object.freeze(defaultOptions);
+const RECURSIVE_ERROR_CODE = 'READDIRP_RECURSIVE_ERROR';
+const NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP', RECURSIVE_ERROR_CODE]);
+const ALL_TYPES = [
+    exports.EntryTypes.DIR_TYPE,
+    exports.EntryTypes.EVERYTHING_TYPE,
+    exports.EntryTypes.FILE_DIR_TYPE,
+    exports.EntryTypes.FILE_TYPE,
+];
+const DIR_TYPES = new Set([
+    exports.EntryTypes.DIR_TYPE,
+    exports.EntryTypes.EVERYTHING_TYPE,
+    exports.EntryTypes.FILE_DIR_TYPE,
+]);
+const FILE_TYPES = new Set([
+    exports.EntryTypes.EVERYTHING_TYPE,
+    exports.EntryTypes.FILE_DIR_TYPE,
+    exports.EntryTypes.FILE_TYPE,
+]);
+const isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+const wantBigintFsStats = process.platform === 'win32';
+const emptyFn = (_entryInfo) => true;
+const normalizeFilter = (filter) => {
+    if (filter === undefined)
+        return emptyFn;
+    if (typeof filter === 'function')
+        return filter;
+    if (typeof filter === 'string') {
+        const fl = filter.trim();
+        return (entry) => entry.basename === fl;
+    }
+    if (Array.isArray(filter)) {
+        const trItems = filter.map((item) => item.trim());
+        return (entry) => trItems.some((f) => entry.basename === f);
+    }
+    return emptyFn;
+};
+/** Readable readdir stream, emitting new files as they're being listed. */
+class ReaddirpStream extends node_stream_1.Readable {
+    constructor(options = {}) {
+        super({
+            objectMode: true,
+            autoDestroy: true,
+            highWaterMark: options.highWaterMark,
+        });
+        const opts = { ...defaultOptions, ...options };
+        const { root, type } = opts;
+        this._fileFilter = normalizeFilter(opts.fileFilter);
+        this._directoryFilter = normalizeFilter(opts.directoryFilter);
+        const statMethod = opts.lstat ? promises_1.lstat : promises_1.stat;
+        // Use bigint stats if it's windows and stat() supports options (node 10+).
+        if (wantBigintFsStats) {
+            this._stat = (path) => statMethod(path, { bigint: true });
+        }
+        else {
+            this._stat = statMethod;
+        }
+        this._maxDepth = opts.depth ?? defaultOptions.depth;
+        this._wantsDir = type ? DIR_TYPES.has(type) : false;
+        this._wantsFile = type ? FILE_TYPES.has(type) : false;
+        this._wantsEverything = type === exports.EntryTypes.EVERYTHING_TYPE;
+        this._root = (0, node_path_1.resolve)(root);
+        this._isDirent = !opts.alwaysStat;
+        this._statsProp = this._isDirent ? 'dirent' : 'stats';
+        this._rdOptions = { encoding: 'utf8', withFileTypes: this._isDirent };
+        // Launch stream with one parent, the root dir.
+        this.parents = [this._exploreDir(root, 1)];
+        this.reading = false;
+        this.parent = undefined;
+    }
+    async _read(batch) {
+        if (this.reading)
+            return;
+        this.reading = true;
+        try {
+            while (!this.destroyed && batch > 0) {
+                const par = this.parent;
+                const fil = par && par.files;
+                if (fil && fil.length > 0) {
+                    const { path, depth } = par;
+                    const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));
+                    const awaited = await Promise.all(slice);
+                    for (const entry of awaited) {
+                        if (!entry)
+                            continue;
+                        if (this.destroyed)
+                            return;
+                        const entryType = await this._getEntryType(entry);
+                        if (entryType === 'directory' && this._directoryFilter(entry)) {
+                            if (depth <= this._maxDepth) {
+                                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+                            }
+                            if (this._wantsDir) {
+                                this.push(entry);
+                                batch--;
+                            }
+                        }
+                        else if ((entryType === 'file' || this._includeAsFile(entry)) &&
+                            this._fileFilter(entry)) {
+                            if (this._wantsFile) {
+                                this.push(entry);
+                                batch--;
+                            }
+                        }
+                    }
+                }
+                else {
+                    const parent = this.parents.pop();
+                    if (!parent) {
+                        this.push(null);
+                        break;
+                    }
+                    this.parent = await parent;
+                    if (this.destroyed)
+                        return;
+                }
+            }
+        }
+        catch (error) {
+            this.destroy(error);
+        }
+        finally {
+            this.reading = false;
+        }
+    }
+    async _exploreDir(path, depth) {
+        let files;
+        try {
+            files = await (0, promises_1.readdir)(path, this._rdOptions);
+        }
+        catch (error) {
+            this._onError(error);
+        }
+        return { files, depth, path };
+    }
+    async _formatEntry(dirent, path) {
+        let entry;
+        const basename = this._isDirent ? dirent.name : dirent;
+        try {
+            const fullPath = (0, node_path_1.resolve)((0, node_path_1.join)(path, basename));
+            entry = { path: (0, node_path_1.relative)(this._root, fullPath), fullPath, basename };
+            entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+        }
+        catch (err) {
+            this._onError(err);
+            return;
+        }
+        return entry;
+    }
+    _onError(err) {
+        if (isNormalFlowError(err) && !this.destroyed) {
+            this.emit('warn', err);
+        }
+        else {
+            this.destroy(err);
+        }
+    }
+    async _getEntryType(entry) {
+        // entry may be undefined, because a warning or an error were emitted
+        // and the statsProp is undefined
+        if (!entry && this._statsProp in entry) {
+            return '';
+        }
+        const stats = entry[this._statsProp];
+        if (stats.isFile())
+            return 'file';
+        if (stats.isDirectory())
+            return 'directory';
+        if (stats && stats.isSymbolicLink()) {
+            const full = entry.fullPath;
+            try {
+                const entryRealPath = await (0, promises_1.realpath)(full);
+                const entryRealPathStats = await (0, promises_1.lstat)(entryRealPath);
+                if (entryRealPathStats.isFile()) {
+                    return 'file';
+                }
+                if (entryRealPathStats.isDirectory()) {
+                    const len = entryRealPath.length;
+                    if (full.startsWith(entryRealPath) && full.substr(len, 1) === node_path_1.sep) {
+                        const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+                        // @ts-ignore
+                        recursiveError.code = RECURSIVE_ERROR_CODE;
+                        return this._onError(recursiveError);
+                    }
+                    return 'directory';
+                }
+            }
+            catch (error) {
+                this._onError(error);
+                return '';
+            }
+        }
+    }
+    _includeAsFile(entry) {
+        const stats = entry && entry[this._statsProp];
+        return stats && this._wantsEverything && !stats.isDirectory();
+    }
+}
+exports.ReaddirpStream = ReaddirpStream;
+/**
+ * Streaming version: Reads all files and directories in given root recursively.
+ * Consumes ~constant small amount of RAM.
+ * @param root Root directory
+ * @param options Options to specify root (start directory), filters and recursion depth
+ */
+function readdirp(root, options = {}) {
+    // @ts-ignore
+    let type = options.entryType || options.type;
+    if (type === 'both')
+        type = exports.EntryTypes.FILE_DIR_TYPE; // backwards-compatibility
+    if (type)
+        options.type = type;
+    if (!root) {
+        throw new Error('readdirp: root argument is required. Usage: readdirp(root, options)');
+    }
+    else if (typeof root !== 'string') {
+        throw new TypeError('readdirp: root argument must be a string. Usage: readdirp(root, options)');
+    }
+    else if (type && !ALL_TYPES.includes(type)) {
+        throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(', ')}`);
+    }
+    options.root = root;
+    return new ReaddirpStream(options);
+}
+/**
+ * Promise version: Reads all files and directories in given root recursively.
+ * Compared to streaming version, will consume a lot of RAM e.g. when 1 million files are listed.
+ * @returns array of paths and their entry infos
+ */
+function readdirpPromise(root, options = {}) {
+    return new Promise((resolve, reject) => {
+        const files = [];
+        readdirp(root, options)
+            .on('data', (entry) => files.push(entry))
+            .on('end', () => resolve(files))
+            .on('error', (error) => reject(error));
+    });
+}
+exports.default = readdirp;

backend/node_modules/readdirp/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "readdirp",
+  "description": "Recursive version of fs.readdir with small RAM & CPU footprint.",
+  "version": "4.1.2",
+  "homepage": "https://github.com/paulmillr/readdirp",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/paulmillr/readdirp.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/paulmillr/readdirp/issues"
+  },
+  "author": "Thorsten Lorenz <thlorenz@gmx.de> (thlorenz.com)",
+  "contributors": [
+    "Thorsten Lorenz <thlorenz@gmx.de> (thlorenz.com)",
+    "Paul Miller (https://paulmillr.com)"
+  ],
+  "engines": {
+    "node": ">= 14.18.0"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "index.d.ts.map",
+    "index.js.map",
+    "esm"
+  ],
+  "main": "./index.js",
+  "module": "./esm/index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./index.js"
+    }
+  },
+  "sideEffects": false,
+  "keywords": [
+    "recursive",
+    "fs",
+    "stream",
+    "streams",
+    "readdir",
+    "filesystem",
+    "find",
+    "filter"
+  ],
+  "scripts": {
+    "build": "tsc && tsc -p tsconfig.cjs.json",
+    "lint": "prettier --check index.ts test/index.test.js",
+    "format": "prettier --write index.ts test/index.test.js",
+    "test": "node test/index.test.js",
+    "test:coverage": "c8 node test/index.test.js"
+  },
+  "devDependencies": {
+    "@paulmillr/jsbt": "0.3.1",
+    "@types/node": "20.14.8",
+    "c8": "10.1.3",
+    "chai": "4.3.4",
+    "chai-subset": "1.6.0",
+    "micro-should": "0.5.0",
+    "prettier": "3.1.1",
+    "typescript": "5.5.2"
+  },
+  "funding": {
+    "type": "individual",
+    "url": "https://paulmillr.com/funding/"
+  }
+}

backend/prisma/migrations/20260516071158_init_auth/migration.sql

@@ -0,0 +1,105 @@
+-- CreateTable
+CREATE TABLE "User" (
+    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    "email" TEXT NOT NULL,
+    "passwordHash" TEXT NOT NULL,
+    "role" TEXT NOT NULL DEFAULT 'user',
+    "isActive" BOOLEAN NOT NULL DEFAULT true,
+    "telegramChatId" TEXT,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL
+);
+
+-- CreateTable
+CREATE TABLE "Market" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "question" TEXT NOT NULL,
+    "category" TEXT,
+    "countryCode" TEXT,
+    "yesPrice" REAL,
+    "noPrice" REAL,
+    "volumeEur" REAL,
+    "liquidityEur" REAL,
+    "status" TEXT NOT NULL DEFAULT 'active',
+    "closesAt" DATETIME,
+    "lastSynced" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+-- CreateTable
+CREATE TABLE "AISignal" (
+    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    "marketId" TEXT NOT NULL,
+    "signal" TEXT NOT NULL,
+    "confidence" REAL NOT NULL,
+    "summary" TEXT,
+    "keyRisk" TEXT,
+    "newsCount" INTEGER NOT NULL DEFAULT 0,
+    "modelVersion" TEXT NOT NULL DEFAULT 'Qwen3-8B',
+    "generatedAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    CONSTRAINT "AISignal_marketId_fkey" FOREIGN KEY ("marketId") REFERENCES "Market" ("id") ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "Position" (
+    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    "userId" INTEGER NOT NULL,
+    "marketId" TEXT NOT NULL,
+    "outcome" TEXT NOT NULL,
+    "amountEur" REAL NOT NULL,
+    "entryPrice" REAL NOT NULL,
+    "currentPrice" REAL,
+    "pnl" REAL NOT NULL DEFAULT 0,
+    "kellyFraction" REAL,
+    "status" TEXT NOT NULL DEFAULT 'open',
+    "openedAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "closedAt" DATETIME,
+    CONSTRAINT "Position_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
+    CONSTRAINT "Position_marketId_fkey" FOREIGN KEY ("marketId") REFERENCES "Market" ("id") ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "Watchlist" (
+    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    "userId" INTEGER NOT NULL,
+    "marketId" TEXT NOT NULL,
+    "alertThreshold" REAL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    CONSTRAINT "Watchlist_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
+    CONSTRAINT "Watchlist_marketId_fkey" FOREIGN KEY ("marketId") REFERENCES "Market" ("id") ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "Alert" (
+    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    "userId" INTEGER NOT NULL,
+    "marketId" TEXT NOT NULL,
+    "type" TEXT NOT NULL,
+    "message" TEXT NOT NULL,
+    "sentAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    CONSTRAINT "Alert_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
+    CONSTRAINT "Alert_marketId_fkey" FOREIGN KEY ("marketId") REFERENCES "Market" ("id") ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "User_email_key" ON "User"("email");
+
+-- CreateIndex
+CREATE INDEX "AISignal_marketId_generatedAt_idx" ON "AISignal"("marketId", "generatedAt");
+
+-- CreateIndex
+CREATE INDEX "Position_userId_status_idx" ON "Position"("userId", "status");
+
+-- CreateIndex
+CREATE INDEX "Position_marketId_idx" ON "Position"("marketId");
+
+-- CreateIndex
+CREATE INDEX "Watchlist_userId_idx" ON "Watchlist"("userId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Watchlist_userId_marketId_key" ON "Watchlist"("userId", "marketId");
+
+-- CreateIndex
+CREATE INDEX "Alert_userId_sentAt_idx" ON "Alert"("userId", "sentAt");
+
+-- CreateIndex
+CREATE INDEX "Alert_marketId_idx" ON "Alert"("marketId");

backend/prisma/migrations/20260516072006_remove_user_role/migration.sql

@@ -0,0 +1,24 @@
+/*
+  Warnings:
+
+  - You are about to drop the column `role` on the `User` table. All the data in the column will be lost.
+
+*/
+-- RedefineTables
+PRAGMA defer_foreign_keys=ON;
+PRAGMA foreign_keys=OFF;
+CREATE TABLE "new_User" (
+    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    "email" TEXT NOT NULL,
+    "passwordHash" TEXT NOT NULL,
+    "isActive" BOOLEAN NOT NULL DEFAULT true,
+    "telegramChatId" TEXT,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL
+);
+INSERT INTO "new_User" ("createdAt", "email", "id", "isActive", "passwordHash", "telegramChatId", "updatedAt") SELECT "createdAt", "email", "id", "isActive", "passwordHash", "telegramChatId", "updatedAt" FROM "User";
+DROP TABLE "User";
+ALTER TABLE "new_User" RENAME TO "User";
+CREATE UNIQUE INDEX "User_email_key" ON "User"("email");
+PRAGMA foreign_keys=ON;
+PRAGMA defer_foreign_keys=OFF;

backend/prisma/migrations/migration_lock.toml

@@ -0,0 +1,3 @@
+# Please do not edit this file manually
+# It should be added in your version-control system (e.g., Git)
+provider = "sqlite"

backend/src/positions/positions.controller.js

@@ -0,0 +1,39 @@
+/**
+ * Controladores del modulo de posiciones (simulador virtual).
+ *
+ * Responsabilidades:
+ *   - open(req, res)   → abre una posicion virtual en un mercado.
+ *   - list(req, res)   → lista las posiciones del usuario autenticado.
+ *   - close(req, res)  → cierra una posicion y calcula P&L final.
+ *
+ * Endpoints (bajo /api/v1/positions, protegidos por requireAuth):
+ *   POST /       → abrir posicion.
+ *   GET /        → listar posiciones (opcional ?status=open|closed).
+ *   DELETE /:id  → cerrar posicion.
+ */
+
+import { ok, created, noContent } from '../utils/apiResponse.js';
+import { positionsService } from './positions.service.js';
+
+export const positionsController = {
+  async open(req, res) {
+    const position = await positionsService.open(req.user.id, req.body);
+    created(res, position);
+  },
+
+  async list(req, res) {
+    const positions = await positionsService.list(req.user.id, req.query.status);
+    ok(res, positions);
+  },
+
+  async close(req, res) {
+    const position = await positionsService.close(req.params.id, req.user.id);
+    ok(res, position);
+  },
+
+  async suggest(req, res) {
+    const bankroll = req.query.bankroll ? parseFloat(req.query.bankroll) : 1000;
+    const suggestion = await positionsService.suggest(req.params.marketId, bankroll);
+    ok(res, suggestion);
+  },
+};

backend/src/positions/positions.validators.js

@@ -0,0 +1,27 @@
+/**
+ * Esquemas Zod para validar inputs del modulo de posiciones.
+ *
+ * Responsabilidades:
+ *   - openBody  → marketId (string), outcome ('YES'|'NO'), amountEur (positivo, max 100k).
+ *   - idParam   → coerce a numero entero positivo.
+ *   - listQuery → status opcional ('open'|'closed').
+ *
+ * Consumido por:
+ *   - positions.routes.js → validate() en POST, GET y DELETE.
+ */
+
+import { z } from 'zod';
+
+export const openBody = z.object({
+  marketId: z.string().min(1),
+  outcome: z.enum(['YES', 'NO']),
+  amountEur: z.number().positive().max(100_000),
+});
+
+export const idParam = z.object({
+  id: z.coerce.number().int().positive(),
+});
+
+export const listQuery = z.object({
+  status: z.enum(['open', 'closed']).optional(),
+});

backend/src/socket/broadcaster.js

@@ -0,0 +1,32 @@
+/**
+ * Broadcaster de eventos en tiempo real via Socket.io.
+ *
+ * Actua como un wrapper singleton sobre la instancia de Socket.io.
+ * Responsabilidades:
+ *   - Recibir la instancia de io en el arranque (attachBroadcaster).
+ *   - Emitir eventos tipados a todos los clientes conectados:
+ *       * market_update  → cambio de precio/volumen de un mercado.
+ *       * ai_signal      → nueva senal generada por el pipeline de IA.
+ *       * price_alert    → alerta de umbral de precio o cambio de senal.
+ *
+ * Los controladores y servicios importan estas funciones para notificar
+ * sin acoplarse directamente a Socket.io.
+ */
+
+let _io = null;
+
+export function attachBroadcaster(io) {
+  _io = io;
+}
+
+export function emitMarketUpdate(payload) {
+  _io?.emit('market_update', payload);
+}
+
+export function emitAiSignal(payload) {
+  _io?.emit('ai_signal', payload);
+}
+
+export function emitPriceAlert(payload) {
+  _io?.emit('price_alert', payload);
+}

backend/src/stats/stats.routes.js

@@ -0,0 +1,42 @@
+/**
+ * Rutas REST de estadisticas globales (publicas).
+ *
+ * Endpoint (montado en /api/v1/stats):
+ *   GET / → estadisticas agregadas del sistema.
+ *
+ * Datos expuestos:
+ *   - marketsCount  : total de mercados activos.
+ *   - volume24h     : suma de volumen de mercados activos.
+ *   - signalsCount  : total de senales IA generadas.
+ *   - alertsToday   : alertas enviadas en las ultimas 24h.
+ */
+
+import { Router } from 'express';
+import { prisma } from '../utils/prisma.js';
+import { ok } from '../utils/apiResponse.js';
+
+const router = Router();
+
+router.get('/', async (_req, res) => {
+  const [marketsCount, signalsCount, alertsToday] = await Promise.all([
+    prisma.market.count({ where: { status: 'active' } }),
+    prisma.aISignal.count(),
+    prisma.alert.count({
+      where: { sentAt: { gte: new Date(Date.now() - 24 * 60 * 60 * 1000) } },
+    }),
+  ]);
+
+  const volumeAgg = await prisma.market.aggregate({
+    where: { status: 'active' },
+    _sum: { volumeEur: true },
+  });
+
+  ok(res, {
+    marketsCount,
+    volume24h: volumeAgg._sum.volumeEur || 0,
+    signalsCount,
+    alertsToday,
+  });
+});
+
+export default router;

backend/src/watchlist/watchlist.controller.js

@@ -0,0 +1,33 @@
+/**
+ * Controladores del modulo de lista de seguimiento (watchlist).
+ *
+ * Responsabilidades:
+ *   - add(req, res)    → anade un mercado a la watchlist con umbral de alerta opcional.
+ *   - remove(req, res) → elimina un mercado de la watchlist.
+ *   - list(req, res)   → devuelve la watchlist del usuario autenticado.
+ *
+ * Endpoints (bajo /api/v1/watchlist, protegidos por requireAuth):
+ *   POST /              → anadir mercado.
+ *   GET /               → listar watchlist.
+ *   DELETE /:marketId   → eliminar mercado.
+ */
+
+import { ok, created, noContent } from '../utils/apiResponse.js';
+import { watchlistService } from './watchlist.service.js';
+
+export const watchlistController = {
+  async add(req, res) {
+    const entry = await watchlistService.add(req.user.id, req.body);
+    created(res, entry);
+  },
+
+  async remove(req, res) {
+    await watchlistService.remove(req.user.id, req.params.marketId);
+    noContent(res);
+  },
+
+  async list(req, res) {
+    const entries = await watchlistService.list(req.user.id);
+    ok(res, entries);
+  },
+};

backend/src/watchlist/watchlist.repository.js

@@ -0,0 +1,46 @@
+/**
+ * Repositorio de acceso a datos para el modelo Watchlist.
+ *
+ * Responsabilidades:
+ *   - create(data)              → inserta entrada en watchlist.
+ *   - findByUser(userId)        → lista con datos del mercado asociado.
+ *   - deleteByUserAndMarket(...) → elimina entrada especifica.
+ *   - findAllWithThreshold()    → entradas con alertThreshold definido (para alertas).
+ *
+ * Constraint:
+ *   - @@unique([userId, marketId]) → un usuario no puede duplicar un mercado.
+ *
+ * Todas las operaciones usan Prisma ORM.
+ */
+
+import { prisma } from '../utils/prisma.js';
+
+export const watchlistRepository = {
+  create({ userId, marketId, alertThreshold }) {
+    return prisma.watchlist.create({ data: { userId, marketId, alertThreshold } });
+  },
+
+  findByUser(userId) {
+    return prisma.watchlist.findMany({
+      where: { userId },
+      include: {
+        market: { select: { id: true, question: true, yesPrice: true, noPrice: true, status: true } },
+      },
+      orderBy: { createdAt: 'desc' },
+    });
+  },
+
+  deleteByUserAndMarket(userId, marketId) {
+    return prisma.watchlist.deleteMany({ where: { userId, marketId } });
+  },
+
+  findAllWithThreshold() {
+    return prisma.watchlist.findMany({
+      where: { alertThreshold: { not: null } },
+      include: {
+        user: { select: { id: true, telegramChatId: true } },
+        market: { select: { id: true, question: true, yesPrice: true } },
+      },
+    });
+  },
+};

backend/src/watchlist/watchlist.routes.js

@@ -0,0 +1,26 @@
+/**
+ * Rutas REST del modulo de lista de seguimiento (watchlist).
+ *
+ * Endpoints (montados en /api/v1/watchlist):
+ *   POST /              → anadir mercado (validate addBody).
+ *   GET /               → listar watchlist.
+ *   DELETE /:marketId   → eliminar mercado (validate marketIdParam en params).
+ *
+ * Todas las rutas requieren autenticacion JWT (router.use(requireAuth)).
+ */
+
+import { Router } from 'express';
+import { validate } from '../middlewares/validate.js';
+import { requireAuth } from '../middlewares/requireAuth.js';
+import { watchlistController } from './watchlist.controller.js';
+import { addBody, marketIdParam } from './watchlist.validators.js';
+
+const router = Router();
+
+router.use(requireAuth);
+
+router.post('/', validate(addBody), watchlistController.add);
+router.get('/', watchlistController.list);
+router.delete('/:marketId', validate(marketIdParam, 'params'), watchlistController.remove);
+
+export default router;

backend/src/watchlist/watchlist.service.js

@@ -0,0 +1,41 @@
+/**
+ * Logica de negocio del modulo de lista de seguimiento (watchlist).
+ *
+ * Responsabilidades:
+ *   - add(userId, { marketId, alertThreshold })
+ *     → valida que el mercado exista, crea entrada en watchlist.
+ *     → si ya existe (P2002), devuelve 409 ALREADY_IN_WATCHLIST.
+ *   - remove(userId, marketId) → elimina entrada; si no existe devuelve 404.
+ *   - list(userId)             → devuelve todas las entradas del usuario.
+ *
+ * Consumido por:
+ *   - watchlist.controller.js (API REST).
+ *   - alerts.service.js       → processAll() revisa watchlist con alertThreshold.
+ */
+
+import { HttpError } from '../utils/apiResponse.js';
+import { watchlistRepository } from './watchlist.repository.js';
+import { marketsRepository } from '../markets/markets.repository.js';
+
+export const watchlistService = {
+  async add(userId, { marketId, alertThreshold }) {
+    const market = await marketsRepository.findById(marketId);
+    if (!market) throw new HttpError(404, 'NOT_FOUND', 'Market not found');
+
+    try {
+      return await watchlistRepository.create({ userId, marketId, alertThreshold });
+    } catch (err) {
+      if (err.code === 'P2002') throw new HttpError(409, 'ALREADY_IN_WATCHLIST', 'Market already in watchlist');
+      throw err;
+    }
+  },
+
+  async remove(userId, marketId) {
+    const { count } = await watchlistRepository.deleteByUserAndMarket(userId, marketId);
+    if (count === 0) throw new HttpError(404, 'NOT_FOUND', 'Entry not found in watchlist');
+  },
+
+  list(userId) {
+    return watchlistRepository.findByUser(userId);
+  },
+};

backend/src/watchlist/watchlist.validators.js

@@ -0,0 +1,21 @@
+/**
+ * Esquemas Zod para validar inputs del modulo de watchlist.
+ *
+ * Responsabilidades:
+ *   - addBody       → marketId (string), alertThreshold opcional (0.0 a 1.0).
+ *   - marketIdParam → string no vacio para el parametro :marketId.
+ *
+ * Consumido por:
+ *   - watchlist.routes.js → validate() en POST y DELETE.
+ */
+
+import { z } from 'zod';
+
+export const addBody = z.object({
+  marketId: z.string().min(1),
+  alertThreshold: z.number().min(0).max(1).optional(),
+});
+
+export const marketIdParam = z.object({
+  marketId: z.string().min(1),
+});