Add files using upload-large-folder tool

.claude/memory/feedback_no_chrome_devtools.md

@@ -0,0 +1,11 @@
+---
+name: No usar Chrome DevTools para verificar UI
+description: El usuario prefiere verificar los cambios de UI él mismo, sin que Claude use Chrome DevTools
+type: feedback
+---
+
+No usar Chrome DevTools MCP para tomar screenshots o interactuar con el navegador después de hacer cambios de UI. El usuario prefiere revisar los cambios visualmente por su cuenta.
+
+**Why:** El usuario lo indicó explícitamente cuando se usaban las herramientas de Chrome para verificar cambios CSS/JS.
+
+**How to apply:** Después de hacer cambios de CSS o JS en la UI, describir los cambios realizados y dejar que el usuario los verifique en el navegador.

.gitattributes

@@ -33,3 +33,10 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+backend/node_modules/prisma/libquery_engine-darwin-arm64.dylib.node filter=lfs diff=lfs merge=lfs -text
+backend/node_modules/@prisma/engines/libquery_engine-darwin-arm64.dylib.node filter=lfs diff=lfs merge=lfs -text
+backend/node_modules/@prisma/engines/schema-engine-darwin-arm64 filter=lfs diff=lfs merge=lfs -text
+backend/node_modules/.prisma/client/libquery_engine-darwin-arm64.dylib.node filter=lfs diff=lfs merge=lfs -text
+backend/node_modules/prisma/build/public/icon-1024.png filter=lfs diff=lfs merge=lfs -text
+backend/node_modules/prisma/build/public/assets/inter-all-400-normal.4c1f8a0d.woff filter=lfs diff=lfs merge=lfs -text
+backend/node_modules/prisma/build/public/assets/inter-all-600-normal.d0a7c8a9.woff filter=lfs diff=lfs merge=lfs -text

backend/node_modules/.prisma/client/libquery_engine-darwin-arm64.dylib.node

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:afb9cb5a12ea42caa6f6498e40e9cb75059cae17098aadcc1001c99bb262e1ee
+size 19356128

backend/node_modules/.prisma/client/query_engine_bg.wasm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ec8cd57e69e5e061c71accb0ae4ea5a258b074e51da112c6d871d398e259eba
+size 2171299

backend/node_modules/@prisma/engines/libquery_engine-darwin-arm64.dylib.node

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:afb9cb5a12ea42caa6f6498e40e9cb75059cae17098aadcc1001c99bb262e1ee
+size 19356128

backend/node_modules/@prisma/engines/schema-engine-darwin-arm64

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:caa2cf90d5b2cfe6cc06e47974f7e3275dd395b4d35cf140d5d4b2362c3b5bb1
+size 21686160

backend/node_modules/c12/dist/index.d.mts

@@ -0,0 +1,157 @@
+import { Jiti, JitiOptions } from 'jiti';
+import { DownloadTemplateOptions } from 'giget';
+import { ChokidarOptions } from 'chokidar';
+import { diff } from 'ohash/utils';
+
+interface DotenvOptions {
+    /**
+     * The project root directory (either absolute or relative to the current working directory).
+     */
+    cwd: string;
+    /**
+     * What file to look in for environment variables (either absolute or relative
+     * to the current working directory). For example, `.env`.
+     */
+    fileName?: string;
+    /**
+     * Whether to interpolate variables within .env.
+     *
+     * @example
+     * ```env
+     * BASE_DIR="/test"
+     * # resolves to "/test/further"
+     * ANOTHER_DIR="${BASE_DIR}/further"
+     * ```
+     */
+    interpolate?: boolean;
+    /**
+     * An object describing environment variables (key, value pairs).
+     */
+    env?: NodeJS.ProcessEnv;
+}
+type Env = typeof process.env;
+/**
+ * Load and interpolate environment variables into `process.env`.
+ * If you need more control (or access to the values), consider using `loadDotenv` instead
+ *
+ */
+declare function setupDotenv(options: DotenvOptions): Promise<Env>;
+/** Load environment variables into an object. */
+declare function loadDotenv(options: DotenvOptions): Promise<Env>;
+declare global {
+    var __c12_dotenv_vars__: Map<Record<string, any>, Set<string>>;
+}
+
+interface ConfigLayerMeta {
+    name?: string;
+    [key: string]: any;
+}
+type UserInputConfig = Record<string, any>;
+interface C12InputConfig<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta> {
+    $test?: T;
+    $development?: T;
+    $production?: T;
+    $env?: Record<string, T>;
+    $meta?: MT;
+}
+type InputConfig<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta> = C12InputConfig<T, MT> & T;
+interface SourceOptions<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta> {
+    /** Custom meta for layer */
+    meta?: MT;
+    /** Layer config overrides */
+    overrides?: T;
+    [key: string]: any;
+    /**
+     * Options for cloning remote sources
+     *
+     * @see https://giget.unjs.io
+     */
+    giget?: DownloadTemplateOptions;
+    /**
+     * Install dependencies after cloning
+     *
+     * @see https://nypm.unjs.io
+     */
+    install?: boolean;
+    /**
+     * Token for cloning private sources
+     *
+     * @see https://giget.unjs.io#providing-token-for-private-repositories
+     */
+    auth?: string;
+}
+interface ConfigLayer<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta> {
+    config: T | null;
+    source?: string;
+    sourceOptions?: SourceOptions<T, MT>;
+    meta?: MT;
+    cwd?: string;
+    configFile?: string;
+}
+interface ResolvedConfig<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta> extends ConfigLayer<T, MT> {
+    config: T;
+    layers?: ConfigLayer<T, MT>[];
+    cwd?: string;
+}
+type ConfigSource = "overrides" | "main" | "rc" | "packageJson" | "defaultConfig";
+interface ResolvableConfigContext<T extends UserInputConfig = UserInputConfig> {
+    configs: Record<ConfigSource, T | null | undefined>;
+    rawConfigs: Record<ConfigSource, ResolvableConfig<T> | null | undefined>;
+}
+type MaybePromise<T> = T | Promise<T>;
+type ResolvableConfig<T extends UserInputConfig = UserInputConfig> = MaybePromise<T | null | undefined> | ((ctx: ResolvableConfigContext<T>) => MaybePromise<T | null | undefined>);
+interface LoadConfigOptions<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta> {
+    name?: string;
+    cwd?: string;
+    configFile?: string;
+    rcFile?: false | string;
+    globalRc?: boolean;
+    dotenv?: boolean | DotenvOptions;
+    envName?: string | false;
+    packageJson?: boolean | string | string[];
+    defaults?: T;
+    defaultConfig?: ResolvableConfig<T>;
+    overrides?: ResolvableConfig<T>;
+    omit$Keys?: boolean;
+    resolve?: (id: string, options: LoadConfigOptions<T, MT>) => null | undefined | ResolvedConfig<T, MT> | Promise<ResolvedConfig<T, MT> | undefined | null>;
+    jiti?: Jiti;
+    jitiOptions?: JitiOptions;
+    giget?: false | DownloadTemplateOptions;
+    merger?: (...sources: Array<T | null | undefined>) => T;
+    extend?: false | {
+        extendKey?: string | string[];
+    };
+}
+type DefineConfig<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta> = (input: InputConfig<T, MT>) => InputConfig<T, MT>;
+declare function createDefineConfig<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta>(): DefineConfig<T, MT>;
+
+declare const SUPPORTED_EXTENSIONS: string[];
+declare function loadConfig<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta>(options: LoadConfigOptions<T, MT>): Promise<ResolvedConfig<T, MT>>;
+
+type DiffEntries = ReturnType<typeof diff>;
+type ConfigWatcher<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta> = ResolvedConfig<T, MT> & {
+    watchingFiles: string[];
+    unwatch: () => Promise<void>;
+};
+interface WatchConfigOptions<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta> extends LoadConfigOptions<T, MT> {
+    chokidarOptions?: ChokidarOptions;
+    debounce?: false | number;
+    onWatch?: (event: {
+        type: "created" | "updated" | "removed";
+        path: string;
+    }) => void | Promise<void>;
+    acceptHMR?: (context: {
+        getDiff: () => DiffEntries;
+        newConfig: ResolvedConfig<T, MT>;
+        oldConfig: ResolvedConfig<T, MT>;
+    }) => void | boolean | Promise<void | boolean>;
+    onUpdate?: (context: {
+        getDiff: () => ReturnType<typeof diff>;
+        newConfig: ResolvedConfig<T, MT>;
+        oldConfig: ResolvedConfig<T, MT>;
+    }) => void | Promise<void>;
+}
+declare function watchConfig<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta>(options: WatchConfigOptions<T, MT>): Promise<ConfigWatcher<T, MT>>;
+
+export { SUPPORTED_EXTENSIONS, createDefineConfig, loadConfig, loadDotenv, setupDotenv, watchConfig };
+export type { C12InputConfig, ConfigLayer, ConfigLayerMeta, ConfigSource, ConfigWatcher, DefineConfig, DotenvOptions, Env, InputConfig, LoadConfigOptions, ResolvableConfig, ResolvableConfigContext, ResolvedConfig, SourceOptions, UserInputConfig, WatchConfigOptions };

backend/node_modules/c12/dist/index.mjs

@@ -0,0 +1,112 @@
+import { l as loadConfig, S as SUPPORTED_EXTENSIONS } from './shared/c12.BXpNC6YI.mjs';
+export { a as loadDotenv, s as setupDotenv } from './shared/c12.BXpNC6YI.mjs';
+import { debounce } from 'perfect-debounce';
+import { resolve } from 'pathe';
+import 'node:fs';
+import 'node:fs/promises';
+import 'node:url';
+import 'node:os';
+import 'exsolve';
+import 'jiti';
+import 'rc9';
+import 'defu';
+import 'pkg-types';
+import 'dotenv';
+
+function createDefineConfig() {
+  return (input) => input;
+}
+
+const eventMap = {
+  add: "created",
+  change: "updated",
+  unlink: "removed"
+};
+async function watchConfig(options) {
+  let config = await loadConfig(options);
+  const configName = options.name || "config";
+  const configFileName = options.configFile ?? (options.name === "config" ? "config" : `${options.name}.config`);
+  const watchingFiles = [
+    ...new Set(
+      (config.layers || []).filter((l) => l.cwd).flatMap((l) => [
+        ...SUPPORTED_EXTENSIONS.flatMap((ext) => [
+          resolve(l.cwd, configFileName + ext),
+          resolve(l.cwd, ".config", configFileName + ext),
+          resolve(
+            l.cwd,
+            ".config",
+            configFileName.replace(/\.config$/, "") + ext
+          )
+        ]),
+        l.source && resolve(l.cwd, l.source),
+        // TODO: Support watching rc from home and workspace
+        options.rcFile && resolve(
+          l.cwd,
+          typeof options.rcFile === "string" ? options.rcFile : `.${configName}rc`
+        ),
+        options.packageJson && resolve(l.cwd, "package.json")
+      ]).filter(Boolean)
+    )
+  ];
+  const watch = await import('chokidar').then((r) => r.watch || r.default || r);
+  const { diff } = await import('ohash/utils');
+  const _fswatcher = watch(watchingFiles, {
+    ignoreInitial: true,
+    ...options.chokidarOptions
+  });
+  const onChange = async (event, path) => {
+    const type = eventMap[event];
+    if (!type) {
+      return;
+    }
+    if (options.onWatch) {
+      await options.onWatch({
+        type,
+        path
+      });
+    }
+    const oldConfig = config;
+    try {
+      config = await loadConfig(options);
+    } catch (error) {
+      console.warn(`Failed to load config ${path}
+${error}`);
+      return;
+    }
+    const changeCtx = {
+      newConfig: config,
+      oldConfig,
+      getDiff: () => diff(oldConfig.config, config.config)
+    };
+    if (options.acceptHMR) {
+      const changeHandled = await options.acceptHMR(changeCtx);
+      if (changeHandled) {
+        return;
+      }
+    }
+    if (options.onUpdate) {
+      await options.onUpdate(changeCtx);
+    }
+  };
+  if (options.debounce === false) {
+    _fswatcher.on("all", onChange);
+  } else {
+    _fswatcher.on("all", debounce(onChange, options.debounce ?? 100));
+  }
+  const utils = {
+    watchingFiles,
+    unwatch: async () => {
+      await _fswatcher.close();
+    }
+  };
+  return new Proxy(utils, {
+    get(_, prop) {
+      if (prop in utils) {
+        return utils[prop];
+      }
+      return config[prop];
+    }
+  });
+}
+
+export { SUPPORTED_EXTENSIONS, createDefineConfig, loadConfig, watchConfig };

