@gzoo/cortex 0.5.13 → 0.5.15

package/dist/cortex.mjs

@@ -1,13 +1,36 @@
 #!/usr/bin/env node
+var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // packages/core/dist/types/llm.js
 var LLMTask;
@@ -4931,249 +4954,2682 @@ var init_dist4 = __esm({
   }
 });
 
-// packages/server/dist/routes/entities.js
-import { Router as Router2 } from "express";
-function createEntityRoutes(bundle) {
-  const router = Router2();
-  const { store } = bundle;
-  router.get("/", async (req, res) => {
-    try {
-      const { type, project, search, limit: rawLimit = "50", offset: rawOffset = "0", status = "active" } = req.query;
-      const parsedLimit = Math.max(1, Math.min(Number(rawLimit) || 50, 500));
-      const parsedOffset = Math.max(0, Number(rawOffset) || 0);
-      if (search && typeof search === "string") {
-        const results = await store.searchEntities(search, parsedLimit);
-        res.json({ success: true, data: results, meta: { total: results.length, limit: parsedLimit, offset: 0 } });
-        return;
+// node_modules/ip-address/dist/common.js
+var require_common = __commonJS({
+  "node_modules/ip-address/dist/common.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isInSubnet = isInSubnet;
+    exports.isCorrect = isCorrect;
+    exports.numberToPaddedHex = numberToPaddedHex;
+    exports.stringToPaddedHex = stringToPaddedHex;
+    exports.testBit = testBit;
+    function isInSubnet(address) {
+      if (this.subnetMask < address.subnetMask) {
+        return false;
       }
-      const entities = await store.findEntities({
-        type,
-        projectId: project,
-        status,
-        limit: parsedLimit,
-        offset: parsedOffset
-      });
-      res.json({ success: true, data: entities, meta: { limit: parsedLimit, offset: parsedOffset } });
-    } catch (err) {
-      logger26.error("Request failed", { error: err instanceof Error ? err.message : String(err) });
-      res.status(500).json({ success: false, error: { code: "SERVER_ERROR", message: "Internal server error" } });
-    }
-  });
-  router.get("/:id", async (req, res) => {
-    try {
-      const entity = await store.getEntity(req.params.id);
-      if (!entity) {
-        res.status(404).json({ success: false, error: { code: "NOT_FOUND", message: "Entity not found" } });
-        return;
+      if (this.mask(address.subnetMask) === address.mask()) {
+        return true;
       }
-      res.json({ success: true, data: entity });
-    } catch (err) {
-      logger26.error("Request failed", { error: err instanceof Error ? err.message : String(err) });
-      res.status(500).json({ success: false, error: { code: "SERVER_ERROR", message: "Internal server error" } });
+      return false;
     }
-  });
-  router.get("/:id/relationships", async (req, res) => {
-    try {
-      const { direction = "both" } = req.query;
-      const relationships = await store.getRelationshipsForEntity(req.params.id, direction);
-      res.json({ success: true, data: relationships });
-    } catch (err) {
-      logger26.error("Request failed", { error: err instanceof Error ? err.message : String(err) });
-      res.status(500).json({ success: false, error: { code: "SERVER_ERROR", message: "Internal server error" } });
+    function isCorrect(defaultBits) {
+      return function() {
+        if (this.addressMinusSuffix !== this.correctForm()) {
+          return false;
+        }
+        if (this.subnetMask === defaultBits && !this.parsedSubnet) {
+          return true;
+        }
+        return this.parsedSubnet === String(this.subnetMask);
+      };
     }
-  });
-  return router;
-}
-var logger26;
-var init_entities = __esm({
-  "packages/server/dist/routes/entities.js"() {
-    "use strict";
-    init_dist();
-    logger26 = createLogger("server:entities");
-  }
-});
-
-// packages/server/dist/routes/relationships.js
-import { Router as Router3 } from "express";
-function createRelationshipRoutes(bundle) {
-  const router = Router3();
-  const { store } = bundle;
-  router.get("/", async (req, res) => {
-    try {
-      const { type, sourceId, targetId, limit: rawLimit = "100" } = req.query;
-      const parsedLimit = Math.max(1, Math.min(Number(rawLimit) || 100, 500));
-      if (sourceId && typeof sourceId === "string") {
-        const rels = await store.getRelationshipsForEntity(sourceId, "out");
-        const filtered = type ? rels.filter((r) => r.type === type) : rels;
-        res.json({ success: true, data: filtered.slice(0, parsedLimit) });
-        return;
-      }
-      if (targetId && typeof targetId === "string") {
-        const rels = await store.getRelationshipsForEntity(targetId, "in");
-        const filtered = type ? rels.filter((r) => r.type === type) : rels;
-        res.json({ success: true, data: filtered.slice(0, parsedLimit) });
-        return;
-      }
-      res.json({
-        success: true,
-        data: [],
-        meta: { message: "Provide sourceId or targetId to query relationships" }
-      });
-    } catch (err) {
-      logger27.error("Request failed", { error: err instanceof Error ? err.message : String(err) });
-      res.status(500).json({ success: false, error: { code: "SERVER_ERROR", message: "Internal server error" } });
+    function numberToPaddedHex(number) {
+      return number.toString(16).padStart(2, "0");
     }
-  });
-  router.get("/:id", async (req, res) => {
-    try {
-      const rel = await store.getRelationship(req.params.id);
-      if (!rel) {
-        res.status(404).json({ success: false, error: { code: "NOT_FOUND", message: "Relationship not found" } });
-        return;
+    function stringToPaddedHex(numberString) {
+      return numberToPaddedHex(parseInt(numberString, 10));
+    }
+    function testBit(binaryValue, position) {
+      const { length } = binaryValue;
+      if (position > length) {
+        return false;
       }
-      res.json({ success: true, data: rel });
-    } catch (err) {
-      logger27.error("Request failed", { error: err instanceof Error ? err.message : String(err) });
-      res.status(500).json({ success: false, error: { code: "SERVER_ERROR", message: "Internal server error" } });
+      const positionInString = length - position;
+      return binaryValue.substring(positionInString, positionInString + 1) === "1";
     }
-  });
-  return router;
-}
-var logger27;
-var init_relationships = __esm({
-  "packages/server/dist/routes/relationships.js"() {
+  }
+});
+
+// node_modules/ip-address/dist/v4/constants.js
+var require_constants = __commonJS({
+  "node_modules/ip-address/dist/v4/constants.js"(exports) {
     "use strict";
-    init_dist();
-    logger27 = createLogger("server:relationships");
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.RE_SUBNET_STRING = exports.RE_ADDRESS = exports.GROUPS = exports.BITS = void 0;
+    exports.BITS = 32;
+    exports.GROUPS = 4;
+    exports.RE_ADDRESS = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/g;
+    exports.RE_SUBNET_STRING = /\/\d{1,2}$/;
   }
 });
 
-// packages/server/dist/routes/projects.js
-import { Router as Router4 } from "express";
-function createProjectRoutes(bundle) {
-  const router = Router4();
-  const { store } = bundle;
-  router.get("/", async (_req, res) => {
-    try {
-      const projects = await store.listProjects();
-      res.json({ success: true, data: projects });
-    } catch (err) {
-      logger28.error("Request failed", { error: err instanceof Error ? err.message : String(err) });
-      res.status(500).json({ success: false, error: { code: "SERVER_ERROR", message: "Internal server error" } });
-    }
-  });
-  router.get("/:id", async (req, res) => {
-    try {
-      const project = await store.getProject(req.params.id);
-      if (!project) {
-        res.status(404).json({ success: false, error: { code: "NOT_FOUND", message: "Project not found" } });
-        return;
-      }
-      res.json({ success: true, data: project });
-    } catch (err) {
-      logger28.error("Request failed", { error: err instanceof Error ? err.message : String(err) });
-      res.status(500).json({ success: false, error: { code: "SERVER_ERROR", message: "Internal server error" } });
-    }
-  });
-  return router;
-}
-var logger28;
-var init_projects = __esm({
-  "packages/server/dist/routes/projects.js"() {
+// node_modules/ip-address/dist/address-error.js
+var require_address_error = __commonJS({
+  "node_modules/ip-address/dist/address-error.js"(exports) {
     "use strict";
-    init_dist();
-    logger28 = createLogger("server:projects");
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AddressError = void 0;
+    var AddressError = class extends Error {
+      constructor(message, parseMessage) {
+        super(message);
+        this.name = "AddressError";
+        this.parseMessage = parseMessage;
+      }
+    };
+    exports.AddressError = AddressError;
   }
 });
 
-// packages/server/dist/routes/query.js
-import { Router as Router5 } from "express";
-function createQueryRoutes(bundle) {
-  const router = Router5();
-  const { store, queryEngine, router: llmRouter } = bundle;
-  router.post("/", async (req, res) => {
-    try {
-      const { query, projectId, stream = false } = req.body;
-      if (!query || typeof query !== "string") {
-        res.status(400).json({ success: false, error: { code: "BAD_REQUEST", message: "query is required" } });
-        return;
+// node_modules/ip-address/dist/ipv4.js
+var require_ipv4 = __commonJS({
+  "node_modules/ip-address/dist/ipv4.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Address4 = void 0;
+    var common = __importStar(require_common());
+    var constants = __importStar(require_constants());
+    var address_error_1 = require_address_error();
+    var Address4 = class _Address4 {
+      constructor(address) {
+        this.groups = constants.GROUPS;
+        this.parsedAddress = [];
+        this.parsedSubnet = "";
+        this.subnet = "/32";
+        this.subnetMask = 32;
+        this.v4 = true;
+        this.isCorrect = common.isCorrect(constants.BITS);
+        this.isInSubnet = common.isInSubnet;
+        this.address = address;
+        const subnet = constants.RE_SUBNET_STRING.exec(address);
+        if (subnet) {
+          this.parsedSubnet = subnet[0].replace("/", "");
+          this.subnetMask = parseInt(this.parsedSubnet, 10);
+          this.subnet = `/${this.subnetMask}`;
+          if (this.subnetMask < 0 || this.subnetMask > constants.BITS) {
+            throw new address_error_1.AddressError("Invalid subnet mask.");
+          }
+          address = address.replace(constants.RE_SUBNET_STRING, "");
+        }
+        this.addressMinusSuffix = address;
+        this.parsedAddress = this.parse(address);
       }
-      if (projectId && typeof projectId === "string") {
-        const project = await store.getProject(projectId);
-        if (!project) {
-          res.status(404).json({ success: false, error: { code: "NOT_FOUND", message: "Project not found" } });
-          return;
+      static isValid(address) {
+        try {
+          new _Address4(address);
+          return true;
+        } catch (e) {
+          return false;
         }
       }
-      const context = await queryEngine.assembleContext(query, void 0, projectId);
-      if (stream) {
-        res.setHeader("Content-Type", "text/event-stream");
-        res.setHeader("Cache-Control", "no-cache");
-        res.setHeader("Connection", "keep-alive");
-        const systemPrompt8 = buildQuerySystemPrompt(context);
-        const gen = llmRouter.stream({
-          systemPrompt: systemPrompt8,
-          userPrompt: query,
-          promptId: "conversational_query",
-          promptVersion: "1.0",
-          task: LLMTask.CONVERSATIONAL_QUERY,
-          modelPreference: "primary",
-          temperature: 0.7
-        });
-        for await (const chunk of gen) {
-          res.write(`data: ${JSON.stringify({ type: "chunk", content: chunk })}
-
-`);
+      /*
+       * Parses a v4 address
+       */
+      parse(address) {
+        const groups = address.split(".");
+        if (!address.match(constants.RE_ADDRESS)) {
+          throw new address_error_1.AddressError("Invalid IPv4 address.");
         }
-        res.write(`data: ${JSON.stringify({ type: "sources", entities: context.entities.slice(0, 10) })}
-
-`);
-        res.write(`data: ${JSON.stringify({ type: "complete" })}
-
-`);
-        res.end();
-        return;
+        return groups;
       }
-      const systemPrompt7 = buildQuerySystemPrompt(context);
-      const result = await llmRouter.complete({
-        systemPrompt: systemPrompt7,
-        userPrompt: query,
-        promptId: "conversational_query",
-        promptVersion: "1.0",
-        task: LLMTask.CONVERSATIONAL_QUERY,
-        modelPreference: "primary",
-        temperature: 0.7
-      });
-      res.json({
-        success: true,
-        data: {
-          answer: result.content,
-          sources: context.entities.slice(0, 10),
-          relationships: context.relationships,
-          model: result.model,
-          tokens: { input: result.inputTokens, output: result.outputTokens }
+      /**
+       * Returns the correct form of an address
+       * @memberof Address4
+       * @instance
+       * @returns {String}
+       */
+      correctForm() {
+        return this.parsedAddress.map((part) => parseInt(part, 10)).join(".");
+      }
+      /**
+       * Converts a hex string to an IPv4 address object
+       * @memberof Address4
+       * @static
+       * @param {string} hex - a hex string to convert
+       * @returns {Address4}
+       */
+      static fromHex(hex) {
+        const padded = hex.replace(/:/g, "").padStart(8, "0");
+        const groups = [];
+        let i;
+        for (i = 0; i < 8; i += 2) {
+          const h = padded.slice(i, i + 2);
+          groups.push(parseInt(h, 16));
         }
-      });
-    } catch (err) {
-      logger29.error("Query failed", { error: err instanceof Error ? err.message : String(err) });
-      res.status(500).json({ success: false, error: { code: "QUERY_FAILED", message: "Query processing failed" } });
-    }
-  });
-  return router;
-}
-function buildQuerySystemPrompt(context) {
-  const entityContext = context.entities.map((e, i) => `[${i + 1}] ${e.type}: ${e.name}
-${e.summary ?? e.content}`).join("\n\n");
-  return `You are Cortex, a knowledge graph assistant. Answer questions using ONLY the context below. Cite sources as [N].
-
-## Knowledge Context
-${entityContext || "No relevant entities found."}
-
-## Instructions
-- Answer concisely and accurately based on the context
-- Cite sources using [N] notation
-- If the context doesn't contain enough information, say so
-- Suggest follow-up questions the user might ask`;
+        return new _Address4(groups.join("."));
+      }
+      /**
+       * Converts an integer into a IPv4 address object
+       * @memberof Address4
+       * @static
+       * @param {integer} integer - a number to convert
+       * @returns {Address4}
+       */
+      static fromInteger(integer) {
+        return _Address4.fromHex(integer.toString(16));
+      }
+      /**
+       * Return an address from in-addr.arpa form
+       * @memberof Address4
+       * @static
+       * @param {string} arpaFormAddress - an 'in-addr.arpa' form ipv4 address
+       * @returns {Adress4}
+       * @example
+       * var address = Address4.fromArpa(42.2.0.192.in-addr.arpa.)
+       * address.correctForm(); // '192.0.2.42'
+       */
+      static fromArpa(arpaFormAddress) {
+        const leader = arpaFormAddress.replace(/(\.in-addr\.arpa)?\.$/, "");
+        const address = leader.split(".").reverse().join(".");
+        return new _Address4(address);
+      }
+      /**
+       * Converts an IPv4 address object to a hex string
+       * @memberof Address4
+       * @instance
+       * @returns {String}
+       */
+      toHex() {
+        return this.parsedAddress.map((part) => common.stringToPaddedHex(part)).join(":");
+      }
+      /**
+       * Converts an IPv4 address object to an array of bytes
+       * @memberof Address4
+       * @instance
+       * @returns {Array}
+       */
+      toArray() {
+        return this.parsedAddress.map((part) => parseInt(part, 10));
+      }
+      /**
+       * Converts an IPv4 address object to an IPv6 address group
+       * @memberof Address4
+       * @instance
+       * @returns {String}
+       */
+      toGroup6() {
+        const output = [];
+        let i;
+        for (i = 0; i < constants.GROUPS; i += 2) {
+          output.push(`${common.stringToPaddedHex(this.parsedAddress[i])}${common.stringToPaddedHex(this.parsedAddress[i + 1])}`);
+        }
+        return output.join(":");
+      }
+      /**
+       * Returns the address as a `bigint`
+       * @memberof Address4
+       * @instance
+       * @returns {bigint}
+       */
+      bigInt() {
+        return BigInt(`0x${this.parsedAddress.map((n) => common.stringToPaddedHex(n)).join("")}`);
+      }
+      /**
+       * Helper function getting start address.
+       * @memberof Address4
+       * @instance
+       * @returns {bigint}
+       */
+      _startAddress() {
+        return BigInt(`0b${this.mask() + "0".repeat(constants.BITS - this.subnetMask)}`);
+      }
+      /**
+       * The first address in the range given by this address' subnet.
+       * Often referred to as the Network Address.
+       * @memberof Address4
+       * @instance
+       * @returns {Address4}
+       */
+      startAddress() {
+        return _Address4.fromBigInt(this._startAddress());
+      }
+      /**
+       * The first host address in the range given by this address's subnet ie
+       * the first address after the Network Address
+       * @memberof Address4
+       * @instance
+       * @returns {Address4}
+       */
+      startAddressExclusive() {
+        const adjust = BigInt("1");
+        return _Address4.fromBigInt(this._startAddress() + adjust);
+      }
+      /**
+       * Helper function getting end address.
+       * @memberof Address4
+       * @instance
+       * @returns {bigint}
+       */
+      _endAddress() {
+        return BigInt(`0b${this.mask() + "1".repeat(constants.BITS - this.subnetMask)}`);
+      }
+      /**
+       * The last address in the range given by this address' subnet
+       * Often referred to as the Broadcast
+       * @memberof Address4
+       * @instance
+       * @returns {Address4}
+       */
+      endAddress() {
+        return _Address4.fromBigInt(this._endAddress());
+      }
+      /**
+       * The last host address in the range given by this address's subnet ie
+       * the last address prior to the Broadcast Address
+       * @memberof Address4
+       * @instance
+       * @returns {Address4}
+       */
+      endAddressExclusive() {
+        const adjust = BigInt("1");
+        return _Address4.fromBigInt(this._endAddress() - adjust);
+      }
+      /**
+       * Converts a BigInt to a v4 address object
+       * @memberof Address4
+       * @static
+       * @param {bigint} bigInt - a BigInt to convert
+       * @returns {Address4}
+       */
+      static fromBigInt(bigInt) {
+        return _Address4.fromHex(bigInt.toString(16));
+      }
+      /**
+       * Returns the first n bits of the address, defaulting to the
+       * subnet mask
+       * @memberof Address4
+       * @instance
+       * @returns {String}
+       */
+      mask(mask) {
+        if (mask === void 0) {
+          mask = this.subnetMask;
+        }
+        return this.getBitsBase2(0, mask);
+      }
+      /**
+       * Returns the bits in the given range as a base-2 string
+       * @memberof Address4
+       * @instance
+       * @returns {string}
+       */
+      getBitsBase2(start, end) {
+        return this.binaryZeroPad().slice(start, end);
+      }
+      /**
+       * Return the reversed ip6.arpa form of the address
+       * @memberof Address4
+       * @param {Object} options
+       * @param {boolean} options.omitSuffix - omit the "in-addr.arpa" suffix
+       * @instance
+       * @returns {String}
+       */
+      reverseForm(options) {
+        if (!options) {
+          options = {};
+        }
+        const reversed = this.correctForm().split(".").reverse().join(".");
+        if (options.omitSuffix) {
+          return reversed;
+        }
+        return `${reversed}.in-addr.arpa.`;
+      }
+      /**
+       * Returns true if the given address is a multicast address
+       * @memberof Address4
+       * @instance
+       * @returns {boolean}
+       */
+      isMulticast() {
+        return this.isInSubnet(new _Address4("224.0.0.0/4"));
+      }
+      /**
+       * Returns a zero-padded base-2 string representation of the address
+       * @memberof Address4
+       * @instance
+       * @returns {string}
+       */
+      binaryZeroPad() {
+        return this.bigInt().toString(2).padStart(constants.BITS, "0");
+      }
+      /**
+       * Groups an IPv4 address for inclusion at the end of an IPv6 address
+       * @returns {String}
+       */
+      groupForV6() {
+        const segments = this.parsedAddress;
+        return this.address.replace(constants.RE_ADDRESS, `<span class="hover-group group-v4 group-6">${segments.slice(0, 2).join(".")}</span>.<span class="hover-group group-v4 group-7">${segments.slice(2, 4).join(".")}</span>`);
+      }
+    };
+    exports.Address4 = Address4;
+  }
+});
+
+// node_modules/ip-address/dist/v6/constants.js
+var require_constants2 = __commonJS({
+  "node_modules/ip-address/dist/v6/constants.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.RE_URL_WITH_PORT = exports.RE_URL = exports.RE_ZONE_STRING = exports.RE_SUBNET_STRING = exports.RE_BAD_ADDRESS = exports.RE_BAD_CHARACTERS = exports.TYPES = exports.SCOPES = exports.GROUPS = exports.BITS = void 0;
+    exports.BITS = 128;
+    exports.GROUPS = 8;
+    exports.SCOPES = {
+      0: "Reserved",
+      1: "Interface local",
+      2: "Link local",
+      4: "Admin local",
+      5: "Site local",
+      8: "Organization local",
+      14: "Global",
+      15: "Reserved"
+    };
+    exports.TYPES = {
+      "ff01::1/128": "Multicast (All nodes on this interface)",
+      "ff01::2/128": "Multicast (All routers on this interface)",
+      "ff02::1/128": "Multicast (All nodes on this link)",
+      "ff02::2/128": "Multicast (All routers on this link)",
+      "ff05::2/128": "Multicast (All routers in this site)",
+      "ff02::5/128": "Multicast (OSPFv3 AllSPF routers)",
+      "ff02::6/128": "Multicast (OSPFv3 AllDR routers)",
+      "ff02::9/128": "Multicast (RIP routers)",
+      "ff02::a/128": "Multicast (EIGRP routers)",
+      "ff02::d/128": "Multicast (PIM routers)",
+      "ff02::16/128": "Multicast (MLDv2 reports)",
+      "ff01::fb/128": "Multicast (mDNSv6)",
+      "ff02::fb/128": "Multicast (mDNSv6)",
+      "ff05::fb/128": "Multicast (mDNSv6)",
+      "ff02::1:2/128": "Multicast (All DHCP servers and relay agents on this link)",
+      "ff05::1:2/128": "Multicast (All DHCP servers and relay agents in this site)",
+      "ff02::1:3/128": "Multicast (All DHCP servers on this link)",
+      "ff05::1:3/128": "Multicast (All DHCP servers in this site)",
+      "::/128": "Unspecified",
+      "::1/128": "Loopback",
+      "ff00::/8": "Multicast",
+      "fe80::/10": "Link-local unicast"
+    };
+    exports.RE_BAD_CHARACTERS = /([^0-9a-f:/%])/gi;
+    exports.RE_BAD_ADDRESS = /([0-9a-f]{5,}|:{3,}|[^:]:$|^:[^:]|\/$)/gi;
+    exports.RE_SUBNET_STRING = /\/\d{1,3}(?=%|$)/;
+    exports.RE_ZONE_STRING = /%.*$/;
+    exports.RE_URL = /^\[{0,1}([0-9a-f:]+)\]{0,1}/;
+    exports.RE_URL_WITH_PORT = /\[([0-9a-f:]+)\]:([0-9]{1,5})/;
+  }
+});
+
+// node_modules/ip-address/dist/v6/helpers.js
+var require_helpers = __commonJS({
+  "node_modules/ip-address/dist/v6/helpers.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.spanAllZeroes = spanAllZeroes;
+    exports.spanAll = spanAll;
+    exports.spanLeadingZeroes = spanLeadingZeroes;
+    exports.simpleGroup = simpleGroup;
+    function spanAllZeroes(s) {
+      return s.replace(/(0+)/g, '<span class="zero">$1</span>');
+    }
+    function spanAll(s, offset = 0) {
+      const letters = s.split("");
+      return letters.map((n, i) => `<span class="digit value-${n} position-${i + offset}">${spanAllZeroes(n)}</span>`).join("");
+    }
+    function spanLeadingZeroesSimple(group) {
+      return group.replace(/^(0+)/, '<span class="zero">$1</span>');
+    }
+    function spanLeadingZeroes(address) {
+      const groups = address.split(":");
+      return groups.map((g) => spanLeadingZeroesSimple(g)).join(":");
+    }
+    function simpleGroup(addressString, offset = 0) {
+      const groups = addressString.split(":");
+      return groups.map((g, i) => {
+        if (/group-v4/.test(g)) {
+          return g;
+        }
+        return `<span class="hover-group group-${i + offset}">${spanLeadingZeroesSimple(g)}</span>`;
+      });
+    }
+  }
+});
+
+// node_modules/ip-address/dist/v6/regular-expressions.js
+var require_regular_expressions = __commonJS({
+  "node_modules/ip-address/dist/v6/regular-expressions.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ADDRESS_BOUNDARY = void 0;
+    exports.groupPossibilities = groupPossibilities;
+    exports.padGroup = padGroup;
+    exports.simpleRegularExpression = simpleRegularExpression;
+    exports.possibleElisions = possibleElisions;
+    var v6 = __importStar(require_constants2());
+    function groupPossibilities(possibilities) {
+      return `(${possibilities.join("|")})`;
+    }
+    function padGroup(group) {
+      if (group.length < 4) {
+        return `0{0,${4 - group.length}}${group}`;
+      }
+      return group;
+    }
+    exports.ADDRESS_BOUNDARY = "[^A-Fa-f0-9:]";
+    function simpleRegularExpression(groups) {
+      const zeroIndexes = [];
+      groups.forEach((group, i) => {
+        const groupInteger = parseInt(group, 16);
+        if (groupInteger === 0) {
+          zeroIndexes.push(i);
+        }
+      });
+      const possibilities = zeroIndexes.map((zeroIndex) => groups.map((group, i) => {
+        if (i === zeroIndex) {
+          const elision = i === 0 || i === v6.GROUPS - 1 ? ":" : "";
+          return groupPossibilities([padGroup(group), elision]);
+        }
+        return padGroup(group);
+      }).join(":"));
+      possibilities.push(groups.map(padGroup).join(":"));
+      return groupPossibilities(possibilities);
+    }
+    function possibleElisions(elidedGroups, moreLeft, moreRight) {
+      const left = moreLeft ? "" : ":";
+      const right = moreRight ? "" : ":";
+      const possibilities = [];
+      if (!moreLeft && !moreRight) {
+        possibilities.push("::");
+      }
+      if (moreLeft && moreRight) {
+        possibilities.push("");
+      }
+      if (moreRight && !moreLeft || !moreRight && moreLeft) {
+        possibilities.push(":");
+      }
+      possibilities.push(`${left}(:0{1,4}){1,${elidedGroups - 1}}`);
+      possibilities.push(`(0{1,4}:){1,${elidedGroups - 1}}${right}`);
+      possibilities.push(`(0{1,4}:){${elidedGroups - 1}}0{1,4}`);
+      for (let groups = 1; groups < elidedGroups - 1; groups++) {
+        for (let position = 1; position < elidedGroups - groups; position++) {
+          possibilities.push(`(0{1,4}:){${position}}:(0{1,4}:){${elidedGroups - position - groups - 1}}0{1,4}`);
+        }
+      }
+      return groupPossibilities(possibilities);
+    }
+  }
+});
+
+// node_modules/ip-address/dist/ipv6.js
+var require_ipv6 = __commonJS({
+  "node_modules/ip-address/dist/ipv6.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Address6 = void 0;
+    var common = __importStar(require_common());
+    var constants4 = __importStar(require_constants());
+    var constants6 = __importStar(require_constants2());
+    var helpers = __importStar(require_helpers());
+    var ipv4_1 = require_ipv4();
+    var regular_expressions_1 = require_regular_expressions();
+    var address_error_1 = require_address_error();
+    var common_1 = require_common();
+    function assert(condition) {
+      if (!condition) {
+        throw new Error("Assertion failed.");
+      }
+    }
+    function addCommas(number) {
+      const r = /(\d+)(\d{3})/;
+      while (r.test(number)) {
+        number = number.replace(r, "$1,$2");
+      }
+      return number;
+    }
+    function spanLeadingZeroes4(n) {
+      n = n.replace(/^(0{1,})([1-9]+)$/, '<span class="parse-error">$1</span>$2');
+      n = n.replace(/^(0{1,})(0)$/, '<span class="parse-error">$1</span>$2');
+      return n;
+    }
+    function compact(address, slice) {
+      const s1 = [];
+      const s2 = [];
+      let i;
+      for (i = 0; i < address.length; i++) {
+        if (i < slice[0]) {
+          s1.push(address[i]);
+        } else if (i > slice[1]) {
+          s2.push(address[i]);
+        }
+      }
+      return s1.concat(["compact"]).concat(s2);
+    }
+    function paddedHex(octet) {
+      return parseInt(octet, 16).toString(16).padStart(4, "0");
+    }
+    function unsignByte(b) {
+      return b & 255;
+    }
+    var Address62 = class _Address6 {
+      constructor(address, optionalGroups) {
+        this.addressMinusSuffix = "";
+        this.parsedSubnet = "";
+        this.subnet = "/128";
+        this.subnetMask = 128;
+        this.v4 = false;
+        this.zone = "";
+        this.isInSubnet = common.isInSubnet;
+        this.isCorrect = common.isCorrect(constants6.BITS);
+        if (optionalGroups === void 0) {
+          this.groups = constants6.GROUPS;
+        } else {
+          this.groups = optionalGroups;
+        }
+        this.address = address;
+        const subnet = constants6.RE_SUBNET_STRING.exec(address);
+        if (subnet) {
+          this.parsedSubnet = subnet[0].replace("/", "");
+          this.subnetMask = parseInt(this.parsedSubnet, 10);
+          this.subnet = `/${this.subnetMask}`;
+          if (Number.isNaN(this.subnetMask) || this.subnetMask < 0 || this.subnetMask > constants6.BITS) {
+            throw new address_error_1.AddressError("Invalid subnet mask.");
+          }
+          address = address.replace(constants6.RE_SUBNET_STRING, "");
+        } else if (/\//.test(address)) {
+          throw new address_error_1.AddressError("Invalid subnet mask.");
+        }
+        const zone = constants6.RE_ZONE_STRING.exec(address);
+        if (zone) {
+          this.zone = zone[0];
+          address = address.replace(constants6.RE_ZONE_STRING, "");
+        }
+        this.addressMinusSuffix = address;
+        this.parsedAddress = this.parse(this.addressMinusSuffix);
+      }
+      static isValid(address) {
+        try {
+          new _Address6(address);
+          return true;
+        } catch (e) {
+          return false;
+        }
+      }
+      /**
+       * Convert a BigInt to a v6 address object
+       * @memberof Address6
+       * @static
+       * @param {bigint} bigInt - a BigInt to convert
+       * @returns {Address6}
+       * @example
+       * var bigInt = BigInt('1000000000000');
+       * var address = Address6.fromBigInt(bigInt);
+       * address.correctForm(); // '::e8:d4a5:1000'
+       */
+      static fromBigInt(bigInt) {
+        const hex = bigInt.toString(16).padStart(32, "0");
+        const groups = [];
+        let i;
+        for (i = 0; i < constants6.GROUPS; i++) {
+          groups.push(hex.slice(i * 4, (i + 1) * 4));
+        }
+        return new _Address6(groups.join(":"));
+      }
+      /**
+       * Convert a URL (with optional port number) to an address object
+       * @memberof Address6
+       * @static
+       * @param {string} url - a URL with optional port number
+       * @example
+       * var addressAndPort = Address6.fromURL('http://[ffff::]:8080/foo/');
+       * addressAndPort.address.correctForm(); // 'ffff::'
+       * addressAndPort.port; // 8080
+       */
+      static fromURL(url) {
+        let host;
+        let port = null;
+        let result;
+        if (url.indexOf("[") !== -1 && url.indexOf("]:") !== -1) {
+          result = constants6.RE_URL_WITH_PORT.exec(url);
+          if (result === null) {
+            return {
+              error: "failed to parse address with port",
+              address: null,
+              port: null
+            };
+          }
+          host = result[1];
+          port = result[2];
+        } else if (url.indexOf("/") !== -1) {
+          url = url.replace(/^[a-z0-9]+:\/\//, "");
+          result = constants6.RE_URL.exec(url);
+          if (result === null) {
+            return {
+              error: "failed to parse address from URL",
+              address: null,
+              port: null
+            };
+          }
+          host = result[1];
+        } else {
+          host = url;
+        }
+        if (port) {
+          port = parseInt(port, 10);
+          if (port < 0 || port > 65536) {
+            port = null;
+          }
+        } else {
+          port = null;
+        }
+        return {
+          address: new _Address6(host),
+          port
+        };
+      }
+      /**
+       * Create an IPv6-mapped address given an IPv4 address
+       * @memberof Address6
+       * @static
+       * @param {string} address - An IPv4 address string
+       * @returns {Address6}
+       * @example
+       * var address = Address6.fromAddress4('192.168.0.1');
+       * address.correctForm(); // '::ffff:c0a8:1'
+       * address.to4in6(); // '::ffff:192.168.0.1'
+       */
+      static fromAddress4(address) {
+        const address4 = new ipv4_1.Address4(address);
+        const mask6 = constants6.BITS - (constants4.BITS - address4.subnetMask);
+        return new _Address6(`::ffff:${address4.correctForm()}/${mask6}`);
+      }
+      /**
+       * Return an address from ip6.arpa form
+       * @memberof Address6
+       * @static
+       * @param {string} arpaFormAddress - an 'ip6.arpa' form address
+       * @returns {Adress6}
+       * @example
+       * var address = Address6.fromArpa(e.f.f.f.3.c.2.6.f.f.f.e.6.6.8.e.1.0.6.7.9.4.e.c.0.0.0.0.1.0.0.2.ip6.arpa.)
+       * address.correctForm(); // '2001:0:ce49:7601:e866:efff:62c3:fffe'
+       */
+      static fromArpa(arpaFormAddress) {
+        let address = arpaFormAddress.replace(/(\.ip6\.arpa)?\.$/, "");
+        const semicolonAmount = 7;
+        if (address.length !== 63) {
+          throw new address_error_1.AddressError("Invalid 'ip6.arpa' form.");
+        }
+        const parts = address.split(".").reverse();
+        for (let i = semicolonAmount; i > 0; i--) {
+          const insertIndex = i * 4;
+          parts.splice(insertIndex, 0, ":");
+        }
+        address = parts.join("");
+        return new _Address6(address);
+      }
+      /**
+       * Return the Microsoft UNC transcription of the address
+       * @memberof Address6
+       * @instance
+       * @returns {String} the Microsoft UNC transcription of the address
+       */
+      microsoftTranscription() {
+        return `${this.correctForm().replace(/:/g, "-")}.ipv6-literal.net`;
+      }
+      /**
+       * Return the first n bits of the address, defaulting to the subnet mask
+       * @memberof Address6
+       * @instance
+       * @param {number} [mask=subnet] - the number of bits to mask
+       * @returns {String} the first n bits of the address as a string
+       */
+      mask(mask = this.subnetMask) {
+        return this.getBitsBase2(0, mask);
+      }
+      /**
+       * Return the number of possible subnets of a given size in the address
+       * @memberof Address6
+       * @instance
+       * @param {number} [subnetSize=128] - the subnet size
+       * @returns {String}
+       */
+      // TODO: probably useful to have a numeric version of this too
+      possibleSubnets(subnetSize = 128) {
+        const availableBits = constants6.BITS - this.subnetMask;
+        const subnetBits = Math.abs(subnetSize - constants6.BITS);
+        const subnetPowers = availableBits - subnetBits;
+        if (subnetPowers < 0) {
+          return "0";
+        }
+        return addCommas((BigInt("2") ** BigInt(subnetPowers)).toString(10));
+      }
+      /**
+       * Helper function getting start address.
+       * @memberof Address6
+       * @instance
+       * @returns {bigint}
+       */
+      _startAddress() {
+        return BigInt(`0b${this.mask() + "0".repeat(constants6.BITS - this.subnetMask)}`);
+      }
+      /**
+       * The first address in the range given by this address' subnet
+       * Often referred to as the Network Address.
+       * @memberof Address6
+       * @instance
+       * @returns {Address6}
+       */
+      startAddress() {
+        return _Address6.fromBigInt(this._startAddress());
+      }
+      /**
+       * The first host address in the range given by this address's subnet ie
+       * the first address after the Network Address
+       * @memberof Address6
+       * @instance
+       * @returns {Address6}
+       */
+      startAddressExclusive() {
+        const adjust = BigInt("1");
+        return _Address6.fromBigInt(this._startAddress() + adjust);
+      }
+      /**
+       * Helper function getting end address.
+       * @memberof Address6
+       * @instance
+       * @returns {bigint}
+       */
+      _endAddress() {
+        return BigInt(`0b${this.mask() + "1".repeat(constants6.BITS - this.subnetMask)}`);
+      }
+      /**
+       * The last address in the range given by this address' subnet
+       * Often referred to as the Broadcast
+       * @memberof Address6
+       * @instance
+       * @returns {Address6}
+       */
+      endAddress() {
+        return _Address6.fromBigInt(this._endAddress());
+      }
+      /**
+       * The last host address in the range given by this address's subnet ie
+       * the last address prior to the Broadcast Address
+       * @memberof Address6
+       * @instance
+       * @returns {Address6}
+       */
+      endAddressExclusive() {
+        const adjust = BigInt("1");
+        return _Address6.fromBigInt(this._endAddress() - adjust);
+      }
+      /**
+       * Return the scope of the address
+       * @memberof Address6
+       * @instance
+       * @returns {String}
+       */
+      getScope() {
+        let scope = constants6.SCOPES[parseInt(this.getBits(12, 16).toString(10), 10)];
+        if (this.getType() === "Global unicast" && scope !== "Link local") {
+          scope = "Global";
+        }
+        return scope || "Unknown";
+      }
+      /**
+       * Return the type of the address
+       * @memberof Address6
+       * @instance
+       * @returns {String}
+       */
+      getType() {
+        for (const subnet of Object.keys(constants6.TYPES)) {
+          if (this.isInSubnet(new _Address6(subnet))) {
+            return constants6.TYPES[subnet];
+          }
+        }
+        return "Global unicast";
+      }
+      /**
+       * Return the bits in the given range as a BigInt
+       * @memberof Address6
+       * @instance
+       * @returns {bigint}
+       */
+      getBits(start, end) {
+        return BigInt(`0b${this.getBitsBase2(start, end)}`);
+      }
+      /**
+       * Return the bits in the given range as a base-2 string
+       * @memberof Address6
+       * @instance
+       * @returns {String}
+       */
+      getBitsBase2(start, end) {
+        return this.binaryZeroPad().slice(start, end);
+      }
+      /**
+       * Return the bits in the given range as a base-16 string
+       * @memberof Address6
+       * @instance
+       * @returns {String}
+       */
+      getBitsBase16(start, end) {
+        const length = end - start;
+        if (length % 4 !== 0) {
+          throw new Error("Length of bits to retrieve must be divisible by four");
+        }
+        return this.getBits(start, end).toString(16).padStart(length / 4, "0");
+      }
+      /**
+       * Return the bits that are set past the subnet mask length
+       * @memberof Address6
+       * @instance
+       * @returns {String}
+       */
+      getBitsPastSubnet() {
+        return this.getBitsBase2(this.subnetMask, constants6.BITS);
+      }
+      /**
+       * Return the reversed ip6.arpa form of the address
+       * @memberof Address6
+       * @param {Object} options
+       * @param {boolean} options.omitSuffix - omit the "ip6.arpa" suffix
+       * @instance
+       * @returns {String}
+       */
+      reverseForm(options) {
+        if (!options) {
+          options = {};
+        }
+        const characters = Math.floor(this.subnetMask / 4);
+        const reversed = this.canonicalForm().replace(/:/g, "").split("").slice(0, characters).reverse().join(".");
+        if (characters > 0) {
+          if (options.omitSuffix) {
+            return reversed;
+          }
+          return `${reversed}.ip6.arpa.`;
+        }
+        if (options.omitSuffix) {
+          return "";
+        }
+        return "ip6.arpa.";
+      }
+      /**
+       * Return the correct form of the address
+       * @memberof Address6
+       * @instance
+       * @returns {String}
+       */
+      correctForm() {
+        let i;
+        let groups = [];
+        let zeroCounter = 0;
+        const zeroes = [];
+        for (i = 0; i < this.parsedAddress.length; i++) {
+          const value = parseInt(this.parsedAddress[i], 16);
+          if (value === 0) {
+            zeroCounter++;
+          }
+          if (value !== 0 && zeroCounter > 0) {
+            if (zeroCounter > 1) {
+              zeroes.push([i - zeroCounter, i - 1]);
+            }
+            zeroCounter = 0;
+          }
+        }
+        if (zeroCounter > 1) {
+          zeroes.push([this.parsedAddress.length - zeroCounter, this.parsedAddress.length - 1]);
+        }
+        const zeroLengths = zeroes.map((n) => n[1] - n[0] + 1);
+        if (zeroes.length > 0) {
+          const index = zeroLengths.indexOf(Math.max(...zeroLengths));
+          groups = compact(this.parsedAddress, zeroes[index]);
+        } else {
+          groups = this.parsedAddress;
+        }
+        for (i = 0; i < groups.length; i++) {
+          if (groups[i] !== "compact") {
+            groups[i] = parseInt(groups[i], 16).toString(16);
+          }
+        }
+        let correct = groups.join(":");
+        correct = correct.replace(/^compact$/, "::");
+        correct = correct.replace(/(^compact)|(compact$)/, ":");
+        correct = correct.replace(/compact/, "");
+        return correct;
+      }
+      /**
+       * Return a zero-padded base-2 string representation of the address
+       * @memberof Address6
+       * @instance
+       * @returns {String}
+       * @example
+       * var address = new Address6('2001:4860:4001:803::1011');
+       * address.binaryZeroPad();
+       * // '0010000000000001010010000110000001000000000000010000100000000011
+       * //  0000000000000000000000000000000000000000000000000001000000010001'
+       */
+      binaryZeroPad() {
+        return this.bigInt().toString(2).padStart(constants6.BITS, "0");
+      }
+      // TODO: Improve the semantics of this helper function
+      parse4in6(address) {
+        const groups = address.split(":");
+        const lastGroup = groups.slice(-1)[0];
+        const address4 = lastGroup.match(constants4.RE_ADDRESS);
+        if (address4) {
+          this.parsedAddress4 = address4[0];
+          this.address4 = new ipv4_1.Address4(this.parsedAddress4);
+          for (let i = 0; i < this.address4.groups; i++) {
+            if (/^0[0-9]+/.test(this.address4.parsedAddress[i])) {
+              throw new address_error_1.AddressError("IPv4 addresses can't have leading zeroes.", address.replace(constants4.RE_ADDRESS, this.address4.parsedAddress.map(spanLeadingZeroes4).join(".")));
+            }
+          }
+          this.v4 = true;
+          groups[groups.length - 1] = this.address4.toGroup6();
+          address = groups.join(":");
+        }
+        return address;
+      }
+      // TODO: Make private?
+      parse(address) {
+        address = this.parse4in6(address);
+        const badCharacters = address.match(constants6.RE_BAD_CHARACTERS);
+        if (badCharacters) {
+          throw new address_error_1.AddressError(`Bad character${badCharacters.length > 1 ? "s" : ""} detected in address: ${badCharacters.join("")}`, address.replace(constants6.RE_BAD_CHARACTERS, '<span class="parse-error">$1</span>'));
+        }
+        const badAddress = address.match(constants6.RE_BAD_ADDRESS);
+        if (badAddress) {
+          throw new address_error_1.AddressError(`Address failed regex: ${badAddress.join("")}`, address.replace(constants6.RE_BAD_ADDRESS, '<span class="parse-error">$1</span>'));
+        }
+        let groups = [];
+        const halves = address.split("::");
+        if (halves.length === 2) {
+          let first = halves[0].split(":");
+          let last = halves[1].split(":");
+          if (first.length === 1 && first[0] === "") {
+            first = [];
+          }
+          if (last.length === 1 && last[0] === "") {
+            last = [];
+          }
+          const remaining = this.groups - (first.length + last.length);
+          if (!remaining) {
+            throw new address_error_1.AddressError("Error parsing groups");
+          }
+          this.elidedGroups = remaining;
+          this.elisionBegin = first.length;
+          this.elisionEnd = first.length + this.elidedGroups;
+          groups = groups.concat(first);
+          for (let i = 0; i < remaining; i++) {
+            groups.push("0");
+          }
+          groups = groups.concat(last);
+        } else if (halves.length === 1) {
+          groups = address.split(":");
+          this.elidedGroups = 0;
+        } else {
+          throw new address_error_1.AddressError("Too many :: groups found");
+        }
+        groups = groups.map((group) => parseInt(group, 16).toString(16));
+        if (groups.length !== this.groups) {
+          throw new address_error_1.AddressError("Incorrect number of groups found");
+        }
+        return groups;
+      }
+      /**
+       * Return the canonical form of the address
+       * @memberof Address6
+       * @instance
+       * @returns {String}
+       */
+      canonicalForm() {
+        return this.parsedAddress.map(paddedHex).join(":");
+      }
+      /**
+       * Return the decimal form of the address
+       * @memberof Address6
+       * @instance
+       * @returns {String}
+       */
+      decimal() {
+        return this.parsedAddress.map((n) => parseInt(n, 16).toString(10).padStart(5, "0")).join(":");
+      }
+      /**
+       * Return the address as a BigInt
+       * @memberof Address6
+       * @instance
+       * @returns {bigint}
+       */
+      bigInt() {
+        return BigInt(`0x${this.parsedAddress.map(paddedHex).join("")}`);
+      }
+      /**
+       * Return the last two groups of this address as an IPv4 address string
+       * @memberof Address6
+       * @instance
+       * @returns {Address4}
+       * @example
+       * var address = new Address6('2001:4860:4001::1825:bf11');
+       * address.to4().correctForm(); // '24.37.191.17'
+       */
+      to4() {
+        const binary = this.binaryZeroPad().split("");
+        return ipv4_1.Address4.fromHex(BigInt(`0b${binary.slice(96, 128).join("")}`).toString(16));
+      }
+      /**
+       * Return the v4-in-v6 form of the address
+       * @memberof Address6
+       * @instance
+       * @returns {String}
+       */
+      to4in6() {
+        const address4 = this.to4();
+        const address6 = new _Address6(this.parsedAddress.slice(0, 6).join(":"), 6);
+        const correct = address6.correctForm();
+        let infix = "";
+        if (!/:$/.test(correct)) {
+          infix = ":";
+        }
+        return correct + infix + address4.address;
+      }
+      /**
+       * Return an object containing the Teredo properties of the address
+       * @memberof Address6
+       * @instance
+       * @returns {Object}
+       */
+      inspectTeredo() {
+        const prefix = this.getBitsBase16(0, 32);
+        const bitsForUdpPort = this.getBits(80, 96);
+        const udpPort = (bitsForUdpPort ^ BigInt("0xffff")).toString();
+        const server4 = ipv4_1.Address4.fromHex(this.getBitsBase16(32, 64));
+        const bitsForClient4 = this.getBits(96, 128);
+        const client4 = ipv4_1.Address4.fromHex((bitsForClient4 ^ BigInt("0xffffffff")).toString(16));
+        const flagsBase2 = this.getBitsBase2(64, 80);
+        const coneNat = (0, common_1.testBit)(flagsBase2, 15);
+        const reserved = (0, common_1.testBit)(flagsBase2, 14);
+        const groupIndividual = (0, common_1.testBit)(flagsBase2, 8);
+        const universalLocal = (0, common_1.testBit)(flagsBase2, 9);
+        const nonce = BigInt(`0b${flagsBase2.slice(2, 6) + flagsBase2.slice(8, 16)}`).toString(10);
+        return {
+          prefix: `${prefix.slice(0, 4)}:${prefix.slice(4, 8)}`,
+          server4: server4.address,
+          client4: client4.address,
+          flags: flagsBase2,
+          coneNat,
+          microsoft: {
+            reserved,
+            universalLocal,
+            groupIndividual,
+            nonce
+          },
+          udpPort
+        };
+      }
+      /**
+       * Return an object containing the 6to4 properties of the address
+       * @memberof Address6
+       * @instance
+       * @returns {Object}
+       */
+      inspect6to4() {
+        const prefix = this.getBitsBase16(0, 16);
+        const gateway = ipv4_1.Address4.fromHex(this.getBitsBase16(16, 48));
+        return {
+          prefix: prefix.slice(0, 4),
+          gateway: gateway.address
+        };
+      }
+      /**
+       * Return a v6 6to4 address from a v6 v4inv6 address
+       * @memberof Address6
+       * @instance
+       * @returns {Address6}
+       */
+      to6to4() {
+        if (!this.is4()) {
+          return null;
+        }
+        const addr6to4 = [
+          "2002",
+          this.getBitsBase16(96, 112),
+          this.getBitsBase16(112, 128),
+          "",
+          "/16"
+        ].join(":");
+        return new _Address6(addr6to4);
+      }
+      /**
+       * Return a byte array
+       * @memberof Address6
+       * @instance
+       * @returns {Array}
+       */
+      toByteArray() {
+        const valueWithoutPadding = this.bigInt().toString(16);
+        const leadingPad = "0".repeat(valueWithoutPadding.length % 2);
+        const value = `${leadingPad}${valueWithoutPadding}`;
+        const bytes = [];
+        for (let i = 0, length = value.length; i < length; i += 2) {
+          bytes.push(parseInt(value.substring(i, i + 2), 16));
+        }
+        return bytes;
+      }
+      /**
+       * Return an unsigned byte array
+       * @memberof Address6
+       * @instance
+       * @returns {Array}
+       */
+      toUnsignedByteArray() {
+        return this.toByteArray().map(unsignByte);
+      }
+      /**
+       * Convert a byte array to an Address6 object
+       * @memberof Address6
+       * @static
+       * @returns {Address6}
+       */
+      static fromByteArray(bytes) {
+        return this.fromUnsignedByteArray(bytes.map(unsignByte));
+      }
+      /**
+       * Convert an unsigned byte array to an Address6 object
+       * @memberof Address6
+       * @static
+       * @returns {Address6}
+       */
+      static fromUnsignedByteArray(bytes) {
+        const BYTE_MAX = BigInt("256");
+        let result = BigInt("0");
+        let multiplier = BigInt("1");
+        for (let i = bytes.length - 1; i >= 0; i--) {
+          result += multiplier * BigInt(bytes[i].toString(10));
+          multiplier *= BYTE_MAX;
+        }
+        return _Address6.fromBigInt(result);
+      }
+      /**
+       * Returns true if the address is in the canonical form, false otherwise
+       * @memberof Address6
+       * @instance
+       * @returns {boolean}
+       */
+      isCanonical() {
+        return this.addressMinusSuffix === this.canonicalForm();
+      }
+      /**
+       * Returns true if the address is a link local address, false otherwise
+       * @memberof Address6
+       * @instance
+       * @returns {boolean}
+       */
+      isLinkLocal() {
+        if (this.getBitsBase2(0, 64) === "1111111010000000000000000000000000000000000000000000000000000000") {
+          return true;
+        }
+        return false;
+      }
+      /**
+       * Returns true if the address is a multicast address, false otherwise
+       * @memberof Address6
+       * @instance
+       * @returns {boolean}
+       */
+      isMulticast() {
+        return this.getType() === "Multicast";
+      }
+      /**
+       * Returns true if the address is a v4-in-v6 address, false otherwise
+       * @memberof Address6
+       * @instance
+       * @returns {boolean}
+       */
+      is4() {
+        return this.v4;
+      }
+      /**
+       * Returns true if the address is a Teredo address, false otherwise
+       * @memberof Address6
+       * @instance
+       * @returns {boolean}
+       */
+      isTeredo() {
+        return this.isInSubnet(new _Address6("2001::/32"));
+      }
+      /**
+       * Returns true if the address is a 6to4 address, false otherwise
+       * @memberof Address6
+       * @instance
+       * @returns {boolean}
+       */
+      is6to4() {
+        return this.isInSubnet(new _Address6("2002::/16"));
+      }
+      /**
+       * Returns true if the address is a loopback address, false otherwise
+       * @memberof Address6
+       * @instance
+       * @returns {boolean}
+       */
+      isLoopback() {
+        return this.getType() === "Loopback";
+      }
+      // #endregion
+      // #region HTML
+      /**
+       * @returns {String} the address in link form with a default port of 80
+       */
+      href(optionalPort) {
+        if (optionalPort === void 0) {
+          optionalPort = "";
+        } else {
+          optionalPort = `:${optionalPort}`;
+        }
+        return `http://[${this.correctForm()}]${optionalPort}/`;
+      }
+      /**
+       * @returns {String} a link suitable for conveying the address via a URL hash
+       */
+      link(options) {
+        if (!options) {
+          options = {};
+        }
+        if (options.className === void 0) {
+          options.className = "";
+        }
+        if (options.prefix === void 0) {
+          options.prefix = "/#address=";
+        }
+        if (options.v4 === void 0) {
+          options.v4 = false;
+        }
+        let formFunction = this.correctForm;
+        if (options.v4) {
+          formFunction = this.to4in6;
+        }
+        const form = formFunction.call(this);
+        if (options.className) {
+          return `<a href="${options.prefix}${form}" class="${options.className}">${form}</a>`;
+        }
+        return `<a href="${options.prefix}${form}">${form}</a>`;
+      }
+      /**
+       * Groups an address
+       * @returns {String}
+       */
+      group() {
+        if (this.elidedGroups === 0) {
+          return helpers.simpleGroup(this.address).join(":");
+        }
+        assert(typeof this.elidedGroups === "number");
+        assert(typeof this.elisionBegin === "number");
+        const output = [];
+        const [left, right] = this.address.split("::");
+        if (left.length) {
+          output.push(...helpers.simpleGroup(left));
+        } else {
+          output.push("");
+        }
+        const classes = ["hover-group"];
+        for (let i = this.elisionBegin; i < this.elisionBegin + this.elidedGroups; i++) {
+          classes.push(`group-${i}`);
+        }
+        output.push(`<span class="${classes.join(" ")}"></span>`);
+        if (right.length) {
+          output.push(...helpers.simpleGroup(right, this.elisionEnd));
+        } else {
+          output.push("");
+        }
+        if (this.is4()) {
+          assert(this.address4 instanceof ipv4_1.Address4);
+          output.pop();
+          output.push(this.address4.groupForV6());
+        }
+        return output.join(":");
+      }
+      // #endregion
+      // #region Regular expressions
+      /**
+       * Generate a regular expression string that can be used to find or validate
+       * all variations of this address
+       * @memberof Address6
+       * @instance
+       * @param {boolean} substringSearch
+       * @returns {string}
+       */
+      regularExpressionString(substringSearch = false) {
+        let output = [];
+        const address6 = new _Address6(this.correctForm());
+        if (address6.elidedGroups === 0) {
+          output.push((0, regular_expressions_1.simpleRegularExpression)(address6.parsedAddress));
+        } else if (address6.elidedGroups === constants6.GROUPS) {
+          output.push((0, regular_expressions_1.possibleElisions)(constants6.GROUPS));
+        } else {
+          const halves = address6.address.split("::");
+          if (halves[0].length) {
+            output.push((0, regular_expressions_1.simpleRegularExpression)(halves[0].split(":")));
+          }
+          assert(typeof address6.elidedGroups === "number");
+          output.push((0, regular_expressions_1.possibleElisions)(address6.elidedGroups, halves[0].length !== 0, halves[1].length !== 0));
+          if (halves[1].length) {
+            output.push((0, regular_expressions_1.simpleRegularExpression)(halves[1].split(":")));
+          }
+          output = [output.join(":")];
+        }
+        if (!substringSearch) {
+          output = [
+            "(?=^|",
+            regular_expressions_1.ADDRESS_BOUNDARY,
+            "|[^\\w\\:])(",
+            ...output,
+            ")(?=[^\\w\\:]|",
+            regular_expressions_1.ADDRESS_BOUNDARY,
+            "|$)"
+          ];
+        }
+        return output.join("");
+      }
+      /**
+       * Generate a regular expression that can be used to find or validate all
+       * variations of this address.
+       * @memberof Address6
+       * @instance
+       * @param {boolean} substringSearch
+       * @returns {RegExp}
+       */
+      regularExpression(substringSearch = false) {
+        return new RegExp(this.regularExpressionString(substringSearch), "i");
+      }
+    };
+    exports.Address6 = Address62;
+  }
+});
+
+// node_modules/ip-address/dist/ip-address.js
+var require_ip_address = __commonJS({
+  "node_modules/ip-address/dist/ip-address.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.v6 = exports.AddressError = exports.Address6 = exports.Address4 = void 0;
+    var ipv4_1 = require_ipv4();
+    Object.defineProperty(exports, "Address4", { enumerable: true, get: function() {
+      return ipv4_1.Address4;
+    } });
+    var ipv6_1 = require_ipv6();
+    Object.defineProperty(exports, "Address6", { enumerable: true, get: function() {
+      return ipv6_1.Address6;
+    } });
+    var address_error_1 = require_address_error();
+    Object.defineProperty(exports, "AddressError", { enumerable: true, get: function() {
+      return address_error_1.AddressError;
+    } });
+    var helpers = __importStar(require_helpers());
+    exports.v6 = { helpers };
+  }
+});
+
+// node_modules/express-rate-limit/dist/index.mjs
+import { isIPv6 } from "node:net";
+import { isIPv6 as isIPv62 } from "node:net";
+import { Buffer as Buffer2 } from "node:buffer";
+import { createHash as createHash3 } from "node:crypto";
+import { isIP } from "node:net";
+function ipKeyGenerator(ip, ipv6Subnet = 56) {
+  if (ipv6Subnet && isIPv6(ip)) {
+    return `${new import_ip_address.Address6(`${ip}/${ipv6Subnet}`).startAddress().correctForm()}/${ipv6Subnet}`;
+  }
+  return ip;
+}
+var import_ip_address, MemoryStore, SUPPORTED_DRAFT_VERSIONS, getResetSeconds, getPartitionKey, setLegacyHeaders, setDraft6Headers, setDraft7Headers, setDraft8Headers, setRetryAfterHeader, omitUndefinedProperties, ValidationError, ChangeWarning, usedStores, singleCountKeys, validations, getValidations, isLegacyStore, promisifyStore, getOptionsFromConfig, parseOptions, handleAsyncErrors, rateLimit, rate_limit_default;
+var init_dist5 = __esm({
+  "node_modules/express-rate-limit/dist/index.mjs"() {
+    import_ip_address = __toESM(require_ip_address(), 1);
+    MemoryStore = class {
+      constructor(validations2) {
+        this.validations = validations2;
+        this.previous = /* @__PURE__ */ new Map();
+        this.current = /* @__PURE__ */ new Map();
+        this.localKeys = true;
+      }
+      /**
+       * Method that initializes the store.
+       *
+       * @param options {Options} - The options used to setup the middleware.
+       */
+      init(options) {
+        this.windowMs = options.windowMs;
+        this.validations?.windowMs(this.windowMs);
+        if (this.interval) clearInterval(this.interval);
+        this.interval = setInterval(() => {
+          this.clearExpired();
+        }, this.windowMs);
+        this.interval.unref?.();
+      }
+      /**
+       * Method to fetch a client's hit count and reset time.
+       *
+       * @param key {string} - The identifier for a client.
+       *
+       * @returns {ClientRateLimitInfo | undefined} - The number of hits and reset time for that client.
+       *
+       * @public
+       */
+      async get(key) {
+        return this.current.get(key) ?? this.previous.get(key);
+      }
+      /**
+       * Method to increment a client's hit counter.
+       *
+       * @param key {string} - The identifier for a client.
+       *
+       * @returns {ClientRateLimitInfo} - The number of hits and reset time for that client.
+       *
+       * @public
+       */
+      async increment(key) {
+        const client = this.getClient(key);
+        const now2 = Date.now();
+        if (client.resetTime.getTime() <= now2) {
+          this.resetClient(client, now2);
+        }
+        client.totalHits++;
+        return client;
+      }
+      /**
+       * Method to decrement a client's hit counter.
+       *
+       * @param key {string} - The identifier for a client.
+       *
+       * @public
+       */
+      async decrement(key) {
+        const client = this.getClient(key);
+        if (client.totalHits > 0) client.totalHits--;
+      }
+      /**
+       * Method to reset a client's hit counter.
+       *
+       * @param key {string} - The identifier for a client.
+       *
+       * @public
+       */
+      async resetKey(key) {
+        this.current.delete(key);
+        this.previous.delete(key);
+      }
+      /**
+       * Method to reset everyone's hit counter.
+       *
+       * @public
+       */
+      async resetAll() {
+        this.current.clear();
+        this.previous.clear();
+      }
+      /**
+       * Method to stop the timer (if currently running) and prevent any memory
+       * leaks.
+       *
+       * @public
+       */
+      shutdown() {
+        clearInterval(this.interval);
+        void this.resetAll();
+      }
+      /**
+       * Recycles a client by setting its hit count to zero, and reset time to
+       * `windowMs` milliseconds from now.
+       *
+       * NOT to be confused with `#resetKey()`, which removes a client from both the
+       * `current` and `previous` maps.
+       *
+       * @param client {Client} - The client to recycle.
+       * @param now {number} - The current time, to which the `windowMs` is added to get the `resetTime` for the client.
+       *
+       * @return {Client} - The modified client that was passed in, to allow for chaining.
+       */
+      resetClient(client, now2 = Date.now()) {
+        client.totalHits = 0;
+        client.resetTime.setTime(now2 + this.windowMs);
+        return client;
+      }
+      /**
+       * Retrieves or creates a client, given a key. Also ensures that the client being
+       * returned is in the `current` map.
+       *
+       * @param key {string} - The key under which the client is (or is to be) stored.
+       *
+       * @returns {Client} - The requested client.
+       */
+      getClient(key) {
+        if (this.current.has(key)) return this.current.get(key);
+        let client;
+        if (this.previous.has(key)) {
+          client = this.previous.get(key);
+          this.previous.delete(key);
+        } else {
+          client = { totalHits: 0, resetTime: /* @__PURE__ */ new Date() };
+          this.resetClient(client);
+        }
+        this.current.set(key, client);
+        return client;
+      }
+      /**
+       * Move current clients to previous, create a new map for current.
+       *
+       * This function is called every `windowMs`.
+       */
+      clearExpired() {
+        this.previous = this.current;
+        this.current = /* @__PURE__ */ new Map();
+      }
+    };
+    SUPPORTED_DRAFT_VERSIONS = [
+      "draft-6",
+      "draft-7",
+      "draft-8"
+    ];
+    getResetSeconds = (windowMs, resetTime) => {
+      let resetSeconds;
+      if (resetTime) {
+        const deltaSeconds = Math.ceil((resetTime.getTime() - Date.now()) / 1e3);
+        resetSeconds = Math.max(0, deltaSeconds);
+      } else {
+        resetSeconds = Math.ceil(windowMs / 1e3);
+      }
+      return resetSeconds;
+    };
+    getPartitionKey = (key) => {
+      const hash = createHash3("sha256");
+      hash.update(key);
+      const partitionKey = hash.digest("hex").slice(0, 12);
+      return Buffer2.from(partitionKey).toString("base64");
+    };
+    setLegacyHeaders = (response, info) => {
+      if (response.headersSent) return;
+      response.setHeader("X-RateLimit-Limit", info.limit.toString());
+      response.setHeader("X-RateLimit-Remaining", info.remaining.toString());
+      if (info.resetTime instanceof Date) {
+        response.setHeader("Date", (/* @__PURE__ */ new Date()).toUTCString());
+        response.setHeader(
+          "X-RateLimit-Reset",
+          Math.ceil(info.resetTime.getTime() / 1e3).toString()
+        );
+      }
+    };
+    setDraft6Headers = (response, info, windowMs) => {
+      if (response.headersSent) return;
+      const windowSeconds = Math.ceil(windowMs / 1e3);
+      const resetSeconds = getResetSeconds(windowMs, info.resetTime);
+      response.setHeader("RateLimit-Policy", `${info.limit};w=${windowSeconds}`);
+      response.setHeader("RateLimit-Limit", info.limit.toString());
+      response.setHeader("RateLimit-Remaining", info.remaining.toString());
+      if (typeof resetSeconds === "number")
+        response.setHeader("RateLimit-Reset", resetSeconds.toString());
+    };
+    setDraft7Headers = (response, info, windowMs) => {
+      if (response.headersSent) return;
+      const windowSeconds = Math.ceil(windowMs / 1e3);
+      const resetSeconds = getResetSeconds(windowMs, info.resetTime);
+      response.setHeader("RateLimit-Policy", `${info.limit};w=${windowSeconds}`);
+      response.setHeader(
+        "RateLimit",
+        `limit=${info.limit}, remaining=${info.remaining}, reset=${resetSeconds}`
+      );
+    };
+    setDraft8Headers = (response, info, windowMs, name, key) => {
+      if (response.headersSent) return;
+      const windowSeconds = Math.ceil(windowMs / 1e3);
+      const resetSeconds = getResetSeconds(windowMs, info.resetTime);
+      const partitionKey = getPartitionKey(key);
+      const header = `r=${info.remaining}; t=${resetSeconds}`;
+      const policy = `q=${info.limit}; w=${windowSeconds}; pk=:${partitionKey}:`;
+      response.append("RateLimit", `"${name}"; ${header}`);
+      response.append("RateLimit-Policy", `"${name}"; ${policy}`);
+    };
+    setRetryAfterHeader = (response, info, windowMs) => {
+      if (response.headersSent) return;
+      const resetSeconds = getResetSeconds(windowMs, info.resetTime);
+      response.setHeader("Retry-After", resetSeconds.toString());
+    };
+    omitUndefinedProperties = (passedOptions) => {
+      const omittedOptions = {};
+      for (const k of Object.keys(passedOptions)) {
+        const key = k;
+        if (passedOptions[key] !== void 0) {
+          omittedOptions[key] = passedOptions[key];
+        }
+      }
+      return omittedOptions;
+    };
+    ValidationError = class extends Error {
+      /**
+       * The code must be a string, in snake case and all capital, that starts with
+       * the substring `ERR_ERL_`.
+       *
+       * The message must be a string, starting with an uppercase character,
+       * describing the issue in detail.
+       */
+      constructor(code, message) {
+        const url = `https://express-rate-limit.github.io/${code}/`;
+        super(`${message} See ${url} for more information.`);
+        this.name = this.constructor.name;
+        this.code = code;
+        this.help = url;
+      }
+    };
+    ChangeWarning = class extends ValidationError {
+    };
+    usedStores = /* @__PURE__ */ new Set();
+    singleCountKeys = /* @__PURE__ */ new WeakMap();
+    validations = {
+      enabled: {
+        default: true
+      },
+      // Should be EnabledValidations type, but that's a circular reference
+      disable() {
+        for (const k of Object.keys(this.enabled)) this.enabled[k] = false;
+      },
+      /**
+       * Checks whether the IP address is valid, and that it does not have a port
+       * number in it.
+       *
+       * See https://github.com/express-rate-limit/express-rate-limit/wiki/Error-Codes#err_erl_invalid_ip_address.
+       *
+       * @param ip {string | undefined} - The IP address provided by Express as request.ip.
+       *
+       * @returns {void}
+       */
+      ip(ip) {
+        if (ip === void 0) {
+          throw new ValidationError(
+            "ERR_ERL_UNDEFINED_IP_ADDRESS",
+            `An undefined 'request.ip' was detected. This might indicate a misconfiguration or the connection being destroyed prematurely.`
+          );
+        }
+        if (!isIP(ip)) {
+          throw new ValidationError(
+            "ERR_ERL_INVALID_IP_ADDRESS",
+            `An invalid 'request.ip' (${ip}) was detected. Consider passing a custom 'keyGenerator' function to the rate limiter.`
+          );
+        }
+      },
+      /**
+       * Makes sure the trust proxy setting is not set to `true`.
+       *
+       * See https://github.com/express-rate-limit/express-rate-limit/wiki/Error-Codes#err_erl_permissive_trust_proxy.
+       *
+       * @param request {Request} - The Express request object.
+       *
+       * @returns {void}
+       */
+      trustProxy(request) {
+        if (request.app.get("trust proxy") === true) {
+          throw new ValidationError(
+            "ERR_ERL_PERMISSIVE_TRUST_PROXY",
+            `The Express 'trust proxy' setting is true, which allows anyone to trivially bypass IP-based rate limiting.`
+          );
+        }
+      },
+      /**
+       * Makes sure the trust proxy setting is set in case the `X-Forwarded-For`
+       * header is present.
+       *
+       * See https://github.com/express-rate-limit/express-rate-limit/wiki/Error-Codes#err_erl_unset_trust_proxy.
+       *
+       * @param request {Request} - The Express request object.
+       *
+       * @returns {void}
+       */
+      xForwardedForHeader(request) {
+        if (request.headers["x-forwarded-for"] && request.app.get("trust proxy") === false) {
+          throw new ValidationError(
+            "ERR_ERL_UNEXPECTED_X_FORWARDED_FOR",
+            `The 'X-Forwarded-For' header is set but the Express 'trust proxy' setting is false (default). This could indicate a misconfiguration which would prevent express-rate-limit from accurately identifying users.`
+          );
+        }
+      },
+      /**
+       * Alert the user if the Forwarded header is set (standardized version of X-Forwarded-For - not supported by express as of version 5.1.0)
+       *
+       * @param request {Request} - The Express request object.
+       *
+       * @returns {void}
+       */
+      forwardedHeader(request) {
+        if (request.headers.forwarded && request.ip === request.socket?.remoteAddress) {
+          throw new ValidationError(
+            "ERR_ERL_FORWARDED_HEADER",
+            `The 'Forwarded' header (standardized X-Forwarded-For) is set but currently being ignored. Add a custom keyGenerator to use a value from this header.`
+          );
+        }
+      },
+      /**
+       * Ensures totalHits value from store is a positive integer.
+       *
+       * @param hits {any} - The `totalHits` returned by the store.
+       */
+      positiveHits(hits) {
+        if (typeof hits !== "number" || hits < 1 || hits !== Math.round(hits)) {
+          throw new ValidationError(
+            "ERR_ERL_INVALID_HITS",
+            `The totalHits value returned from the store must be a positive integer, got ${hits}`
+          );
+        }
+      },
+      /**
+       * Ensures a single store instance is not used with multiple express-rate-limit instances
+       */
+      unsharedStore(store) {
+        if (usedStores.has(store)) {
+          const maybeUniquePrefix = store?.localKeys ? "" : " (with a unique prefix)";
+          throw new ValidationError(
+            "ERR_ERL_STORE_REUSE",
+            `A Store instance must not be shared across multiple rate limiters. Create a new instance of ${store.constructor.name}${maybeUniquePrefix} for each limiter instead.`
+          );
+        }
+        usedStores.add(store);
+      },
+      /**
+       * Ensures a given key is incremented only once per request.
+       *
+       * @param request {Request} - The Express request object.
+       * @param store {Store} - The store class.
+       * @param key {string} - The key used to store the client's hit count.
+       *
+       * @returns {void}
+       */
+      singleCount(request, store, key) {
+        let storeKeys = singleCountKeys.get(request);
+        if (!storeKeys) {
+          storeKeys = /* @__PURE__ */ new Map();
+          singleCountKeys.set(request, storeKeys);
+        }
+        const storeKey = store.localKeys ? store : store.constructor.name;
+        let keys = storeKeys.get(storeKey);
+        if (!keys) {
+          keys = [];
+          storeKeys.set(storeKey, keys);
+        }
+        const prefixedKey = `${store.prefix ?? ""}${key}`;
+        if (keys.includes(prefixedKey)) {
+          throw new ValidationError(
+            "ERR_ERL_DOUBLE_COUNT",
+            `The hit count for ${key} was incremented more than once for a single request.`
+          );
+        }
+        keys.push(prefixedKey);
+      },
+      /**
+       * Warns the user that the behaviour for `max: 0` / `limit: 0` is
+       * changing in the next major release.
+       *
+       * @param limit {number} - The maximum number of hits per client.
+       *
+       * @returns {void}
+       */
+      limit(limit) {
+        if (limit === 0) {
+          throw new ChangeWarning(
+            "WRN_ERL_MAX_ZERO",
+            "Setting limit or max to 0 disables rate limiting in express-rate-limit v6 and older, but will cause all requests to be blocked in v7"
+          );
+        }
+      },
+      /**
+       * Warns the user that the `draft_polli_ratelimit_headers` option is deprecated
+       * and will be removed in the next major release.
+       *
+       * @param draft_polli_ratelimit_headers {any | undefined} - The now-deprecated setting that was used to enable standard headers.
+       *
+       * @returns {void}
+       */
+      draftPolliHeaders(draft_polli_ratelimit_headers) {
+        if (draft_polli_ratelimit_headers) {
+          throw new ChangeWarning(
+            "WRN_ERL_DEPRECATED_DRAFT_POLLI_HEADERS",
+            `The draft_polli_ratelimit_headers configuration option is deprecated and has been removed in express-rate-limit v7, please set standardHeaders: 'draft-6' instead.`
+          );
+        }
+      },
+      /**
+       * Warns the user that the `onLimitReached` option is deprecated and
+       * will be removed in the next major release.
+       *
+       * @param onLimitReached {any | undefined} - The maximum number of hits per client.
+       *
+       * @returns {void}
+       */
+      onLimitReached(onLimitReached) {
+        if (onLimitReached) {
+          throw new ChangeWarning(
+            "WRN_ERL_DEPRECATED_ON_LIMIT_REACHED",
+            "The onLimitReached configuration option is deprecated and has been removed in express-rate-limit v7."
+          );
+        }
+      },
+      /**
+       * Warns the user when an invalid/unsupported version of the draft spec is passed.
+       *
+       * @param version {any | undefined} - The version passed by the user.
+       *
+       * @returns {void}
+       */
+      headersDraftVersion(version) {
+        if (typeof version !== "string" || // @ts-expect-error This is fine. If version is not in the array, it will just return false.
+        !SUPPORTED_DRAFT_VERSIONS.includes(version)) {
+          const versionString = SUPPORTED_DRAFT_VERSIONS.join(", ");
+          throw new ValidationError(
+            "ERR_ERL_HEADERS_UNSUPPORTED_DRAFT_VERSION",
+            `standardHeaders: only the following versions of the IETF draft specification are supported: ${versionString}.`
+          );
+        }
+      },
+      /**
+       * Warns the user when the selected headers option requires a reset time but
+       * the store does not provide one.
+       *
+       * @param resetTime {Date | undefined} - The timestamp when the client's hit count will be reset.
+       *
+       * @returns {void}
+       */
+      headersResetTime(resetTime) {
+        if (!resetTime) {
+          throw new ValidationError(
+            "ERR_ERL_HEADERS_NO_RESET",
+            `standardHeaders:  'draft-7' requires a 'resetTime', but the store did not provide one. The 'windowMs' value will be used instead, which may cause clients to wait longer than necessary.`
+          );
+        }
+      },
+      knownOptions(passedOptions) {
+        if (!passedOptions) return;
+        const optionsMap = {
+          windowMs: true,
+          limit: true,
+          message: true,
+          statusCode: true,
+          legacyHeaders: true,
+          standardHeaders: true,
+          identifier: true,
+          requestPropertyName: true,
+          skipFailedRequests: true,
+          skipSuccessfulRequests: true,
+          keyGenerator: true,
+          ipv6Subnet: true,
+          handler: true,
+          skip: true,
+          requestWasSuccessful: true,
+          store: true,
+          validate: true,
+          headers: true,
+          max: true,
+          passOnStoreError: true
+        };
+        const validOptions = Object.keys(optionsMap).concat(
+          "draft_polli_ratelimit_headers",
+          // not a valid option anymore, but we have a more specific check for this one, so don't warn for it here
+          // from express-slow-down - https://github.com/express-rate-limit/express-slow-down/blob/main/source/types.ts#L65
+          "delayAfter",
+          "delayMs",
+          "maxDelayMs"
+        );
+        for (const key of Object.keys(passedOptions)) {
+          if (!validOptions.includes(key)) {
+            throw new ValidationError(
+              "ERR_ERL_UNKNOWN_OPTION",
+              `Unexpected configuration option: ${key}`
+              // todo: suggest a valid option with a short levenstein distance?
+            );
+          }
+        }
+      },
+      /**
+       * Checks the options.validate setting to ensure that only recognized
+       * validations are enabled or disabled.
+       *
+       * If any unrecognized values are found, an error is logged that
+       * includes the list of supported validations.
+       */
+      validationsConfig() {
+        const supportedValidations = Object.keys(this).filter(
+          (k) => !["enabled", "disable"].includes(k)
+        );
+        supportedValidations.push("default");
+        for (const key of Object.keys(this.enabled)) {
+          if (!supportedValidations.includes(key)) {
+            throw new ValidationError(
+              "ERR_ERL_UNKNOWN_VALIDATION",
+              `options.validate.${key} is not recognized. Supported validate options are: ${supportedValidations.join(
+                ", "
+              )}.`
+            );
+          }
+        }
+      },
+      /**
+       * Checks to see if the instance was created inside of a request handler,
+       * which would prevent it from working correctly, with the default memory
+       * store (or any other store with localKeys.)
+       */
+      creationStack(store) {
+        const { stack } = new Error(
+          "express-rate-limit validation check (set options.validate.creationStack=false to disable)"
+        );
+        if (stack?.includes("Layer.handle [as handle_request]") || // express v4
+        stack?.includes("Layer.handleRequest")) {
+          if (!store.localKeys) {
+            throw new ValidationError(
+              "ERR_ERL_CREATED_IN_REQUEST_HANDLER",
+              "express-rate-limit instance should *usually* be created at app initialization, not when responding to a request."
+            );
+          }
+          throw new ValidationError(
+            "ERR_ERL_CREATED_IN_REQUEST_HANDLER",
+            "express-rate-limit instance should be created at app initialization, not when responding to a request."
+          );
+        }
+      },
+      ipv6Subnet(ipv6Subnet) {
+        if (ipv6Subnet === false) {
+          return;
+        }
+        if (!Number.isInteger(ipv6Subnet) || ipv6Subnet < 32 || ipv6Subnet > 64) {
+          throw new ValidationError(
+            "ERR_ERL_IPV6_SUBNET",
+            `Unexpected ipv6Subnet value: ${ipv6Subnet}. Expected an integer between 32 and 64 (usually 48-64).`
+          );
+        }
+      },
+      ipv6SubnetOrKeyGenerator(options) {
+        if (options.ipv6Subnet !== void 0 && options.keyGenerator) {
+          throw new ValidationError(
+            "ERR_ERL_IPV6SUBNET_OR_KEYGENERATOR",
+            `Incompatible options: the 'ipv6Subnet' option is ignored when a custom 'keyGenerator' function is also set.`
+          );
+        }
+      },
+      keyGeneratorIpFallback(keyGenerator) {
+        if (!keyGenerator) {
+          return;
+        }
+        const src = keyGenerator.toString();
+        if ((src.includes("req.ip") || src.includes("request.ip")) && !src.includes("ipKeyGenerator")) {
+          throw new ValidationError(
+            "ERR_ERL_KEY_GEN_IPV6",
+            "Custom keyGenerator appears to use request IP without calling the ipKeyGenerator helper function for IPv6 addresses. This could allow IPv6 users to bypass limits."
+          );
+        }
+      },
+      /**
+       * Checks to see if the window duration is greater than 2^32 - 1. This is only
+       * called by the default MemoryStore, since it uses Node's setInterval method.
+       *
+       * See https://nodejs.org/api/timers.html#setintervalcallback-delay-args.
+       */
+      windowMs(windowMs) {
+        const SET_TIMEOUT_MAX = 2 ** 31 - 1;
+        if (typeof windowMs !== "number" || Number.isNaN(windowMs) || windowMs < 1 || windowMs > SET_TIMEOUT_MAX) {
+          throw new ValidationError(
+            "ERR_ERL_WINDOW_MS",
+            `Invalid windowMs value: ${windowMs}${typeof windowMs !== "number" ? ` (${typeof windowMs})` : ""}, must be a number between 1 and ${SET_TIMEOUT_MAX} when using the default MemoryStore`
+          );
+        }
+      }
+    };
+    getValidations = (_enabled) => {
+      let enabled;
+      if (typeof _enabled === "boolean") {
+        enabled = {
+          default: _enabled
+        };
+      } else {
+        enabled = {
+          default: true,
+          ..._enabled
+        };
+      }
+      const wrappedValidations = { enabled };
+      for (const [name, validation] of Object.entries(validations)) {
+        if (typeof validation === "function")
+          wrappedValidations[name] = (...args) => {
+            if (!(enabled[name] ?? enabled.default)) {
+              return;
+            }
+            try {
+              ;
+              validation.apply(
+                wrappedValidations,
+                args
+              );
+            } catch (error) {
+              if (error instanceof ChangeWarning) console.warn(error);
+              else console.error(error);
+            }
+          };
+      }
+      return wrappedValidations;
+    };
+    isLegacyStore = (store) => (
+      // Check that `incr` exists but `increment` does not - store authors might want
+      // to keep both around for backwards compatibility.
+      typeof store.incr === "function" && typeof store.increment !== "function"
+    );
+    promisifyStore = (passedStore) => {
+      if (!isLegacyStore(passedStore)) {
+        return passedStore;
+      }
+      const legacyStore = passedStore;
+      class PromisifiedStore {
+        async increment(key) {
+          return new Promise((resolve24, reject) => {
+            legacyStore.incr(
+              key,
+              (error, totalHits, resetTime) => {
+                if (error) reject(error);
+                resolve24({ totalHits, resetTime });
+              }
+            );
+          });
+        }
+        async decrement(key) {
+          return legacyStore.decrement(key);
+        }
+        async resetKey(key) {
+          return legacyStore.resetKey(key);
+        }
+        /* istanbul ignore next */
+        async resetAll() {
+          if (typeof legacyStore.resetAll === "function")
+            return legacyStore.resetAll();
+        }
+      }
+      return new PromisifiedStore();
+    };
+    getOptionsFromConfig = (config8) => {
+      const { validations: validations2, ...directlyPassableEntries } = config8;
+      return {
+        ...directlyPassableEntries,
+        validate: validations2.enabled
+      };
+    };
+    parseOptions = (passedOptions) => {
+      const notUndefinedOptions = omitUndefinedProperties(passedOptions);
+      const validations2 = getValidations(notUndefinedOptions?.validate ?? true);
+      validations2.validationsConfig();
+      validations2.knownOptions(passedOptions);
+      validations2.draftPolliHeaders(
+        // @ts-expect-error see the note above.
+        notUndefinedOptions.draft_polli_ratelimit_headers
+      );
+      validations2.onLimitReached(notUndefinedOptions.onLimitReached);
+      if (notUndefinedOptions.ipv6Subnet !== void 0 && typeof notUndefinedOptions.ipv6Subnet !== "function") {
+        validations2.ipv6Subnet(notUndefinedOptions.ipv6Subnet);
+      }
+      validations2.keyGeneratorIpFallback(notUndefinedOptions.keyGenerator);
+      validations2.ipv6SubnetOrKeyGenerator(notUndefinedOptions);
+      let standardHeaders = notUndefinedOptions.standardHeaders ?? false;
+      if (standardHeaders === true) standardHeaders = "draft-6";
+      const config8 = {
+        windowMs: 60 * 1e3,
+        limit: passedOptions.max ?? 5,
+        // `max` is deprecated, but support it anyways.
+        message: "Too many requests, please try again later.",
+        statusCode: 429,
+        legacyHeaders: passedOptions.headers ?? true,
+        identifier(request, _response) {
+          let duration = "";
+          const property = config8.requestPropertyName;
+          const { limit } = request[property];
+          const seconds = config8.windowMs / 1e3;
+          const minutes = config8.windowMs / (1e3 * 60);
+          const hours = config8.windowMs / (1e3 * 60 * 60);
+          const days = config8.windowMs / (1e3 * 60 * 60 * 24);
+          if (seconds < 60) duration = `${seconds}sec`;
+          else if (minutes < 60) duration = `${minutes}min`;
+          else if (hours < 24) duration = `${hours}hr${hours > 1 ? "s" : ""}`;
+          else duration = `${days}day${days > 1 ? "s" : ""}`;
+          return `${limit}-in-${duration}`;
+        },
+        requestPropertyName: "rateLimit",
+        skipFailedRequests: false,
+        skipSuccessfulRequests: false,
+        requestWasSuccessful: (_request, response) => response.statusCode < 400,
+        skip: (_request, _response) => false,
+        async keyGenerator(request, response) {
+          validations2.ip(request.ip);
+          validations2.trustProxy(request);
+          validations2.xForwardedForHeader(request);
+          validations2.forwardedHeader(request);
+          const ip = request.ip;
+          let subnet = 56;
+          if (isIPv62(ip)) {
+            subnet = typeof config8.ipv6Subnet === "function" ? await config8.ipv6Subnet(request, response) : config8.ipv6Subnet;
+            if (typeof config8.ipv6Subnet === "function")
+              validations2.ipv6Subnet(subnet);
+          }
+          return ipKeyGenerator(ip, subnet);
+        },
+        ipv6Subnet: 56,
+        async handler(request, response, _next, _optionsUsed) {
+          response.status(config8.statusCode);
+          const message = typeof config8.message === "function" ? await config8.message(
+            request,
+            response
+          ) : config8.message;
+          if (!response.writableEnded) response.send(message);
+        },
+        passOnStoreError: false,
+        // Allow the default options to be overridden by the passed options.
+        ...notUndefinedOptions,
+        // `standardHeaders` is resolved into a draft version above, use that.
+        standardHeaders,
+        // Note that this field is declared after the user's options are spread in,
+        // so that this field doesn't get overridden with an un-promisified store!
+        store: promisifyStore(
+          notUndefinedOptions.store ?? new MemoryStore(validations2)
+        ),
+        // Print an error to the console if a few known misconfigurations are detected.
+        validations: validations2
+      };
+      if (typeof config8.store.increment !== "function" || typeof config8.store.decrement !== "function" || typeof config8.store.resetKey !== "function" || config8.store.resetAll !== void 0 && typeof config8.store.resetAll !== "function" || config8.store.init !== void 0 && typeof config8.store.init !== "function") {
+        throw new TypeError(
+          "An invalid store was passed. Please ensure that the store is a class that implements the `Store` interface."
+        );
+      }
+      return config8;
+    };
+    handleAsyncErrors = (fn) => async (request, response, next) => {
+      try {
+        await Promise.resolve(fn(request, response, next)).catch(next);
+      } catch (error) {
+        next(error);
+      }
+    };
+    rateLimit = (passedOptions) => {
+      const config8 = parseOptions(passedOptions ?? {});
+      const options = getOptionsFromConfig(config8);
+      config8.validations.creationStack(config8.store);
+      config8.validations.unsharedStore(config8.store);
+      if (typeof config8.store.init === "function") config8.store.init(options);
+      const middleware = handleAsyncErrors(
+        async (request, response, next) => {
+          const skip = await config8.skip(request, response);
+          if (skip) {
+            next();
+            return;
+          }
+          const augmentedRequest = request;
+          const key = await config8.keyGenerator(request, response);
+          let totalHits = 0;
+          let resetTime;
+          try {
+            const incrementResult = await config8.store.increment(key);
+            totalHits = incrementResult.totalHits;
+            resetTime = incrementResult.resetTime;
+          } catch (error) {
+            if (config8.passOnStoreError) {
+              console.error(
+                "express-rate-limit: error from store, allowing request without rate-limiting.",
+                error
+              );
+              next();
+              return;
+            }
+            throw error;
+          }
+          config8.validations.positiveHits(totalHits);
+          config8.validations.singleCount(request, config8.store, key);
+          const retrieveLimit = typeof config8.limit === "function" ? config8.limit(request, response) : config8.limit;
+          const limit = await retrieveLimit;
+          config8.validations.limit(limit);
+          const info = {
+            limit,
+            used: totalHits,
+            remaining: Math.max(limit - totalHits, 0),
+            resetTime,
+            key
+          };
+          Object.defineProperty(info, "current", {
+            configurable: false,
+            enumerable: false,
+            value: totalHits
+          });
+          augmentedRequest[config8.requestPropertyName] = info;
+          if (config8.legacyHeaders && !response.headersSent) {
+            setLegacyHeaders(response, info);
+          }
+          if (config8.standardHeaders && !response.headersSent) {
+            switch (config8.standardHeaders) {
+              case "draft-6": {
+                setDraft6Headers(response, info, config8.windowMs);
+                break;
+              }
+              case "draft-7": {
+                config8.validations.headersResetTime(info.resetTime);
+                setDraft7Headers(response, info, config8.windowMs);
+                break;
+              }
+              case "draft-8": {
+                const retrieveName = typeof config8.identifier === "function" ? config8.identifier(request, response) : config8.identifier;
+                const name = await retrieveName;
+                config8.validations.headersResetTime(info.resetTime);
+                setDraft8Headers(response, info, config8.windowMs, name, key);
+                break;
+              }
+              default: {
+                config8.validations.headersDraftVersion(config8.standardHeaders);
+                break;
+              }
+            }
+          }
+          if (config8.skipFailedRequests || config8.skipSuccessfulRequests) {
+            let decremented = false;
+            const decrementKey = async () => {
+              if (!decremented) {
+                await config8.store.decrement(key);
+                decremented = true;
+              }
+            };
+            if (config8.skipFailedRequests) {
+              response.on("finish", async () => {
+                if (!await config8.requestWasSuccessful(request, response))
+                  await decrementKey();
+              });
+              response.on("close", async () => {
+                if (!response.writableEnded) await decrementKey();
+              });
+              response.on("error", async () => {
+                await decrementKey();
+              });
+            }
+            if (config8.skipSuccessfulRequests) {
+              response.on("finish", async () => {
+                if (await config8.requestWasSuccessful(request, response))
+                  await decrementKey();
+              });
+            }
+          }
+          config8.validations.disable();
+          if (totalHits > limit) {
+            if (config8.legacyHeaders || config8.standardHeaders) {
+              setRetryAfterHeader(response, info, config8.windowMs);
+            }
+            config8.handler(request, response, next, options);
+            return;
+          }
+          next();
+        }
+      );
+      const getThrowFn = () => {
+        throw new Error("The current store does not support the get/getKey method");
+      };
+      middleware.resetKey = config8.store.resetKey.bind(config8.store);
+      middleware.getKey = typeof config8.store.get === "function" ? config8.store.get.bind(config8.store) : getThrowFn;
+      return middleware;
+    };
+    rate_limit_default = rateLimit;
+  }
+});
+
+// packages/server/dist/routes/entities.js
+import { Router as Router2 } from "express";
+function createEntityRoutes(bundle) {
+  const router = Router2();
+  const { store } = bundle;
+  router.get("/", async (req, res) => {
+    try {
+      const { type, project, search, limit: rawLimit = "50", offset: rawOffset = "0", status = "active" } = req.query;
+      const parsedLimit = Math.max(1, Math.min(Number(rawLimit) || 50, 500));
+      const parsedOffset = Math.max(0, Number(rawOffset) || 0);
+      if (search && typeof search === "string") {
+        const results = await store.searchEntities(search, parsedLimit);
+        res.json({ success: true, data: results, meta: { total: results.length, limit: parsedLimit, offset: 0 } });
+        return;
+      }
+      const entities = await store.findEntities({
+        type,
+        projectId: project,
+        status,
+        limit: parsedLimit,
+        offset: parsedOffset
+      });
+      res.json({ success: true, data: entities, meta: { limit: parsedLimit, offset: parsedOffset } });
+    } catch (err) {
+      logger26.error("Request failed", { error: err instanceof Error ? err.message : String(err) });
+      res.status(500).json({ success: false, error: { code: "SERVER_ERROR", message: "Internal server error" } });
+    }
+  });
+  router.get("/:id", async (req, res) => {
+    try {
+      const entity = await store.getEntity(req.params.id);
+      if (!entity) {
+        res.status(404).json({ success: false, error: { code: "NOT_FOUND", message: "Entity not found" } });
+        return;
+      }
+      res.json({ success: true, data: entity });
+    } catch (err) {
+      logger26.error("Request failed", { error: err instanceof Error ? err.message : String(err) });
+      res.status(500).json({ success: false, error: { code: "SERVER_ERROR", message: "Internal server error" } });
+    }
+  });
+  router.get("/:id/relationships", async (req, res) => {
+    try {
+      const { direction = "both" } = req.query;
+      const relationships = await store.getRelationshipsForEntity(req.params.id, direction);
+      res.json({ success: true, data: relationships });
+    } catch (err) {
+      logger26.error("Request failed", { error: err instanceof Error ? err.message : String(err) });
+      res.status(500).json({ success: false, error: { code: "SERVER_ERROR", message: "Internal server error" } });
+    }
+  });
+  return router;
+}
+var logger26;
+var init_entities = __esm({
+  "packages/server/dist/routes/entities.js"() {
+    "use strict";
+    init_dist();
+    logger26 = createLogger("server:entities");
+  }
+});
+
+// packages/server/dist/routes/relationships.js
+import { Router as Router3 } from "express";
+function createRelationshipRoutes(bundle) {
+  const router = Router3();
+  const { store } = bundle;
+  router.get("/", async (req, res) => {
+    try {
+      const { type, sourceId, targetId, limit: rawLimit = "100" } = req.query;
+      const parsedLimit = Math.max(1, Math.min(Number(rawLimit) || 100, 500));
+      if (sourceId && typeof sourceId === "string") {
+        const rels = await store.getRelationshipsForEntity(sourceId, "out");
+        const filtered = type ? rels.filter((r) => r.type === type) : rels;
+        res.json({ success: true, data: filtered.slice(0, parsedLimit) });
+        return;
+      }
+      if (targetId && typeof targetId === "string") {
+        const rels = await store.getRelationshipsForEntity(targetId, "in");
+        const filtered = type ? rels.filter((r) => r.type === type) : rels;
+        res.json({ success: true, data: filtered.slice(0, parsedLimit) });
+        return;
+      }
+      res.json({
+        success: true,
+        data: [],
+        meta: { message: "Provide sourceId or targetId to query relationships" }
+      });
+    } catch (err) {
+      logger27.error("Request failed", { error: err instanceof Error ? err.message : String(err) });
+      res.status(500).json({ success: false, error: { code: "SERVER_ERROR", message: "Internal server error" } });
+    }
+  });
+  router.get("/:id", async (req, res) => {
+    try {
+      const rel = await store.getRelationship(req.params.id);
+      if (!rel) {
+        res.status(404).json({ success: false, error: { code: "NOT_FOUND", message: "Relationship not found" } });
+        return;
+      }
+      res.json({ success: true, data: rel });
+    } catch (err) {
+      logger27.error("Request failed", { error: err instanceof Error ? err.message : String(err) });
+      res.status(500).json({ success: false, error: { code: "SERVER_ERROR", message: "Internal server error" } });
+    }
+  });
+  return router;
+}
+var logger27;
+var init_relationships = __esm({
+  "packages/server/dist/routes/relationships.js"() {
+    "use strict";
+    init_dist();
+    logger27 = createLogger("server:relationships");
+  }
+});
+
+// packages/server/dist/routes/projects.js
+import { Router as Router4 } from "express";
+function createProjectRoutes(bundle) {
+  const router = Router4();
+  const { store } = bundle;
+  router.get("/", async (_req, res) => {
+    try {
+      const projects = await store.listProjects();
+      res.json({ success: true, data: projects });
+    } catch (err) {
+      logger28.error("Request failed", { error: err instanceof Error ? err.message : String(err) });
+      res.status(500).json({ success: false, error: { code: "SERVER_ERROR", message: "Internal server error" } });
+    }
+  });
+  router.get("/:id", async (req, res) => {
+    try {
+      const project = await store.getProject(req.params.id);
+      if (!project) {
+        res.status(404).json({ success: false, error: { code: "NOT_FOUND", message: "Project not found" } });
+        return;
+      }
+      res.json({ success: true, data: project });
+    } catch (err) {
+      logger28.error("Request failed", { error: err instanceof Error ? err.message : String(err) });
+      res.status(500).json({ success: false, error: { code: "SERVER_ERROR", message: "Internal server error" } });
+    }
+  });
+  return router;
+}
+var logger28;
+var init_projects = __esm({
+  "packages/server/dist/routes/projects.js"() {
+    "use strict";
+    init_dist();
+    logger28 = createLogger("server:projects");
+  }
+});
+
+// packages/server/dist/routes/query.js
+import { Router as Router5 } from "express";
+function createQueryRoutes(bundle) {
+  const router = Router5();
+  const { store, queryEngine, router: llmRouter } = bundle;
+  router.post("/", async (req, res) => {
+    try {
+      const { query, projectId, stream = false } = req.body;
+      if (!query || typeof query !== "string") {
+        res.status(400).json({ success: false, error: { code: "BAD_REQUEST", message: "query is required" } });
+        return;
+      }
+      if (projectId && typeof projectId === "string") {
+        const project = await store.getProject(projectId);
+        if (!project) {
+          res.status(404).json({ success: false, error: { code: "NOT_FOUND", message: "Project not found" } });
+          return;
+        }
+      }
+      const context = await queryEngine.assembleContext(query, void 0, projectId);
+      if (stream) {
+        res.setHeader("Content-Type", "text/event-stream");
+        res.setHeader("Cache-Control", "no-cache");
+        res.setHeader("Connection", "keep-alive");
+        const systemPrompt8 = buildQuerySystemPrompt(context);
+        const gen = llmRouter.stream({
+          systemPrompt: systemPrompt8,
+          userPrompt: query,
+          promptId: "conversational_query",
+          promptVersion: "1.0",
+          task: LLMTask.CONVERSATIONAL_QUERY,
+          modelPreference: "primary",
+          temperature: 0.7
+        });
+        for await (const chunk of gen) {
+          res.write(`data: ${JSON.stringify({ type: "chunk", content: chunk })}
+
+`);
+        }
+        res.write(`data: ${JSON.stringify({ type: "sources", entities: context.entities.slice(0, 10) })}
+
+`);
+        res.write(`data: ${JSON.stringify({ type: "complete" })}
+
+`);
+        res.end();
+        return;
+      }
+      const systemPrompt7 = buildQuerySystemPrompt(context);
+      const result = await llmRouter.complete({
+        systemPrompt: systemPrompt7,
+        userPrompt: query,
+        promptId: "conversational_query",
+        promptVersion: "1.0",
+        task: LLMTask.CONVERSATIONAL_QUERY,
+        modelPreference: "primary",
+        temperature: 0.7
+      });
+      res.json({
+        success: true,
+        data: {
+          answer: result.content,
+          sources: context.entities.slice(0, 10),
+          relationships: context.relationships,
+          model: result.model,
+          tokens: { input: result.inputTokens, output: result.outputTokens }
+        }
+      });
+    } catch (err) {
+      logger29.error("Query failed", { error: err instanceof Error ? err.message : String(err) });
+      res.status(500).json({ success: false, error: { code: "QUERY_FAILED", message: "Query processing failed" } });
+    }
+  });
+  return router;
+}
+function buildQuerySystemPrompt(context) {
+  const entityContext = context.entities.map((e, i) => `[${i + 1}] ${e.type}: ${e.name}
+${e.summary ?? e.content}`).join("\n\n");
+  return `You are Cortex, a knowledge graph assistant. Answer questions using ONLY the context below. Cite sources as [N].
+
+## Knowledge Context
+${entityContext || "No relevant entities found."}
+
+## Instructions
+- Answer concisely and accurately based on the context
+- Cite sources using [N] notation
+- If the context doesn't contain enough information, say so
+- Suggest follow-up questions the user might ask`;
 }
 var logger29;
 var init_query = __esm({
@@ -5601,7 +8057,8 @@ async function startServer(options) {
   if (options.webDistPath) {
     const webDist = resolve20(options.webDistPath);
     app.use(express.static(webDist));
-    app.get("*", (_req, res) => {
+    const spaLimiter = rate_limit_default({ windowMs: 6e4, max: 60 });
+    app.get("*", spaLimiter, (_req, res) => {
       res.sendFile(resolve20(webDist, "index.html"));
     });
     logger34.info("Serving web dashboard", { path: webDist });
@@ -5675,9 +8132,10 @@ async function startServer(options) {
   process.on("SIGTERM", shutdown);
 }
 var logger34;
-var init_dist5 = __esm({
+var init_dist6 = __esm({
   "packages/server/dist/index.js"() {
     "use strict";
+    init_dist5();
     init_dist();
     init_dist2();
     init_dist3();
@@ -6426,6 +8884,9 @@ import { resolve as resolve7 } from "node:path";
 import { statSync as statSync3 } from "node:fs";
 import chalk5 from "chalk";
 var logger15 = createLogger("cli:status");
+function sanitizeConfigValue(val) {
+  return [...val].map((c) => c).join("");
+}
 function sanitizeUrl(url) {
   try {
     const parsed = new URL(url);
@@ -6473,10 +8934,17 @@ async function runStatus(globals) {
       vectorSizeBytes = vectorStat.size;
     } catch {
     }
+    const cloudProvider = sanitizeConfigValue(config8.llm.cloud.provider);
+    const cloudPrimary = sanitizeConfigValue(config8.llm.cloud.models.primary);
+    const cloudFast = sanitizeConfigValue(config8.llm.cloud.models.fast);
+    const localModel = sanitizeConfigValue(config8.llm.local.model);
+    const localHost = sanitizeUrl(config8.llm.local.host);
+    const localNumCtx = Number(config8.llm.local.numCtx) || 8192;
+    const localNumGpu = Number(config8.llm.local.numGpu) ?? -1;
     const apiKeySource = config8.llm.cloud.apiKeySource;
     const apiKeyEnvVar = apiKeySource.startsWith("env:") ? apiKeySource.slice(4) : void 0;
-    const hasApiKey = apiKeyEnvVar ? Boolean(process.env[apiKeyEnvVar]) : false;
-    const mode = config8.llm.mode;
+    const hasApiKey = apiKeyEnvVar ? Object.hasOwn(process.env, apiKeyEnvVar) : false;
+    const mode = sanitizeConfigValue(config8.llm.mode);
     const ollamaAvailable = mode !== "cloud-first" ? await checkOllamaAvailable(config8.llm.local.host) : false;
     if (globals.json)
       setGlobalLogLevel("error");
@@ -6505,15 +8973,15 @@ async function runStatus(globals) {
         llm: {
           mode,
           cloud: {
-            provider: config8.llm.cloud.provider,
+            provider: cloudProvider,
             available: hasApiKey
           },
           local: {
             provider: "ollama",
             available: ollamaAvailable,
-            host: sanitizeUrl(config8.llm.local.host),
-            model: config8.llm.local.model,
-            numCtx: localProvider?.getNumCtx() ?? config8.llm.local.numCtx
+            host: localHost,
+            model: localModel,
+            numCtx: localProvider?.getNumCtx() ?? localNumCtx
           }
         },
         budget: {
@@ -6536,11 +9004,11 @@ async function runStatus(globals) {
     console.log(chalk5.white("Files:     ") + `${stats.fileCount} tracked`);
     console.log(chalk5.white("Storage:   ") + `${formatBytes(stats.dbSizeBytes)} (SQLite) | ${formatBytes(vectorSizeBytes)} (vectors)`);
     console.log("");
-    const numCtx = localProvider?.getNumCtx() ?? config8.llm.local.numCtx;
-    const numGpu = localProvider?.getNumGpu() ?? config8.llm.local.numGpu;
+    const numCtx = localProvider?.getNumCtx() ?? localNumCtx;
+    const numGpu = localProvider?.getNumGpu() ?? localNumGpu;
     console.log(chalk5.white("LLM Mode:  ") + mode);
-    const cloudLabel = `${config8.llm.cloud.models.primary} / ${config8.llm.cloud.models.fast} (${config8.llm.cloud.provider})`;
-    const localLabel = `${config8.llm.local.model} @ ${sanitizeUrl(config8.llm.local.host)}`;
+    const cloudLabel = `${cloudPrimary} / ${cloudFast} (${cloudProvider})`;
+    const localLabel = `${localModel} @ ${localHost}`;
     const localDetail = `${numCtx.toLocaleString()} ctx | GPU: ${numGpu === -1 ? "auto" : numGpu} layers | ~30 tok/s est.`;
     if (mode === "cloud-first") {
       const llmStatus = hasApiKey ? chalk5.green("\u2713") : chalk5.red("\u2717");
@@ -6829,9 +9297,15 @@ function setNestedValue(obj, path, value) {
     current = current[part];
   }
   const lastKey = parts[parts.length - 1];
-  if (DANGEROUS_KEYS.has(lastKey))
+  if (lastKey === "__proto__" || lastKey === "constructor" || lastKey === "prototype") {
     throw new Error(`Invalid config key: ${lastKey}`);
-  current[lastKey] = value;
+  }
+  Object.defineProperty(current, lastKey, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
 }
 function parseValue(value) {
   try {
@@ -8283,7 +10757,7 @@ async function runServe(opts, globals) {
       }
     } catch {
     }
-    const { startServer: startServer2 } = await Promise.resolve().then(() => (init_dist5(), dist_exports2));
+    const { startServer: startServer2 } = await Promise.resolve().then(() => (init_dist6(), dist_exports2));
     const pidDir = resolve21(homedir7(), ".cortex");
     mkdirSync6(pidDir, { recursive: true });
     writeFileSync5(resolve21(pidDir, "cortex.pid"), String(process.pid));