backend/node_modules/c12/dist/shared/c12.BXpNC6YI.mjs

@@ -0,0 +1,401 @@
+import { statSync, promises, existsSync } from 'node:fs';
+import { rm, readFile } from 'node:fs/promises';
+import { pathToFileURL } from 'node:url';
+import { homedir } from 'node:os';
+import { resolve, join, dirname, basename, extname, normalize } from 'pathe';
+import { resolveModulePath } from 'exsolve';
+import { createJiti } from 'jiti';
+import * as rc9 from 'rc9';
+import { defu } from 'defu';
+import { findWorkspaceDir, readPackageJSON } from 'pkg-types';
+import * as dotenv from 'dotenv';
+
+async function setupDotenv(options) {
+  const targetEnvironment = options.env ?? process.env;
+  const environment = await loadDotenv({
+    cwd: options.cwd,
+    fileName: options.fileName ?? ".env",
+    env: targetEnvironment,
+    interpolate: options.interpolate ?? true
+  });
+  const dotenvVars = getDotEnvVars(targetEnvironment);
+  for (const key in environment) {
+    if (key.startsWith("_")) {
+      continue;
+    }
+    if (targetEnvironment[key] === void 0 || dotenvVars.has(key)) {
+      targetEnvironment[key] = environment[key];
+    }
+  }
+  return environment;
+}
+async function loadDotenv(options) {
+  const environment = /* @__PURE__ */ Object.create(null);
+  const dotenvFile = resolve(options.cwd, options.fileName);
+  const dotenvVars = getDotEnvVars(options.env || {});
+  Object.assign(environment, options.env);
+  if (statSync(dotenvFile, { throwIfNoEntry: false })?.isFile()) {
+    const parsed = dotenv.parse(await promises.readFile(dotenvFile, "utf8"));
+    for (const key in parsed) {
+      if (key in environment && !dotenvVars.has(key)) {
+        continue;
+      }
+      environment[key] = parsed[key];
+      dotenvVars.add(key);
+    }
+  }
+  if (options.interpolate) {
+    interpolate(environment);
+  }
+  return environment;
+}
+function interpolate(target, source = {}, parse = (v) => v) {
+  function getValue(key) {
+    return source[key] === void 0 ? target[key] : source[key];
+  }
+  function interpolate2(value, parents = []) {
+    if (typeof value !== "string") {
+      return value;
+    }
+    const matches = value.match(/(.?\${?(?:[\w:]+)?}?)/g) || [];
+    return parse(
+      // eslint-disable-next-line unicorn/no-array-reduce
+      matches.reduce((newValue, match) => {
+        const parts = /(.?)\${?([\w:]+)?}?/g.exec(match) || [];
+        const prefix = parts[1];
+        let value2, replacePart;
+        if (prefix === "\\") {
+          replacePart = parts[0] || "";
+          value2 = replacePart.replace(String.raw`\$`, "$");
+        } else {
+          const key = parts[2];
+          replacePart = (parts[0] || "").slice(prefix.length);
+          if (parents.includes(key)) {
+            console.warn(
+              `Please avoid recursive environment variables ( loop: ${parents.join(
+                " > "
+              )} > ${key} )`
+            );
+            return "";
+          }
+          value2 = getValue(key);
+          value2 = interpolate2(value2, [...parents, key]);
+        }
+        return value2 === void 0 ? newValue : newValue.replace(replacePart, value2);
+      }, value)
+    );
+  }
+  for (const key in target) {
+    target[key] = interpolate2(getValue(key));
+  }
+}
+function getDotEnvVars(targetEnvironment) {
+  const globalRegistry = globalThis.__c12_dotenv_vars__ ||= /* @__PURE__ */ new Map();
+  if (!globalRegistry.has(targetEnvironment)) {
+    globalRegistry.set(targetEnvironment, /* @__PURE__ */ new Set());
+  }
+  return globalRegistry.get(targetEnvironment);
+}
+
+const _normalize = (p) => p?.replace(/\\/g, "/");
+const ASYNC_LOADERS = {
+  ".yaml": () => import('confbox/yaml').then((r) => r.parseYAML),
+  ".yml": () => import('confbox/yaml').then((r) => r.parseYAML),
+  ".jsonc": () => import('confbox/jsonc').then((r) => r.parseJSONC),
+  ".json5": () => import('confbox/json5').then((r) => r.parseJSON5),
+  ".toml": () => import('confbox/toml').then((r) => r.parseTOML)
+};
+const SUPPORTED_EXTENSIONS = Object.freeze([
+  // with jiti
+  ".js",
+  ".ts",
+  ".mjs",
+  ".cjs",
+  ".mts",
+  ".cts",
+  ".json",
+  // with confbox
+  ".jsonc",
+  ".json5",
+  ".yaml",
+  ".yml",
+  ".toml"
+]);
+async function loadConfig(options) {
+  options.cwd = resolve(process.cwd(), options.cwd || ".");
+  options.name = options.name || "config";
+  options.envName = options.envName ?? process.env.NODE_ENV;
+  options.configFile = options.configFile ?? (options.name === "config" ? "config" : `${options.name}.config`);
+  options.rcFile = options.rcFile ?? `.${options.name}rc`;
+  if (options.extend !== false) {
+    options.extend = {
+      extendKey: "extends",
+      ...options.extend
+    };
+  }
+  const _merger = options.merger || defu;
+  options.jiti = options.jiti || createJiti(join(options.cwd, options.configFile), {
+    interopDefault: true,
+    moduleCache: false,
+    extensions: [...SUPPORTED_EXTENSIONS],
+    ...options.jitiOptions
+  });
+  const r = {
+    config: {},
+    cwd: options.cwd,
+    configFile: resolve(options.cwd, options.configFile),
+    layers: []
+  };
+  const rawConfigs = {
+    overrides: options.overrides,
+    main: void 0,
+    rc: void 0,
+    packageJson: void 0,
+    defaultConfig: options.defaultConfig
+  };
+  if (options.dotenv) {
+    await setupDotenv({
+      cwd: options.cwd,
+      ...options.dotenv === true ? {} : options.dotenv
+    });
+  }
+  const _mainConfig = await resolveConfig(".", options);
+  if (_mainConfig.configFile) {
+    rawConfigs.main = _mainConfig.config;
+    r.configFile = _mainConfig.configFile;
+  }
+  if (_mainConfig.meta) {
+    r.meta = _mainConfig.meta;
+  }
+  if (options.rcFile) {
+    const rcSources = [];
+    rcSources.push(rc9.read({ name: options.rcFile, dir: options.cwd }));
+    if (options.globalRc) {
+      const workspaceDir = await findWorkspaceDir(options.cwd).catch(() => {
+      });
+      if (workspaceDir) {
+        rcSources.push(rc9.read({ name: options.rcFile, dir: workspaceDir }));
+      }
+      rcSources.push(rc9.readUser({ name: options.rcFile, dir: options.cwd }));
+    }
+    rawConfigs.rc = _merger({}, ...rcSources);
+  }
+  if (options.packageJson) {
+    const keys = (Array.isArray(options.packageJson) ? options.packageJson : [
+      typeof options.packageJson === "string" ? options.packageJson : options.name
+    ]).filter((t) => t && typeof t === "string");
+    const pkgJsonFile = await readPackageJSON(options.cwd).catch(() => {
+    });
+    const values = keys.map((key) => pkgJsonFile?.[key]);
+    rawConfigs.packageJson = _merger({}, ...values);
+  }
+  const configs = {};
+  for (const key in rawConfigs) {
+    const value = rawConfigs[key];
+    configs[key] = await (typeof value === "function" ? value({ configs, rawConfigs }) : value);
+  }
+  r.config = _merger(
+    configs.overrides,
+    configs.main,
+    configs.rc,
+    configs.packageJson,
+    configs.defaultConfig
+  );
+  if (options.extend) {
+    await extendConfig(r.config, options);
+    r.layers = r.config._layers;
+    delete r.config._layers;
+    r.config = _merger(r.config, ...r.layers.map((e) => e.config));
+  }
+  const baseLayers = [
+    configs.overrides && {
+      config: configs.overrides,
+      configFile: void 0,
+      cwd: void 0
+    },
+    { config: configs.main, configFile: options.configFile, cwd: options.cwd },
+    configs.rc && { config: configs.rc, configFile: options.rcFile },
+    configs.packageJson && {
+      config: configs.packageJson,
+      configFile: "package.json"
+    }
+  ].filter((l) => l && l.config);
+  r.layers = [...baseLayers, ...r.layers];
+  if (options.defaults) {
+    r.config = _merger(r.config, options.defaults);
+  }
+  if (options.omit$Keys) {
+    for (const key in r.config) {
+      if (key.startsWith("$")) {
+        delete r.config[key];
+      }
+    }
+  }
+  return r;
+}
+async function extendConfig(config, options) {
+  config._layers = config._layers || [];
+  if (!options.extend) {
+    return;
+  }
+  let keys = options.extend.extendKey;
+  if (typeof keys === "string") {
+    keys = [keys];
+  }
+  const extendSources = [];
+  for (const key of keys) {
+    extendSources.push(
+      ...(Array.isArray(config[key]) ? config[key] : [config[key]]).filter(
+        Boolean
+      )
+    );
+    delete config[key];
+  }
+  for (let extendSource of extendSources) {
+    const originalExtendSource = extendSource;
+    let sourceOptions = {};
+    if (extendSource.source) {
+      sourceOptions = extendSource.options || {};
+      extendSource = extendSource.source;
+    }
+    if (Array.isArray(extendSource)) {
+      sourceOptions = extendSource[1] || {};
+      extendSource = extendSource[0];
+    }
+    if (typeof extendSource !== "string") {
+      console.warn(
+        `Cannot extend config from \`${JSON.stringify(
+          originalExtendSource
+        )}\` in ${options.cwd}`
+      );
+      continue;
+    }
+    const _config = await resolveConfig(extendSource, options, sourceOptions);
+    if (!_config.config) {
+      console.warn(
+        `Cannot extend config from \`${extendSource}\` in ${options.cwd}`
+      );
+      continue;
+    }
+    await extendConfig(_config.config, { ...options, cwd: _config.cwd });
+    config._layers.push(_config);
+    if (_config.config._layers) {
+      config._layers.push(..._config.config._layers);
+      delete _config.config._layers;
+    }
+  }
+}
+const GIGET_PREFIXES = [
+  "gh:",
+  "github:",
+  "gitlab:",
+  "bitbucket:",
+  "https://",
+  "http://"
+];
+const NPM_PACKAGE_RE = /^(@[\da-z~-][\d._a-z~-]*\/)?[\da-z~-][\d._a-z~-]*($|\/.*)/;
+async function resolveConfig(source, options, sourceOptions = {}) {
+  if (options.resolve) {
+    const res2 = await options.resolve(source, options);
+    if (res2) {
+      return res2;
+    }
+  }
+  const _merger = options.merger || defu;
+  const customProviderKeys = Object.keys(
+    sourceOptions.giget?.providers || {}
+  ).map((key) => `${key}:`);
+  const gigetPrefixes = customProviderKeys.length > 0 ? [.../* @__PURE__ */ new Set([...customProviderKeys, ...GIGET_PREFIXES])] : GIGET_PREFIXES;
+  if (options.giget !== false && gigetPrefixes.some((prefix) => source.startsWith(prefix))) {
+    const { downloadTemplate } = await import('giget');
+    const { digest } = await import('ohash');
+    const cloneName = source.replace(/\W+/g, "_").split("_").splice(0, 3).join("_") + "_" + digest(source).slice(0, 10).replace(/[-_]/g, "");
+    let cloneDir;
+    const localNodeModules = resolve(options.cwd, "node_modules");
+    const parentDir = dirname(options.cwd);
+    if (basename(parentDir) === ".c12") {
+      cloneDir = join(parentDir, cloneName);
+    } else if (existsSync(localNodeModules)) {
+      cloneDir = join(localNodeModules, ".c12", cloneName);
+    } else {
+      cloneDir = process.env.XDG_CACHE_HOME ? resolve(process.env.XDG_CACHE_HOME, "c12", cloneName) : resolve(homedir(), ".cache/c12", cloneName);
+    }
+    if (existsSync(cloneDir) && !sourceOptions.install) {
+      await rm(cloneDir, { recursive: true });
+    }
+    const cloned = await downloadTemplate(source, {
+      dir: cloneDir,
+      install: sourceOptions.install,
+      force: sourceOptions.install,
+      auth: sourceOptions.auth,
+      ...options.giget,
+      ...sourceOptions.giget
+    });
+    source = cloned.dir;
+  }
+  if (NPM_PACKAGE_RE.test(source)) {
+    source = tryResolve(source, options) || source;
+  }
+  const ext = extname(source);
+  const isDir = !ext || ext === basename(source);
+  const cwd = resolve(options.cwd, isDir ? source : dirname(source));
+  if (isDir) {
+    source = options.configFile;
+  }
+  const res = {
+    config: void 0,
+    configFile: void 0,
+    cwd,
+    source,
+    sourceOptions
+  };
+  res.configFile = tryResolve(resolve(cwd, source), options) || tryResolve(
+    resolve(cwd, ".config", source.replace(/\.config$/, "")),
+    options
+  ) || tryResolve(resolve(cwd, ".config", source), options) || source;
+  if (!existsSync(res.configFile)) {
+    return res;
+  }
+  const configFileExt = extname(res.configFile) || "";
+  if (configFileExt in ASYNC_LOADERS) {
+    const asyncLoader = await ASYNC_LOADERS[configFileExt]();
+    const contents = await readFile(res.configFile, "utf8");
+    res.config = asyncLoader(contents);
+  } else {
+    res.config = await options.jiti.import(res.configFile, {
+      default: true
+    });
+  }
+  if (typeof res.config === "function") {
+    res.config = await res.config();
+  }
+  if (options.envName) {
+    const envConfig = {
+      ...res.config["$" + options.envName],
+      ...res.config.$env?.[options.envName]
+    };
+    if (Object.keys(envConfig).length > 0) {
+      res.config = _merger(envConfig, res.config);
+    }
+  }
+  res.meta = defu(res.sourceOptions.meta, res.config.$meta);
+  delete res.config.$meta;
+  if (res.sourceOptions.overrides) {
+    res.config = _merger(res.sourceOptions.overrides, res.config);
+  }
+  res.configFile = _normalize(res.configFile);
+  res.source = _normalize(res.source);
+  return res;
+}
+function tryResolve(id, options) {
+  const res = resolveModulePath(id, {
+    try: true,
+    from: pathToFileURL(join(options.cwd || ".", options.configFile || "/")),
+    suffixes: ["", "/index"],
+    extensions: SUPPORTED_EXTENSIONS,
+    cache: false
+  });
+  return res ? normalize(res) : void 0;
+}
+
+export { SUPPORTED_EXTENSIONS as S, loadDotenv as a, loadConfig as l, setupDotenv as s };

backend/node_modules/c12/dist/update.d.mts

@@ -0,0 +1,53 @@
+import * as magicast from 'magicast';
+
+/**
+ * @experimental Update a config file or create a new one.
+ */
+declare function updateConfig(opts: UpdateConfigOptions): Promise<UpdateConfigResult>;
+interface UpdateConfigResult {
+    configFile?: string;
+    created?: boolean;
+}
+type MaybePromise<T> = T | Promise<T>;
+type MagicAstOptions = Exclude<Parameters<(typeof magicast)["parseModule"]>[1], undefined>;
+interface UpdateConfigOptions {
+    /**
+     * Current working directory
+     */
+    cwd: string;
+    /**
+     * Config file name
+     */
+    configFile: string;
+    /**
+     * Extension used for new config file.
+     */
+    createExtension?: string;
+    /**
+     * Magicast options
+     */
+    magicast?: MagicAstOptions;
+    /**
+     * Update function.
+     */
+    onUpdate?: (config: any) => MaybePromise<void>;
+    /**
+     * Handle default config creation.
+     *
+     * Tip: you can use this option as a hook to prompt users about config creation.
+     *
+     * Context object:
+     *  - path: determined full path to the config file
+     *
+     * Returns types:
+     *  - string: custom config template
+     *  - true: write the template
+     *  - false: abort the operation
+     */
+    onCreate?: (ctx: {
+        configFile: string;
+    }) => MaybePromise<string | boolean>;
+}
+
+export { updateConfig };
+export type { UpdateConfigOptions, UpdateConfigResult };

backend/node_modules/c12/dist/update.mjs

@@ -0,0 +1,74 @@
+import { resolveModulePath } from 'exsolve';
+import { S as SUPPORTED_EXTENSIONS } from './shared/c12.BXpNC6YI.mjs';
+import { join, normalize } from 'pathe';
+import { mkdir, writeFile, readFile } from 'node:fs/promises';
+import { dirname, extname } from 'node:path';
+import 'node:fs';
+import 'node:url';
+import 'node:os';
+import 'jiti';
+import 'rc9';
+import 'defu';
+import 'pkg-types';
+import 'dotenv';
+
+const UPDATABLE_EXTS = [".js", ".ts", ".mjs", ".cjs", ".mts", ".cts"];
+async function updateConfig(opts) {
+  const { parseModule } = await import('magicast');
+  let configFile = tryResolve(`./${opts.configFile}`, opts.cwd, SUPPORTED_EXTENSIONS) || tryResolve(
+    `./.config/${opts.configFile}`,
+    opts.cwd,
+    SUPPORTED_EXTENSIONS
+  ) || tryResolve(
+    `./.config/${opts.configFile.split(".")[0]}`,
+    opts.cwd,
+    SUPPORTED_EXTENSIONS
+  );
+  let created = false;
+  if (!configFile) {
+    configFile = join(
+      opts.cwd,
+      opts.configFile + (opts.createExtension || ".ts")
+    );
+    const createResult = await opts.onCreate?.({ configFile }) ?? true;
+    if (!createResult) {
+      throw new Error("Config file creation aborted.");
+    }
+    const content = typeof createResult === "string" ? createResult : `export default {}
+`;
+    await mkdir(dirname(configFile), { recursive: true });
+    await writeFile(configFile, content, "utf8");
+    created = true;
+  }
+  const ext = extname(configFile);
+  if (!UPDATABLE_EXTS.includes(ext)) {
+    throw new Error(
+      `Unsupported config file extension: ${ext} (${configFile}) (supported: ${UPDATABLE_EXTS.join(", ")})`
+    );
+  }
+  const contents = await readFile(configFile, "utf8");
+  const _module = parseModule(contents, opts.magicast);
+  const defaultExport = _module.exports.default;
+  if (!defaultExport) {
+    throw new Error("Default export is missing in the config file!");
+  }
+  const configObj = defaultExport.$type === "function-call" ? defaultExport.$args[0] : defaultExport;
+  await opts.onUpdate?.(configObj);
+  await writeFile(configFile, _module.generate().code);
+  return {
+    configFile,
+    created
+  };
+}
+function tryResolve(path, cwd, extensions) {
+  const res = resolveModulePath(path, {
+    try: true,
+    from: join(cwd, "/"),
+    extensions,
+    suffixes: ["", "/index"],
+    cache: false
+  });
+  return res ? normalize(res) : void 0;
+}
+
+export { updateConfig };

backend/node_modules/chokidar/esm/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/esm/handler.js

@@ -0,0 +1,629 @@
+import { watchFile, unwatchFile, watch as fs_watch } from 'fs';
+import { open, stat, lstat, realpath as fsrealpath } from 'fs/promises';
+import * as sysPath from 'path';
+import { type as osType } from 'os';
+export const STR_DATA = 'data';
+export const STR_END = 'end';
+export const STR_CLOSE = 'close';
+export const EMPTY_FN = () => { };
+export const IDENTITY_FN = (val) => val;
+const pl = process.platform;
+export const isWindows = pl === 'win32';
+export const isMacos = pl === 'darwin';
+export const isLinux = pl === 'linux';
+export const isFreeBSD = pl === 'freebsd';
+export const isIBMi = osType() === 'OS400';
+export const EVENTS = {
+    ALL: 'all',
+    READY: 'ready',
+    ADD: 'add',
+    CHANGE: 'change',
+    ADD_DIR: 'addDir',
+    UNLINK: 'unlink',
+    UNLINK_DIR: 'unlinkDir',
+    RAW: 'raw',
+    ERROR: 'error',
+};
+const EV = EVENTS;
+const THROTTLE_MODE_WATCH = 'watch';
+const statMethods = { lstat, 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 fs_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 (isWindows && error.code === 'EPERM') {
+                try {
+                    const fd = await 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;
+        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: 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);
+            unwatchFile(fullPath);
+            cont.options = cont.watcher = undefined;
+            Object.freeze(cont);
+        }
+    };
+};
+/**
+ * @mixin
+ */
+export 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 = 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 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 ((isMacos || isLinux || 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 fsrealpath(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(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(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 fsrealpath(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 fsrealpath(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;
+            }
+        }
+    }
+}

backend/node_modules/chokidar/esm/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/esm/index.js

@@ -0,0 +1,798 @@
+/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
+import { stat as statcb } from 'fs';
+import { stat, readdir } from 'fs/promises';
+import { EventEmitter } from 'events';
+import * as sysPath from 'path';
+import { readdirp } from 'readdirp';
+import { NodeFsHandler, EVENTS as EV, isWindows, isIBMi, EMPTY_FN, STR_CLOSE, STR_END, } from './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 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 = EMPTY_FN;
+        this.items = EMPTY_SET;
+        Object.freeze(this);
+    }
+}
+const STAT_METHOD_F = 'stat';
+const STAT_METHOD_L = 'lstat';
+export 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);
+    }
+}
+/**
+ * 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 class FSWatcher extends 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 (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 = EMPTY_FN;
+                this._readyEmitted = true;
+                // use process.nextTick to allow time for listener to be bound
+                process.nextTick(() => this.emit(EV.READY));
+            }
+        };
+        this._emitRaw = (...args) => this.emit(EV.RAW, ...args);
+        this._boundRemove = this._remove.bind(this);
+        this.options = opts;
+        this._nodeFsHandler = new 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 !== EV.ERROR)
+            this.emit(EV.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 (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 === EV.UNLINK) {
+                this._pendingUnlinks.set(path, [event, ...args]);
+                setTimeout(() => {
+                    this._pendingUnlinks.forEach((entry, path) => {
+                        this.emit(...entry);
+                        this.emit(EV.ALL, ...entry);
+                        this._pendingUnlinks.delete(path);
+                    });
+                }, typeof opts.atomic === 'number' ? opts.atomic : 100);
+                return this;
+            }
+            if (event === EV.ADD && this._pendingUnlinks.has(path)) {
+                event = EV.CHANGE;
+                this._pendingUnlinks.delete(path);
+            }
+        }
+        if (awf && (event === EV.ADD || event === EV.CHANGE) && this._readyEmitted) {
+            const awfEmit = (err, stats) => {
+                if (err) {
+                    event = EV.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 === EV.CHANGE) {
+            const isThrottled = !this._throttle(EV.CHANGE, path, 50);
+            if (isThrottled)
+                return this;
+        }
+        if (opts.alwaysStat &&
+            stats === undefined &&
+            (event === EV.ADD || event === EV.ADD_DIR || event === EV.CHANGE)) {
+            const fullPath = opts.cwd ? sysPath.join(opts.cwd, path) : path;
+            let stats;
+            try {
+                stats = await 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(EV.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) {
+            statcb(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 === EV.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 ? EV.UNLINK_DIR : EV.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: EV.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
+        let stream = readdirp(root, options);
+        this._streams.add(stream);
+        stream.once(STR_CLOSE, () => {
+            stream = undefined;
+        });
+        stream.once(STR_END, () => {
+            if (stream) {
+                this._streams.delete(stream);
+                stream = undefined;
+            }
+        });
+        return stream;
+    }
+}
+/**
+ * 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 function watch(paths, options = {}) {
+    const watcher = new FSWatcher(options);
+    watcher.add(paths);
+    return watcher;
+}
+export default { watch, FSWatcher };

backend/node_modules/chokidar/esm/package.json

@@ -0,0 +1 @@
+{ "type": "module", "sideEffects": false }

backend/node_modules/dotenv/lib/cli-options.js

@@ -0,0 +1,17 @@
+const re = /^dotenv_config_(encoding|path|quiet|debug|override|DOTENV_KEY)=(.+)$/
+
+module.exports = function optionMatcher (args) {
+  const options = args.reduce(function (acc, cur) {
+    const matches = cur.match(re)
+    if (matches) {
+      acc[matches[1]] = matches[2]
+    }
+    return acc
+  }, {})
+
+  if (!('quiet' in options)) {
+    options.quiet = 'true'
+  }
+
+  return options
+}

backend/node_modules/dotenv/lib/env-options.js

@@ -0,0 +1,28 @@
+// ../config.js accepts options via environment variables
+const options = {}
+
+if (process.env.DOTENV_CONFIG_ENCODING != null) {
+  options.encoding = process.env.DOTENV_CONFIG_ENCODING
+}
+
+if (process.env.DOTENV_CONFIG_PATH != null) {
+  options.path = process.env.DOTENV_CONFIG_PATH
+}
+
+if (process.env.DOTENV_CONFIG_QUIET != null) {
+  options.quiet = process.env.DOTENV_CONFIG_QUIET
+}
+
+if (process.env.DOTENV_CONFIG_DEBUG != null) {
+  options.debug = process.env.DOTENV_CONFIG_DEBUG
+}
+
+if (process.env.DOTENV_CONFIG_OVERRIDE != null) {
+  options.override = process.env.DOTENV_CONFIG_OVERRIDE
+}
+
+if (process.env.DOTENV_CONFIG_DOTENV_KEY != null) {
+  options.DOTENV_KEY = process.env.DOTENV_CONFIG_DOTENV_KEY
+}
+
+module.exports = options

backend/node_modules/dotenv/lib/main.d.ts

@@ -0,0 +1,162 @@
+// TypeScript Version: 3.0
+/// <reference types="node" />
+import type { URL } from 'url';
+
+export interface DotenvParseOutput {
+  [name: string]: string;
+}
+
+/**
+ * Parses a string or buffer in the .env file format into an object.
+ *
+ * See https://dotenvx.com/docs
+ *
+ * @param src - contents to be parsed. example: `'DB_HOST=localhost'`
+ * @returns an object with keys and values based on `src`. example: `{ DB_HOST : 'localhost' }`
+ */
+export function parse<T extends DotenvParseOutput = DotenvParseOutput>(
+  src: string | Buffer
+): T;
+
+export interface DotenvConfigOptions {
+  /**
+   * Default: `path.resolve(process.cwd(), '.env')`
+   *
+   * Specify a custom path if your file containing environment variables is located elsewhere.
+   * Can also be an array of strings, specifying multiple paths.
+   *
+   * example: `require('dotenv').config({ path: '/custom/path/to/.env' })`
+   * example: `require('dotenv').config({ path: ['/path/to/first.env', '/path/to/second.env'] })`
+   */
+  path?: string | string[] | URL;
+
+  /**
+   * Default: `utf8`
+   *
+   * Specify the encoding of your file containing environment variables.
+   *
+   * example: `require('dotenv').config({ encoding: 'latin1' })`
+   */
+  encoding?: string;
+
+  /**
+   * Default: `false`
+   *
+   * Suppress all output (except errors).
+   *
+   * example: `require('dotenv').config({ quiet: true })`
+   */
+  quiet?: boolean;
+
+  /**
+   * Default: `false`
+   *
+   * Turn on logging to help debug why certain keys or values are not being set as you expect.
+   *
+   * example: `require('dotenv').config({ debug: process.env.DEBUG })`
+   */
+  debug?: boolean;
+
+  /**
+   * Default: `false`
+   *
+   * Override any environment variables that have already been set on your machine with values from your .env file.
+   *
+   * example: `require('dotenv').config({ override: true })`
+   */
+  override?: boolean;
+
+  /**
+   * Default: `process.env`
+   *
+   * Specify an object to write your secrets to. Defaults to process.env environment variables.
+   *
+   * example: `const processEnv = {}; require('dotenv').config({ processEnv: processEnv })`
+   */
+  processEnv?: DotenvPopulateInput;
+
+  /**
+   * Default: `undefined`
+   *
+   * Pass the DOTENV_KEY directly to config options. Defaults to looking for process.env.DOTENV_KEY environment variable. Note this only applies to decrypting .env.vault files. If passed as null or undefined, or not passed at all, dotenv falls back to its traditional job of parsing a .env file.
+   *
+   * example: `require('dotenv').config({ DOTENV_KEY: 'dotenv://:key_1234…@dotenvx.com/vault/.env.vault?environment=production' })`
+   */
+  DOTENV_KEY?: string;
+}
+
+export interface DotenvConfigOutput {
+  error?: Error;
+  parsed?: DotenvParseOutput;
+}
+
+export interface DotenvPopulateOptions {
+  /**
+   * Default: `false`
+   *
+   * Turn on logging to help debug why certain keys or values are not being set as you expect.
+   *
+   * example: `require('dotenv').config({ debug: process.env.DEBUG })`
+   */
+  debug?: boolean;
+
+  /**
+   * Default: `false`
+   *
+   * Override any environment variables that have already been set on your machine with values from your .env file.
+   *
+   * example: `require('dotenv').config({ override: true })`
+   */
+  override?: boolean;
+}
+
+export interface DotenvPopulateInput {
+  [name: string]: string;
+}
+
+/**
+ * Loads `.env` file contents into process.env by default. If `DOTENV_KEY` is present, it smartly attempts to load encrypted `.env.vault` file contents into process.env.
+ *
+ * See https://dotenvx.com/docs
+ *
+ * @param options - additional options. example: `{ path: './custom/path', encoding: 'latin1', quiet: false, debug: true, override: false }`
+ * @returns an object with a `parsed` key if successful or `error` key if an error occurred. example: { parsed: { KEY: 'value' } }
+ *
+ */
+export function config(options?: DotenvConfigOptions): DotenvConfigOutput;
+
+/**
+ * Loads `.env` file contents into process.env.
+ *
+ * See https://dotenvx.com/docs
+ *
+ * @param options - additional options. example: `{ path: './custom/path', encoding: 'latin1', quiet: false, debug: true, override: false }`
+ * @returns an object with a `parsed` key if successful or `error` key if an error occurred. example: { parsed: { KEY: 'value' } }
+ *
+ */
+export function configDotenv(options?: DotenvConfigOptions): DotenvConfigOutput;
+
+/**
+ * Loads `source` json contents into `target` like process.env.
+ *
+ * See https://dotenvx.com/docs
+ *
+ * @param processEnv - the target JSON object. in most cases use process.env but you can also pass your own JSON object
+ * @param parsed - the source JSON object
+ * @param options - additional options. example: `{ quiet: false, debug: true, override: false }`
+ * @returns {void}
+ *
+ */
+export function populate(processEnv: DotenvPopulateInput, parsed: DotenvPopulateInput, options?: DotenvConfigOptions): void;
+
+/**
+ * Decrypt ciphertext
+ *
+ * See https://dotenvx.com/docs
+ *
+ * @param encrypted - the encrypted ciphertext string
+ * @param keyStr - the decryption key string
+ * @returns {string}
+ *
+ */
+export function decrypt(encrypted: string, keyStr: string): string;

backend/node_modules/dotenv/lib/main.js

@@ -0,0 +1,386 @@
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+const crypto = require('crypto')
+const packageJson = require('../package.json')
+
+const version = packageJson.version
+
+const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg
+
+// Parse src into an Object
+function parse (src) {
+  const obj = {}
+
+  // Convert buffer to string
+  let lines = src.toString()
+
+  // Convert line breaks to same format
+  lines = lines.replace(/\r\n?/mg, '\n')
+
+  let match
+  while ((match = LINE.exec(lines)) != null) {
+    const key = match[1]
+
+    // Default undefined or null to empty string
+    let value = (match[2] || '')
+
+    // Remove whitespace
+    value = value.trim()
+
+    // Check if double quoted
+    const maybeQuote = value[0]
+
+    // Remove surrounding quotes
+    value = value.replace(/^(['"`])([\s\S]*)\1$/mg, '$2')
+
+    // Expand newlines if double quoted
+    if (maybeQuote === '"') {
+      value = value.replace(/\\n/g, '\n')
+      value = value.replace(/\\r/g, '\r')
+    }
+
+    // Add to object
+    obj[key] = value
+  }
+
+  return obj
+}
+
+function _parseVault (options) {
+  options = options || {}
+
+  const vaultPath = _vaultPath(options)
+  options.path = vaultPath // parse .env.vault
+  const result = DotenvModule.configDotenv(options)
+  if (!result.parsed) {
+    const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`)
+    err.code = 'MISSING_DATA'
+    throw err
+  }
+
+  // handle scenario for comma separated keys - for use with key rotation
+  // example: DOTENV_KEY="dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=prod,dotenv://:key_7890@dotenvx.com/vault/.env.vault?environment=prod"
+  const keys = _dotenvKey(options).split(',')
+  const length = keys.length
+
+  let decrypted
+  for (let i = 0; i < length; i++) {
+    try {
+      // Get full key
+      const key = keys[i].trim()
+
+      // Get instructions for decrypt
+      const attrs = _instructions(result, key)
+
+      // Decrypt
+      decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key)
+
+      break
+    } catch (error) {
+      // last key
+      if (i + 1 >= length) {
+        throw error
+      }
+      // try next key
+    }
+  }
+
+  // Parse decrypted .env string
+  return DotenvModule.parse(decrypted)
+}
+
+function _warn (message) {
+  console.log(`[dotenv@${version}][WARN] ${message}`)
+}
+
+function _debug (message) {
+  console.log(`[dotenv@${version}][DEBUG] ${message}`)
+}
+
+function _log (message) {
+  console.log(`[dotenv@${version}] ${message}`)
+}
+
+function _dotenvKey (options) {
+  // prioritize developer directly setting options.DOTENV_KEY
+  if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+    return options.DOTENV_KEY
+  }
+
+  // secondary infra already contains a DOTENV_KEY environment variable
+  if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+    return process.env.DOTENV_KEY
+  }
+
+  // fallback to empty string
+  return ''
+}
+
+function _instructions (result, dotenvKey) {
+  // Parse DOTENV_KEY. Format is a URI
+  let uri
+  try {
+    uri = new URL(dotenvKey)
+  } catch (error) {
+    if (error.code === 'ERR_INVALID_URL') {
+      const err = new Error('INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development')
+      err.code = 'INVALID_DOTENV_KEY'
+      throw err
+    }
+
+    throw error
+  }
+
+  // Get decrypt key
+  const key = uri.password
+  if (!key) {
+    const err = new Error('INVALID_DOTENV_KEY: Missing key part')
+    err.code = 'INVALID_DOTENV_KEY'
+    throw err
+  }
+
+  // Get environment
+  const environment = uri.searchParams.get('environment')
+  if (!environment) {
+    const err = new Error('INVALID_DOTENV_KEY: Missing environment part')
+    err.code = 'INVALID_DOTENV_KEY'
+    throw err
+  }
+
+  // Get ciphertext payload
+  const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`
+  const ciphertext = result.parsed[environmentKey] // DOTENV_VAULT_PRODUCTION
+  if (!ciphertext) {
+    const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`)
+    err.code = 'NOT_FOUND_DOTENV_ENVIRONMENT'
+    throw err
+  }
+
+  return { ciphertext, key }
+}
+
+function _vaultPath (options) {
+  let possibleVaultPath = null
+
+  if (options && options.path && options.path.length > 0) {
+    if (Array.isArray(options.path)) {
+      for (const filepath of options.path) {
+        if (fs.existsSync(filepath)) {
+          possibleVaultPath = filepath.endsWith('.vault') ? filepath : `${filepath}.vault`
+        }
+      }
+    } else {
+      possibleVaultPath = options.path.endsWith('.vault') ? options.path : `${options.path}.vault`
+    }
+  } else {
+    possibleVaultPath = path.resolve(process.cwd(), '.env.vault')
+  }
+
+  if (fs.existsSync(possibleVaultPath)) {
+    return possibleVaultPath
+  }
+
+  return null
+}
+
+function _resolveHome (envPath) {
+  return envPath[0] === '~' ? path.join(os.homedir(), envPath.slice(1)) : envPath
+}
+
+function _configVault (options) {
+  const debug = Boolean(options && options.debug)
+  const quiet = options && 'quiet' in options ? options.quiet : true
+
+  if (debug || !quiet) {
+    _log('Loading env from encrypted .env.vault')
+  }
+
+  const parsed = DotenvModule._parseVault(options)
+
+  let processEnv = process.env
+  if (options && options.processEnv != null) {
+    processEnv = options.processEnv
+  }
+
+  DotenvModule.populate(processEnv, parsed, options)
+
+  return { parsed }
+}
+
+function configDotenv (options) {
+  const dotenvPath = path.resolve(process.cwd(), '.env')
+  let encoding = 'utf8'
+  const debug = Boolean(options && options.debug)
+  const quiet = options && 'quiet' in options ? options.quiet : true
+
+  if (options && options.encoding) {
+    encoding = options.encoding
+  } else {
+    if (debug) {
+      _debug('No encoding is specified. UTF-8 is used by default')
+    }
+  }
+
+  let optionPaths = [dotenvPath] // default, look for .env
+  if (options && options.path) {
+    if (!Array.isArray(options.path)) {
+      optionPaths = [_resolveHome(options.path)]
+    } else {
+      optionPaths = [] // reset default
+      for (const filepath of options.path) {
+        optionPaths.push(_resolveHome(filepath))
+      }
+    }
+  }
+
+  // Build the parsed data in a temporary object (because we need to return it).  Once we have the final
+  // parsed data, we will combine it with process.env (or options.processEnv if provided).
+  let lastError
+  const parsedAll = {}
+  for (const path of optionPaths) {
+    try {
+      // Specifying an encoding returns a string instead of a buffer
+      const parsed = DotenvModule.parse(fs.readFileSync(path, { encoding }))
+
+      DotenvModule.populate(parsedAll, parsed, options)
+    } catch (e) {
+      if (debug) {
+        _debug(`Failed to load ${path} ${e.message}`)
+      }
+      lastError = e
+    }
+  }
+
+  let processEnv = process.env
+  if (options && options.processEnv != null) {
+    processEnv = options.processEnv
+  }
+
+  DotenvModule.populate(processEnv, parsedAll, options)
+
+  if (debug || !quiet) {
+    const keysCount = Object.keys(parsedAll).length
+    const shortPaths = []
+    for (const filePath of optionPaths) {
+      try {
+        const relative = path.relative(process.cwd(), filePath)
+        shortPaths.push(relative)
+      } catch (e) {
+        if (debug) {
+          _debug(`Failed to load ${filePath} ${e.message}`)
+        }
+        lastError = e
+      }
+    }
+
+    _log(`injecting env (${keysCount}) from ${shortPaths.join(',')}`)
+  }
+
+  if (lastError) {
+    return { parsed: parsedAll, error: lastError }
+  } else {
+    return { parsed: parsedAll }
+  }
+}
+
+// Populates process.env from .env file
+function config (options) {
+  // fallback to original dotenv if DOTENV_KEY is not set
+  if (_dotenvKey(options).length === 0) {
+    return DotenvModule.configDotenv(options)
+  }
+
+  const vaultPath = _vaultPath(options)
+
+  // dotenvKey exists but .env.vault file does not exist
+  if (!vaultPath) {
+    _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`)
+
+    return DotenvModule.configDotenv(options)
+  }
+
+  return DotenvModule._configVault(options)
+}
+
+function decrypt (encrypted, keyStr) {
+  const key = Buffer.from(keyStr.slice(-64), 'hex')
+  let ciphertext = Buffer.from(encrypted, 'base64')
+
+  const nonce = ciphertext.subarray(0, 12)
+  const authTag = ciphertext.subarray(-16)
+  ciphertext = ciphertext.subarray(12, -16)
+
+  try {
+    const aesgcm = crypto.createDecipheriv('aes-256-gcm', key, nonce)
+    aesgcm.setAuthTag(authTag)
+    return `${aesgcm.update(ciphertext)}${aesgcm.final()}`
+  } catch (error) {
+    const isRange = error instanceof RangeError
+    const invalidKeyLength = error.message === 'Invalid key length'
+    const decryptionFailed = error.message === 'Unsupported state or unable to authenticate data'
+
+    if (isRange || invalidKeyLength) {
+      const err = new Error('INVALID_DOTENV_KEY: It must be 64 characters long (or more)')
+      err.code = 'INVALID_DOTENV_KEY'
+      throw err
+    } else if (decryptionFailed) {
+      const err = new Error('DECRYPTION_FAILED: Please check your DOTENV_KEY')
+      err.code = 'DECRYPTION_FAILED'
+      throw err
+    } else {
+      throw error
+    }
+  }
+}
+
+// Populate process.env with parsed values
+function populate (processEnv, parsed, options = {}) {
+  const debug = Boolean(options && options.debug)
+  const override = Boolean(options && options.override)
+
+  if (typeof parsed !== 'object') {
+    const err = new Error('OBJECT_REQUIRED: Please check the processEnv argument being passed to populate')
+    err.code = 'OBJECT_REQUIRED'
+    throw err
+  }
+
+  // Set process.env
+  for (const key of Object.keys(parsed)) {
+    if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+      if (override === true) {
+        processEnv[key] = parsed[key]
+      }
+
+      if (debug) {
+        if (override === true) {
+          _debug(`"${key}" is already defined and WAS overwritten`)
+        } else {
+          _debug(`"${key}" is already defined and was NOT overwritten`)
+        }
+      }
+    } else {
+      processEnv[key] = parsed[key]
+    }
+  }
+}
+
+const DotenvModule = {
+  configDotenv,
+  _configVault,
+  _parseVault,
+  config,
+  decrypt,
+  parse,
+  populate
+}
+
+module.exports.configDotenv = DotenvModule.configDotenv
+module.exports._configVault = DotenvModule._configVault
+module.exports._parseVault = DotenvModule._parseVault
+module.exports.config = DotenvModule.config
+module.exports.decrypt = DotenvModule.decrypt
+module.exports.parse = DotenvModule.parse
+module.exports.populate = DotenvModule.populate
+
+module.exports = DotenvModule

backend/node_modules/effect/src/internal/layer/circular.ts

@@ -0,0 +1,214 @@
+import type * as ConfigProvider from "../../ConfigProvider.js"
+import * as Context from "../../Context.js"
+import type * as Effect from "../../Effect.js"
+import type * as Exit from "../../Exit.js"
+import { dual } from "../../Function.js"
+import * as HashSet from "../../HashSet.js"
+import type * as Layer from "../../Layer.js"
+import type * as Logger from "../../Logger.js"
+import type * as LogLevel from "../../LogLevel.js"
+import type { Scope } from "../../Scope.js"
+import type * as Supervisor from "../../Supervisor.js"
+import type * as Tracer from "../../Tracer.js"
+import * as core from "../core.js"
+import * as fiberRuntime from "../fiberRuntime.js"
+import * as layer from "../layer.js"
+import * as runtimeFlags from "../runtimeFlags.js"
+import * as runtimeFlagsPatch from "../runtimeFlagsPatch.js"
+import * as supervisor_ from "../supervisor.js"
+import * as tracer from "../tracer.js"
+
+// circular with Logger
+
+/** @internal */
+export const minimumLogLevel = (level: LogLevel.LogLevel): Layer.Layer<never> =>
+  layer.scopedDiscard(
+    fiberRuntime.fiberRefLocallyScoped(
+      fiberRuntime.currentMinimumLogLevel,
+      level
+    )
+  )
+
+/** @internal */
+export const withMinimumLogLevel = dual<
+  (level: LogLevel.LogLevel) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(self: Effect.Effect<A, E, R>, level: LogLevel.LogLevel) => Effect.Effect<A, E, R>
+>(2, (self, level) =>
+  core.fiberRefLocally(
+    fiberRuntime.currentMinimumLogLevel,
+    level
+  )(self))
+
+/** @internal */
+export const addLogger = <A>(logger: Logger.Logger<unknown, A>): Layer.Layer<never> =>
+  layer.scopedDiscard(
+    fiberRuntime.fiberRefLocallyScopedWith(
+      fiberRuntime.currentLoggers,
+      HashSet.add(logger)
+    )
+  )
+
+/** @internal */
+export const addLoggerEffect = <A, E, R>(
+  effect: Effect.Effect<Logger.Logger<unknown, A>, E, R>
+): Layer.Layer<never, E, R> =>
+  layer.unwrapEffect(
+    core.map(effect, addLogger)
+  )
+
+/** @internal */
+export const addLoggerScoped = <A, E, R>(
+  effect: Effect.Effect<Logger.Logger<unknown, A>, E, R>
+): Layer.Layer<never, E, Exclude<R, Scope>> =>
+  layer.unwrapScoped(
+    core.map(effect, addLogger)
+  )
+
+/** @internal */
+export const removeLogger = <A>(logger: Logger.Logger<unknown, A>): Layer.Layer<never> =>
+  layer.scopedDiscard(
+    fiberRuntime.fiberRefLocallyScopedWith(
+      fiberRuntime.currentLoggers,
+      HashSet.remove(logger)
+    )
+  )
+
+/** @internal */
+export const replaceLogger = dual<
+  <B>(that: Logger.Logger<unknown, B>) => <A>(self: Logger.Logger<unknown, A>) => Layer.Layer<never>,
+  <A, B>(self: Logger.Logger<unknown, A>, that: Logger.Logger<unknown, B>) => Layer.Layer<never>
+>(2, (self, that) => layer.flatMap(removeLogger(self), () => addLogger(that)))
+
+/** @internal */
+export const replaceLoggerEffect = dual<
+  <B, E, R>(
+    that: Effect.Effect<Logger.Logger<unknown, B>, E, R>
+  ) => <A>(self: Logger.Logger<unknown, A>) => Layer.Layer<never, E, R>,
+  <A, B, E, R>(
+    self: Logger.Logger<unknown, A>,
+    that: Effect.Effect<Logger.Logger<unknown, B>, E, R>
+  ) => Layer.Layer<never, E, R>
+>(2, (self, that) => layer.flatMap(removeLogger(self), () => addLoggerEffect(that)))
+
+/** @internal */
+export const replaceLoggerScoped = dual<
+  <B, E, R>(
+    that: Effect.Effect<Logger.Logger<unknown, B>, E, R>
+  ) => <A>(self: Logger.Logger<unknown, A>) => Layer.Layer<never, E, Exclude<R, Scope>>,
+  <A, B, E, R>(
+    self: Logger.Logger<unknown, A>,
+    that: Effect.Effect<Logger.Logger<unknown, B>, E, R>
+  ) => Layer.Layer<never, E, Exclude<R, Scope>>
+>(2, (self, that) => layer.flatMap(removeLogger(self), () => addLoggerScoped(that)))
+
+/** @internal */
+export const addSupervisor = <A>(supervisor: Supervisor.Supervisor<A>): Layer.Layer<never> =>
+  layer.scopedDiscard(
+    fiberRuntime.fiberRefLocallyScopedWith(
+      fiberRuntime.currentSupervisor,
+      (current) => new supervisor_.Zip(current, supervisor)
+    )
+  )
+
+/** @internal */
+export const enableCooperativeYielding: Layer.Layer<never> = layer.scopedDiscard(
+  fiberRuntime.withRuntimeFlagsScoped(
+    runtimeFlagsPatch.enable(runtimeFlags.CooperativeYielding)
+  )
+)
+
+/** @internal */
+export const enableInterruption: Layer.Layer<never> = layer.scopedDiscard(
+  fiberRuntime.withRuntimeFlagsScoped(
+    runtimeFlagsPatch.enable(runtimeFlags.Interruption)
+  )
+)
+
+/** @internal */
+export const enableOpSupervision: Layer.Layer<never> = layer.scopedDiscard(
+  fiberRuntime.withRuntimeFlagsScoped(
+    runtimeFlagsPatch.enable(runtimeFlags.OpSupervision)
+  )
+)
+
+/** @internal */
+export const enableRuntimeMetrics: Layer.Layer<never> = layer.scopedDiscard(
+  fiberRuntime.withRuntimeFlagsScoped(
+    runtimeFlagsPatch.enable(runtimeFlags.RuntimeMetrics)
+  )
+)
+
+/** @internal */
+export const enableWindDown: Layer.Layer<never> = layer.scopedDiscard(
+  fiberRuntime.withRuntimeFlagsScoped(
+    runtimeFlagsPatch.enable(runtimeFlags.WindDown)
+  )
+)
+
+/** @internal */
+export const disableCooperativeYielding: Layer.Layer<never> = layer.scopedDiscard(
+  fiberRuntime.withRuntimeFlagsScoped(
+    runtimeFlagsPatch.disable(runtimeFlags.CooperativeYielding)
+  )
+)
+
+/** @internal */
+export const disableInterruption: Layer.Layer<never> = layer.scopedDiscard(
+  fiberRuntime.withRuntimeFlagsScoped(
+    runtimeFlagsPatch.disable(runtimeFlags.Interruption)
+  )
+)
+
+/** @internal */
+export const disableOpSupervision: Layer.Layer<never> = layer.scopedDiscard(
+  fiberRuntime.withRuntimeFlagsScoped(
+    runtimeFlagsPatch.disable(runtimeFlags.OpSupervision)
+  )
+)
+
+/** @internal */
+export const disableRuntimeMetrics: Layer.Layer<never> = layer.scopedDiscard(
+  fiberRuntime.withRuntimeFlagsScoped(
+    runtimeFlagsPatch.disable(runtimeFlags.RuntimeMetrics)
+  )
+)
+
+/** @internal */
+export const disableWindDown: Layer.Layer<never> = layer.scopedDiscard(
+  fiberRuntime.withRuntimeFlagsScoped(
+    runtimeFlagsPatch.disable(runtimeFlags.WindDown)
+  )
+)
+
+/** @internal */
+export const setConfigProvider = (configProvider: ConfigProvider.ConfigProvider): Layer.Layer<never> =>
+  layer.scopedDiscard(fiberRuntime.withConfigProviderScoped(configProvider))
+
+/** @internal */
+export const parentSpan = (span: Tracer.AnySpan): Layer.Layer<Tracer.ParentSpan> =>
+  layer.succeedContext(Context.make(tracer.spanTag, span))
+
+/** @internal */
+export const span = (
+  name: string,
+  options?: Tracer.SpanOptions & {
+    readonly onEnd?:
+      | ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>)
+      | undefined
+  }
+): Layer.Layer<Tracer.ParentSpan> => {
+  options = tracer.addSpanStackTrace(options) as any
+  return layer.scoped(
+    tracer.spanTag,
+    options?.onEnd
+      ? core.tap(
+        fiberRuntime.makeSpanScoped(name, options),
+        (span) => fiberRuntime.addFinalizer((exit) => options.onEnd!(span, exit))
+      )
+      : fiberRuntime.makeSpanScoped(name, options)
+  )
+}
+
+/** @internal */
+export const setTracer = (tracer: Tracer.Tracer): Layer.Layer<never> =>
+  layer.scopedDiscard(fiberRuntime.withTracerScoped(tracer))

backend/node_modules/effect/src/internal/metric/label.ts

@@ -0,0 +1,41 @@
+import * as Equal from "../../Equal.js"
+import * as Hash from "../../Hash.js"
+import type * as MetricLabel from "../../MetricLabel.js"
+import { pipeArguments } from "../../Pipeable.js"
+import { hasProperty } from "../../Predicate.js"
+
+/** @internal */
+const MetricLabelSymbolKey = "effect/MetricLabel"
+
+/** @internal */
+export const MetricLabelTypeId: MetricLabel.MetricLabelTypeId = Symbol.for(
+  MetricLabelSymbolKey
+) as MetricLabel.MetricLabelTypeId
+
+/** @internal */
+class MetricLabelImpl implements MetricLabel.MetricLabel {
+  readonly [MetricLabelTypeId]: MetricLabel.MetricLabelTypeId = MetricLabelTypeId
+  readonly _hash: number
+  constructor(readonly key: string, readonly value: string) {
+    this._hash = Hash.string(MetricLabelSymbolKey + this.key + this.value)
+  }
+  [Hash.symbol](): number {
+    return this._hash
+  }
+  [Equal.symbol](that: unknown): boolean {
+    return isMetricLabel(that) &&
+      this.key === that.key &&
+      this.value === that.value
+  }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** @internal */
+export const make = (key: string, value: string): MetricLabel.MetricLabel => {
+  return new MetricLabelImpl(key, value)
+}
+
+/** @internal */
+export const isMetricLabel = (u: unknown): u is MetricLabel.MetricLabel => hasProperty(u, MetricLabelTypeId)

backend/node_modules/effect/src/internal/metric/pair.ts

@@ -0,0 +1,48 @@
+import type * as MetricKey from "../../MetricKey.js"
+import type * as MetricKeyType from "../../MetricKeyType.js"
+import type * as MetricPair from "../../MetricPair.js"
+import type * as MetricState from "../../MetricState.js"
+import { pipeArguments } from "../../Pipeable.js"
+
+/** @internal */
+const MetricPairSymbolKey = "effect/MetricPair"
+
+/** @internal */
+export const MetricPairTypeId: MetricPair.MetricPairTypeId = Symbol.for(
+  MetricPairSymbolKey
+) as MetricPair.MetricPairTypeId
+
+const metricPairVariance = {
+  /* c8 ignore next */
+  _Type: (_: never) => _
+}
+
+/** @internal */
+export const make = <Type extends MetricKeyType.MetricKeyType<any, any>>(
+  metricKey: MetricKey.MetricKey<Type>,
+  metricState: MetricState.MetricState<MetricKeyType.MetricKeyType.OutType<Type>>
+): MetricPair.MetricPair.Untyped => {
+  return {
+    [MetricPairTypeId]: metricPairVariance,
+    metricKey,
+    metricState,
+    pipe() {
+      return pipeArguments(this, arguments)
+    }
+  }
+}
+
+/** @internal */
+export const unsafeMake = <Type extends MetricKeyType.MetricKeyType<any, any>>(
+  metricKey: MetricKey.MetricKey<Type>,
+  metricState: MetricState.MetricState.Untyped
+): MetricPair.MetricPair.Untyped => {
+  return {
+    [MetricPairTypeId]: metricPairVariance,
+    metricKey,
+    metricState,
+    pipe() {
+      return pipeArguments(this, arguments)
+    }
+  }
+}

backend/node_modules/effect/src/internal/metric/polling.ts

@@ -0,0 +1,149 @@
+import type * as Effect from "../../Effect.js"
+import type * as Fiber from "../../Fiber.js"
+import { dual, pipe } from "../../Function.js"
+import type * as Metric from "../../Metric.js"
+import type * as MetricPolling from "../../MetricPolling.js"
+import { pipeArguments } from "../../Pipeable.js"
+import type * as Schedule from "../../Schedule.js"
+import type * as Scope from "../../Scope.js"
+import * as core from "../core.js"
+import * as metric from "../metric.js"
+import * as schedule_ from "../schedule.js"
+
+/** @internal */
+const MetricPollingSymbolKey = "effect/MetricPolling"
+
+/** @internal */
+export const MetricPollingTypeId: MetricPolling.MetricPollingTypeId = Symbol.for(
+  MetricPollingSymbolKey
+) as MetricPolling.MetricPollingTypeId
+
+/** @internal */
+export const make = <Type, In, Out, R, E>(
+  metric: Metric.Metric<Type, In, Out>,
+  poll: Effect.Effect<In, E, R>
+): MetricPolling.MetricPolling<Type, In, R, E, Out> => {
+  return {
+    [MetricPollingTypeId]: MetricPollingTypeId,
+    pipe() {
+      return pipeArguments(this, arguments)
+    },
+    metric,
+    poll
+  }
+}
+
+/** @internal */
+export const collectAll = <R, E, Out>(
+  iterable: Iterable<MetricPolling.MetricPolling<any, any, R, E, Out>>
+): MetricPolling.MetricPolling<Array<any>, Array<any>, R, E, Array<Out>> => {
+  const metrics = Array.from(iterable)
+  return {
+    [MetricPollingTypeId]: MetricPollingTypeId,
+    pipe() {
+      return pipeArguments(this, arguments)
+    },
+    metric: metric.make(
+      Array.of<any>(void 0) as Array<any>,
+      (inputs: Array<any>, extraTags) => {
+        for (let i = 0; i < inputs.length; i++) {
+          const pollingMetric = metrics[i]!
+          const input = pipe(inputs, (x) => x[i])
+          pollingMetric.metric.unsafeUpdate(input, extraTags)
+        }
+      },
+      (extraTags) =>
+        Array.from(
+          metrics.map((pollingMetric) => pollingMetric.metric.unsafeValue(extraTags))
+        ),
+      (inputs: Array<any>, extraTags) => {
+        for (let i = 0; i < inputs.length; i++) {
+          const pollingMetric = metrics[i]!
+          const input = pipe(inputs, (x) => x[i])
+          pollingMetric.metric.unsafeModify(input, extraTags)
+        }
+      }
+    ),
+    poll: core.forEachSequential(metrics, (metric) => metric.poll)
+  }
+}
+
+/** @internal */
+export const launch = dual<
+  <A2, R2>(
+    schedule: Schedule.Schedule<A2, unknown, R2>
+  ) => <Type, In, R, E, Out>(
+    self: MetricPolling.MetricPolling<Type, In, R, E, Out>
+  ) => Effect.Effect<Fiber.Fiber<A2, E>, never, R | R2 | Scope.Scope>,
+  <Type, In, R, E, Out, A2, R2>(
+    self: MetricPolling.MetricPolling<Type, In, R, E, Out>,
+    schedule: Schedule.Schedule<A2, unknown, R2>
+  ) => Effect.Effect<Fiber.Fiber<A2, E>, never, R | R2 | Scope.Scope>
+>(2, (self, schedule) =>
+  pipe(
+    pollAndUpdate(self),
+    core.zipRight(metric.value(self.metric)),
+    schedule_.scheduleForked(schedule)
+  ))
+
+/** @internal */
+export const poll = <Type, In, R, E, Out>(
+  self: MetricPolling.MetricPolling<Type, In, R, E, Out>
+): Effect.Effect<In, E, R> => self.poll
+
+/** @internal */
+export const pollAndUpdate = <Type, In, R, E, Out>(
+  self: MetricPolling.MetricPolling<Type, In, R, E, Out>
+): Effect.Effect<void, E, R> => core.flatMap(self.poll, (value) => metric.update(self.metric, value))
+
+/** @internal */
+export const retry = dual<
+  <X, E, R2>(
+    policy: Schedule.Schedule<X, E, R2>
+  ) => <Type, In, R, Out>(
+    self: MetricPolling.MetricPolling<Type, In, R, E, Out>
+  ) => MetricPolling.MetricPolling<Type, In, R | R2, E, Out>,
+  <Type, In, R, E, Out, X, R2>(
+    self: MetricPolling.MetricPolling<Type, In, R, E, Out>,
+    policy: Schedule.Schedule<X, E, R2>
+  ) => MetricPolling.MetricPolling<Type, In, R | R2, E, Out>
+>(2, (self, policy) => ({
+  [MetricPollingTypeId]: MetricPollingTypeId,
+  pipe() {
+    return pipeArguments(this, arguments)
+  },
+  metric: self.metric,
+  poll: schedule_.retry_Effect(self.poll, policy)
+}))
+
+/** @internal */
+export const zip = dual<
+  <Type2, In2, R2, E2, Out2>(
+    that: MetricPolling.MetricPolling<Type2, In2, R2, E2, Out2>
+  ) => <Type, In, R, E, Out>(
+    self: MetricPolling.MetricPolling<Type, In, R, E, Out>
+  ) => MetricPolling.MetricPolling<
+    readonly [Type, Type2],
+    readonly [In, In2],
+    R | R2,
+    E | E2,
+    [Out, Out2]
+  >,
+  <Type, In, R, E, Out, Type2, In2, R2, E2, Out2>(
+    self: MetricPolling.MetricPolling<Type, In, R, E, Out>,
+    that: MetricPolling.MetricPolling<Type2, In2, R2, E2, Out2>
+  ) => MetricPolling.MetricPolling<
+    readonly [Type, Type2],
+    readonly [In, In2],
+    R | R2,
+    E | E2,
+    [Out, Out2]
+  >
+>(2, (self, that) => ({
+  [MetricPollingTypeId]: MetricPollingTypeId,
+  pipe() {
+    return pipeArguments(this, arguments)
+  },
+  metric: pipe(self.metric, metric.zip(that.metric)),
+  poll: core.zip(self.poll, that.poll)
+}))

backend/node_modules/effect/src/internal/metric/state.ts

@@ -0,0 +1,290 @@
+import * as Arr from "../../Array.js"
+import * as Equal from "../../Equal.js"
+import { pipe } from "../../Function.js"
+import * as Hash from "../../Hash.js"
+import type * as MetricState from "../../MetricState.js"
+import type * as Option from "../../Option.js"
+import { pipeArguments } from "../../Pipeable.js"
+import { hasProperty } from "../../Predicate.js"
+
+/** @internal */
+const MetricStateSymbolKey = "effect/MetricState"
+
+/** @internal */
+export const MetricStateTypeId: MetricState.MetricStateTypeId = Symbol.for(
+  MetricStateSymbolKey
+) as MetricState.MetricStateTypeId
+
+/** @internal */
+const CounterStateSymbolKey = "effect/MetricState/Counter"
+
+/** @internal */
+export const CounterStateTypeId: MetricState.CounterStateTypeId = Symbol.for(
+  CounterStateSymbolKey
+) as MetricState.CounterStateTypeId
+
+/** @internal */
+const FrequencyStateSymbolKey = "effect/MetricState/Frequency"
+
+/** @internal */
+export const FrequencyStateTypeId: MetricState.FrequencyStateTypeId = Symbol.for(
+  FrequencyStateSymbolKey
+) as MetricState.FrequencyStateTypeId
+
+/** @internal */
+const GaugeStateSymbolKey = "effect/MetricState/Gauge"
+
+/** @internal */
+export const GaugeStateTypeId: MetricState.GaugeStateTypeId = Symbol.for(
+  GaugeStateSymbolKey
+) as MetricState.GaugeStateTypeId
+
+/** @internal */
+const HistogramStateSymbolKey = "effect/MetricState/Histogram"
+
+/** @internal */
+export const HistogramStateTypeId: MetricState.HistogramStateTypeId = Symbol.for(
+  HistogramStateSymbolKey
+) as MetricState.HistogramStateTypeId
+
+/** @internal */
+const SummaryStateSymbolKey = "effect/MetricState/Summary"
+
+/** @internal */
+export const SummaryStateTypeId: MetricState.SummaryStateTypeId = Symbol.for(
+  SummaryStateSymbolKey
+) as MetricState.SummaryStateTypeId
+
+const metricStateVariance = {
+  /* c8 ignore next */
+  _A: (_: unknown) => _
+}
+
+/** @internal */
+class CounterState<A extends (number | bigint)> implements MetricState.MetricState.Counter<A> {
+  readonly [MetricStateTypeId] = metricStateVariance
+  readonly [CounterStateTypeId]: MetricState.CounterStateTypeId = CounterStateTypeId
+  constructor(readonly count: A) {}
+  [Hash.symbol](): number {
+    return pipe(
+      Hash.hash(CounterStateSymbolKey),
+      Hash.combine(Hash.hash(this.count)),
+      Hash.cached(this)
+    )
+  }
+  [Equal.symbol](that: unknown): boolean {
+    return isCounterState(that) && this.count === that.count
+  }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+const arrayEquals = Arr.getEquivalence(Equal.equals)
+
+/** @internal */
+class FrequencyState implements MetricState.MetricState.Frequency {
+  readonly [MetricStateTypeId] = metricStateVariance
+  readonly [FrequencyStateTypeId]: MetricState.FrequencyStateTypeId = FrequencyStateTypeId
+  constructor(readonly occurrences: ReadonlyMap<string, number>) {}
+  _hash: number | undefined;
+  [Hash.symbol](): number {
+    return pipe(
+      Hash.string(FrequencyStateSymbolKey),
+      Hash.combine(Hash.array(Arr.fromIterable(this.occurrences.entries()))),
+      Hash.cached(this)
+    )
+  }
+  [Equal.symbol](that: unknown): boolean {
+    return isFrequencyState(that) && arrayEquals(
+      Arr.fromIterable(this.occurrences.entries()),
+      Arr.fromIterable(that.occurrences.entries())
+    )
+  }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** @internal */
+class GaugeState<A extends (number | bigint)> implements MetricState.MetricState.Gauge<A> {
+  readonly [MetricStateTypeId] = metricStateVariance
+  readonly [GaugeStateTypeId]: MetricState.GaugeStateTypeId = GaugeStateTypeId
+  constructor(readonly value: A) {}
+  [Hash.symbol](): number {
+    return pipe(
+      Hash.hash(GaugeStateSymbolKey),
+      Hash.combine(Hash.hash(this.value)),
+      Hash.cached(this)
+    )
+  }
+  [Equal.symbol](u: unknown): boolean {
+    return isGaugeState(u) && this.value === u.value
+  }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** @internal */
+export class HistogramState implements MetricState.MetricState.Histogram {
+  readonly [MetricStateTypeId] = metricStateVariance
+  readonly [HistogramStateTypeId]: MetricState.HistogramStateTypeId = HistogramStateTypeId
+  constructor(
+    readonly buckets: ReadonlyArray<readonly [number, number]>,
+    readonly count: number,
+    readonly min: number,
+    readonly max: number,
+    readonly sum: number
+  ) {}
+  [Hash.symbol](): number {
+    return pipe(
+      Hash.hash(HistogramStateSymbolKey),
+      Hash.combine(Hash.hash(this.buckets)),
+      Hash.combine(Hash.hash(this.count)),
+      Hash.combine(Hash.hash(this.min)),
+      Hash.combine(Hash.hash(this.max)),
+      Hash.combine(Hash.hash(this.sum)),
+      Hash.cached(this)
+    )
+  }
+  [Equal.symbol](that: unknown): boolean {
+    return isHistogramState(that) &&
+      Equal.equals(this.buckets, that.buckets) &&
+      this.count === that.count &&
+      this.min === that.min &&
+      this.max === that.max &&
+      this.sum === that.sum
+  }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** @internal */
+export class SummaryState implements MetricState.MetricState.Summary {
+  readonly [MetricStateTypeId] = metricStateVariance
+  readonly [SummaryStateTypeId]: MetricState.SummaryStateTypeId = SummaryStateTypeId
+  constructor(
+    readonly error: number,
+    readonly quantiles: ReadonlyArray<readonly [number, Option.Option<number>]>,
+    readonly count: number,
+    readonly min: number,
+    readonly max: number,
+    readonly sum: number
+  ) {}
+  [Hash.symbol](): number {
+    return pipe(
+      Hash.hash(SummaryStateSymbolKey),
+      Hash.combine(Hash.hash(this.error)),
+      Hash.combine(Hash.hash(this.quantiles)),
+      Hash.combine(Hash.hash(this.count)),
+      Hash.combine(Hash.hash(this.min)),
+      Hash.combine(Hash.hash(this.max)),
+      Hash.combine(Hash.hash(this.sum)),
+      Hash.cached(this)
+    )
+  }
+  [Equal.symbol](that: unknown): boolean {
+    return isSummaryState(that) &&
+      this.error === that.error &&
+      Equal.equals(this.quantiles, that.quantiles) &&
+      this.count === that.count &&
+      this.min === that.min &&
+      this.max === that.max &&
+      this.sum === that.sum
+  }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** @internal */
+export const counter: {
+  (count: number): MetricState.MetricState.Counter<number>
+  (count: bigint): MetricState.MetricState.Counter<bigint>
+} = (count) => new CounterState(count) as any
+
+/** @internal */
+export const frequency = (occurrences: ReadonlyMap<string, number>): MetricState.MetricState.Frequency => {
+  return new FrequencyState(occurrences)
+}
+
+/** @internal */
+export const gauge: {
+  (count: number): MetricState.MetricState.Gauge<number>
+  (count: bigint): MetricState.MetricState.Gauge<bigint>
+} = (count) => new GaugeState(count) as any
+
+/** @internal */
+export const histogram = (
+  options: {
+    readonly buckets: ReadonlyArray<readonly [number, number]>
+    readonly count: number
+    readonly min: number
+    readonly max: number
+    readonly sum: number
+  }
+): MetricState.MetricState.Histogram =>
+  new HistogramState(
+    options.buckets,
+    options.count,
+    options.min,
+    options.max,
+    options.sum
+  )
+
+/** @internal */
+export const summary = (
+  options: {
+    readonly error: number
+    readonly quantiles: ReadonlyArray<readonly [number, Option.Option<number>]>
+    readonly count: number
+    readonly min: number
+    readonly max: number
+    readonly sum: number
+  }
+): MetricState.MetricState.Summary =>
+  new SummaryState(
+    options.error,
+    options.quantiles,
+    options.count,
+    options.min,
+    options.max,
+    options.sum
+  )
+
+/** @internal */
+export const isMetricState = (u: unknown): u is MetricState.MetricState.Counter<number | bigint> =>
+  hasProperty(u, MetricStateTypeId)
+
+/** @internal */
+export const isCounterState = (u: unknown): u is MetricState.MetricState.Counter<number | bigint> =>
+  hasProperty(u, CounterStateTypeId)
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isFrequencyState = (u: unknown): u is MetricState.MetricState.Frequency =>
+  hasProperty(u, FrequencyStateTypeId)
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isGaugeState = (u: unknown): u is MetricState.MetricState.Gauge<number | bigint> =>
+  hasProperty(u, GaugeStateTypeId)
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isHistogramState = (u: unknown): u is MetricState.MetricState.Histogram =>
+  hasProperty(u, HistogramStateTypeId)
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isSummaryState = (u: unknown): u is MetricState.MetricState.Summary => hasProperty(u, SummaryStateTypeId)

backend/node_modules/effect/src/internal/opCodes/channelUpstreamPullStrategy.ts

@@ -0,0 +1,11 @@
+/** @internal */
+export const OP_PULL_AFTER_NEXT = "PullAfterNext" as const
+
+/** @internal */
+export type OP_PULL_AFTER_NEXT = typeof OP_PULL_AFTER_NEXT
+
+/** @internal */
+export const OP_PULL_AFTER_ALL_ENQUEUED = "PullAfterAllEnqueued" as const
+
+/** @internal */
+export type OP_PULL_AFTER_ALL_ENQUEUED = typeof OP_PULL_AFTER_ALL_ENQUEUED

backend/node_modules/effect/src/internal/schema/util.ts

@@ -0,0 +1,50 @@
+import type { NonEmptyReadonlyArray } from "../../Array.js"
+import * as Inspectable from "../../Inspectable.js"
+import type * as ParseResult from "../../ParseResult.js"
+import type * as AST from "../../SchemaAST.js"
+
+/** @internal */
+export const getKeysForIndexSignature = (
+  input: { readonly [x: PropertyKey]: unknown },
+  parameter: AST.Parameter
+): ReadonlyArray<string> | ReadonlyArray<symbol> => {
+  switch (parameter._tag) {
+    case "StringKeyword":
+    case "TemplateLiteral":
+      return Object.keys(input)
+    case "SymbolKeyword":
+      return Object.getOwnPropertySymbols(input)
+    case "Refinement":
+      return getKeysForIndexSignature(input, parameter.from)
+  }
+}
+
+/** @internal */
+export const memoizeThunk = <A>(f: () => A): () => A => {
+  let done = false
+  let a: A
+  return () => {
+    if (done) {
+      return a
+    }
+    a = f()
+    done = true
+    return a
+  }
+}
+
+/** @internal */
+export type SingleOrArray<A> = A | ReadonlyArray<A>
+
+/** @internal */
+export const isNonEmpty = <A>(x: ParseResult.SingleOrNonEmpty<A>): x is NonEmptyReadonlyArray<A> => Array.isArray(x)
+
+/** @internal */
+export const isSingle = <A>(x: A | ReadonlyArray<A>): x is A => !Array.isArray(x)
+
+/** @internal */
+export const formatPathKey = (key: PropertyKey): string => `[${Inspectable.formatPropertyKey(key)}]`
+
+/** @internal */
+export const formatPath = (path: ParseResult.Path): string =>
+  isNonEmpty(path) ? path.map(formatPathKey).join("") : formatPathKey(path)

backend/node_modules/effect/src/internal/supervisor/patch.ts

@@ -0,0 +1,190 @@
+import * as Chunk from "../../Chunk.js"
+import * as Differ from "../../Differ.js"
+import * as Equal from "../../Equal.js"
+import { pipe } from "../../Function.js"
+import * as HashSet from "../../HashSet.js"
+import type * as Supervisor from "../../Supervisor.js"
+import * as supervisor from "../supervisor.js"
+
+/** @internal */
+export type SupervisorPatch = Empty | AddSupervisor | RemoveSupervisor | AndThen
+
+/** @internal */
+export const OP_EMPTY = "Empty" as const
+
+/** @internal */
+export type OP_EMPTY = typeof OP_EMPTY
+
+/** @internal */
+export const OP_ADD_SUPERVISOR = "AddSupervisor" as const
+
+/** @internal */
+export type OP_ADD_SUPERVISOR = typeof OP_ADD_SUPERVISOR
+
+/** @internal */
+export const OP_REMOVE_SUPERVISOR = "RemoveSupervisor" as const
+
+/** @internal */
+export type OP_REMOVE_SUPERVISOR = typeof OP_REMOVE_SUPERVISOR
+
+/** @internal */
+export const OP_AND_THEN = "AndThen" as const
+
+/** @internal */
+export type OP_AND_THEN = typeof OP_AND_THEN
+
+/** @internal */
+export interface Empty {
+  readonly _tag: OP_EMPTY
+}
+
+/** @internal */
+export interface AddSupervisor {
+  readonly _tag: OP_ADD_SUPERVISOR
+  readonly supervisor: Supervisor.Supervisor<any>
+}
+
+/** @internal */
+export interface RemoveSupervisor {
+  readonly _tag: OP_REMOVE_SUPERVISOR
+  readonly supervisor: Supervisor.Supervisor<any>
+}
+
+/** @internal */
+export interface AndThen {
+  readonly _tag: OP_AND_THEN
+  readonly first: SupervisorPatch
+  readonly second: SupervisorPatch
+}
+
+/**
+ * The empty `SupervisorPatch`.
+ *
+ * @internal
+ */
+export const empty: SupervisorPatch = { _tag: OP_EMPTY }
+
+/**
+ * Combines two patches to produce a new patch that describes applying the
+ * updates from this patch and then the updates from the specified patch.
+ *
+ * @internal
+ */
+export const combine = (self: SupervisorPatch, that: SupervisorPatch): SupervisorPatch => {
+  return {
+    _tag: OP_AND_THEN,
+    first: self,
+    second: that
+  }
+}
+
+/**
+ * Applies a `SupervisorPatch` to a `Supervisor` to produce a new `Supervisor`.
+ *
+ * @internal
+ */
+export const patch = (
+  self: SupervisorPatch,
+  supervisor: Supervisor.Supervisor<any>
+): Supervisor.Supervisor<any> => {
+  return patchLoop(supervisor, Chunk.of(self))
+}
+
+/** @internal */
+const patchLoop = (
+  _supervisor: Supervisor.Supervisor<any>,
+  _patches: Chunk.Chunk<SupervisorPatch>
+): Supervisor.Supervisor<any> => {
+  let supervisor = _supervisor
+  let patches = _patches
+  while (Chunk.isNonEmpty(patches)) {
+    const head = Chunk.headNonEmpty(patches)
+    switch (head._tag) {
+      case OP_EMPTY: {
+        patches = Chunk.tailNonEmpty(patches)
+        break
+      }
+      case OP_ADD_SUPERVISOR: {
+        supervisor = supervisor.zip(head.supervisor)
+        patches = Chunk.tailNonEmpty(patches)
+        break
+      }
+      case OP_REMOVE_SUPERVISOR: {
+        supervisor = removeSupervisor(supervisor, head.supervisor)
+        patches = Chunk.tailNonEmpty(patches)
+        break
+      }
+      case OP_AND_THEN: {
+        patches = Chunk.prepend(head.first)(Chunk.prepend(head.second)(Chunk.tailNonEmpty(patches)))
+        break
+      }
+    }
+  }
+  return supervisor
+}
+
+/** @internal */
+const removeSupervisor = (
+  self: Supervisor.Supervisor<any>,
+  that: Supervisor.Supervisor<any>
+): Supervisor.Supervisor<any> => {
+  if (Equal.equals(self, that)) {
+    return supervisor.none
+  } else {
+    if (supervisor.isZip(self)) {
+      return removeSupervisor(self.left, that).zip(removeSupervisor(self.right, that))
+    } else {
+      return self
+    }
+  }
+}
+
+/** @internal */
+const toSet = (self: Supervisor.Supervisor<any>): HashSet.HashSet<Supervisor.Supervisor<any>> => {
+  if (Equal.equals(self, supervisor.none)) {
+    return HashSet.empty()
+  } else {
+    if (supervisor.isZip(self)) {
+      return pipe(toSet(self.left), HashSet.union(toSet(self.right)))
+    } else {
+      return HashSet.make(self)
+    }
+  }
+}
+
+/** @internal */
+export const diff = (
+  oldValue: Supervisor.Supervisor<any>,
+  newValue: Supervisor.Supervisor<any>
+): SupervisorPatch => {
+  if (Equal.equals(oldValue, newValue)) {
+    return empty
+  }
+  const oldSupervisors = toSet(oldValue)
+  const newSupervisors = toSet(newValue)
+  const added = pipe(
+    newSupervisors,
+    HashSet.difference(oldSupervisors),
+    HashSet.reduce(
+      empty as SupervisorPatch,
+      (patch, supervisor) => combine(patch, { _tag: OP_ADD_SUPERVISOR, supervisor })
+    )
+  )
+  const removed = pipe(
+    oldSupervisors,
+    HashSet.difference(newSupervisors),
+    HashSet.reduce(
+      empty as SupervisorPatch,
+      (patch, supervisor) => combine(patch, { _tag: OP_REMOVE_SUPERVISOR, supervisor })
+    )
+  )
+  return combine(added, removed)
+}
+
+/** @internal */
+export const differ = Differ.make<Supervisor.Supervisor<any>, SupervisorPatch>({
+  empty,
+  patch,
+  combine,
+  diff
+})

backend/node_modules/perfect-debounce/dist/index.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+const DEBOUNCE_DEFAULTS = {
+  trailing: true
+};
+function debounce(fn, wait = 25, options = {}) {
+  options = { ...DEBOUNCE_DEFAULTS, ...options };
+  if (!Number.isFinite(wait)) {
+    throw new TypeError("Expected `wait` to be a finite number");
+  }
+  let leadingValue;
+  let timeout;
+  let resolveList = [];
+  let currentPromise;
+  let trailingArgs;
+  const applyFn = (_this, args) => {
+    currentPromise = _applyPromised(fn, _this, args);
+    currentPromise.finally(() => {
+      currentPromise = null;
+      if (options.trailing && trailingArgs && !timeout) {
+        const promise = applyFn(_this, trailingArgs);
+        trailingArgs = null;
+        return promise;
+      }
+    });
+    return currentPromise;
+  };
+  return function(...args) {
+    if (currentPromise) {
+      if (options.trailing) {
+        trailingArgs = args;
+      }
+      return currentPromise;
+    }
+    return new Promise((resolve) => {
+      const shouldCallNow = !timeout && options.leading;
+      clearTimeout(timeout);
+      timeout = setTimeout(() => {
+        timeout = null;
+        const promise = options.leading ? leadingValue : applyFn(this, args);
+        for (const _resolve of resolveList) {
+          _resolve(promise);
+        }
+        resolveList = [];
+      }, wait);
+      if (shouldCallNow) {
+        leadingValue = applyFn(this, args);
+        resolve(leadingValue);
+      } else {
+        resolveList.push(resolve);
+      }
+    });
+  };
+}
+async function _applyPromised(fn, _this, args) {
+  return await fn.apply(_this, args);
+}
+
+exports.debounce = debounce;

backend/node_modules/perfect-debounce/dist/index.d.ts

@@ -0,0 +1,34 @@
+interface DebounceOptions {
+    /**
+    Call the `fn` on the [leading edge of the timeout](https://css-tricks.com/debouncing-throttling-explained-examples/#article-header-id-1).
+    Meaning immediately, instead of waiting for `wait` milliseconds.
+    @default false
+    */
+    readonly leading?: boolean;
+    /**
+    Call the `fn` on trailing edge with last used arguments. Result of call is from previous call.
+    @default false
+    */
+    readonly trailing?: boolean;
+}
+/**
+Debounce functions
+@param fn - Promise-returning/async function to debounce.
+@param wait - Milliseconds to wait before calling `fn`. Default value is 25ms
+@returns A function that delays calling `fn` until after `wait` milliseconds have elapsed since the last time it was called.
+@example
+```
+import { debounce } from 'perfect-debounce';
+const expensiveCall = async input => input;
+const debouncedFn = debounce(expensiveCall, 200);
+for (const number of [1, 2, 3]) {
+  console.log(await debouncedFn(number));
+}
+//=> 3
+//=> 3
+//=> 3
+```
+*/
+declare function debounce<ArgumentsT extends unknown[], ReturnT>(fn: (...args: ArgumentsT) => PromiseLike<ReturnT> | ReturnT, wait?: number, options?: DebounceOptions): (...args: ArgumentsT) => Promise<ReturnT>;
+
+export { DebounceOptions, debounce };

backend/node_modules/perfect-debounce/dist/index.mjs

@@ -0,0 +1,57 @@
+const DEBOUNCE_DEFAULTS = {
+  trailing: true
+};
+function debounce(fn, wait = 25, options = {}) {
+  options = { ...DEBOUNCE_DEFAULTS, ...options };
+  if (!Number.isFinite(wait)) {
+    throw new TypeError("Expected `wait` to be a finite number");
+  }
+  let leadingValue;
+  let timeout;
+  let resolveList = [];
+  let currentPromise;
+  let trailingArgs;
+  const applyFn = (_this, args) => {
+    currentPromise = _applyPromised(fn, _this, args);
+    currentPromise.finally(() => {
+      currentPromise = null;
+      if (options.trailing && trailingArgs && !timeout) {
+        const promise = applyFn(_this, trailingArgs);
+        trailingArgs = null;
+        return promise;
+      }
+    });
+    return currentPromise;
+  };
+  return function(...args) {
+    if (currentPromise) {
+      if (options.trailing) {
+        trailingArgs = args;
+      }
+      return currentPromise;
+    }
+    return new Promise((resolve) => {
+      const shouldCallNow = !timeout && options.leading;
+      clearTimeout(timeout);
+      timeout = setTimeout(() => {
+        timeout = null;
+        const promise = options.leading ? leadingValue : applyFn(this, args);
+        for (const _resolve of resolveList) {
+          _resolve(promise);
+        }
+        resolveList = [];
+      }, wait);
+      if (shouldCallNow) {
+        leadingValue = applyFn(this, args);
+        resolve(leadingValue);
+      } else {
+        resolveList.push(resolve);
+      }
+    });
+  };
+}
+async function _applyPromised(fn, _this, args) {
+  return await fn.apply(_this, args);
+}
+
+export { debounce };

backend/node_modules/prisma/build/prisma_schema_build_bg.wasm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bca8b35bd5ebe0164323d5f761a7a5075fa6ad00e1dfc7906e9da5d4c13c0287
+size 2966822

backend/node_modules/prisma/build/public/assets/inter-all-400-normal.4c1f8a0d.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4c1f8a0d5ef1e04d7e14d194a4ef624345e7c7c1cdb4ff61d4552e32a60ac1d0
+size 121716

backend/node_modules/prisma/build/public/assets/inter-all-600-normal.d0a7c8a9.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d0a7c8a993b9310ebb74a893fa564133bc129f6af41126eb98d207c813b96093
+size 131632