Add files using upload-large-folder tool

novas/novacore-zephyr/claude-code-router/node_modules/content-disposition/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2014-2017 Douglas Christopher Wilson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

novas/novacore-zephyr/claude-code-router/node_modules/content-disposition/index.js

@@ -0,0 +1,458 @@
+/*!
+ * content-disposition
+ * Copyright(c) 2014-2017 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+'use strict'
+
+/**
+ * Module exports.
+ * @public
+ */
+
+module.exports = contentDisposition
+module.exports.parse = parse
+
+/**
+ * Module dependencies.
+ * @private
+ */
+
+var basename = require('path').basename
+var Buffer = require('safe-buffer').Buffer
+
+/**
+ * RegExp to match non attr-char, *after* encodeURIComponent (i.e. not including "%")
+ * @private
+ */
+
+var ENCODE_URL_ATTR_CHAR_REGEXP = /[\x00-\x20"'()*,/:;<=>?@[\\\]{}\x7f]/g // eslint-disable-line no-control-regex
+
+/**
+ * RegExp to match percent encoding escape.
+ * @private
+ */
+
+var HEX_ESCAPE_REGEXP = /%[0-9A-Fa-f]{2}/
+var HEX_ESCAPE_REPLACE_REGEXP = /%([0-9A-Fa-f]{2})/g
+
+/**
+ * RegExp to match non-latin1 characters.
+ * @private
+ */
+
+var NON_LATIN1_REGEXP = /[^\x20-\x7e\xa0-\xff]/g
+
+/**
+ * RegExp to match quoted-pair in RFC 2616
+ *
+ * quoted-pair = "\" CHAR
+ * CHAR        = <any US-ASCII character (octets 0 - 127)>
+ * @private
+ */
+
+var QESC_REGEXP = /\\([\u0000-\u007f])/g // eslint-disable-line no-control-regex
+
+/**
+ * RegExp to match chars that must be quoted-pair in RFC 2616
+ * @private
+ */
+
+var QUOTE_REGEXP = /([\\"])/g
+
+/**
+ * RegExp for various RFC 2616 grammar
+ *
+ * parameter     = token "=" ( token | quoted-string )
+ * token         = 1*<any CHAR except CTLs or separators>
+ * separators    = "(" | ")" | "<" | ">" | "@"
+ *               | "," | ";" | ":" | "\" | <">
+ *               | "/" | "[" | "]" | "?" | "="
+ *               | "{" | "}" | SP | HT
+ * quoted-string = ( <"> *(qdtext | quoted-pair ) <"> )
+ * qdtext        = <any TEXT except <">>
+ * quoted-pair   = "\" CHAR
+ * CHAR          = <any US-ASCII character (octets 0 - 127)>
+ * TEXT          = <any OCTET except CTLs, but including LWS>
+ * LWS           = [CRLF] 1*( SP | HT )
+ * CRLF          = CR LF
+ * CR            = <US-ASCII CR, carriage return (13)>
+ * LF            = <US-ASCII LF, linefeed (10)>
+ * SP            = <US-ASCII SP, space (32)>
+ * HT            = <US-ASCII HT, horizontal-tab (9)>
+ * CTL           = <any US-ASCII control character (octets 0 - 31) and DEL (127)>
+ * OCTET         = <any 8-bit sequence of data>
+ * @private
+ */
+
+var PARAM_REGEXP = /;[\x09\x20]*([!#$%&'*+.0-9A-Z^_`a-z|~-]+)[\x09\x20]*=[\x09\x20]*("(?:[\x20!\x23-\x5b\x5d-\x7e\x80-\xff]|\\[\x20-\x7e])*"|[!#$%&'*+.0-9A-Z^_`a-z|~-]+)[\x09\x20]*/g // eslint-disable-line no-control-regex
+var TEXT_REGEXP = /^[\x20-\x7e\x80-\xff]+$/
+var TOKEN_REGEXP = /^[!#$%&'*+.0-9A-Z^_`a-z|~-]+$/
+
+/**
+ * RegExp for various RFC 5987 grammar
+ *
+ * ext-value     = charset  "'" [ language ] "'" value-chars
+ * charset       = "UTF-8" / "ISO-8859-1" / mime-charset
+ * mime-charset  = 1*mime-charsetc
+ * mime-charsetc = ALPHA / DIGIT
+ *               / "!" / "#" / "$" / "%" / "&"
+ *               / "+" / "-" / "^" / "_" / "`"
+ *               / "{" / "}" / "~"
+ * language      = ( 2*3ALPHA [ extlang ] )
+ *               / 4ALPHA
+ *               / 5*8ALPHA
+ * extlang       = *3( "-" 3ALPHA )
+ * value-chars   = *( pct-encoded / attr-char )
+ * pct-encoded   = "%" HEXDIG HEXDIG
+ * attr-char     = ALPHA / DIGIT
+ *               / "!" / "#" / "$" / "&" / "+" / "-" / "."
+ *               / "^" / "_" / "`" / "|" / "~"
+ * @private
+ */
+
+var EXT_VALUE_REGEXP = /^([A-Za-z0-9!#$%&+\-^_`{}~]+)'(?:[A-Za-z]{2,3}(?:-[A-Za-z]{3}){0,3}|[A-Za-z]{4,8}|)'((?:%[0-9A-Fa-f]{2}|[A-Za-z0-9!#$&+.^_`|~-])+)$/
+
+/**
+ * RegExp for various RFC 6266 grammar
+ *
+ * disposition-type = "inline" | "attachment" | disp-ext-type
+ * disp-ext-type    = token
+ * disposition-parm = filename-parm | disp-ext-parm
+ * filename-parm    = "filename" "=" value
+ *                  | "filename*" "=" ext-value
+ * disp-ext-parm    = token "=" value
+ *                  | ext-token "=" ext-value
+ * ext-token        = <the characters in token, followed by "*">
+ * @private
+ */
+
+var DISPOSITION_TYPE_REGEXP = /^([!#$%&'*+.0-9A-Z^_`a-z|~-]+)[\x09\x20]*(?:$|;)/ // eslint-disable-line no-control-regex
+
+/**
+ * Create an attachment Content-Disposition header.
+ *
+ * @param {string} [filename]
+ * @param {object} [options]
+ * @param {string} [options.type=attachment]
+ * @param {string|boolean} [options.fallback=true]
+ * @return {string}
+ * @public
+ */
+
+function contentDisposition (filename, options) {
+  var opts = options || {}
+
+  // get type
+  var type = opts.type || 'attachment'
+
+  // get parameters
+  var params = createparams(filename, opts.fallback)
+
+  // format into string
+  return format(new ContentDisposition(type, params))
+}
+
+/**
+ * Create parameters object from filename and fallback.
+ *
+ * @param {string} [filename]
+ * @param {string|boolean} [fallback=true]
+ * @return {object}
+ * @private
+ */
+
+function createparams (filename, fallback) {
+  if (filename === undefined) {
+    return
+  }
+
+  var params = {}
+
+  if (typeof filename !== 'string') {
+    throw new TypeError('filename must be a string')
+  }
+
+  // fallback defaults to true
+  if (fallback === undefined) {
+    fallback = true
+  }
+
+  if (typeof fallback !== 'string' && typeof fallback !== 'boolean') {
+    throw new TypeError('fallback must be a string or boolean')
+  }
+
+  if (typeof fallback === 'string' && NON_LATIN1_REGEXP.test(fallback)) {
+    throw new TypeError('fallback must be ISO-8859-1 string')
+  }
+
+  // restrict to file base name
+  var name = basename(filename)
+
+  // determine if name is suitable for quoted string
+  var isQuotedString = TEXT_REGEXP.test(name)
+
+  // generate fallback name
+  var fallbackName = typeof fallback !== 'string'
+    ? fallback && getlatin1(name)
+    : basename(fallback)
+  var hasFallback = typeof fallbackName === 'string' && fallbackName !== name
+
+  // set extended filename parameter
+  if (hasFallback || !isQuotedString || HEX_ESCAPE_REGEXP.test(name)) {
+    params['filename*'] = name
+  }
+
+  // set filename parameter
+  if (isQuotedString || hasFallback) {
+    params.filename = hasFallback
+      ? fallbackName
+      : name
+  }
+
+  return params
+}
+
+/**
+ * Format object to Content-Disposition header.
+ *
+ * @param {object} obj
+ * @param {string} obj.type
+ * @param {object} [obj.parameters]
+ * @return {string}
+ * @private
+ */
+
+function format (obj) {
+  var parameters = obj.parameters
+  var type = obj.type
+
+  if (!type || typeof type !== 'string' || !TOKEN_REGEXP.test(type)) {
+    throw new TypeError('invalid type')
+  }
+
+  // start with normalized type
+  var string = String(type).toLowerCase()
+
+  // append parameters
+  if (parameters && typeof parameters === 'object') {
+    var param
+    var params = Object.keys(parameters).sort()
+
+    for (var i = 0; i < params.length; i++) {
+      param = params[i]
+
+      var val = param.substr(-1) === '*'
+        ? ustring(parameters[param])
+        : qstring(parameters[param])
+
+      string += '; ' + param + '=' + val
+    }
+  }
+
+  return string
+}
+
+/**
+ * Decode a RFC 5987 field value (gracefully).
+ *
+ * @param {string} str
+ * @return {string}
+ * @private
+ */
+
+function decodefield (str) {
+  var match = EXT_VALUE_REGEXP.exec(str)
+
+  if (!match) {
+    throw new TypeError('invalid extended field value')
+  }
+
+  var charset = match[1].toLowerCase()
+  var encoded = match[2]
+  var value
+
+  // to binary string
+  var binary = encoded.replace(HEX_ESCAPE_REPLACE_REGEXP, pdecode)
+
+  switch (charset) {
+    case 'iso-8859-1':
+      value = getlatin1(binary)
+      break
+    case 'utf-8':
+      value = Buffer.from(binary, 'binary').toString('utf8')
+      break
+    default:
+      throw new TypeError('unsupported charset in extended field')
+  }
+
+  return value
+}
+
+/**
+ * Get ISO-8859-1 version of string.
+ *
+ * @param {string} val
+ * @return {string}
+ * @private
+ */
+
+function getlatin1 (val) {
+  // simple Unicode -> ISO-8859-1 transformation
+  return String(val).replace(NON_LATIN1_REGEXP, '?')
+}
+
+/**
+ * Parse Content-Disposition header string.
+ *
+ * @param {string} string
+ * @return {object}
+ * @public
+ */
+
+function parse (string) {
+  if (!string || typeof string !== 'string') {
+    throw new TypeError('argument string is required')
+  }
+
+  var match = DISPOSITION_TYPE_REGEXP.exec(string)
+
+  if (!match) {
+    throw new TypeError('invalid type format')
+  }
+
+  // normalize type
+  var index = match[0].length
+  var type = match[1].toLowerCase()
+
+  var key
+  var names = []
+  var params = {}
+  var value
+
+  // calculate index to start at
+  index = PARAM_REGEXP.lastIndex = match[0].substr(-1) === ';'
+    ? index - 1
+    : index
+
+  // match parameters
+  while ((match = PARAM_REGEXP.exec(string))) {
+    if (match.index !== index) {
+      throw new TypeError('invalid parameter format')
+    }
+
+    index += match[0].length
+    key = match[1].toLowerCase()
+    value = match[2]
+
+    if (names.indexOf(key) !== -1) {
+      throw new TypeError('invalid duplicate parameter')
+    }
+
+    names.push(key)
+
+    if (key.indexOf('*') + 1 === key.length) {
+      // decode extended value
+      key = key.slice(0, -1)
+      value = decodefield(value)
+
+      // overwrite existing value
+      params[key] = value
+      continue
+    }
+
+    if (typeof params[key] === 'string') {
+      continue
+    }
+
+    if (value[0] === '"') {
+      // remove quotes and escapes
+      value = value
+        .substr(1, value.length - 2)
+        .replace(QESC_REGEXP, '$1')
+    }
+
+    params[key] = value
+  }
+
+  if (index !== -1 && index !== string.length) {
+    throw new TypeError('invalid parameter format')
+  }
+
+  return new ContentDisposition(type, params)
+}
+
+/**
+ * Percent decode a single character.
+ *
+ * @param {string} str
+ * @param {string} hex
+ * @return {string}
+ * @private
+ */
+
+function pdecode (str, hex) {
+  return String.fromCharCode(parseInt(hex, 16))
+}
+
+/**
+ * Percent encode a single character.
+ *
+ * @param {string} char
+ * @return {string}
+ * @private
+ */
+
+function pencode (char) {
+  return '%' + String(char)
+    .charCodeAt(0)
+    .toString(16)
+    .toUpperCase()
+}
+
+/**
+ * Quote a string for HTTP.
+ *
+ * @param {string} val
+ * @return {string}
+ * @private
+ */
+
+function qstring (val) {
+  var str = String(val)
+
+  return '"' + str.replace(QUOTE_REGEXP, '\\$1') + '"'
+}
+
+/**
+ * Encode a Unicode string for HTTP (RFC 5987).
+ *
+ * @param {string} val
+ * @return {string}
+ * @private
+ */
+
+function ustring (val) {
+  var str = String(val)
+
+  // percent encode as UTF-8
+  var encoded = encodeURIComponent(str)
+    .replace(ENCODE_URL_ATTR_CHAR_REGEXP, pencode)
+
+  return 'UTF-8\'\'' + encoded
+}
+
+/**
+ * Class for parsed Content-Disposition header for v8 optimization
+ *
+ * @public
+ * @param {string} type
+ * @param {object} parameters
+ * @constructor
+ */
+
+function ContentDisposition (type, parameters) {
+  this.type = type
+  this.parameters = parameters
+}

novas/novacore-zephyr/claude-code-router/node_modules/esbuild/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Evan Wallace
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

novas/novacore-zephyr/claude-code-router/node_modules/esbuild/README.md

@@ -0,0 +1,3 @@
+# esbuild
+
+This is a JavaScript bundler and minifier. See https://github.com/evanw/esbuild and the [JavaScript API documentation](https://esbuild.github.io/api/) for details.

novas/novacore-zephyr/claude-code-router/node_modules/esbuild/install.js

@@ -0,0 +1,289 @@
+"use strict";
+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 __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
+));
+
+// lib/npm/node-platform.ts
+var fs = require("fs");
+var os = require("os");
+var path = require("path");
+var ESBUILD_BINARY_PATH = process.env.ESBUILD_BINARY_PATH || ESBUILD_BINARY_PATH;
+var isValidBinaryPath = (x) => !!x && x !== "/usr/bin/esbuild";
+var knownWindowsPackages = {
+  "win32 arm64 LE": "@esbuild/win32-arm64",
+  "win32 ia32 LE": "@esbuild/win32-ia32",
+  "win32 x64 LE": "@esbuild/win32-x64"
+};
+var knownUnixlikePackages = {
+  "aix ppc64 BE": "@esbuild/aix-ppc64",
+  "android arm64 LE": "@esbuild/android-arm64",
+  "darwin arm64 LE": "@esbuild/darwin-arm64",
+  "darwin x64 LE": "@esbuild/darwin-x64",
+  "freebsd arm64 LE": "@esbuild/freebsd-arm64",
+  "freebsd x64 LE": "@esbuild/freebsd-x64",
+  "linux arm LE": "@esbuild/linux-arm",
+  "linux arm64 LE": "@esbuild/linux-arm64",
+  "linux ia32 LE": "@esbuild/linux-ia32",
+  "linux mips64el LE": "@esbuild/linux-mips64el",
+  "linux ppc64 LE": "@esbuild/linux-ppc64",
+  "linux riscv64 LE": "@esbuild/linux-riscv64",
+  "linux s390x BE": "@esbuild/linux-s390x",
+  "linux x64 LE": "@esbuild/linux-x64",
+  "linux loong64 LE": "@esbuild/linux-loong64",
+  "netbsd arm64 LE": "@esbuild/netbsd-arm64",
+  "netbsd x64 LE": "@esbuild/netbsd-x64",
+  "openbsd arm64 LE": "@esbuild/openbsd-arm64",
+  "openbsd x64 LE": "@esbuild/openbsd-x64",
+  "sunos x64 LE": "@esbuild/sunos-x64"
+};
+var knownWebAssemblyFallbackPackages = {
+  "android arm LE": "@esbuild/android-arm",
+  "android x64 LE": "@esbuild/android-x64",
+  "openharmony arm64 LE": "@esbuild/openharmony-arm64"
+};
+function pkgAndSubpathForCurrentPlatform() {
+  let pkg;
+  let subpath;
+  let isWASM = false;
+  let platformKey = `${process.platform} ${os.arch()} ${os.endianness()}`;
+  if (platformKey in knownWindowsPackages) {
+    pkg = knownWindowsPackages[platformKey];
+    subpath = "esbuild.exe";
+  } else if (platformKey in knownUnixlikePackages) {
+    pkg = knownUnixlikePackages[platformKey];
+    subpath = "bin/esbuild";
+  } else if (platformKey in knownWebAssemblyFallbackPackages) {
+    pkg = knownWebAssemblyFallbackPackages[platformKey];
+    subpath = "bin/esbuild";
+    isWASM = true;
+  } else {
+    throw new Error(`Unsupported platform: ${platformKey}`);
+  }
+  return { pkg, subpath, isWASM };
+}
+function downloadedBinPath(pkg, subpath) {
+  const esbuildLibDir = path.dirname(require.resolve("esbuild"));
+  return path.join(esbuildLibDir, `downloaded-${pkg.replace("/", "-")}-${path.basename(subpath)}`);
+}
+
+// lib/npm/node-install.ts
+var fs2 = require("fs");
+var os2 = require("os");
+var path2 = require("path");
+var zlib = require("zlib");
+var https = require("https");
+var child_process = require("child_process");
+var versionFromPackageJSON = require(path2.join(__dirname, "package.json")).version;
+var toPath = path2.join(__dirname, "bin", "esbuild");
+var isToPathJS = true;
+function validateBinaryVersion(...command) {
+  command.push("--version");
+  let stdout;
+  try {
+    stdout = child_process.execFileSync(command.shift(), command, {
+      // Without this, this install script strangely crashes with the error
+      // "EACCES: permission denied, write" but only on Ubuntu Linux when node is
+      // installed from the Snap Store. This is not a problem when you download
+      // the official version of node. The problem appears to be that stderr
+      // (i.e. file descriptor 2) isn't writable?
+      //
+      // More info:
+      // - https://snapcraft.io/ (what the Snap Store is)
+      // - https://nodejs.org/dist/ (download the official version of node)
+      // - https://github.com/evanw/esbuild/issues/1711#issuecomment-1027554035
+      //
+      stdio: "pipe"
+    }).toString().trim();
+  } catch (err) {
+    if (os2.platform() === "darwin" && /_SecTrustEvaluateWithError/.test(err + "")) {
+      let os3 = "this version of macOS";
+      try {
+        os3 = "macOS " + child_process.execFileSync("sw_vers", ["-productVersion"]).toString().trim();
+      } catch {
+      }
+      throw new Error(`The "esbuild" package cannot be installed because ${os3} is too outdated.
+
+The Go compiler (which esbuild relies on) no longer supports ${os3},
+which means the "esbuild" binary executable can't be run. You can either:
+
+  * Update your version of macOS to one that the Go compiler supports
+  * Use the "esbuild-wasm" package instead of the "esbuild" package
+  * Build esbuild yourself using an older version of the Go compiler
+`);
+    }
+    throw err;
+  }
+  if (stdout !== versionFromPackageJSON) {
+    throw new Error(`Expected ${JSON.stringify(versionFromPackageJSON)} but got ${JSON.stringify(stdout)}`);
+  }
+}
+function isYarn() {
+  const { npm_config_user_agent } = process.env;
+  if (npm_config_user_agent) {
+    return /\byarn\//.test(npm_config_user_agent);
+  }
+  return false;
+}
+function fetch(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      if ((res.statusCode === 301 || res.statusCode === 302) && res.headers.location)
+        return fetch(res.headers.location).then(resolve, reject);
+      if (res.statusCode !== 200)
+        return reject(new Error(`Server responded with ${res.statusCode}`));
+      let chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => resolve(Buffer.concat(chunks)));
+    }).on("error", reject);
+  });
+}
+function extractFileFromTarGzip(buffer, subpath) {
+  try {
+    buffer = zlib.unzipSync(buffer);
+  } catch (err) {
+    throw new Error(`Invalid gzip data in archive: ${err && err.message || err}`);
+  }
+  let str = (i, n) => String.fromCharCode(...buffer.subarray(i, i + n)).replace(/\0.*$/, "");
+  let offset = 0;
+  subpath = `package/${subpath}`;
+  while (offset < buffer.length) {
+    let name = str(offset, 100);
+    let size = parseInt(str(offset + 124, 12), 8);
+    offset += 512;
+    if (!isNaN(size)) {
+      if (name === subpath) return buffer.subarray(offset, offset + size);
+      offset += size + 511 & ~511;
+    }
+  }
+  throw new Error(`Could not find ${JSON.stringify(subpath)} in archive`);
+}
+function installUsingNPM(pkg, subpath, binPath) {
+  const env = { ...process.env, npm_config_global: void 0 };
+  const esbuildLibDir = path2.dirname(require.resolve("esbuild"));
+  const installDir = path2.join(esbuildLibDir, "npm-install");
+  fs2.mkdirSync(installDir);
+  try {
+    fs2.writeFileSync(path2.join(installDir, "package.json"), "{}");
+    child_process.execSync(
+      `npm install --loglevel=error --prefer-offline --no-audit --progress=false ${pkg}@${versionFromPackageJSON}`,
+      { cwd: installDir, stdio: "pipe", env }
+    );
+    const installedBinPath = path2.join(installDir, "node_modules", pkg, subpath);
+    fs2.renameSync(installedBinPath, binPath);
+  } finally {
+    try {
+      removeRecursive(installDir);
+    } catch {
+    }
+  }
+}
+function removeRecursive(dir) {
+  for (const entry of fs2.readdirSync(dir)) {
+    const entryPath = path2.join(dir, entry);
+    let stats;
+    try {
+      stats = fs2.lstatSync(entryPath);
+    } catch {
+      continue;
+    }
+    if (stats.isDirectory()) removeRecursive(entryPath);
+    else fs2.unlinkSync(entryPath);
+  }
+  fs2.rmdirSync(dir);
+}
+function applyManualBinaryPathOverride(overridePath) {
+  const pathString = JSON.stringify(overridePath);
+  fs2.writeFileSync(toPath, `#!/usr/bin/env node
+require('child_process').execFileSync(${pathString}, process.argv.slice(2), { stdio: 'inherit' });
+`);
+  const libMain = path2.join(__dirname, "lib", "main.js");
+  const code = fs2.readFileSync(libMain, "utf8");
+  fs2.writeFileSync(libMain, `var ESBUILD_BINARY_PATH = ${pathString};
+${code}`);
+}
+function maybeOptimizePackage(binPath) {
+  const { isWASM } = pkgAndSubpathForCurrentPlatform();
+  if (os2.platform() !== "win32" && !isYarn() && !isWASM) {
+    const tempPath = path2.join(__dirname, "bin-esbuild");
+    try {
+      fs2.linkSync(binPath, tempPath);
+      fs2.renameSync(tempPath, toPath);
+      isToPathJS = false;
+      fs2.unlinkSync(tempPath);
+    } catch {
+    }
+  }
+}
+async function downloadDirectlyFromNPM(pkg, subpath, binPath) {
+  const url = `https://registry.npmjs.org/${pkg}/-/${pkg.replace("@esbuild/", "")}-${versionFromPackageJSON}.tgz`;
+  console.error(`[esbuild] Trying to download ${JSON.stringify(url)}`);
+  try {
+    fs2.writeFileSync(binPath, extractFileFromTarGzip(await fetch(url), subpath));
+    fs2.chmodSync(binPath, 493);
+  } catch (e) {
+    console.error(`[esbuild] Failed to download ${JSON.stringify(url)}: ${e && e.message || e}`);
+    throw e;
+  }
+}
+async function checkAndPreparePackage() {
+  if (isValidBinaryPath(ESBUILD_BINARY_PATH)) {
+    if (!fs2.existsSync(ESBUILD_BINARY_PATH)) {
+      console.warn(`[esbuild] Ignoring bad configuration: ESBUILD_BINARY_PATH=${ESBUILD_BINARY_PATH}`);
+    } else {
+      applyManualBinaryPathOverride(ESBUILD_BINARY_PATH);
+      return;
+    }
+  }
+  const { pkg, subpath } = pkgAndSubpathForCurrentPlatform();
+  let binPath;
+  try {
+    binPath = require.resolve(`${pkg}/${subpath}`);
+  } catch (e) {
+    console.error(`[esbuild] Failed to find package "${pkg}" on the file system
+
+This can happen if you use the "--no-optional" flag. The "optionalDependencies"
+package.json feature is used by esbuild to install the correct binary executable
+for your current platform. This install script will now attempt to work around
+this. If that fails, you need to remove the "--no-optional" flag to use esbuild.
+`);
+    binPath = downloadedBinPath(pkg, subpath);
+    try {
+      console.error(`[esbuild] Trying to install package "${pkg}" using npm`);
+      installUsingNPM(pkg, subpath, binPath);
+    } catch (e2) {
+      console.error(`[esbuild] Failed to install package "${pkg}" using npm: ${e2 && e2.message || e2}`);
+      try {
+        await downloadDirectlyFromNPM(pkg, subpath, binPath);
+      } catch (e3) {
+        throw new Error(`Failed to install package "${pkg}"`);
+      }
+    }
+  }
+  maybeOptimizePackage(binPath);
+}
+checkAndPreparePackage().then(() => {
+  if (isToPathJS) {
+    validateBinaryVersion(process.execPath, toPath);
+  } else {
+    validateBinaryVersion(toPath);
+  }
+});

novas/novacore-zephyr/claude-code-router/node_modules/esbuild/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "esbuild",
+  "version": "0.25.9",
+  "description": "An extremely fast JavaScript and CSS bundler and minifier.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/evanw/esbuild.git"
+  },
+  "scripts": {
+    "postinstall": "node install.js"
+  },
+  "main": "lib/main.js",
+  "types": "lib/main.d.ts",
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "esbuild": "bin/esbuild"
+  },
+  "optionalDependencies": {
+    "@esbuild/aix-ppc64": "0.25.9",
+    "@esbuild/android-arm": "0.25.9",
+    "@esbuild/android-arm64": "0.25.9",
+    "@esbuild/android-x64": "0.25.9",
+    "@esbuild/darwin-arm64": "0.25.9",
+    "@esbuild/darwin-x64": "0.25.9",
+    "@esbuild/freebsd-arm64": "0.25.9",
+    "@esbuild/freebsd-x64": "0.25.9",
+    "@esbuild/linux-arm": "0.25.9",
+    "@esbuild/linux-arm64": "0.25.9",
+    "@esbuild/linux-ia32": "0.25.9",
+    "@esbuild/linux-loong64": "0.25.9",
+    "@esbuild/linux-mips64el": "0.25.9",
+    "@esbuild/linux-ppc64": "0.25.9",
+    "@esbuild/linux-riscv64": "0.25.9",
+    "@esbuild/linux-s390x": "0.25.9",
+    "@esbuild/linux-x64": "0.25.9",
+    "@esbuild/netbsd-arm64": "0.25.9",
+    "@esbuild/netbsd-x64": "0.25.9",
+    "@esbuild/openbsd-arm64": "0.25.9",
+    "@esbuild/openbsd-x64": "0.25.9",
+    "@esbuild/openharmony-arm64": "0.25.9",
+    "@esbuild/sunos-x64": "0.25.9",
+    "@esbuild/win32-arm64": "0.25.9",
+    "@esbuild/win32-ia32": "0.25.9",
+    "@esbuild/win32-x64": "0.25.9"
+  },
+  "license": "MIT"
+}

novas/novacore-zephyr/claude-code-router/node_modules/execa/index.js

@@ -0,0 +1,361 @@
+'use strict';
+const path = require('path');
+const childProcess = require('child_process');
+const crossSpawn = require('cross-spawn');
+const stripEof = require('strip-eof');
+const npmRunPath = require('npm-run-path');
+const isStream = require('is-stream');
+const _getStream = require('get-stream');
+const pFinally = require('p-finally');
+const onExit = require('signal-exit');
+const errname = require('./lib/errname');
+const stdio = require('./lib/stdio');
+
+const TEN_MEGABYTES = 1000 * 1000 * 10;
+
+function handleArgs(cmd, args, opts) {
+	let parsed;
+
+	opts = Object.assign({
+		extendEnv: true,
+		env: {}
+	}, opts);
+
+	if (opts.extendEnv) {
+		opts.env = Object.assign({}, process.env, opts.env);
+	}
+
+	if (opts.__winShell === true) {
+		delete opts.__winShell;
+		parsed = {
+			command: cmd,
+			args,
+			options: opts,
+			file: cmd,
+			original: {
+				cmd,
+				args
+			}
+		};
+	} else {
+		parsed = crossSpawn._parse(cmd, args, opts);
+	}
+
+	opts = Object.assign({
+		maxBuffer: TEN_MEGABYTES,
+		buffer: true,
+		stripEof: true,
+		preferLocal: true,
+		localDir: parsed.options.cwd || process.cwd(),
+		encoding: 'utf8',
+		reject: true,
+		cleanup: true
+	}, parsed.options);
+
+	opts.stdio = stdio(opts);
+
+	if (opts.preferLocal) {
+		opts.env = npmRunPath.env(Object.assign({}, opts, {cwd: opts.localDir}));
+	}
+
+	if (opts.detached) {
+		// #115
+		opts.cleanup = false;
+	}
+
+	if (process.platform === 'win32' && path.basename(parsed.command) === 'cmd.exe') {
+		// #116
+		parsed.args.unshift('/q');
+	}
+
+	return {
+		cmd: parsed.command,
+		args: parsed.args,
+		opts,
+		parsed
+	};
+}
+
+function handleInput(spawned, input) {
+	if (input === null || input === undefined) {
+		return;
+	}
+
+	if (isStream(input)) {
+		input.pipe(spawned.stdin);
+	} else {
+		spawned.stdin.end(input);
+	}
+}
+
+function handleOutput(opts, val) {
+	if (val && opts.stripEof) {
+		val = stripEof(val);
+	}
+
+	return val;
+}
+
+function handleShell(fn, cmd, opts) {
+	let file = '/bin/sh';
+	let args = ['-c', cmd];
+
+	opts = Object.assign({}, opts);
+
+	if (process.platform === 'win32') {
+		opts.__winShell = true;
+		file = process.env.comspec || 'cmd.exe';
+		args = ['/s', '/c', `"${cmd}"`];
+		opts.windowsVerbatimArguments = true;
+	}
+
+	if (opts.shell) {
+		file = opts.shell;
+		delete opts.shell;
+	}
+
+	return fn(file, args, opts);
+}
+
+function getStream(process, stream, {encoding, buffer, maxBuffer}) {
+	if (!process[stream]) {
+		return null;
+	}
+
+	let ret;
+
+	if (!buffer) {
+		// TODO: Use `ret = util.promisify(stream.finished)(process[stream]);` when targeting Node.js 10
+		ret = new Promise((resolve, reject) => {
+			process[stream]
+				.once('end', resolve)
+				.once('error', reject);
+		});
+	} else if (encoding) {
+		ret = _getStream(process[stream], {
+			encoding,
+			maxBuffer
+		});
+	} else {
+		ret = _getStream.buffer(process[stream], {maxBuffer});
+	}
+
+	return ret.catch(err => {
+		err.stream = stream;
+		err.message = `${stream} ${err.message}`;
+		throw err;
+	});
+}
+
+function makeError(result, options) {
+	const {stdout, stderr} = result;
+
+	let err = result.error;
+	const {code, signal} = result;
+
+	const {parsed, joinedCmd} = options;
+	const timedOut = options.timedOut || false;
+
+	if (!err) {
+		let output = '';
+
+		if (Array.isArray(parsed.opts.stdio)) {
+			if (parsed.opts.stdio[2] !== 'inherit') {
+				output += output.length > 0 ? stderr : `\n${stderr}`;
+			}
+
+			if (parsed.opts.stdio[1] !== 'inherit') {
+				output += `\n${stdout}`;
+			}
+		} else if (parsed.opts.stdio !== 'inherit') {
+			output = `\n${stderr}${stdout}`;
+		}
+
+		err = new Error(`Command failed: ${joinedCmd}${output}`);
+		err.code = code < 0 ? errname(code) : code;
+	}
+
+	err.stdout = stdout;
+	err.stderr = stderr;
+	err.failed = true;
+	err.signal = signal || null;
+	err.cmd = joinedCmd;
+	err.timedOut = timedOut;
+
+	return err;
+}
+
+function joinCmd(cmd, args) {
+	let joinedCmd = cmd;
+
+	if (Array.isArray(args) && args.length > 0) {
+		joinedCmd += ' ' + args.join(' ');
+	}
+
+	return joinedCmd;
+}
+
+module.exports = (cmd, args, opts) => {
+	const parsed = handleArgs(cmd, args, opts);
+	const {encoding, buffer, maxBuffer} = parsed.opts;
+	const joinedCmd = joinCmd(cmd, args);
+
+	let spawned;
+	try {
+		spawned = childProcess.spawn(parsed.cmd, parsed.args, parsed.opts);
+	} catch (err) {
+		return Promise.reject(err);
+	}
+
+	let removeExitHandler;
+	if (parsed.opts.cleanup) {
+		removeExitHandler = onExit(() => {
+			spawned.kill();
+		});
+	}
+
+	let timeoutId = null;
+	let timedOut = false;
+
+	const cleanup = () => {
+		if (timeoutId) {
+			clearTimeout(timeoutId);
+			timeoutId = null;
+		}
+
+		if (removeExitHandler) {
+			removeExitHandler();
+		}
+	};
+
+	if (parsed.opts.timeout > 0) {
+		timeoutId = setTimeout(() => {
+			timeoutId = null;
+			timedOut = true;
+			spawned.kill(parsed.opts.killSignal);
+		}, parsed.opts.timeout);
+	}
+
+	const processDone = new Promise(resolve => {
+		spawned.on('exit', (code, signal) => {
+			cleanup();
+			resolve({code, signal});
+		});
+
+		spawned.on('error', err => {
+			cleanup();
+			resolve({error: err});
+		});
+
+		if (spawned.stdin) {
+			spawned.stdin.on('error', err => {
+				cleanup();
+				resolve({error: err});
+			});
+		}
+	});
+
+	function destroy() {
+		if (spawned.stdout) {
+			spawned.stdout.destroy();
+		}
+
+		if (spawned.stderr) {
+			spawned.stderr.destroy();
+		}
+	}
+
+	const handlePromise = () => pFinally(Promise.all([
+		processDone,
+		getStream(spawned, 'stdout', {encoding, buffer, maxBuffer}),
+		getStream(spawned, 'stderr', {encoding, buffer, maxBuffer})
+	]).then(arr => {
+		const result = arr[0];
+		result.stdout = arr[1];
+		result.stderr = arr[2];
+
+		if (result.error || result.code !== 0 || result.signal !== null) {
+			const err = makeError(result, {
+				joinedCmd,
+				parsed,
+				timedOut
+			});
+
+			// TODO: missing some timeout logic for killed
+			// https://github.com/nodejs/node/blob/master/lib/child_process.js#L203
+			// err.killed = spawned.killed || killed;
+			err.killed = err.killed || spawned.killed;
+
+			if (!parsed.opts.reject) {
+				return err;
+			}
+
+			throw err;
+		}
+
+		return {
+			stdout: handleOutput(parsed.opts, result.stdout),
+			stderr: handleOutput(parsed.opts, result.stderr),
+			code: 0,
+			failed: false,
+			killed: false,
+			signal: null,
+			cmd: joinedCmd,
+			timedOut: false
+		};
+	}), destroy);
+
+	crossSpawn._enoent.hookChildProcess(spawned, parsed.parsed);
+
+	handleInput(spawned, parsed.opts.input);
+
+	spawned.then = (onfulfilled, onrejected) => handlePromise().then(onfulfilled, onrejected);
+	spawned.catch = onrejected => handlePromise().catch(onrejected);
+
+	return spawned;
+};
+
+// TODO: set `stderr: 'ignore'` when that option is implemented
+module.exports.stdout = (...args) => module.exports(...args).then(x => x.stdout);
+
+// TODO: set `stdout: 'ignore'` when that option is implemented
+module.exports.stderr = (...args) => module.exports(...args).then(x => x.stderr);
+
+module.exports.shell = (cmd, opts) => handleShell(module.exports, cmd, opts);
+
+module.exports.sync = (cmd, args, opts) => {
+	const parsed = handleArgs(cmd, args, opts);
+	const joinedCmd = joinCmd(cmd, args);
+
+	if (isStream(parsed.opts.input)) {
+		throw new TypeError('The `input` option cannot be a stream in sync mode');
+	}
+
+	const result = childProcess.spawnSync(parsed.cmd, parsed.args, parsed.opts);
+	result.code = result.status;
+
+	if (result.error || result.status !== 0 || result.signal !== null) {
+		const err = makeError(result, {
+			joinedCmd,
+			parsed
+		});
+
+		if (!parsed.opts.reject) {
+			return err;
+		}
+
+		throw err;
+	}
+
+	return {
+		stdout: handleOutput(parsed.opts, result.stdout),
+		stderr: handleOutput(parsed.opts, result.stderr),
+		code: 0,
+		failed: false,
+		signal: null,
+		cmd: joinedCmd,
+		timedOut: false
+	};
+};
+
+module.exports.shellSync = (cmd, opts) => handleShell(module.exports.sync, cmd, opts);

novas/novacore-zephyr/claude-code-router/node_modules/execa/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

novas/novacore-zephyr/claude-code-router/node_modules/execa/package.json

@@ -0,0 +1,69 @@
+{
+	"name": "execa",
+	"version": "1.0.0",
+	"description": "A better `child_process`",
+	"license": "MIT",
+	"repository": "sindresorhus/execa",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "sindresorhus.com"
+	},
+	"engines": {
+		"node": ">=6"
+	},
+	"scripts": {
+		"test": "xo && nyc ava"
+	},
+	"files": [
+		"index.js",
+		"lib"
+	],
+	"keywords": [
+		"exec",
+		"child",
+		"process",
+		"execute",
+		"fork",
+		"execfile",
+		"spawn",
+		"file",
+		"shell",
+		"bin",
+		"binary",
+		"binaries",
+		"npm",
+		"path",
+		"local"
+	],
+	"dependencies": {
+		"cross-spawn": "^6.0.0",
+		"get-stream": "^4.0.0",
+		"is-stream": "^1.1.0",
+		"npm-run-path": "^2.0.0",
+		"p-finally": "^1.0.0",
+		"signal-exit": "^3.0.0",
+		"strip-eof": "^1.0.0"
+	},
+	"devDependencies": {
+		"ava": "*",
+		"cat-names": "^1.0.2",
+		"coveralls": "^3.0.1",
+		"delay": "^3.0.0",
+		"is-running": "^2.0.0",
+		"nyc": "^13.0.1",
+		"tempfile": "^2.0.0",
+		"xo": "*"
+	},
+	"nyc": {
+		"reporter": [
+			"text",
+			"lcov"
+		],
+		"exclude": [
+			"**/fixtures/**",
+			"**/test.js",
+			"**/test/**"
+		]
+	}
+}

novas/novacore-zephyr/claude-code-router/node_modules/execa/readme.md

@@ -0,0 +1,327 @@
+# execa [![Build Status: Linux](https://travis-ci.org/sindresorhus/execa.svg?branch=master)](https://travis-ci.org/sindresorhus/execa) [![Build status: Windows](https://ci.appveyor.com/api/projects/status/x5ajamxtjtt93cqv/branch/master?svg=true)](https://ci.appveyor.com/project/sindresorhus/execa/branch/master) [![Coverage Status](https://coveralls.io/repos/github/sindresorhus/execa/badge.svg?branch=master)](https://coveralls.io/github/sindresorhus/execa?branch=master)
+
+> A better [`child_process`](https://nodejs.org/api/child_process.html)
+
+
+## Why
+
+- Promise interface.
+- [Strips EOF](https://github.com/sindresorhus/strip-eof) from the output so you don't have to `stdout.trim()`.
+- Supports [shebang](https://en.wikipedia.org/wiki/Shebang_(Unix)) binaries cross-platform.
+- [Improved Windows support.](https://github.com/IndigoUnited/node-cross-spawn#why)
+- Higher max buffer. 10 MB instead of 200 KB.
+- [Executes locally installed binaries by name.](#preferlocal)
+- [Cleans up spawned processes when the parent process dies.](#cleanup)
+
+
+## Install
+
+```
+$ npm install execa
+```
+
+<a href="https://www.patreon.com/sindresorhus">
+	<img src="https://c5.patreon.com/external/logo/become_a_patron_button@2x.png" width="160">
+</a>
+
+
+## Usage
+
+```js
+const execa = require('execa');
+
+(async () => {
+	const {stdout} = await execa('echo', ['unicorns']);
+	console.log(stdout);
+	//=> 'unicorns'
+})();
+```
+
+Additional examples:
+
+```js
+const execa = require('execa');
+
+(async () => {
+	// Pipe the child process stdout to the current stdout
+	execa('echo', ['unicorns']).stdout.pipe(process.stdout);
+
+
+	// Run a shell command
+	const {stdout} = await execa.shell('echo unicorns');
+	//=> 'unicorns'
+
+
+	// Catching an error
+	try {
+		await execa.shell('exit 3');
+	} catch (error) {
+		console.log(error);
+		/*
+		{
+			message: 'Command failed: /bin/sh -c exit 3'
+			killed: false,
+			code: 3,
+			signal: null,
+			cmd: '/bin/sh -c exit 3',
+			stdout: '',
+			stderr: '',
+			timedOut: false
+		}
+		*/
+	}
+})();
+
+// Catching an error with a sync method
+try {
+	execa.shellSync('exit 3');
+} catch (error) {
+	console.log(error);
+	/*
+	{
+		message: 'Command failed: /bin/sh -c exit 3'
+		code: 3,
+		signal: null,
+		cmd: '/bin/sh -c exit 3',
+		stdout: '',
+		stderr: '',
+		timedOut: false
+	}
+	*/
+}
+```
+
+
+## API
+
+### execa(file, [arguments], [options])
+
+Execute a file.
+
+Think of this as a mix of `child_process.execFile` and `child_process.spawn`.
+
+Returns a [`child_process` instance](https://nodejs.org/api/child_process.html#child_process_class_childprocess), which is enhanced to also be a `Promise` for a result `Object` with `stdout` and `stderr` properties.
+
+### execa.stdout(file, [arguments], [options])
+
+Same as `execa()`, but returns only `stdout`.
+
+### execa.stderr(file, [arguments], [options])
+
+Same as `execa()`, but returns only `stderr`.
+
+### execa.shell(command, [options])
+
+Execute a command through the system shell. Prefer `execa()` whenever possible, as it's both faster and safer.
+
+Returns a [`child_process` instance](https://nodejs.org/api/child_process.html#child_process_class_childprocess).
+
+The `child_process` instance is enhanced to also be promise for a result object with `stdout` and `stderr` properties.
+
+### execa.sync(file, [arguments], [options])
+
+Execute a file synchronously.
+
+Returns the same result object as [`child_process.spawnSync`](https://nodejs.org/api/child_process.html#child_process_child_process_spawnsync_command_args_options).
+
+This method throws an `Error` if the command fails.
+
+### execa.shellSync(file, [options])
+
+Execute a command synchronously through the system shell.
+
+Returns the same result object as [`child_process.spawnSync`](https://nodejs.org/api/child_process.html#child_process_child_process_spawnsync_command_args_options).
+
+### options
+
+Type: `Object`
+
+#### cwd
+
+Type: `string`<br>
+Default: `process.cwd()`
+
+Current working directory of the child process.
+
+#### env
+
+Type: `Object`<br>
+Default: `process.env`
+
+Environment key-value pairs. Extends automatically from `process.env`. Set `extendEnv` to `false` if you don't want this.
+
+#### extendEnv
+
+Type: `boolean`<br>
+Default: `true`
+
+Set to `false` if you don't want to extend the environment variables when providing the `env` property.
+
+#### argv0
+
+Type: `string`
+
+Explicitly set the value of `argv[0]` sent to the child process. This will be set to `command` or `file` if not specified.
+
+#### stdio
+
+Type: `string[]` `string`<br>
+Default: `pipe`
+
+Child's [stdio](https://nodejs.org/api/child_process.html#child_process_options_stdio) configuration.
+
+#### detached
+
+Type: `boolean`
+
+Prepare child to run independently of its parent process. Specific behavior [depends on the platform](https://nodejs.org/api/child_process.html#child_process_options_detached).
+
+#### uid
+
+Type: `number`
+
+Sets the user identity of the process.
+
+#### gid
+
+Type: `number`
+
+Sets the group identity of the process.
+
+#### shell
+
+Type: `boolean` `string`<br>
+Default: `false`
+
+If `true`, runs `command` inside of a shell. Uses `/bin/sh` on UNIX and `cmd.exe` on Windows. A different shell can be specified as a string. The shell should understand the `-c` switch on UNIX or `/d /s /c` on Windows.
+
+#### stripEof
+
+Type: `boolean`<br>
+Default: `true`
+
+[Strip EOF](https://github.com/sindresorhus/strip-eof) (last newline) from the output.
+
+#### preferLocal
+
+Type: `boolean`<br>
+Default: `true`
+
+Prefer locally installed binaries when looking for a binary to execute.<br>
+If you `$ npm install foo`, you can then `execa('foo')`.
+
+#### localDir
+
+Type: `string`<br>
+Default: `process.cwd()`
+
+Preferred path to find locally installed binaries in (use with `preferLocal`).
+
+#### input
+
+Type: `string` `Buffer` `stream.Readable`
+
+Write some input to the `stdin` of your binary.<br>
+Streams are not allowed when using the synchronous methods.
+
+#### reject
+
+Type: `boolean`<br>
+Default: `true`
+
+Setting this to `false` resolves the promise with the error instead of rejecting it.
+
+#### cleanup
+
+Type: `boolean`<br>
+Default: `true`
+
+Keep track of the spawned process and `kill` it when the parent process exits.
+
+#### encoding
+
+Type: `string`<br>
+Default: `utf8`
+
+Specify the character encoding used to decode the `stdout` and `stderr` output.
+
+#### timeout
+
+Type: `number`<br>
+Default: `0`
+
+If timeout is greater than `0`, the parent will send the signal identified by the `killSignal` property (the default is `SIGTERM`) if the child runs longer than timeout milliseconds.
+
+#### buffer
+
+Type: `boolean`<br>
+Default: `true`
+
+Buffer the output from the spawned process. When buffering is disabled you must consume the output of the `stdout` and `stderr` streams because the promise will not be resolved/rejected until they have completed.
+
+#### maxBuffer
+
+Type: `number`<br>
+Default: `10000000` (10MB)
+
+Largest amount of data in bytes allowed on `stdout` or `stderr`.
+
+#### killSignal
+
+Type: `string` `number`<br>
+Default: `SIGTERM`
+
+Signal value to be used when the spawned process will be killed.
+
+#### stdin
+
+Type: `string` `number` `Stream` `undefined` `null`<br>
+Default: `pipe`
+
+Same options as [`stdio`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio).
+
+#### stdout
+
+Type: `string` `number` `Stream` `undefined` `null`<br>
+Default: `pipe`
+
+Same options as [`stdio`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio).
+
+#### stderr
+
+Type: `string` `number` `Stream` `undefined` `null`<br>
+Default: `pipe`
+
+Same options as [`stdio`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio).
+
+#### windowsVerbatimArguments
+
+Type: `boolean`<br>
+Default: `false`
+
+If `true`, no quoting or escaping of arguments is done on Windows. Ignored on other platforms. This is set to `true` automatically when the `shell` option is `true`.
+
+
+## Tips
+
+### Save and pipe output from a child process
+
+Let's say you want to show the output of a child process in real-time while also saving it to a variable.
+
+```js
+const execa = require('execa');
+const getStream = require('get-stream');
+
+const stream = execa('echo', ['foo']).stdout;
+
+stream.pipe(process.stdout);
+
+getStream(stream).then(value => {
+	console.log('child output:', value);
+});
+```
+
+
+## License
+
+MIT © [Sindre Sorhus](https://sindresorhus.com)

novas/novacore-zephyr/claude-code-router/node_modules/fastify/.borp.yaml

@@ -0,0 +1,3 @@
+files:
+  - 'test/**/*.test.js'
+  - 'test/**/*.test.mjs'

novas/novacore-zephyr/claude-code-router/node_modules/fastify/.markdownlint-cli2.yaml

@@ -0,0 +1,22 @@
+# See https://github.com/DavidAnson/markdownlint-cli2
+config:
+  # Disable all rules by default.
+  default: false
+
+  # Enforce line length.
+  MD013:
+    line_length: 80
+    code_block_line_length: 120
+    headings: false
+    tables: false
+    strict: false
+    stern: false
+
+globs:
+  - '**/*.md'
+
+ignores:
+  - 'node_modules/**'
+  - 'test/**/*.md'
+
+noProgress: true

novas/novacore-zephyr/claude-code-router/node_modules/fastify/.prettierignore

@@ -0,0 +1 @@
+*

novas/novacore-zephyr/claude-code-router/node_modules/fastify/GOVERNANCE.md

@@ -0,0 +1,4 @@
+# Fastify Project Governance
+
+Please see Fastify's [organization-wide governance
+](https://github.com/fastify/.github/blob/main/GOVERNANCE.md) document.

novas/novacore-zephyr/claude-code-router/node_modules/fastify/LICENSE

@@ -0,0 +1,24 @@
+MIT License
+
+Copyright (c) 2016-present The Fastify Team
+
+The Fastify team members are listed at https://github.com/fastify/fastify#team
+and in the README file.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

novas/novacore-zephyr/claude-code-router/node_modules/fastify/PROJECT_CHARTER.md

@@ -0,0 +1,126 @@
+# Fastify Charter
+
+The Fastify project aims to build a fast and low-overhead web framework for
+Node.js.
+
+
+## Section 0: Guiding Principles
+
+The Fastify project is part of the [OpenJS Foundation][openjs foundation]. It
+operates transparently, openly, collaboratively, and ethically. Project
+proposals, timelines, and status must not merely be open, but also easily
+visible to outsiders.
+
+
+## Section 1: Scope
+
+Fastify is a web framework highly focused on providing the best developer
+experience with the least overhead and a plugin architecture.
+
+### 1.1: In-scope
+
++ Develop a web framework for Node.js with a focus on developer experience,
+  performance, and extensibility.
++ Plugin Architecture
++ Support web protocols
++ Official plugins for common user requirements
++ Documentation:
+  + Project (policies, processes, and releases)
+  + Guides and Tutorials
+  + Framework API
+  + Website
++ Write easier APIs for developers
++ Tools:
+  + CI services
+  + Bots to improve overall efficiency
+  + Releases
++ Support:
+  + Community
+  + Users's issues and questions
++ Contributors's pull request review
+
+### 1.2: Out-of-Scope
+
++ Support versions of Node.js at EOL (end of life) stage
++ Support serverless architecture
++ Contributions that violate the [Code of Conduct](CODE_OF_CONDUCT.md)
+
+
+## Section 2: Relationship with OpenJS Foundation CPC.
+
+Technical leadership for the projects within the [OpenJS Foundation][openjs
+foundation] is delegated to the projects through their project charters by the
+[OpenJS Foundation Cross-Project Council](https://openjsf.org/about/governance/)
+(CPC). In the case of the Fastify project, it is delegated to the [Fastify
+Collaborators](README.md#team). The OpenJS Foundation's business leadership is
+the Board of Directors (the "Board").
+
+This Fastify Charter reflects a carefully constructed balanced role for the
+Collaborators and the CPC in the governance of the OpenJS Foundation. The
+charter amendment process is for the Fastify Collaborators to propose change
+using a majority of the full Fastify Organization, the proposed changes
+being subject to review and approval by the CPC. The CPC may additionally make
+amendments to the Collaborators charter at any time, though the CPC will not
+interfere with day-to-day discussions, votes, or meetings of the Fastify
+Organization.
+
+
+### 2.1 Other Formal Project Relationships
+
+Section Intentionally Left Blank
+
+
+## Section 3: Fastify Governing Body
+
+Fastify is governed by its [maintainers](README.md#team). See [how it is
+structured](GOVERNANCE.md) for more information.
+
+
+## Section 4: Roles & Responsibilities
+
+The roles and responsibilities of Fastify's maintainers are described in [the
+project organization](GOVERNANCE.md).
+
+### Section 4.1 Project Operations & Management
+
+Section Intentionally Left Blank
+
+### Section 4.2: Decision-making, Voting, and/or Elections
+
+**Decision-making**
+
+Fastify's features can be discussed in GitHub issues and/or projects. Consensus
+on a discussion is reached when there is no objection by any collaborators.
+
+When there is no consensus, Lead Maintainers will have the final say on the
+topic.
+
+**Voting, and/or Elections**
+
+These processes are described in the [GOVERNANCE](GOVERNANCE.md) document.
+
+### Section 4.3: Other Project Roles
+
+Section Intentionally Left Blank
+
+## Section 5: Definitions
+
++ *Contributors*: contribute code or other artifacts, but do not have the right
+  to commit to the code base. Contributors work with the project’s Collaborators
+  to have code committed to the code base. Contributors should rarely be
+  encumbered by the Fastify Collaborators and never by the CPC or OpenJS
+  Foundation Board.
+
++ *Collaborators*: contribute code and other artifacts, have the right to commit
+  to the code base, and release plugin projects. Collaborators follow the
+  [CONTRIBUTING](CONTRIBUTING.md) guidelines to manage the project. A
+  Collaborator could be encumbered by other Fastify Collaborators and never by
+  the CPC or OpenJS Foundation Board.
+
++ *Lead Maintainers*: founders of the project, contribute code and other
+  artifacts, have the right to commit to the code base and release the project.
+  Lead Maintainers follow the [CONTRIBUTING](CONTRIBUTING.md) guidelines to
+  manage the project. A Lead Maintainer will be encumbered by the Fastify
+  Collaborators and by the CPC or OpenJS Foundation Board.
+
+[openjs foundation]: https://openjsf.org

novas/novacore-zephyr/claude-code-router/node_modules/fastify/README.md

@@ -0,0 +1,421 @@
+<div align="center"> <a href="https://fastify.dev/">
+    <img
+      src="https://github.com/fastify/graphics/raw/HEAD/fastify-landscape-outlined.svg"
+      width="650"
+      height="auto"
+    />
+  </a>
+</div>
+
+<div align="center">
+
+[![CI](https://github.com/fastify/fastify/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/fastify/fastify/actions/workflows/ci.yml)
+[![Package Manager
+CI](https://github.com/fastify/fastify/actions/workflows/package-manager-ci.yml/badge.svg?branch=main)](https://github.com/fastify/fastify/actions/workflows/package-manager-ci.yml)
+[![Web
+site](https://github.com/fastify/fastify/actions/workflows/website.yml/badge.svg?branch=main)](https://github.com/fastify/fastify/actions/workflows/website.yml)
+[![neostandard javascript style](https://img.shields.io/badge/code_style-neostandard-brightgreen?style=flat)](https://github.com/neostandard/neostandard)
+[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/7585/badge)](https://bestpractices.coreinfrastructure.org/projects/7585)
+
+</div>
+
+<div align="center">
+
+[![NPM
+version](https://img.shields.io/npm/v/fastify.svg?style=flat)](https://www.npmjs.com/package/fastify)
+[![NPM
+downloads](https://img.shields.io/npm/dm/fastify.svg?style=flat)](https://www.npmjs.com/package/fastify)
+[![Security Responsible
+Disclosure](https://img.shields.io/badge/Security-Responsible%20Disclosure-yellow.svg)](https://github.com/fastify/fastify/blob/main/SECURITY.md)
+[![Discord](https://img.shields.io/discord/725613461949906985)](https://discord.gg/fastify)
+[![Contribute with Gitpod](https://img.shields.io/badge/Contribute%20with-Gitpod-908a85?logo=gitpod&color=blue)](https://gitpod.io/#https://github.com/fastify/fastify)
+[![Open Collective backers and sponsors](https://img.shields.io/opencollective/all/fastify)](https://github.com/sponsors/fastify#sponsors)
+
+</div>
+
+<br />
+
+An efficient server implies a lower cost of the infrastructure, better
+responsiveness under load, and happy users. How can you efficiently handle the
+resources of your server, knowing that you are serving the highest number of
+requests possible, without sacrificing security validations and handy
+development?
+
+Enter Fastify. Fastify is a web framework highly focused on providing the best
+developer experience with the least overhead and a powerful plugin architecture.
+It is inspired by Hapi and Express and as far as we know, it is one of the
+fastest web frameworks in town.
+
+The `main` branch refers to the Fastify `v5` release.
+Check out the [`4.x` branch](https://github.com/fastify/fastify/tree/4.x) for `v4`.
+
+### Table of Contents
+
+ - [Quick start](#quick-start)
+ - [Install](#install)
+ - [Example](#example)
+ - [Core features](#core-features)
+ - [Benchmarks](#benchmarks)
+ - [Documentation](#documentation)
+ - [Ecosystem](#ecosystem)
+ - [Support](#support)
+ - [Team](#team)
+ - [Hosted by](#hosted-by)
+ - [License](#license)
+
+
+### Quick start
+
+Create a folder and make it your current working directory:
+
+```sh
+mkdir my-app
+cd my-app
+```
+
+Generate a fastify project with `npm init`:
+
+```sh
+npm init fastify
+```
+
+Install dependencies:
+
+```sh
+npm i
+```
+
+To start the app in dev mode:
+
+```sh
+npm run dev
+```
+
+For production mode:
+
+```sh
+npm start
+```
+
+Under the hood `npm init` downloads and runs [Fastify
+Create](https://github.com/fastify/create-fastify), which in turn uses the
+generate functionality of [Fastify CLI](https://github.com/fastify/fastify-cli).
+
+
+### Install
+
+To install Fastify in an existing project as a dependency:
+
+```sh
+npm i fastify
+```
+
+### Example
+
+```js
+// Require the framework and instantiate it
+
+// ESM
+import Fastify from 'fastify'
+
+const fastify = Fastify({
+  logger: true
+})
+// CommonJs
+const fastify = require('fastify')({
+  logger: true
+})
+
+// Declare a route
+fastify.get('/', (request, reply) => {
+  reply.send({ hello: 'world' })
+})
+
+// Run the server!
+fastify.listen({ port: 3000 }, (err, address) => {
+  if (err) throw err
+  // Server is now listening on ${address}
+})
+```
+
+With async-await:
+
+```js
+// ESM
+import Fastify from 'fastify'
+
+const fastify = Fastify({
+  logger: true
+})
+// CommonJs
+const fastify = require('fastify')({
+  logger: true
+})
+
+fastify.get('/', async (request, reply) => {
+  reply.type('application/json').code(200)
+  return { hello: 'world' }
+})
+
+fastify.listen({ port: 3000 }, (err, address) => {
+  if (err) throw err
+  // Server is now listening on ${address}
+})
+```
+
+Do you want to know more? Head to the <a
+href="./docs/Guides/Getting-Started.md"><code><b>Getting Started</b></code></a>.
+If you learn best by reading code, explore the official [demo](https://github.com/fastify/demo).
+
+> ## Note
+> `.listen` binds to the local host, `localhost`, interface by default
+> (`127.0.0.1` or `::1`, depending on the operating system configuration). If
+> you are running Fastify in a container (Docker,
+> [GCP](https://cloud.google.com/), etc.), you may need to bind to `0.0.0.0`. Be
+> careful when listening on all interfaces; it comes with inherent
+> [security
+> risks](https://web.archive.org/web/20170711105010/https://snyk.io/blog/mongodb-hack-and-secure-defaults/).
+> See [the documentation](./docs/Reference/Server.md#listen) for more
+> information.
+
+### Core features
+
+- **Highly performant:** as far as we know, Fastify is one of the fastest web
+  frameworks in town, depending on the code complexity we can serve up to 76+
+  thousand requests per second.
+- **Extensible:** Fastify is fully extensible via its hooks, plugins, and
+  decorators.
+- **Schema-based:** even if it is not mandatory we recommend using [JSON
+  Schema](https://json-schema.org/) to validate your routes and serialize your
+  outputs. Internally Fastify compiles the schema in a highly performant
+  function.
+- **Logging:** logs are extremely important but are costly; we chose the best
+  logger to almost remove this cost, [Pino](https://github.com/pinojs/pino)!
+- **Developer friendly:** the framework is built to be very expressive and help
+  developers in their daily use without sacrificing performance and
+  security.
+
+### Benchmarks
+
+__Machine:__ EX41S-SSD, Intel Core i7, 4Ghz, 64GB RAM, 4C/8T, SSD.
+
+__Method:__: `autocannon -c 100 -d 40 -p 10 localhost:3000` * 2, taking the
+second average
+
+| Framework          | Version                    | Router?      |  Requests/sec |
+| :----------------- | :------------------------- | :----------: | ------------: |
+| Express            | 4.17.3                     | &#10003;     | 14,200        |
+| hapi               | 20.2.1                     | &#10003;     | 42,284        |
+| Restify            | 8.6.1                      | &#10003;     | 50,363        |
+| Koa                | 2.13.0                     | &#10007;     | 54,272        |
+| **Fastify**        | **4.0.0**                  | **&#10003;** | **77,193**    |
+| -                  |                            |              |               |
+| `http.Server`      | 16.14.2	                  | &#10007;     | 74,513        |
+
+These benchmarks taken using https://github.com/fastify/benchmarks. This is a
+synthetic "hello world" benchmark that aims to evaluate the framework overhead.
+The overhead that each framework has on your application depends on your
+application. You should __always__ benchmark if performance matters to you.
+
+## Documentation
+* [__`Getting Started`__](./docs/Guides/Getting-Started.md)
+* [__`Guides`__](./docs/Guides/Index.md)
+* [__`Server`__](./docs/Reference/Server.md)
+* [__`Routes`__](./docs/Reference/Routes.md)
+* [__`Encapsulation`__](./docs/Reference/Encapsulation.md)
+* [__`Logging`__](./docs/Reference/Logging.md)
+* [__`Middleware`__](./docs/Reference/Middleware.md)
+* [__`Hooks`__](./docs/Reference/Hooks.md)
+* [__`Decorators`__](./docs/Reference/Decorators.md)
+* [__`Validation and Serialization`__](./docs/Reference/Validation-and-Serialization.md)
+* [__`Fluent Schema`__](./docs/Guides/Fluent-Schema.md)
+* [__`Lifecycle`__](./docs/Reference/Lifecycle.md)
+* [__`Reply`__](./docs/Reference/Reply.md)
+* [__`Request`__](./docs/Reference/Request.md)
+* [__`Errors`__](./docs/Reference/Errors.md)
+* [__`Content Type Parser`__](./docs/Reference/ContentTypeParser.md)
+* [__`Plugins`__](./docs/Reference/Plugins.md)
+* [__`Testing`__](./docs/Guides/Testing.md)
+* [__`Benchmarking`__](./docs/Guides/Benchmarking.md)
+* [__`How to write a good plugin`__](./docs/Guides/Write-Plugin.md)
+* [__`Plugins Guide`__](./docs/Guides/Plugins-Guide.md)
+* [__`HTTP2`__](./docs/Reference/HTTP2.md)
+* [__`Long Term Support`__](./docs/Reference/LTS.md)
+* [__`TypeScript and types support`__](./docs/Reference/TypeScript.md)
+* [__`Serverless`__](./docs/Guides/Serverless.md)
+* [__`Recommendations`__](./docs/Guides/Recommendations.md)
+
+## Ecosystem
+
+- [Core](./docs/Guides/Ecosystem.md#core) - Core plugins maintained by the
+  _Fastify_ [team](#team).
+- [Community](./docs/Guides/Ecosystem.md#community) - Community-supported
+  plugins.
+- [Live Examples](https://github.com/fastify/example) - Multirepo with a broad
+  set of real working examples.
+- [Discord](https://discord.gg/D3FZYPy) - Join our discord server and chat with
+  the maintainers.
+
+## Support
+Please visit [Fastify help](https://github.com/fastify/help) to view prior
+support issues and to ask new support questions.
+
+Version 3 of Fastify and lower are EOL and will not receive any security or bug fixes.
+
+Fastify's partner, HeroDevs, provides commercial security fixes for all
+unsupported versions at [https://herodevs.com/support/fastify-nes][hd-link].
+Fastify's supported version matrix is available in the
+[Long Term Support][lts-link] documentation.
+
+## Contributing
+
+Whether reporting bugs, discussing improvements and new ideas, or writing code,
+we welcome contributions from anyone and everyone. Please read the [CONTRIBUTING](./CONTRIBUTING.md)
+guidelines before submitting pull requests.
+
+## Team
+
+_Fastify_ is the result of the work of a great community. Team members are
+listed in alphabetical order.
+
+**Lead Maintainers:**
+* [__Matteo Collina__](https://github.com/mcollina),
+  <https://twitter.com/matteocollina>, <https://www.npmjs.com/~matteo.collina>
+* [__Tomas Della Vedova__](https://github.com/delvedor),
+  <https://twitter.com/delvedor>, <https://www.npmjs.com/~delvedor>
+* [__KaKa Ng__](https://github.com/climba03003),
+  <https://www.npmjs.com/~climba03003>
+* [__Manuel Spigolon__](https://github.com/eomm),
+  <https://twitter.com/manueomm>, <https://www.npmjs.com/~eomm>
+* [__James Sumners__](https://github.com/jsumners),
+  <https://twitter.com/jsumners79>, <https://www.npmjs.com/~jsumners>
+
+### Fastify Core team
+* [__Aras Abbasi__](https://github.com/uzlopak),
+  <https://www.npmjs.com/~uzlopak>
+* [__Harry Brundage__](https://github.com/airhorns/),
+  <https://twitter.com/harrybrundage>, <https://www.npmjs.com/~airhorns>
+* [__Matteo Collina__](https://github.com/mcollina),
+  <https://twitter.com/matteocollina>, <https://www.npmjs.com/~matteo.collina>
+* [__Gürgün Dayıoğlu__](https://github.com/gurgunday),
+  <https://www.npmjs.com/~gurgunday>
+* [__Tomas Della Vedova__](https://github.com/delvedor),
+  <https://twitter.com/delvedor>, <https://www.npmjs.com/~delvedor>
+* [__Carlos Fuentes__](https://github.com/metcoder95),
+  <https://twitter.com/metcoder95>, <https://www.npmjs.com/~metcoder95>
+* [__Vincent Le Goff__](https://github.com/zekth)
+* [__Luciano Mammino__](https://github.com/lmammino),
+  <https://twitter.com/loige>, <https://www.npmjs.com/~lmammino>
+* [__Jean Michelet__](https://github.com/jean-michelet),
+  <https://www.npmjs.com/~jean-michelet>
+* [__KaKa Ng__](https://github.com/climba03003),
+  <https://www.npmjs.com/~climba03003>
+* [__Luis Orbaiceta__](https://github.com/luisorbaiceta),
+  <https://twitter.com/luisorbai>, <https://www.npmjs.com/~luisorbaiceta>
+* [__Maksim Sinik__](https://github.com/fox1t),
+  <https://twitter.com/maksimsinik>, <https://www.npmjs.com/~fox1t>
+* [__Manuel Spigolon__](https://github.com/eomm),
+  <https://twitter.com/manueomm>, <https://www.npmjs.com/~eomm>
+* [__James Sumners__](https://github.com/jsumners),
+  <https://twitter.com/jsumners79>, <https://www.npmjs.com/~jsumners>
+
+### Fastify Plugins team
+* [__Harry Brundage__](https://github.com/airhorns/),
+  <https://twitter.com/harrybrundage>, <https://www.npmjs.com/~airhorns>
+* [__Simone Busoli__](https://github.com/simoneb),
+  <https://twitter.com/simonebu>, <https://www.npmjs.com/~simoneb>
+* [__Dan Castillo__](https://github.com/dancastillo),
+  <https://www.npmjs.com/~dancastillo>
+* [__Matteo Collina__](https://github.com/mcollina),
+  <https://twitter.com/matteocollina>, <https://www.npmjs.com/~matteo.collina>
+* [__Gürgün Dayıoğlu__](https://github.com/gurgunday),
+  <https://www.npmjs.com/~gurgunday>
+* [__Tomas Della Vedova__](https://github.com/delvedor),
+  <https://twitter.com/delvedor>, <https://www.npmjs.com/~delvedor>
+* [__Carlos Fuentes__](https://github.com/metcoder95),
+  <https://twitter.com/metcoder95>, <https://www.npmjs.com/~metcoder95>
+* [__Vincent Le Goff__](https://github.com/zekth)
+* [__Jean Michelet__](https://github.com/jean-michelet),
+  <https://www.npmjs.com/~jean-michelet>
+* [__KaKa Ng__](https://github.com/climba03003),
+  <https://www.npmjs.com/~climba03003>
+* [__Maksim Sinik__](https://github.com/fox1t),
+  <https://twitter.com/maksimsinik>, <https://www.npmjs.com/~fox1t>
+* [__Frazer Smith__](https://github.com/Fdawgs), <https://www.npmjs.com/~fdawgs>
+* [__Manuel Spigolon__](https://github.com/eomm),
+  <https://twitter.com/manueomm>, <https://www.npmjs.com/~eomm>
+
+### Emeritus Contributors
+Great contributors to a specific area of the Fastify ecosystem will be invited
+to join this group by Lead Maintainers when they decide to step down from the
+active contributor's group.
+
+* [__Tommaso Allevi__](https://github.com/allevo),
+  <https://twitter.com/allevitommaso>, <https://www.npmjs.com/~allevo>
+* [__Ethan Arrowood__](https://github.com/Ethan-Arrowood/),
+  <https://twitter.com/arrowoodtech>, <https://www.npmjs.com/~ethan_arrowood>
+* [__Çağatay Çalı__](https://github.com/cagataycali),
+  <https://twitter.com/cagataycali>, <https://www.npmjs.com/~cagataycali>
+* [__David Mark Clements__](https://github.com/davidmarkclements),
+  <https://twitter.com/davidmarkclem>,
+  <https://www.npmjs.com/~davidmarkclements>
+* [__dalisoft__](https://github.com/dalisoft), <https://twitter.com/dalisoft>,
+  <https://www.npmjs.com/~dalisoft>
+* [__Dustin Deus__](https://github.com/StarpTech),
+  <https://twitter.com/dustindeus>, <https://www.npmjs.com/~starptech>
+* [__Denis Fäcke__](https://github.com/SerayaEryn),
+  <https://twitter.com/serayaeryn>, <https://www.npmjs.com/~serayaeryn>
+* [__Rafael Gonzaga__](https://github.com/rafaelgss),
+  <https://twitter.com/_rafaelgss>, <https://www.npmjs.com/~rafaelgss>
+* [__Trivikram Kamat__](https://github.com/trivikr),
+  <https://twitter.com/trivikram>, <https://www.npmjs.com/~trivikr>
+* [__Ayoub El Khattabi__](https://github.com/AyoubElk),
+  <https://twitter.com/ayoubelkh>, <https://www.npmjs.com/~ayoubelk>
+* [__Cemre Mengu__](https://github.com/cemremengu),
+  <https://twitter.com/cemremengu>, <https://www.npmjs.com/~cemremengu>
+* [__Salman Mitha__](https://github.com/salmanm),
+  <https://www.npmjs.com/~salmanm>
+* [__Nathan Woltman__](https://github.com/nwoltman),
+  <https://twitter.com/NathanWoltman>, <https://www.npmjs.com/~nwoltman>
+
+## Hosted by
+
+[<img
+src="https://github.com/openjs-foundation/artwork/blob/main/openjs_foundation/openjs_foundation-logo-horizontal-color.png?raw=true"
+width="250px;"/>](https://openjsf.org/projects)
+
+We are an [At-Large
+Project](https://github.com/openjs-foundation/cross-project-council/blob/HEAD/PROJECT_PROGRESSION.md#at-large-projects)
+in the [OpenJS Foundation](https://openjsf.org/).
+
+## Sponsors
+
+Support this project by becoming a [SPONSOR](./SPONSORS.md)!
+Fastify has an [Open Collective](https://opencollective.com/fastify)
+page where we accept and manage financial contributions.
+
+## Acknowledgments
+
+This project is kindly sponsored by:
+- [NearForm](https://nearform.com)
+- [Platformatic](https://platformatic.dev)
+
+Past Sponsors:
+- [LetzDoIt](https://www.letzdoitapp.com/)
+
+This list includes all companies that support one or more team members
+in maintaining this project.
+
+## License
+
+Licensed under [MIT](./LICENSE).
+
+For your convenience, here is a list of all the licenses of our production
+dependencies:
+- MIT
+- ISC
+- BSD-3-Clause
+- BSD-2-Clause
+
+[hd-link]: https://www.herodevs.com/support/fastify-nes?utm_source=fastify&utm_medium=link&utm_campaign=github_readme
+[lts-link]: https://fastify.dev/docs/latest/Reference/LTS/

novas/novacore-zephyr/claude-code-router/node_modules/fastify/SECURITY.md

@@ -0,0 +1,160 @@
+# Security Policy
+
+This document describes the management of vulnerabilities for the Fastify
+project and its official plugins.
+
+## Reporting vulnerabilities
+
+Individuals who find potential vulnerabilities in Fastify are invited to
+complete a vulnerability report via the dedicated pages:
+
+1. [HackerOne](https://hackerone.com/fastify)
+2. [GitHub Security Advisory](https://github.com/fastify/fastify/security/advisories/new)
+
+### Strict measures when reporting vulnerabilities
+
+It is of the utmost importance that you read carefully and follow these
+guidelines to ensure the ecosystem as a whole isn't disrupted due to improperly
+reported vulnerabilities:
+
+* Avoid creating new "informative" reports. Only create new
+  reports on a vulnerability if you are absolutely sure this should be
+  tagged as an actual vulnerability. Third-party vendors and individuals are
+  tracking any new vulnerabilities reported in HackerOne or GitHub and will flag
+  them as such for their customers (think about snyk, npm audit, ...).
+* Security reports should never be created and triaged by the same person. If
+  you are creating a report for a vulnerability that you found, or on
+  behalf of someone else, there should always be a 2nd Security Team member who
+  triages it. If in doubt, invite more Fastify Collaborators to help triage the
+  validity of the report. In any case, the report should follow the same process
+  as outlined below of inviting the maintainers to review and accept the
+  vulnerability.
+* ***Do not*** attempt to show CI/CD vulnerabilities by creating new pull
+  requests to any of the Fastify organization's repositories. Doing so will
+  result in a [content report][cr] to GitHub as an unsolicited exploit.
+  The proper way to provide such reports is by creating a new repository,
+  configured in the same manner as the repository you would like to submit
+  a report about, and with a pull request to your own repository showing
+  the proof of concept.
+
+[cr]: https://docs.github.com/en/communities/maintaining-your-safety-on-github/reporting-abuse-or-spam#reporting-an-issue-or-pull-request
+
+### Vulnerabilities found outside this process
+
+⚠ The Fastify project does not support any reporting outside the process mentioned
+in this document.
+
+## Handling vulnerability reports
+
+When a potential vulnerability is reported, the following actions are taken:
+
+### Triage
+
+**Delay:** 4 business days
+
+Within 4 business days, a member of the security team provides a first answer to
+the individual who submitted the potential vulnerability. The possible responses
+can be:
+
+* **Acceptance**: what was reported is considered as a new vulnerability
+* **Rejection**: what was reported is not considered as a new vulnerability
+* **Need more information**: the security team needs more information in order to
+  evaluate what was reported.
+
+Triaging should include updating issue fields:
+* Asset - set/create the module affected by the report
+* Severity - TBD, currently left empty
+
+Reference: [HackerOne: Submitting
+Reports](https://docs.hackerone.com/hackers/submitting-reports.html)
+
+### Correction follow-up
+
+**Delay:** 90 days
+
+When a vulnerability is confirmed, a member of the security team volunteers to
+follow up on this report.
+
+With the help of the individual who reported the vulnerability, they contact the
+maintainers of the vulnerable package to make them aware of the vulnerability.
+The maintainers can be invited as participants to the reported issue.
+
+With the package maintainer, they define a release date for the publication of
+the vulnerability. Ideally, this release date should not happen before the
+package has been patched.
+
+The report's vulnerable versions upper limit should be set to:
+* `*` if there is no fixed version available by the time of publishing the
+  report.
+* the last vulnerable version. For example: `<=1.2.3` if a fix exists in `1.2.4`
+
+### Publication
+
+**Delay:** 90 days
+
+Within 90 days after the triage date, the vulnerability must be made public.
+
+**Severity**: Vulnerability severity is assessed using [CVSS
+v.3](https://www.first.org/cvss/user-guide). More information can be found on
+[HackerOne documentation](https://docs.hackerone.com/hackers/severity.html)
+
+If the package maintainer is actively developing a patch, an additional delay
+can be added with the approval of the security team and the individual who
+reported the vulnerability.
+
+At this point, a CVE should be requested through the selected platform through
+the UI, which should include the Report ID and a summary.
+
+Within HackerOne, this is handled through a "public disclosure request".
+
+Reference: [HackerOne:
+Disclosure](https://docs.hackerone.com/hackers/disclosure.html)
+
+## The Fastify Security team
+
+The core team is responsible for the management of the security program and
+this policy and process.
+
+Members of this team are expected to keep all information that they have
+privileged access to by being on the team completely private to the team. This
+includes agreeing to not notify anyone outside the team of issues that have not
+yet been disclosed publicly, including the existence of issues, expectations of
+upcoming releases, and patching of any issues other than in the process of their
+work as a member of the Fastify Core team.
+
+### Members
+
+* [__Matteo Collina__](https://github.com/mcollina),
+  <https://twitter.com/matteocollina>, <https://www.npmjs.com/~matteo.collina>
+* [__Tomas Della Vedova__](https://github.com/delvedor),
+  <https://twitter.com/delvedor>, <https://www.npmjs.com/~delvedor>
+* [__Vincent Le Goff__](https://github.com/zekth)
+* [__KaKa Ng__](https://github.com/climba03003)
+* [__James Sumners__](https://github.com/jsumners),
+  <https://twitter.com/jsumners79>, <https://www.npmjs.com/~jsumners>
+
+## OpenSSF CII Best Practices
+
+[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/7585/badge)](https://bestpractices.coreinfrastructure.org/projects/7585)
+
+There are three “tiers”: passing, silver, and gold.
+
+### Passing
+We meet 100% of the “passing” criteria.
+
+### Silver
+We meet 87% of the “silver” criteria. The gaps are as follows:
+  - we do not have a DCO or a CLA process for contributions.
+  - we do not currently document
+    “what the user can and cannot expect in terms of security” for our project.
+  - we do not currently document ”the architecture (aka high-level design)”
+    for our project.
+
+### Gold
+We meet 70% of the “gold” criteria. The gaps are as follows:
+  - we do not yet have the “silver” badge; see all the gaps above.
+  - We do not include a copyright or license statement in each source file.
+    Efforts are underway to change this archaic practice into a
+    suggestion instead of a hard requirement.
+  - There are a few unanswered questions around cryptography that are
+    waiting for clarification.

novas/novacore-zephyr/claude-code-router/node_modules/fastify/SPONSORS.md

@@ -0,0 +1,23 @@
+# Sponsors
+
+All active sponsors of Fastify are listed here, in order of contribution!
+Our sponsors are the reason why we can work on some issues or features
+that otherwise would be impossible to do.
+
+If you want to become a sponsor, please check out our [Open Collective page](https://opencollective.com/fastify)
+or [GitHub Sponsors](https://github.com/sponsors/fastify)!
+
+## Tier 4
+
+_Be the first!_
+
+## Tier 3
+
+- [Mercedes-Benz Group](https://github.com/mercedes-benz)
+- [Val Town, Inc.](https://opencollective.com/valtown)
+- [Handsontable - JavaScript Data Grid](https://handsontable.com/docs/react-data-grid/?utm_source=Fastify_GH&utm_medium=sponsorship&utm_campaign=library_sponsorship_2024)
+- [Lokalise - A Localization and Translation Software Tool](https://lokalise.com/?utm_source=Fastify_GH&utm_medium=sponsorship)
+
+## Tier 2
+
+_Be the first!_

novas/novacore-zephyr/claude-code-router/node_modules/fastify/eslint.config.js

@@ -0,0 +1,19 @@
+'use strict'
+const neostandard = require('neostandard')
+
+module.exports = [
+  ...neostandard({
+    ignores: [
+      'lib/configValidator.js',
+      'lib/error-serializer.js',
+      'test/same-shape.test.js',
+      'test/types/import.js'
+    ],
+    ts: true
+  }),
+  {
+    rules: {
+      'comma-dangle': ['error', 'never']
+    }
+  }
+]

novas/novacore-zephyr/claude-code-router/node_modules/fastify/fastify.d.ts

@@ -0,0 +1,240 @@
+import * as http from 'node:http'
+import * as http2 from 'node:http2'
+import * as https from 'node:https'
+import { Socket } from 'node:net'
+
+import { Options as AjvOptions, ValidatorFactory } from '@fastify/ajv-compiler'
+import { FastifyError } from '@fastify/error'
+import { Options as FJSOptions, SerializerFactory } from '@fastify/fast-json-stringify-compiler'
+import { ConstraintStrategy, HTTPVersion } from 'find-my-way'
+import { InjectOptions, CallbackFunc as LightMyRequestCallback, Chain as LightMyRequestChain, Response as LightMyRequestResponse } from 'light-my-request'
+
+import { AddContentTypeParser, ConstructorAction, FastifyBodyParser, FastifyContentTypeParser, getDefaultJsonParser, hasContentTypeParser, ProtoAction } from './types/content-type-parser'
+import { FastifyContextConfig, FastifyReplyContext, FastifyRequestContext } from './types/context'
+import { FastifyErrorCodes } from './types/errors'
+import { DoneFuncWithErrOrRes, HookHandlerDoneFunction, onCloseAsyncHookHandler, onCloseHookHandler, onErrorAsyncHookHandler, onErrorHookHandler, onListenAsyncHookHandler, onListenHookHandler, onReadyAsyncHookHandler, onReadyHookHandler, onRegisterHookHandler, onRequestAbortAsyncHookHandler, onRequestAbortHookHandler, onRequestAsyncHookHandler, onRequestHookHandler, onResponseAsyncHookHandler, onResponseHookHandler, onRouteHookHandler, onSendAsyncHookHandler, onSendHookHandler, onTimeoutAsyncHookHandler, onTimeoutHookHandler, preCloseAsyncHookHandler, preCloseHookHandler, preHandlerAsyncHookHandler, preHandlerHookHandler, preParsingAsyncHookHandler, preParsingHookHandler, preSerializationAsyncHookHandler, preSerializationHookHandler, preValidationAsyncHookHandler, preValidationHookHandler, RequestPayload } from './types/hooks'
+import { FastifyInstance, FastifyListenOptions, PrintRoutesOptions } from './types/instance'
+import {
+  FastifyBaseLogger,
+  FastifyChildLoggerFactory,
+  FastifyLogFn,
+  FastifyLoggerInstance,
+  FastifyLoggerOptions,
+  LogLevel,
+  PinoLoggerOptions
+} from './types/logger'
+import { FastifyPlugin, FastifyPluginAsync, FastifyPluginCallback, FastifyPluginOptions } from './types/plugin'
+import { FastifyRegister, FastifyRegisterOptions, RegisterOptions } from './types/register'
+import { FastifyReply } from './types/reply'
+import { FastifyRequest, RequestGenericInterface } from './types/request'
+import { RouteGenericInterface, RouteHandler, RouteHandlerMethod, RouteOptions, RouteShorthandMethod, RouteShorthandOptions, RouteShorthandOptionsWithHandler } from './types/route'
+import { FastifySchema, FastifySchemaValidationError, FastifySchemaCompiler, FastifySerializerCompiler, SchemaErrorDataVar, SchemaErrorFormatter } from './types/schema'
+import { FastifyServerFactory, FastifyServerFactoryHandler } from './types/serverFactory'
+import { FastifyTypeProvider, FastifyTypeProviderDefault, SafePromiseLike } from './types/type-provider'
+import { ContextConfigDefault, HTTPMethods, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault, RequestBodyDefault, RequestHeadersDefault, RequestParamsDefault, RequestQuerystringDefault } from './types/utils'
+
+declare module '@fastify/error' {
+  interface FastifyError {
+    validationContext?: SchemaErrorDataVar;
+    validation?: FastifySchemaValidationError[];
+  }
+}
+
+type Fastify = typeof fastify
+
+declare namespace fastify {
+  export const errorCodes: FastifyErrorCodes
+
+  export type FastifyHttp2SecureOptions<
+    Server extends http2.Http2SecureServer,
+    Logger extends FastifyBaseLogger = FastifyBaseLogger
+  > = FastifyServerOptions<Server, Logger> & {
+    http2: true,
+    https: http2.SecureServerOptions,
+    http2SessionTimeout?: number
+  }
+
+  export type FastifyHttp2Options<
+    Server extends http2.Http2Server,
+    Logger extends FastifyBaseLogger = FastifyBaseLogger
+  > = FastifyServerOptions<Server, Logger> & {
+    http2: true,
+    http2SessionTimeout?: number
+  }
+
+  export type FastifyHttpsOptions<
+    Server extends https.Server,
+    Logger extends FastifyBaseLogger = FastifyBaseLogger
+  > = FastifyServerOptions<Server, Logger> & {
+    https: https.ServerOptions | null
+  }
+
+  export type FastifyHttpOptions<
+    Server extends http.Server,
+    Logger extends FastifyBaseLogger = FastifyBaseLogger
+  > = FastifyServerOptions<Server, Logger> & {
+    http?: http.ServerOptions | null
+  }
+
+  type FindMyWayVersion<RawServer extends RawServerBase> = RawServer extends http.Server ? HTTPVersion.V1 : HTTPVersion.V2
+
+  export interface ConnectionError extends Error {
+    code: string,
+    bytesParsed: number,
+    rawPacket: {
+      type: string,
+      data: number[]
+    }
+  }
+
+  type TrustProxyFunction = (address: string, hop: number) => boolean
+
+  /**
+   * Options for a fastify server instance. Utilizes conditional logic on the generic server parameter to enforce certain https and http2
+   */
+  export type FastifyServerOptions<
+    RawServer extends RawServerBase = RawServerDefault,
+    Logger extends FastifyBaseLogger = FastifyBaseLogger
+  > = {
+    ignoreTrailingSlash?: boolean,
+    ignoreDuplicateSlashes?: boolean,
+    connectionTimeout?: number,
+    keepAliveTimeout?: number,
+    maxRequestsPerSocket?: number,
+    forceCloseConnections?: boolean | 'idle',
+    requestTimeout?: number,
+    pluginTimeout?: number,
+    bodyLimit?: number,
+    maxParamLength?: number,
+    disableRequestLogging?: boolean,
+    exposeHeadRoutes?: boolean,
+    onProtoPoisoning?: ProtoAction,
+    onConstructorPoisoning?: ConstructorAction,
+    logger?: boolean | FastifyLoggerOptions<RawServer> & PinoLoggerOptions,
+    loggerInstance?: Logger
+    serializerOpts?: FJSOptions | Record<string, unknown>,
+    serverFactory?: FastifyServerFactory<RawServer>,
+    caseSensitive?: boolean,
+    allowUnsafeRegex?: boolean,
+    requestIdHeader?: string | false,
+    requestIdLogLabel?: string;
+    useSemicolonDelimiter?: boolean,
+    genReqId?: (req: RawRequestDefaultExpression<RawServer>) => string,
+    trustProxy?: boolean | string | string[] | number | TrustProxyFunction,
+    querystringParser?: (str: string) => { [key: string]: unknown },
+    constraints?: {
+      [name: string]: ConstraintStrategy<FindMyWayVersion<RawServer>, unknown>,
+    },
+    schemaController?: {
+      bucket?: (parentSchemas?: unknown) => {
+        add(schema: unknown): FastifyInstance;
+        getSchema(schemaId: string): unknown;
+        getSchemas(): Record<string, unknown>;
+      };
+      compilersFactory?: {
+        buildValidator?: ValidatorFactory;
+        buildSerializer?: SerializerFactory;
+      };
+    };
+    return503OnClosing?: boolean,
+    ajv?: {
+      customOptions?: AjvOptions,
+      plugins?: (Function | [Function, unknown])[]
+    },
+    frameworkErrors?: <RequestGeneric extends RequestGenericInterface = RequestGenericInterface, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault, SchemaCompiler extends FastifySchema = FastifySchema>(
+      error: FastifyError,
+      req: FastifyRequest<RequestGeneric, RawServer, RawRequestDefaultExpression<RawServer>, FastifySchema, TypeProvider>,
+      res: FastifyReply<RequestGeneric, RawServer, RawRequestDefaultExpression<RawServer>, RawReplyDefaultExpression<RawServer>, FastifyContextConfig, SchemaCompiler, TypeProvider>
+    ) => void,
+    rewriteUrl?: (
+      // The RawRequestDefaultExpression, RawReplyDefaultExpression, and FastifyTypeProviderDefault parameters
+      // should be narrowed further but those generic parameters are not passed to this FastifyServerOptions type
+      this: FastifyInstance<RawServer, RawRequestDefaultExpression<RawServer>, RawReplyDefaultExpression<RawServer>, Logger, FastifyTypeProviderDefault>,
+      req: RawRequestDefaultExpression<RawServer>
+    ) => string,
+    schemaErrorFormatter?: SchemaErrorFormatter,
+    /**
+     * listener to error events emitted by client connections
+     */
+    clientErrorHandler?: (error: ConnectionError, socket: Socket) => void,
+    childLoggerFactory?: FastifyChildLoggerFactory,
+    allowErrorHandlerOverride?: boolean
+  }
+
+  /**
+   * @deprecated use {@link FastifySchemaValidationError}
+   */
+  export type ValidationResult = FastifySchemaValidationError
+
+  /* Export additional types */
+  export type {
+    LightMyRequestChain, InjectOptions, LightMyRequestResponse, LightMyRequestCallback, // 'light-my-request'
+    FastifyRequest, RequestGenericInterface, // './types/request'
+    FastifyReply, // './types/reply'
+    FastifyPluginCallback, FastifyPluginAsync, FastifyPluginOptions, FastifyPlugin, // './types/plugin'
+    FastifyListenOptions, FastifyInstance, PrintRoutesOptions, // './types/instance'
+    FastifyLoggerOptions, FastifyBaseLogger, FastifyLoggerInstance, FastifyLogFn, LogLevel, // './types/logger'
+    FastifyRequestContext, FastifyContextConfig, FastifyReplyContext, // './types/context'
+    RouteHandler, RouteHandlerMethod, RouteOptions, RouteShorthandMethod, RouteShorthandOptions, RouteShorthandOptionsWithHandler, RouteGenericInterface, // './types/route'
+    FastifyRegister, FastifyRegisterOptions, RegisterOptions, // './types/register'
+    FastifyBodyParser, FastifyContentTypeParser, AddContentTypeParser, hasContentTypeParser, getDefaultJsonParser, ProtoAction, ConstructorAction, // './types/content-type-parser'
+    FastifyError, // '@fastify/error'
+    FastifySchema, FastifySchemaValidationError, FastifySchemaCompiler, FastifySerializerCompiler, // './types/schema'
+    HTTPMethods, RawServerBase, RawRequestDefaultExpression, RawReplyDefaultExpression, RawServerDefault, ContextConfigDefault, RequestBodyDefault, RequestQuerystringDefault, RequestParamsDefault, RequestHeadersDefault, // './types/utils'
+    DoneFuncWithErrOrRes, HookHandlerDoneFunction, RequestPayload, onCloseAsyncHookHandler, onCloseHookHandler, onErrorAsyncHookHandler, onErrorHookHandler, onReadyAsyncHookHandler, onReadyHookHandler, onListenAsyncHookHandler, onListenHookHandler, onRegisterHookHandler, onRequestAsyncHookHandler, onRequestHookHandler, onResponseAsyncHookHandler, onResponseHookHandler, onRouteHookHandler, onSendAsyncHookHandler, onSendHookHandler, onTimeoutAsyncHookHandler, onTimeoutHookHandler, preHandlerAsyncHookHandler, preHandlerHookHandler, preParsingAsyncHookHandler, preParsingHookHandler, preSerializationAsyncHookHandler, preSerializationHookHandler, preValidationAsyncHookHandler, preValidationHookHandler, onRequestAbortHookHandler, onRequestAbortAsyncHookHandler, preCloseAsyncHookHandler, preCloseHookHandler, // './types/hooks'
+    FastifyServerFactory, FastifyServerFactoryHandler, // './types/serverFactory'
+    FastifyTypeProvider, FastifyTypeProviderDefault, SafePromiseLike, // './types/type-provider'
+    FastifyErrorCodes // './types/errors'
+  }
+  // named export
+  // import { plugin } from 'plugin'
+  // const { plugin } = require('plugin')
+  export const fastify: Fastify
+  // default export
+  // import plugin from 'plugin'
+  export { fastify as default }
+}
+
+/**
+ * Fastify factory function for the standard fastify http, https, or http2 server instance.
+ *
+ * The default function utilizes http
+ *
+ * @param opts Fastify server options
+ * @returns Fastify server instance
+ */
+declare function fastify<
+  Server extends http2.Http2SecureServer,
+  Request extends RawRequestDefaultExpression<Server> = RawRequestDefaultExpression<Server>,
+  Reply extends RawReplyDefaultExpression<Server> = RawReplyDefaultExpression<Server>,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
+> (opts: fastify.FastifyHttp2SecureOptions<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & SafePromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
+
+declare function fastify<
+  Server extends http2.Http2Server,
+  Request extends RawRequestDefaultExpression<Server> = RawRequestDefaultExpression<Server>,
+  Reply extends RawReplyDefaultExpression<Server> = RawReplyDefaultExpression<Server>,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
+> (opts: fastify.FastifyHttp2Options<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & SafePromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
+
+declare function fastify<
+  Server extends https.Server,
+  Request extends RawRequestDefaultExpression<Server> = RawRequestDefaultExpression<Server>,
+  Reply extends RawReplyDefaultExpression<Server> = RawReplyDefaultExpression<Server>,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
+> (opts: fastify.FastifyHttpsOptions<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & SafePromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
+
+declare function fastify<
+  Server extends http.Server,
+  Request extends RawRequestDefaultExpression<Server> = RawRequestDefaultExpression<Server>,
+  Reply extends RawReplyDefaultExpression<Server> = RawReplyDefaultExpression<Server>,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
+> (opts?: fastify.FastifyHttpOptions<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & SafePromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
+
+// CJS export
+// const fastify = require('fastify')
+export = fastify

novas/novacore-zephyr/claude-code-router/node_modules/fastify/fastify.js

@@ -0,0 +1,963 @@
+'use strict'
+
+const VERSION = '5.5.0'
+
+const Avvio = require('avvio')
+const http = require('node:http')
+const diagnostics = require('node:diagnostics_channel')
+let lightMyRequest
+
+const {
+  kAvvioBoot,
+  kChildren,
+  kServerBindings,
+  kBodyLimit,
+  kSupportedHTTPMethods,
+  kRoutePrefix,
+  kLogLevel,
+  kLogSerializers,
+  kHooks,
+  kSchemaController,
+  kRequestAcceptVersion,
+  kReplySerializerDefault,
+  kContentTypeParser,
+  kReply,
+  kRequest,
+  kFourOhFour,
+  kState,
+  kOptions,
+  kPluginNameChain,
+  kSchemaErrorFormatter,
+  kErrorHandler,
+  kKeepAliveConnections,
+  kChildLoggerFactory,
+  kGenReqId,
+  kErrorHandlerAlreadySet
+} = require('./lib/symbols.js')
+
+const { createServer } = require('./lib/server')
+const Reply = require('./lib/reply')
+const Request = require('./lib/request')
+const Context = require('./lib/context.js')
+const decorator = require('./lib/decorate')
+const ContentTypeParser = require('./lib/contentTypeParser')
+const SchemaController = require('./lib/schema-controller')
+const { Hooks, hookRunnerApplication, supportedHooks } = require('./lib/hooks')
+const { createChildLogger, defaultChildLoggerFactory, createLogger } = require('./lib/logger-factory')
+const pluginUtils = require('./lib/pluginUtils')
+const { getGenReqId, reqIdGenFactory } = require('./lib/reqIdGenFactory')
+const { buildRouting, validateBodyLimitOption, buildRouterOptions } = require('./lib/route')
+const build404 = require('./lib/fourOhFour')
+const getSecuredInitialConfig = require('./lib/initialConfigValidation')
+const override = require('./lib/pluginOverride')
+const noopSet = require('./lib/noop-set')
+const {
+  appendStackTrace,
+  AVVIO_ERRORS_MAP,
+  ...errorCodes
+} = require('./lib/errors')
+const PonyPromise = require('./lib/promise')
+
+const { defaultInitOptions } = getSecuredInitialConfig
+
+const {
+  FST_ERR_ASYNC_CONSTRAINT,
+  FST_ERR_BAD_URL,
+  FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE,
+  FST_ERR_OPTIONS_NOT_OBJ,
+  FST_ERR_QSP_NOT_FN,
+  FST_ERR_SCHEMA_CONTROLLER_BUCKET_OPT_NOT_FN,
+  FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_OBJ,
+  FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_ARR,
+  FST_ERR_INSTANCE_ALREADY_LISTENING,
+  FST_ERR_REOPENED_CLOSE_SERVER,
+  FST_ERR_ROUTE_REWRITE_NOT_STR,
+  FST_ERR_SCHEMA_ERROR_FORMATTER_NOT_FN,
+  FST_ERR_ERROR_HANDLER_NOT_FN,
+  FST_ERR_ERROR_HANDLER_ALREADY_SET,
+  FST_ERR_ROUTE_METHOD_INVALID
+} = errorCodes
+
+const { buildErrorHandler } = require('./lib/error-handler.js')
+const { FSTWRN004 } = require('./lib/warnings.js')
+
+const initChannel = diagnostics.channel('fastify.initialization')
+
+function defaultBuildPrettyMeta (route) {
+  // return a shallow copy of route's sanitized context
+
+  const cleanKeys = {}
+  const allowedProps = ['errorHandler', 'logLevel', 'logSerializers']
+
+  allowedProps.concat(supportedHooks).forEach(k => {
+    cleanKeys[k] = route.store[k]
+  })
+
+  return Object.assign({}, cleanKeys)
+}
+
+/**
+ * @param {import('./fastify.js').FastifyServerOptions} options
+ */
+function fastify (options) {
+  // Options validations
+  if (options && typeof options !== 'object') {
+    throw new FST_ERR_OPTIONS_NOT_OBJ()
+  } else {
+    // Shallow copy options object to prevent mutations outside of this function
+    options = Object.assign({}, options)
+  }
+
+  if (
+    (options.querystringParser && typeof options.querystringParser !== 'function') ||
+    (
+      options.routerOptions?.querystringParser &&
+      typeof options.routerOptions.querystringParser !== 'function'
+    )
+  ) {
+    throw new FST_ERR_QSP_NOT_FN(typeof (options.querystringParser ?? options.routerOptions.querystringParser))
+  }
+
+  if (options.schemaController && options.schemaController.bucket && typeof options.schemaController.bucket !== 'function') {
+    throw new FST_ERR_SCHEMA_CONTROLLER_BUCKET_OPT_NOT_FN(typeof options.schemaController.bucket)
+  }
+
+  validateBodyLimitOption(options.bodyLimit)
+
+  const requestIdHeader = typeof options.requestIdHeader === 'string' && options.requestIdHeader.length !== 0 ? options.requestIdHeader.toLowerCase() : (options.requestIdHeader === true && 'request-id')
+  const genReqId = reqIdGenFactory(requestIdHeader, options.genReqId)
+  const requestIdLogLabel = options.requestIdLogLabel || 'reqId'
+  const bodyLimit = options.bodyLimit || defaultInitOptions.bodyLimit
+  const disableRequestLogging = options.disableRequestLogging || false
+
+  const ajvOptions = Object.assign({
+    customOptions: {},
+    plugins: []
+  }, options.ajv)
+  const frameworkErrors = options.frameworkErrors
+
+  // Ajv options
+  if (!ajvOptions.customOptions || Object.prototype.toString.call(ajvOptions.customOptions) !== '[object Object]') {
+    throw new FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_OBJ(typeof ajvOptions.customOptions)
+  }
+  if (!ajvOptions.plugins || !Array.isArray(ajvOptions.plugins)) {
+    throw new FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_ARR(typeof ajvOptions.plugins)
+  }
+
+  // Instance Fastify components
+
+  const { logger, hasLogger } = createLogger(options)
+
+  // Update the options with the fixed values
+  options.connectionTimeout = options.connectionTimeout || defaultInitOptions.connectionTimeout
+  options.keepAliveTimeout = options.keepAliveTimeout || defaultInitOptions.keepAliveTimeout
+  options.maxRequestsPerSocket = options.maxRequestsPerSocket || defaultInitOptions.maxRequestsPerSocket
+  options.requestTimeout = options.requestTimeout || defaultInitOptions.requestTimeout
+  options.logger = logger
+  options.requestIdHeader = requestIdHeader
+  options.requestIdLogLabel = requestIdLogLabel
+  options.disableRequestLogging = disableRequestLogging
+  options.ajv = ajvOptions
+  options.clientErrorHandler = options.clientErrorHandler || defaultClientErrorHandler
+  options.allowErrorHandlerOverride = options.allowErrorHandlerOverride ?? defaultInitOptions.allowErrorHandlerOverride
+
+  const initialConfig = getSecuredInitialConfig(options)
+
+  // exposeHeadRoutes have its default set from the validator
+  options.exposeHeadRoutes = initialConfig.exposeHeadRoutes
+
+  options.routerOptions = buildRouterOptions(options, {
+    defaultRoute,
+    onBadUrl,
+    ignoreTrailingSlash: defaultInitOptions.ignoreTrailingSlash,
+    ignoreDuplicateSlashes: defaultInitOptions.ignoreDuplicateSlashes,
+    maxParamLength: defaultInitOptions.maxParamLength,
+    allowUnsafeRegex: defaultInitOptions.allowUnsafeRegex,
+    buildPrettyMeta: defaultBuildPrettyMeta,
+    useSemicolonDelimiter: defaultInitOptions.useSemicolonDelimiter
+  })
+
+  // Default router
+  const router = buildRouting({
+    config: options.routerOptions
+  })
+
+  // 404 router, used for handling encapsulated 404 handlers
+  const fourOhFour = build404(options)
+
+  // HTTP server and its handler
+  const httpHandler = wrapRouting(router, options)
+
+  // we need to set this before calling createServer
+  options.http2SessionTimeout = initialConfig.http2SessionTimeout
+  const { server, listen } = createServer(options, httpHandler)
+
+  const serverHasCloseAllConnections = typeof server.closeAllConnections === 'function'
+  const serverHasCloseIdleConnections = typeof server.closeIdleConnections === 'function'
+
+  let forceCloseConnections = options.forceCloseConnections
+  if (forceCloseConnections === 'idle' && !serverHasCloseIdleConnections) {
+    throw new FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE()
+  } else if (typeof forceCloseConnections !== 'boolean') {
+    /* istanbul ignore next: only one branch can be valid in a given Node.js version */
+    forceCloseConnections = serverHasCloseIdleConnections ? 'idle' : false
+  }
+
+  const keepAliveConnections = !serverHasCloseAllConnections && forceCloseConnections === true ? new Set() : noopSet()
+
+  const setupResponseListeners = Reply.setupResponseListeners
+  const schemaController = SchemaController.buildSchemaController(null, options.schemaController)
+
+  // Public API
+  const fastify = {
+    // Fastify internals
+    [kState]: {
+      listening: false,
+      closing: false,
+      started: false,
+      ready: false,
+      booting: false,
+      aborted: false,
+      readyResolver: null
+    },
+    [kKeepAliveConnections]: keepAliveConnections,
+    [kSupportedHTTPMethods]: {
+      bodyless: new Set([
+        // Standard
+        'GET',
+        'HEAD',
+        'TRACE'
+      ]),
+      bodywith: new Set([
+        // Standard
+        'DELETE',
+        'OPTIONS',
+        'PATCH',
+        'PUT',
+        'POST'
+      ])
+    },
+    [kOptions]: options,
+    [kChildren]: [],
+    [kServerBindings]: [],
+    [kBodyLimit]: bodyLimit,
+    [kRoutePrefix]: '',
+    [kLogLevel]: '',
+    [kLogSerializers]: null,
+    [kHooks]: new Hooks(),
+    [kSchemaController]: schemaController,
+    [kSchemaErrorFormatter]: null,
+    [kErrorHandler]: buildErrorHandler(),
+    [kErrorHandlerAlreadySet]: false,
+    [kChildLoggerFactory]: defaultChildLoggerFactory,
+    [kReplySerializerDefault]: null,
+    [kContentTypeParser]: new ContentTypeParser(
+      bodyLimit,
+      (options.onProtoPoisoning || defaultInitOptions.onProtoPoisoning),
+      (options.onConstructorPoisoning || defaultInitOptions.onConstructorPoisoning)
+    ),
+    [kReply]: Reply.buildReply(Reply),
+    [kRequest]: Request.buildRequest(Request, options.trustProxy),
+    [kFourOhFour]: fourOhFour,
+    [pluginUtils.kRegisteredPlugins]: [],
+    [kPluginNameChain]: ['fastify'],
+    [kAvvioBoot]: null,
+    [kGenReqId]: genReqId,
+    // routing method
+    routing: httpHandler,
+    // routes shorthand methods
+    delete: function _delete (url, options, handler) {
+      return router.prepareRoute.call(this, { method: 'DELETE', url, options, handler })
+    },
+    get: function _get (url, options, handler) {
+      return router.prepareRoute.call(this, { method: 'GET', url, options, handler })
+    },
+    head: function _head (url, options, handler) {
+      return router.prepareRoute.call(this, { method: 'HEAD', url, options, handler })
+    },
+    trace: function _trace (url, options, handler) {
+      return router.prepareRoute.call(this, { method: 'TRACE', url, options, handler })
+    },
+    patch: function _patch (url, options, handler) {
+      return router.prepareRoute.call(this, { method: 'PATCH', url, options, handler })
+    },
+    post: function _post (url, options, handler) {
+      return router.prepareRoute.call(this, { method: 'POST', url, options, handler })
+    },
+    put: function _put (url, options, handler) {
+      return router.prepareRoute.call(this, { method: 'PUT', url, options, handler })
+    },
+    options: function _options (url, options, handler) {
+      return router.prepareRoute.call(this, { method: 'OPTIONS', url, options, handler })
+    },
+    all: function _all (url, options, handler) {
+      return router.prepareRoute.call(this, { method: this.supportedMethods, url, options, handler })
+    },
+    // extended route
+    route: function _route (options) {
+      // we need the fastify object that we are producing so we apply a lazy loading of the function,
+      // otherwise we should bind it after the declaration
+      return router.route.call(this, { options })
+    },
+    hasRoute: function _route (options) {
+      return router.hasRoute.call(this, { options })
+    },
+    findRoute: function _findRoute (options) {
+      return router.findRoute(options)
+    },
+    // expose logger instance
+    log: logger,
+    // type provider
+    withTypeProvider,
+    // hooks
+    addHook,
+    // schemas
+    addSchema,
+    getSchema: schemaController.getSchema.bind(schemaController),
+    getSchemas: schemaController.getSchemas.bind(schemaController),
+    setValidatorCompiler,
+    setSerializerCompiler,
+    setSchemaController,
+    setReplySerializer,
+    setSchemaErrorFormatter,
+    // set generated request id
+    setGenReqId,
+    // custom parsers
+    addContentTypeParser: ContentTypeParser.helpers.addContentTypeParser,
+    hasContentTypeParser: ContentTypeParser.helpers.hasContentTypeParser,
+    getDefaultJsonParser: ContentTypeParser.defaultParsers.getDefaultJsonParser,
+    defaultTextParser: ContentTypeParser.defaultParsers.defaultTextParser,
+    removeContentTypeParser: ContentTypeParser.helpers.removeContentTypeParser,
+    removeAllContentTypeParsers: ContentTypeParser.helpers.removeAllContentTypeParsers,
+    // Fastify architecture methods (initialized by Avvio)
+    register: null,
+    after: null,
+    ready: null,
+    onClose: null,
+    close: null,
+    printPlugins: null,
+    hasPlugin: function (name) {
+      return this[pluginUtils.kRegisteredPlugins].includes(name) || this[kPluginNameChain].includes(name)
+    },
+    // http server
+    listen,
+    server,
+    addresses: function () {
+      /* istanbul ignore next */
+      const binded = this[kServerBindings].map(b => b.address())
+      binded.push(this.server.address())
+      return binded.filter(adr => adr)
+    },
+    // extend fastify objects
+    decorate: decorator.add,
+    hasDecorator: decorator.exist,
+    decorateReply: decorator.decorateReply,
+    decorateRequest: decorator.decorateRequest,
+    hasRequestDecorator: decorator.existRequest,
+    hasReplyDecorator: decorator.existReply,
+    getDecorator: decorator.getInstanceDecorator,
+    addHttpMethod,
+    // fake http injection
+    inject,
+    // pretty print of the registered routes
+    printRoutes,
+    // custom error handling
+    setNotFoundHandler,
+    setErrorHandler,
+    // child logger
+    setChildLoggerFactory,
+    // Set fastify initial configuration options read-only object
+    initialConfig,
+    // constraint strategies
+    addConstraintStrategy: router.addConstraintStrategy.bind(router),
+    hasConstraintStrategy: router.hasConstraintStrategy.bind(router)
+  }
+
+  Object.defineProperties(fastify, {
+    listeningOrigin: {
+      get () {
+        const address = this.addresses().slice(-1).pop()
+        /* ignore if windows: unix socket is not testable on Windows platform */
+        /* c8 ignore next 3 */
+        if (typeof address === 'string') {
+          return address
+        }
+        const host = address.family === 'IPv6' ? `[${address.address}]` : address.address
+        return `${this[kOptions].https ? 'https' : 'http'}://${host}:${address.port}`
+      }
+    },
+    pluginName: {
+      configurable: true,
+      get () {
+        if (this[kPluginNameChain].length > 1) {
+          return this[kPluginNameChain].join(' -> ')
+        }
+        return this[kPluginNameChain][0]
+      }
+    },
+    prefix: {
+      configurable: true,
+      get () { return this[kRoutePrefix] }
+    },
+    validatorCompiler: {
+      configurable: true,
+      get () { return this[kSchemaController].getValidatorCompiler() }
+    },
+    serializerCompiler: {
+      configurable: true,
+      get () { return this[kSchemaController].getSerializerCompiler() }
+    },
+    childLoggerFactory: {
+      configurable: true,
+      get () { return this[kChildLoggerFactory] }
+    },
+    version: {
+      configurable: true,
+      get () { return VERSION }
+    },
+    errorHandler: {
+      configurable: true,
+      get () {
+        return this[kErrorHandler].func
+      }
+    },
+    genReqId: {
+      configurable: true,
+      get () { return this[kGenReqId] }
+    },
+    supportedMethods: {
+      configurable: false,
+      get () {
+        return [
+          ...this[kSupportedHTTPMethods].bodyless,
+          ...this[kSupportedHTTPMethods].bodywith
+        ]
+      }
+    }
+  })
+
+  if (options.schemaErrorFormatter) {
+    validateSchemaErrorFormatter(options.schemaErrorFormatter)
+    fastify[kSchemaErrorFormatter] = options.schemaErrorFormatter.bind(fastify)
+  }
+
+  // Install and configure Avvio
+  // Avvio will update the following Fastify methods:
+  // - register
+  // - after
+  // - ready
+  // - onClose
+  // - close
+
+  const avvioPluginTimeout = Number(options.pluginTimeout)
+  const avvio = Avvio(fastify, {
+    autostart: false,
+    timeout: isNaN(avvioPluginTimeout) === false ? avvioPluginTimeout : defaultInitOptions.pluginTimeout,
+    expose: {
+      use: 'register'
+    }
+  })
+  // Override to allow the plugin encapsulation
+  avvio.override = override
+  avvio.on('start', () => (fastify[kState].started = true))
+  fastify[kAvvioBoot] = fastify.ready // the avvio ready function
+  fastify.ready = ready // overwrite the avvio ready function
+  fastify.printPlugins = avvio.prettyPrint.bind(avvio)
+
+  // cache the closing value, since we are checking it in an hot path
+  avvio.once('preReady', () => {
+    fastify.onClose((instance, done) => {
+      fastify[kState].closing = true
+      router.closeRoutes()
+
+      hookRunnerApplication('preClose', fastify[kAvvioBoot], fastify, function () {
+        if (fastify[kState].listening) {
+          /* istanbul ignore next: Cannot test this without Node.js core support */
+          if (forceCloseConnections === 'idle') {
+            // Not needed in Node 19
+            instance.server.closeIdleConnections()
+            /* istanbul ignore next: Cannot test this without Node.js core support */
+          } else if (serverHasCloseAllConnections && forceCloseConnections) {
+            instance.server.closeAllConnections()
+          } else if (forceCloseConnections === true) {
+            for (const conn of fastify[kKeepAliveConnections]) {
+              // We must invoke the destroy method instead of merely unreffing
+              // the sockets. If we only unref, then the callback passed to
+              // `fastify.close` will never be invoked; nor will any of the
+              // registered `onClose` hooks.
+              conn.destroy()
+              fastify[kKeepAliveConnections].delete(conn)
+            }
+          }
+        }
+
+        // No new TCP connections are accepted.
+        // We must call close on the server even if we are not listening
+        // otherwise memory will be leaked.
+        // https://github.com/nodejs/node/issues/48604
+        if (!options.serverFactory || fastify[kState].listening) {
+          instance.server.close(function (err) {
+            /* c8 ignore next 6 */
+            if (err && err.code !== 'ERR_SERVER_NOT_RUNNING') {
+              done(null)
+            } else {
+              done()
+            }
+          })
+        } else {
+          process.nextTick(done, null)
+        }
+      })
+    })
+  })
+
+  // Create bad URL context
+  const onBadUrlContext = new Context({
+    server: fastify,
+    config: {}
+  })
+
+  // Set the default 404 handler
+  fastify.setNotFoundHandler()
+  fourOhFour.arrange404(fastify)
+
+  router.setup(options, {
+    avvio,
+    fourOhFour,
+    logger,
+    hasLogger,
+    setupResponseListeners,
+    throwIfAlreadyStarted,
+    keepAliveConnections
+  })
+
+  // Delay configuring clientError handler so that it can access fastify state.
+  server.on('clientError', options.clientErrorHandler.bind(fastify))
+
+  if (initChannel.hasSubscribers) {
+    initChannel.publish({ fastify })
+  }
+
+  // Older nodejs versions may not have asyncDispose
+  if ('asyncDispose' in Symbol) {
+    fastify[Symbol.asyncDispose] = function dispose () {
+      return fastify.close()
+    }
+  }
+
+  return fastify
+
+  function throwIfAlreadyStarted (msg) {
+    if (fastify[kState].started) throw new FST_ERR_INSTANCE_ALREADY_LISTENING(msg)
+  }
+
+  // HTTP injection handling
+  // If the server is not ready yet, this
+  // utility will automatically force it.
+  function inject (opts, cb) {
+    // lightMyRequest is dynamically loaded as it seems very expensive
+    // because of Ajv
+    if (lightMyRequest === undefined) {
+      lightMyRequest = require('light-my-request')
+    }
+
+    if (fastify[kState].started) {
+      if (fastify[kState].closing) {
+        // Force to return an error
+        const error = new FST_ERR_REOPENED_CLOSE_SERVER()
+        if (cb) {
+          cb(error)
+          return
+        } else {
+          return Promise.reject(error)
+        }
+      }
+      return lightMyRequest(httpHandler, opts, cb)
+    }
+
+    if (cb) {
+      this.ready(err => {
+        if (err) cb(err, null)
+        else lightMyRequest(httpHandler, opts, cb)
+      })
+    } else {
+      return lightMyRequest((req, res) => {
+        this.ready(function (err) {
+          if (err) {
+            res.emit('error', err)
+            return
+          }
+          httpHandler(req, res)
+        })
+      }, opts)
+    }
+  }
+
+  function ready (cb) {
+    if (this[kState].readyResolver !== null) {
+      if (cb != null) {
+        this[kState].readyResolver.promise.then(() => cb(null, fastify), cb)
+        return
+      }
+
+      return this[kState].readyResolver.promise
+    }
+
+    // run the hooks after returning the promise
+    process.nextTick(runHooks)
+
+    // Create a promise no matter what
+    // It will work as a barrier for all the .ready() calls (ensuring single hook execution)
+    // as well as a flow control mechanism to chain cbs and further
+    // promises
+    this[kState].readyResolver = PonyPromise.withResolvers()
+
+    if (!cb) {
+      return this[kState].readyResolver.promise
+    } else {
+      this[kState].readyResolver.promise.then(() => cb(null, fastify), cb)
+    }
+
+    function runHooks () {
+      // start loading
+      fastify[kAvvioBoot]((err, done) => {
+        if (err || fastify[kState].started || fastify[kState].ready || fastify[kState].booting) {
+          manageErr(err)
+        } else {
+          fastify[kState].booting = true
+          hookRunnerApplication('onReady', fastify[kAvvioBoot], fastify, manageErr)
+        }
+        done()
+      })
+    }
+
+    function manageErr (err) {
+      // If the error comes out of Avvio's Error codes
+      // We create a make and preserve the previous error
+      // as cause
+      err = err != null && AVVIO_ERRORS_MAP[err.code] != null
+        ? appendStackTrace(err, new AVVIO_ERRORS_MAP[err.code](err.message))
+        : err
+
+      if (err) {
+        return fastify[kState].readyResolver.reject(err)
+      }
+
+      fastify[kState].readyResolver.resolve(fastify)
+      fastify[kState].booting = false
+      fastify[kState].ready = true
+      fastify[kState].readyResolver = null
+    }
+  }
+
+  // Used exclusively in TypeScript contexts to enable auto type inference from JSON schema.
+  function withTypeProvider () {
+    return this
+  }
+
+  // wrapper that we expose to the user for hooks handling
+  function addHook (name, fn) {
+    throwIfAlreadyStarted('Cannot call "addHook"!')
+
+    if (fn == null) {
+      throw new errorCodes.FST_ERR_HOOK_INVALID_HANDLER(name, fn)
+    }
+
+    if (name === 'onSend' || name === 'preSerialization' || name === 'onError' || name === 'preParsing') {
+      if (fn.constructor.name === 'AsyncFunction' && fn.length === 4) {
+        throw new errorCodes.FST_ERR_HOOK_INVALID_ASYNC_HANDLER()
+      }
+    } else if (name === 'onReady' || name === 'onListen') {
+      if (fn.constructor.name === 'AsyncFunction' && fn.length !== 0) {
+        throw new errorCodes.FST_ERR_HOOK_INVALID_ASYNC_HANDLER()
+      }
+    } else if (name === 'onRequestAbort') {
+      if (fn.constructor.name === 'AsyncFunction' && fn.length !== 1) {
+        throw new errorCodes.FST_ERR_HOOK_INVALID_ASYNC_HANDLER()
+      }
+    } else {
+      if (fn.constructor.name === 'AsyncFunction' && fn.length === 3) {
+        throw new errorCodes.FST_ERR_HOOK_INVALID_ASYNC_HANDLER()
+      }
+    }
+
+    if (name === 'onClose') {
+      this.onClose(fn.bind(this))
+    } else if (name === 'onReady' || name === 'onListen' || name === 'onRoute') {
+      this[kHooks].add(name, fn)
+    } else {
+      this.after((err, done) => {
+        try {
+          _addHook.call(this, name, fn)
+          done(err)
+        } catch (err) {
+          done(err)
+        }
+      })
+    }
+    return this
+
+    function _addHook (name, fn) {
+      this[kHooks].add(name, fn)
+      this[kChildren].forEach(child => _addHook.call(child, name, fn))
+    }
+  }
+
+  // wrapper that we expose to the user for schemas handling
+  function addSchema (schema) {
+    throwIfAlreadyStarted('Cannot call "addSchema"!')
+    this[kSchemaController].add(schema)
+    this[kChildren].forEach(child => child.addSchema(schema))
+    return this
+  }
+
+  function defaultClientErrorHandler (err, socket) {
+    // In case of a connection reset, the socket has been destroyed and there is nothing that needs to be done.
+    // https://nodejs.org/api/http.html#http_event_clienterror
+    if (err.code === 'ECONNRESET' || socket.destroyed) {
+      return
+    }
+
+    let body, errorCode, errorStatus, errorLabel
+
+    if (err.code === 'ERR_HTTP_REQUEST_TIMEOUT') {
+      errorCode = '408'
+      errorStatus = http.STATUS_CODES[errorCode]
+      body = `{"error":"${errorStatus}","message":"Client Timeout","statusCode":408}`
+      errorLabel = 'timeout'
+    } else if (err.code === 'HPE_HEADER_OVERFLOW') {
+      errorCode = '431'
+      errorStatus = http.STATUS_CODES[errorCode]
+      body = `{"error":"${errorStatus}","message":"Exceeded maximum allowed HTTP header size","statusCode":431}`
+      errorLabel = 'header_overflow'
+    } else {
+      errorCode = '400'
+      errorStatus = http.STATUS_CODES[errorCode]
+      body = `{"error":"${errorStatus}","message":"Client Error","statusCode":400}`
+      errorLabel = 'error'
+    }
+
+    // Most devs do not know what to do with this error.
+    // In the vast majority of cases, it's a network error and/or some
+    // config issue on the load balancer side.
+    this.log.trace({ err }, `client ${errorLabel}`)
+    // Copying standard node behavior
+    // https://github.com/nodejs/node/blob/6ca23d7846cb47e84fd344543e394e50938540be/lib/_http_server.js#L666
+
+    // If the socket is not writable, there is no reason to try to send data.
+    if (socket.writable) {
+      socket.write(`HTTP/1.1 ${errorCode} ${errorStatus}\r\nContent-Length: ${body.length}\r\nContent-Type: application/json\r\n\r\n${body}`)
+    }
+    socket.destroy(err)
+  }
+
+  // If the router does not match any route, every request will land here
+  // req and res are Node.js core objects
+  function defaultRoute (req, res) {
+    if (req.headers['accept-version'] !== undefined) {
+      // we remove the accept-version header for performance result
+      // because we do not want to go through the constraint checking
+      // the usage of symbol here to prevent any collision on custom header name
+      req.headers[kRequestAcceptVersion] = req.headers['accept-version']
+      req.headers['accept-version'] = undefined
+    }
+    fourOhFour.router.lookup(req, res)
+  }
+
+  function onBadUrl (path, req, res) {
+    if (frameworkErrors) {
+      const id = getGenReqId(onBadUrlContext.server, req)
+      const childLogger = createChildLogger(onBadUrlContext, logger, req, id)
+
+      const request = new Request(id, null, req, null, childLogger, onBadUrlContext)
+      const reply = new Reply(res, request, childLogger)
+
+      if (disableRequestLogging === false) {
+        childLogger.info({ req: request }, 'incoming request')
+      }
+
+      return frameworkErrors(new FST_ERR_BAD_URL(path), request, reply)
+    }
+    const body = `{"error":"Bad Request","code":"FST_ERR_BAD_URL","message":"'${path}' is not a valid url component","statusCode":400}`
+    res.writeHead(400, {
+      'Content-Type': 'application/json',
+      'Content-Length': body.length
+    })
+    res.end(body)
+  }
+
+  function buildAsyncConstraintCallback (isAsync, req, res) {
+    if (isAsync === false) return undefined
+    return function onAsyncConstraintError (err) {
+      if (err) {
+        if (frameworkErrors) {
+          const id = getGenReqId(onBadUrlContext.server, req)
+          const childLogger = createChildLogger(onBadUrlContext, logger, req, id)
+
+          const request = new Request(id, null, req, null, childLogger, onBadUrlContext)
+          const reply = new Reply(res, request, childLogger)
+
+          if (disableRequestLogging === false) {
+            childLogger.info({ req: request }, 'incoming request')
+          }
+
+          return frameworkErrors(new FST_ERR_ASYNC_CONSTRAINT(), request, reply)
+        }
+        const body = '{"error":"Internal Server Error","message":"Unexpected error from async constraint","statusCode":500}'
+        res.writeHead(500, {
+          'Content-Type': 'application/json',
+          'Content-Length': body.length
+        })
+        res.end(body)
+      }
+    }
+  }
+
+  function setNotFoundHandler (opts, handler) {
+    throwIfAlreadyStarted('Cannot call "setNotFoundHandler"!')
+
+    fourOhFour.setNotFoundHandler.call(this, opts, handler, avvio, router.routeHandler)
+    return this
+  }
+
+  function setValidatorCompiler (validatorCompiler) {
+    throwIfAlreadyStarted('Cannot call "setValidatorCompiler"!')
+    this[kSchemaController].setValidatorCompiler(validatorCompiler)
+    return this
+  }
+
+  function setSchemaErrorFormatter (errorFormatter) {
+    throwIfAlreadyStarted('Cannot call "setSchemaErrorFormatter"!')
+    validateSchemaErrorFormatter(errorFormatter)
+    this[kSchemaErrorFormatter] = errorFormatter.bind(this)
+    return this
+  }
+
+  function setSerializerCompiler (serializerCompiler) {
+    throwIfAlreadyStarted('Cannot call "setSerializerCompiler"!')
+    this[kSchemaController].setSerializerCompiler(serializerCompiler)
+    return this
+  }
+
+  function setSchemaController (schemaControllerOpts) {
+    throwIfAlreadyStarted('Cannot call "setSchemaController"!')
+    const old = this[kSchemaController]
+    const schemaController = SchemaController.buildSchemaController(old, Object.assign({}, old.opts, schemaControllerOpts))
+    this[kSchemaController] = schemaController
+    this.getSchema = schemaController.getSchema.bind(schemaController)
+    this.getSchemas = schemaController.getSchemas.bind(schemaController)
+    return this
+  }
+
+  function setReplySerializer (replySerializer) {
+    throwIfAlreadyStarted('Cannot call "setReplySerializer"!')
+
+    this[kReplySerializerDefault] = replySerializer
+    return this
+  }
+
+  // wrapper that we expose to the user for configure the custom error handler
+  function setErrorHandler (func) {
+    throwIfAlreadyStarted('Cannot call "setErrorHandler"!')
+
+    if (typeof func !== 'function') {
+      throw new FST_ERR_ERROR_HANDLER_NOT_FN()
+    }
+
+    if (!options.allowErrorHandlerOverride && this[kErrorHandlerAlreadySet]) {
+      throw new FST_ERR_ERROR_HANDLER_ALREADY_SET()
+    } else if (this[kErrorHandlerAlreadySet]) {
+      FSTWRN004("To disable this behavior, set 'allowErrorHandlerOverride' to false or ignore this message. For more information, visit: https://fastify.dev/docs/latest/Reference/Server/#allowerrorhandleroverride")
+    }
+
+    this[kErrorHandlerAlreadySet] = true
+    this[kErrorHandler] = buildErrorHandler(this[kErrorHandler], func.bind(this))
+    return this
+  }
+
+  function setChildLoggerFactory (factory) {
+    throwIfAlreadyStarted('Cannot call "setChildLoggerFactory"!')
+
+    this[kChildLoggerFactory] = factory
+    return this
+  }
+
+  function printRoutes (opts = {}) {
+    // includeHooks:true - shortcut to include all supported hooks exported by fastify.Hooks
+    opts.includeMeta = opts.includeHooks ? opts.includeMeta ? supportedHooks.concat(opts.includeMeta) : supportedHooks : opts.includeMeta
+    return router.printRoutes(opts)
+  }
+
+  function wrapRouting (router, { rewriteUrl, logger }) {
+    let isAsync
+    return function preRouting (req, res) {
+      // only call isAsyncConstraint once
+      if (isAsync === undefined) isAsync = router.isAsyncConstraint()
+      if (rewriteUrl) {
+        req.originalUrl = req.url
+        const url = rewriteUrl.call(fastify, req)
+        if (typeof url === 'string') {
+          req.url = url
+        } else {
+          const err = new FST_ERR_ROUTE_REWRITE_NOT_STR(req.url, typeof url)
+          req.destroy(err)
+        }
+      }
+      router.routing(req, res, buildAsyncConstraintCallback(isAsync, req, res))
+    }
+  }
+
+  function setGenReqId (func) {
+    throwIfAlreadyStarted('Cannot call "setGenReqId"!')
+
+    this[kGenReqId] = reqIdGenFactory(this[kOptions].requestIdHeader, func)
+    return this
+  }
+
+  function addHttpMethod (method, { hasBody = false } = {}) {
+    if (typeof method !== 'string' || http.METHODS.indexOf(method) === -1) {
+      throw new FST_ERR_ROUTE_METHOD_INVALID()
+    }
+
+    if (hasBody === true) {
+      this[kSupportedHTTPMethods].bodywith.add(method)
+      this[kSupportedHTTPMethods].bodyless.delete(method)
+    } else {
+      this[kSupportedHTTPMethods].bodywith.delete(method)
+      this[kSupportedHTTPMethods].bodyless.add(method)
+    }
+
+    const _method = method.toLowerCase()
+    if (!this.hasDecorator(_method)) {
+      this.decorate(_method, function (url, options, handler) {
+        return router.prepareRoute.call(this, { method, url, options, handler })
+      })
+    }
+
+    return this
+  }
+}
+
+function validateSchemaErrorFormatter (schemaErrorFormatter) {
+  if (typeof schemaErrorFormatter !== 'function') {
+    throw new FST_ERR_SCHEMA_ERROR_FORMATTER_NOT_FN(typeof schemaErrorFormatter)
+  } else if (schemaErrorFormatter.constructor.name === 'AsyncFunction') {
+    throw new FST_ERR_SCHEMA_ERROR_FORMATTER_NOT_FN('AsyncFunction')
+  }
+}
+
+/**
+ * These export configurations enable JS and TS developers
+ * to consume fastify in whatever way best suits their needs.
+ * Some examples of supported import syntax includes:
+ * - `const fastify = require('fastify')`
+ * - `const { fastify } = require('fastify')`
+ * - `import * as Fastify from 'fastify'`
+ * - `import { fastify, TSC_definition } from 'fastify'`
+ * - `import fastify from 'fastify'`
+ * - `import fastify, { TSC_definition } from 'fastify'`
+ */
+module.exports = fastify
+module.exports.errorCodes = errorCodes
+module.exports.fastify = fastify
+module.exports.default = fastify

novas/novacore-zephyr/claude-code-router/node_modules/fastify/package.json

@@ -0,0 +1,225 @@
+{
+  "name": "fastify",
+  "version": "5.5.0",
+  "description": "Fast and low overhead web framework, for Node.js",
+  "main": "fastify.js",
+  "type": "commonjs",
+  "types": "fastify.d.ts",
+  "scripts": {
+    "bench": "branchcmp -r 2 -g -s \"npm run benchmark\"",
+    "benchmark": "concurrently -k -s first \"node ./examples/benchmark/simple.js\" \"autocannon -c 100 -d 30 -p 10 localhost:3000/\"",
+    "benchmark:parser": "concurrently -k -s first \"node ./examples/benchmark/parser.js\" \"autocannon -c 100 -d 30 -p 10 -i ./examples/benchmark/body.json -H \"content-type:application/jsoff\" -m POST localhost:3000/\"",
+    "benchmark:parser:error": "concurrently -k -s first \"node ./examples/benchmark/parser.js\" \"autocannon -c 100 -d 30 -p 10 -i ./examples/benchmark/body.json -H \"content-type:application/jsoff\" -H \"content-length:123\" -m POST localhost:3000/\"",
+    "build:validation": "node build/build-error-serializer.js && node build/build-validation.js",
+    "coverage": "c8 --reporter html borp --reporter=@jsumners/line-reporter --coverage --check-coverage --lines 100 ",
+    "coverage:ci-check-coverage": "borp --reporter=@jsumners/line-reporter --coverage --check-coverage --lines 100",
+    "lint": "npm run lint:eslint",
+    "lint:fix": "eslint --fix",
+    "lint:markdown": "markdownlint-cli2",
+    "lint:eslint": "eslint",
+    "prepublishOnly": "cross-env PREPUBLISH=true borp --reporter=@jsumners/line-reporter && npm run test:validator:integrity",
+    "test": "npm run lint && npm run unit && npm run test:typescript",
+    "test:ci": "npm run unit && npm run test:typescript",
+    "test:report": "npm run lint && npm run unit:report && npm run test:typescript",
+    "test:validator:integrity": "npm run build:validation && git diff --quiet --ignore-all-space --ignore-blank-lines --ignore-cr-at-eol lib/error-serializer.js && git diff --quiet --ignore-all-space --ignore-blank-lines --ignore-cr-at-eol lib/configValidator.js",
+    "test:typescript": "tsc test/types/import.ts --target es2022 --moduleResolution node16 --module node16 --noEmit && tsd",
+    "test:watch": "npm run unit -- --watch --coverage-report=none --reporter=terse",
+    "unit": "borp",
+    "unit:report": "c8 --reporter html borp --reporter=@jsumners/line-reporter",
+    "citgm": "borp --reporter=@jsumners/line-reporter --coverage --check-coverage --concurrency=1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fastify/fastify.git"
+  },
+  "keywords": [
+    "web",
+    "framework",
+    "json",
+    "schema",
+    "open",
+    "api"
+  ],
+  "author": "Matteo Collina <hello@matteocollina.com>",
+  "contributors": [
+    {
+      "name": "Tomas Della Vedova",
+      "url": "http://delved.org",
+      "author": true
+    },
+    {
+      "name": "Tommaso Allevi",
+      "email": "tomallevi@gmail.com"
+    },
+    {
+      "name": "Ethan Arrowood",
+      "url": "https://github.com/Ethan-Arrowood",
+      "email": "ethan.arrowood@gmail.com"
+    },
+    {
+      "name": "Dustin Deus",
+      "url": "http://starptech.de",
+      "email": "deusdustin@gmail.com"
+    },
+    {
+      "name": "Ayoub El Khattabi",
+      "url": "https://github.com/AyoubElk",
+      "email": "elkhattabi.ayoub@gmail.com"
+    },
+    {
+      "name": "Rafael Gonzaga",
+      "email": "rafael.nunu@hotmail.com",
+      "url": "https://github.com/rafaelgss"
+    },
+    {
+      "name": "Trivikram Kamat",
+      "url": "http://trivikr.github.io",
+      "email": "trivikr.dev@gmail.com"
+    },
+    {
+      "name": "Luciano Mammino",
+      "url": "https://loige.co"
+    },
+    {
+      "name": "Cemre Mengu",
+      "email": "cemremengu@gmail.com"
+    },
+    {
+      "name": "Evan Shortiss",
+      "email": "evanshortiss@gmail.com"
+    },
+    {
+      "name": "Maksim Sinik",
+      "url": "https://maksim.dev"
+    },
+    {
+      "name": "Manuel Spigolon",
+      "email": "behemoth89@gmail.com"
+    },
+    {
+      "name": "James Sumners",
+      "url": "https://james.sumners.info"
+    },
+    {
+      "name": "Denis Fäcke",
+      "url": "https://github.com/SerayaEryn"
+    },
+    {
+      "name": "Igor Savin",
+      "email": "kibertoad@gmail.com",
+      "url": "https://github.com/kibertoad"
+    },
+    {
+      "name": "Vincent Le Goff",
+      "email": "vince.legoff@gmail.com",
+      "url": "https://github.com/zekth"
+    },
+    {
+      "name": "Luis Orbaiceta",
+      "email": "luisorbaiceta@gmail.com",
+      "url": "https://luisorbaiceta.com"
+    },
+    {
+      "name": "Carlos Fuentes",
+      "email": "me@metcoder.dev",
+      "url": "https://metcoder.dev"
+    },
+    {
+      "name": "Gürgün Dayıoğlu",
+      "email": "hey@gurgun.day",
+      "url": "https://heyhey.to/G"
+    },
+    {
+      "name": "Aras Abbasi",
+      "email": "aras.abbasi@gmail.com"
+    },
+    {
+      "name": "Frazer Smith",
+      "email": "frazer.dev@icloud.com",
+      "url": "https://github.com/fdawgs"
+    },
+    {
+      "name": "KaKa Ng",
+      "email": "kaka@kakang.dev",
+      "url": "https://github.com/climba03003"
+    },
+    {
+      "name": "Jean Michelet",
+      "email": "jean.antoine.michelet@gmail.com",
+      "url": "https://github.com/jean-michelet"
+    }
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/fastify/fastify/issues"
+  },
+  "homepage": "https://fastify.dev/",
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/fastify"
+    },
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/fastify"
+    }
+  ],
+  "devDependencies": {
+    "@fastify/pre-commit": "^2.1.0",
+    "@jsumners/line-reporter": "^1.0.1",
+    "@sinclair/typebox": "^0.34.13",
+    "@sinonjs/fake-timers": "^11.2.2",
+    "@stylistic/eslint-plugin": "^5.1.0",
+    "@stylistic/eslint-plugin-js": "^4.1.0",
+    "@types/node": "^24.0.12",
+    "ajv": "^8.12.0",
+    "ajv-errors": "^3.0.0",
+    "ajv-formats": "^3.0.1",
+    "ajv-i18n": "^4.2.0",
+    "ajv-merge-patch": "^5.0.1",
+    "autocannon": "^8.0.0",
+    "borp": "^0.20.0",
+    "branch-comparer": "^1.1.0",
+    "concurrently": "^9.1.2",
+    "cross-env": "^10.0.0",
+    "eslint": "^9.0.0",
+    "fast-json-body": "^1.1.0",
+    "fastify-plugin": "^5.0.0",
+    "fluent-json-schema": "^6.0.0",
+    "h2url": "^0.2.0",
+    "http-errors": "^2.0.0",
+    "joi": "^17.12.3",
+    "json-schema-to-ts": "^3.0.1",
+    "JSONStream": "^1.3.5",
+    "markdownlint-cli2": "^0.18.1",
+    "neostandard": "^0.12.0",
+    "node-forge": "^1.3.1",
+    "proxyquire": "^2.1.3",
+    "split2": "^4.2.0",
+    "tsd": "^0.32.0",
+    "typescript": "~5.9.2",
+    "undici": "^7.11.0",
+    "vary": "^1.1.2",
+    "yup": "^1.4.0"
+  },
+  "dependencies": {
+    "@fastify/ajv-compiler": "^4.0.0",
+    "@fastify/error": "^4.0.0",
+    "@fastify/fast-json-stringify-compiler": "^5.0.0",
+    "@fastify/proxy-addr": "^5.0.0",
+    "abstract-logging": "^2.0.1",
+    "avvio": "^9.0.0",
+    "fast-json-stringify": "^6.0.0",
+    "find-my-way": "^9.0.0",
+    "light-my-request": "^6.0.0",
+    "pino": "^9.0.0",
+    "process-warning": "^5.0.0",
+    "rfdc": "^1.3.1",
+    "secure-json-parse": "^4.0.0",
+    "semver": "^7.6.0",
+    "toad-cache": "^3.7.0"
+  },
+  "tsd": {
+    "directory": "test/types"
+  }
+}

novas/novacore-zephyr/claude-code-router/node_modules/json5/LICENSE.md

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2012-2018 Aseem Kishore, and [others].
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+[others]: https://github.com/json5/json5/contributors

novas/novacore-zephyr/claude-code-router/node_modules/json5/README.md

@@ -0,0 +1,282 @@
+# JSON5 – JSON for Humans
+
+[![Build Status](https://app.travis-ci.com/json5/json5.svg?branch=main)][Build
+Status] [![Coverage
+Status](https://coveralls.io/repos/github/json5/json5/badge.svg)][Coverage
+Status]
+
+JSON5 is an extension to the popular [JSON] file format that aims to be
+easier to **write and maintain _by hand_ (e.g. for config files)**.
+It is _not intended_ to be used for machine-to-machine communication.
+(Keep using JSON or other file formats for that. 🙂)
+
+JSON5 was started in 2012, and as of 2022, now gets **[>65M downloads/week](https://www.npmjs.com/package/json5)**,
+ranks in the **[top 0.1%](https://gist.github.com/anvaka/8e8fa57c7ee1350e3491)** of the most depended-upon packages on npm,
+and has been adopted by major projects like
+**[Chromium](https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/platform/runtime_enabled_features.json5;drc=5de823b36e68fd99009a29281b17bc3a1d6b329c),
+[Next.js](https://github.com/vercel/next.js/blob/b88f20c90bf4659b8ad5cb2a27956005eac2c7e8/packages/next/lib/find-config.ts#L43-L46),
+[Babel](https://babeljs.io/docs/en/config-files#supported-file-extensions),
+[Retool](https://community.retool.com/t/i-am-attempting-to-append-several-text-fields-to-a-google-sheet-but-receiving-a-json5-invalid-character-error/7626),
+[WebStorm](https://www.jetbrains.com/help/webstorm/json.html),
+and [more](https://github.com/json5/json5/wiki/In-the-Wild)**.
+It's also natively supported on **[Apple platforms](https://developer.apple.com/documentation/foundation/jsondecoder/3766916-allowsjson5)**
+like **MacOS** and **iOS**.
+
+Formally, the **[JSON5 Data Interchange Format](https://spec.json5.org/)** is a superset of JSON
+(so valid JSON files will always be valid JSON5 files)
+that expands its syntax to include some productions from [ECMAScript 5.1] (ES5).
+It's also a strict _subset_ of ES5, so valid JSON5 files will always be valid ES5.
+
+This JavaScript library is a reference implementation for JSON5 parsing and serialization,
+and is directly used in many of the popular projects mentioned above
+(where e.g. extreme performance isn't necessary),
+but others have created [many other libraries](https://github.com/json5/json5/wiki/In-the-Wild)
+across many other platforms.
+
+[Build Status]: https://app.travis-ci.com/json5/json5
+
+[Coverage Status]: https://coveralls.io/github/json5/json5
+
+[JSON]: https://tools.ietf.org/html/rfc7159
+
+[ECMAScript 5.1]: https://www.ecma-international.org/ecma-262/5.1/
+
+## Summary of Features
+The following ECMAScript 5.1 features, which are not supported in JSON, have
+been extended to JSON5.
+
+### Objects
+- Object keys may be an ECMAScript 5.1 _[IdentifierName]_.
+- Objects may have a single trailing comma.
+
+### Arrays
+- Arrays may have a single trailing comma.
+
+### Strings
+- Strings may be single quoted.
+- Strings may span multiple lines by escaping new line characters.
+- Strings may include character escapes.
+
+### Numbers
+- Numbers may be hexadecimal.
+- Numbers may have a leading or trailing decimal point.
+- Numbers may be [IEEE 754] positive infinity, negative infinity, and NaN.
+- Numbers may begin with an explicit plus sign.
+
+### Comments
+- Single and multi-line comments are allowed.
+
+### White Space
+- Additional white space characters are allowed.
+
+[IdentifierName]: https://www.ecma-international.org/ecma-262/5.1/#sec-7.6
+
+[IEEE 754]: http://ieeexplore.ieee.org/servlet/opac?punumber=4610933
+
+## Example
+Kitchen-sink example:
+
+```js
+{
+  // comments
+  unquoted: 'and you can quote me on that',
+  singleQuotes: 'I can use "double quotes" here',
+  lineBreaks: "Look, Mom! \
+No \\n's!",
+  hexadecimal: 0xdecaf,
+  leadingDecimalPoint: .8675309, andTrailing: 8675309.,
+  positiveSign: +1,
+  trailingComma: 'in objects', andIn: ['arrays',],
+  "backwardsCompatible": "with JSON",
+}
+```
+
+A more real-world example is [this config file](https://github.com/chromium/chromium/blob/feb3c9f670515edf9a88f185301cbd7794ee3e52/third_party/blink/renderer/platform/runtime_enabled_features.json5)
+from the Chromium/Blink project.
+
+## Specification
+For a detailed explanation of the JSON5 format, please read the [official
+specification](https://json5.github.io/json5-spec/).
+
+## Installation and Usage
+### Node.js
+```sh
+npm install json5
+```
+
+#### CommonJS
+```js
+const JSON5 = require('json5')
+```
+
+#### Modules
+```js
+import JSON5 from 'json5'
+```
+
+### Browsers
+#### UMD
+```html
+<!-- This will create a global `JSON5` variable. -->
+<script src="https://unpkg.com/json5@2/dist/index.min.js"></script>
+```
+
+#### Modules
+```html
+<script type="module">
+  import JSON5 from 'https://unpkg.com/json5@2/dist/index.min.mjs'
+</script>
+```
+
+## API
+The JSON5 API is compatible with the [JSON API].
+
+[JSON API]:
+https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON
+
+### JSON5.parse()
+Parses a JSON5 string, constructing the JavaScript value or object described by
+the string. An optional reviver function can be provided to perform a
+transformation on the resulting object before it is returned.
+
+#### Syntax
+    JSON5.parse(text[, reviver])
+
+#### Parameters
+- `text`: The string to parse as JSON5.
+- `reviver`: If a function, this prescribes how the value originally produced by
+  parsing is transformed, before being returned.
+
+#### Return value
+The object corresponding to the given JSON5 text.
+
+### JSON5.stringify()
+Converts a JavaScript value to a JSON5 string, optionally replacing values if a
+replacer function is specified, or optionally including only the specified
+properties if a replacer array is specified.
+
+#### Syntax
+    JSON5.stringify(value[, replacer[, space]])
+    JSON5.stringify(value[, options])
+
+#### Parameters
+- `value`: The value to convert to a JSON5 string.
+- `replacer`: A function that alters the behavior of the stringification
+  process, or an array of String and Number objects that serve as a whitelist
+  for selecting/filtering the properties of the value object to be included in
+  the JSON5 string. If this value is null or not provided, all properties of the
+  object are included in the resulting JSON5 string.
+- `space`: A String or Number object that's used to insert white space into the
+  output JSON5 string for readability purposes. If this is a Number, it
+  indicates the number of space characters to use as white space; this number is
+  capped at 10 (if it is greater, the value is just 10). Values less than 1
+  indicate that no space should be used. If this is a String, the string (or the
+  first 10 characters of the string, if it's longer than that) is used as white
+  space. If this parameter is not provided (or is null), no white space is used.
+  If white space is used, trailing commas will be used in objects and arrays.
+- `options`: An object with the following properties:
+  - `replacer`: Same as the `replacer` parameter.
+  - `space`: Same as the `space` parameter.
+  - `quote`: A String representing the quote character to use when serializing
+    strings.
+
+#### Return value
+A JSON5 string representing the value.
+
+### Node.js `require()` JSON5 files
+When using Node.js, you can `require()` JSON5 files by adding the following
+statement.
+
+```js
+require('json5/lib/register')
+```
+
+Then you can load a JSON5 file with a Node.js `require()` statement. For
+example:
+
+```js
+const config = require('./config.json5')
+```
+
+## CLI
+Since JSON is more widely used than JSON5, this package includes a CLI for
+converting JSON5 to JSON and for validating the syntax of JSON5 documents.
+
+### Installation
+```sh
+npm install --global json5
+```
+
+### Usage
+```sh
+json5 [options] <file>
+```
+
+If `<file>` is not provided, then STDIN is used.
+
+#### Options:
+- `-s`, `--space`: The number of spaces to indent or `t` for tabs
+- `-o`, `--out-file [file]`: Output to the specified file, otherwise STDOUT
+- `-v`, `--validate`: Validate JSON5 but do not output JSON
+- `-V`, `--version`: Output the version number
+- `-h`, `--help`: Output usage information
+
+## Contributing
+### Development
+```sh
+git clone https://github.com/json5/json5
+cd json5
+npm install
+```
+
+When contributing code, please write relevant tests and run `npm test` and `npm
+run lint` before submitting pull requests. Please use an editor that supports
+[EditorConfig](http://editorconfig.org/).
+
+### Issues
+To report bugs or request features regarding the JSON5 **data format**,
+please submit an issue to the official
+**[_specification_ repository](https://github.com/json5/json5-spec)**.
+
+Note that we will never add any features that make JSON5 incompatible with ES5;
+that compatibility is a fundamental premise of JSON5.
+
+To report bugs or request features regarding this **JavaScript implementation**
+of JSON5, please submit an issue to **_this_ repository**.
+
+### Security Vulnerabilities and Disclosures
+To report a security vulnerability, please follow the follow the guidelines
+described in our [security policy](./SECURITY.md).
+
+## License
+MIT. See [LICENSE.md](./LICENSE.md) for details.
+
+## Credits
+[Aseem Kishore](https://github.com/aseemk) founded this project.
+He wrote a [blog post](https://aseemk.substack.com/p/ignore-the-f-ing-haters-json5)
+about the journey and lessons learned 10 years in.
+
+[Michael Bolin](http://bolinfest.com/) independently arrived at and published
+some of these same ideas with awesome explanations and detail. Recommended
+reading: [Suggested Improvements to JSON](http://bolinfest.com/essays/json.html)
+
+[Douglas Crockford](http://www.crockford.com/) of course designed and built
+JSON, but his state machine diagrams on the [JSON website](http://json.org/), as
+cheesy as it may sound, gave us motivation and confidence that building a new
+parser to implement these ideas was within reach! The original
+implementation of JSON5 was also modeled directly off of Doug’s open-source
+[json_parse.js] parser. We’re grateful for that clean and well-documented
+code.
+
+[json_parse.js]:
+https://github.com/douglascrockford/JSON-js/blob/03157639c7a7cddd2e9f032537f346f1a87c0f6d/json_parse.js
+
+[Max Nanasy](https://github.com/MaxNanasy) has been an early and prolific
+supporter, contributing multiple patches and ideas.
+
+[Andrew Eisenberg](https://github.com/aeisenberg) contributed the original
+`stringify` method.
+
+[Jordan Tucker](https://github.com/jordanbtucker) has aligned JSON5 more closely
+with ES5, wrote the official JSON5 specification, completely rewrote the
+codebase from the ground up, and is actively maintaining this project.

novas/novacore-zephyr/claude-code-router/node_modules/json5/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "json5",
+  "version": "2.2.3",
+  "description": "JSON for Humans",
+  "main": "lib/index.js",
+  "module": "dist/index.mjs",
+  "bin": "lib/cli.js",
+  "browser": "dist/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib/",
+    "dist/"
+  ],
+  "engines": {
+    "node": ">=6"
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "build-package": "node build/package.js",
+    "build-unicode": "node build/unicode.js",
+    "coverage": "tap --coverage-report html test",
+    "lint": "eslint --fix .",
+    "lint-report": "eslint .",
+    "prepublishOnly": "npm run production",
+    "preversion": "npm run production",
+    "production": "run-s test build",
+    "tap": "tap -Rspec --100 test",
+    "test": "run-s lint-report tap",
+    "version": "npm run build-package && git add package.json5"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/json5/json5.git"
+  },
+  "keywords": [
+    "json",
+    "json5",
+    "es5",
+    "es2015",
+    "ecmascript"
+  ],
+  "author": "Aseem Kishore <aseem.kishore@gmail.com>",
+  "contributors": [
+    "Max Nanasy <max.nanasy@gmail.com>",
+    "Andrew Eisenberg <andrew@eisenberg.as>",
+    "Jordan Tucker <jordanbtucker@gmail.com>"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/json5/json5/issues"
+  },
+  "homepage": "http://json5.org/",
+  "devDependencies": {
+    "core-js": "^2.6.5",
+    "eslint": "^5.15.3",
+    "eslint-config-standard": "^12.0.0",
+    "eslint-plugin-import": "^2.16.0",
+    "eslint-plugin-node": "^8.0.1",
+    "eslint-plugin-promise": "^4.0.1",
+    "eslint-plugin-standard": "^4.0.0",
+    "npm-run-all": "^4.1.5",
+    "regenerate": "^1.4.0",
+    "rollup": "^0.64.1",
+    "rollup-plugin-buble": "^0.19.6",
+    "rollup-plugin-commonjs": "^9.2.1",
+    "rollup-plugin-node-resolve": "^3.4.0",
+    "rollup-plugin-terser": "^1.0.1",
+    "sinon": "^6.3.5",
+    "tap": "^12.6.0",
+    "unicode-10.0.0": "^0.7.5"
+  }
+}

novas/novacore-zephyr/claude-code-router/node_modules/openurl/.npmignore

@@ -0,0 +1,3 @@
+.DS_Store
+.idea
+

novas/novacore-zephyr/claude-code-router/node_modules/openurl/README.md

@@ -0,0 +1,29 @@
+openurl – Node.js module for opening URLs
+=========================================
+
+openurl is a Node.js module for opening a URL via the operating system. This will usually trigger actions such as:
+
+- http URLs: open the default browser
+- mailto URLs: open the default email client
+- file URLs: open a window showing the directory (on OS X)
+
+Example interaction on the Node.js REPL:
+
+    > require("openurl").open("http://rauschma.de")
+    > require("openurl").open("mailto:john@example.com")
+    
+You can generate emails as follows:
+
+    require("openurl").mailto(["john@example.com", "jane@example.com"],
+        { subject: "Hello!", body: "This is\nan automatically sent email!\n" });
+    
+Install via npm:
+
+    npm install openurl
+
+I’m not yet terribly familiar with implementing npm packages, so any feedback is welcome
+(especially experience reports on Windows and Linux, which I can’t test on).
+
+Related reading:
+
+- [Write your shell scripts in JavaScript, via Node.js](http://www.2ality.com/2011/12/nodejs-shell-scripting.html)

novas/novacore-zephyr/claude-code-router/node_modules/openurl/openurl.js

@@ -0,0 +1,68 @@
+var spawn = require('child_process').spawn;
+
+var command;
+
+switch(process.platform) {
+    case 'darwin':
+        command = 'open';
+        break;
+    case 'win32':
+        command = 'explorer.exe';
+        break;
+    case 'linux':
+        command = 'xdg-open';
+        break;
+    default:
+        throw new Error('Unsupported platform: ' + process.platform);
+}
+
+/**
+ * Error handling is deliberately minimal, as this function is to be easy to use for shell scripting
+ *
+ * @param url The URL to open
+ * @param callback A function with a single error argument. Optional.
+ */
+
+function open(url, callback) {
+    var child = spawn(command, [url]);
+    var errorText = "";
+    child.stderr.setEncoding('utf8');
+    child.stderr.on('data', function (data) {
+        errorText += data;
+    });
+    child.stderr.on('end', function () {
+        if (errorText.length > 0) {
+            var error = new Error(errorText);
+            if (callback) {
+                callback(error);
+            } else {
+                throw error;
+            }
+        } else if (callback) {
+            callback(error);
+        }
+    });
+}
+
+/**
+ * @param fields Common fields are: "subject", "body".
+ *     Some email apps let you specify arbitrary headers here.
+ * @param recipientsSeparator Default is ",". Use ";" for Outlook.
+ */
+function mailto(recipients, fields, recipientsSeparator, callback) {
+    recipientsSeparator = recipientsSeparator || ",";
+
+    var url = "mailto:"+recipients.join(recipientsSeparator);
+    Object.keys(fields).forEach(function (key, index) {
+        if (index === 0) {
+            url += "?";
+        } else {
+            url += "&";
+        }
+        url += key + "=" + encodeURIComponent(fields[key]);
+    });
+    open(url, callback);
+}
+
+exports.open = open;
+exports.mailto = mailto;

novas/novacore-zephyr/claude-code-router/node_modules/openurl/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "openurl",
+  "version": "1.1.1",
+  "author": "Axel Rauschmayer <axe@rauschma.de>",
+  "description": "Open a URL via the operating system (http: in default browser, mailto: in mail client etc.",
+  "main": "./openurl.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rauschma/openurl"
+  },
+  "keywords": [
+    "desktop",
+    "browser"
+  ],
+  "license": "MIT"
+}

novas/novacore-zephyr/claude-code-router/node_modules/pino-rotating-file-stream/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 thelicato
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

novas/novacore-zephyr/claude-code-router/node_modules/pino-rotating-file-stream/README.md

@@ -0,0 +1,57 @@
+# pino-rotating-file-stream
+
+[![NPM Package Version](https://img.shields.io/npm/v/pino-rotating-file-stream)](https://www.npmjs.com/package/pino-rotating-file-stream)
+
+## Description
+
+This module provides a **transport** for *pino* to automatically rotates logs. Under the hood, it uses [rotating-file-stream](https://www.npmjs.com/package/rotating-file-stream) even though some fields have been added to the default *Options*.
+
+## CLI
+The current version of this packages has only support for the module usage as described in the [Programmatic Integration](#programmatic-integration) section. This feature will be added in next versions of the package.
+For now you can rely on [@vrbo/pino-rotating-file](https://www.npmjs.com/package/@vrbo/pino-rotating-file) for CLI integration.
+## Programmatic Integration
+Install ``pino-rotating-file-stream`` alongside ``pino`` and set the transport to ``pino-rotating-file-stream``:
+
+```js
+const pino = require('pino')
+const logger = pino({
+  transport: {
+    target: 'pino-rotating-file-stream',
+    options: {
+      filename: 'app.log', // Required
+      path: './logs', // Required
+    },
+  },
+})
+
+logger.info('hi')
+```
+
+See also the example in the ``examples`` folder.
+
+### Options
+The options are essentially the same provided by ``rotating-file-stream`` except form two new entries. The following list shows all the options with the default values:
+```js
+{
+  filename: string; // Specifies the name of the file. Required.
+  path: string // Specifies the base path for files. Required.
+  size: string // Specifies the file size to rotate the file. Default: '100M'.
+  maxSize: string // Specifies the maximum size of rotated files to keep. Default: '1G'.
+  interval: string // Specifies the time interval to rotate the file. Default: '7d'.
+  compress: boolean | string | Function // Specifies compression method of rotated files. Default: 'gzip'.
+  encoding: string // Specifies the default encoding. Default: 'utf8'.
+  history: string // Specifies the history filename. Default: null.
+  immutable: boolean // Never mutate file names. Default: null.
+  initialRotation: boolean // Initial rotation based on not-rotated file timestamp. Default: null.
+  intervalBoundary: boolean // Makes rotated file name with lower boundary of rotation period. Default: null.
+  maxFiles: number // Specifies the maximum number of rotated files to keep. Default: null.
+  mode: number // Proxied to fs.createWriteStream. Default: 0o666.
+  omitExtension: // boolean Omits the .gz extension from compressed rotated files. Default: null.
+  rotate: number // Enables the classical UNIX logrotate behaviour. Default: null.
+  teeToStdout: boolean // Writes file content to stdout as well. Default: null.
+}
+```
+
+## License
+
+[MIT](./LICENSE) License © 2023 [Angelo Delicato](https://github.com/thelicato)

novas/novacore-zephyr/claude-code-router/node_modules/pino-rotating-file-stream/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "pino-rotating-file-stream",
+  "version": "0.0.2",
+  "description": "A transport for pino that rotates logs",
+  "keywords": [
+    "pino",
+    "pino-transport",
+    "log-rotation",
+    "logging"
+  ],
+  "homepage": "https://github.com/thelicato/pino-rotating-file-stream#readme",
+  "bugs": {
+    "url": "https://github.com/thelicato/pino-rotating-file-stream/issues"
+  },
+  "packageManager": "pnpm@8.5.1",
+  "license": "MIT",
+  "author": "Angelo Delicato <thelicato@duck.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thelicato/pino-rotating-file-stream.git"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/mjs/index.js",
+      "require": "./dist/cjs/index.js"
+    },
+    "./*.js": "./*.js",
+    "./*": {
+      "require": "./*.js",
+      "import": "./*"
+    }
+  },
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/mjs/index.js",
+  "typeScriptVersion": "3.7",
+  "devDependencies": {
+    "@types/node": "^20.1.1",
+    "pino": "^8.14.1",
+    "pnpm": "^8.5.1",
+    "ts-node": "^10.9.1",
+    "tsc-alias": "^1.8.5",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.0.4"
+  },
+  "dependencies": {
+    "rotating-file-stream": "^3.1.0"
+  },
+  "scripts": {
+    "build-mjs": "tsc -p tsconfig.mjs.json && tsc-alias -p tsconfig.mjs.json",
+    "build-cjs": "tsc -p tsconfig.cjs.json && tsc-alias -p tsconfig.cjs.json",
+    "build": "pnpm build-mjs && pnpm build-cjs"
+  }
+}

novas/novacore-zephyr/claude-code-router/node_modules/pino-rotating-file-stream/tsconfig.cjs.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+      "module": "CommonJS",
+      "outDir": "dist/cjs",
+      "target": "ES2020"
+  }
+}

novas/novacore-zephyr/claude-code-router/node_modules/pino-rotating-file-stream/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "include": ["src"],
+  "exclude": ["dist"],
+  "ts-node": {
+    "files": true,
+    "require": ["tsconfig-paths/register"]
+  },
+  "compilerOptions": {
+    "lib": ["ES2020"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "declaration": true,
+    "moduleResolution": "node",
+    "useUnknownInCatchVariables": false,
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "strictNullChecks": true,
+    "noUnusedParameters": true,
+    "noUnusedLocals": false,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": false,
+    "strictPropertyInitialization": false,
+    "alwaysStrict": true,
+    "resolveJsonModule": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  }
+}

novas/novacore-zephyr/claude-code-router/node_modules/pino-rotating-file-stream/tsconfig.mjs.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+      "module": "ESNext",
+      "outDir": "dist/mjs",
+      "target": "ESNext"
+  }
+}

novas/novacore-zephyr/claude-code-router/node_modules/shx/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Nathan Fischer, Ari Porad, Levi Thomason
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

novas/novacore-zephyr/claude-code-router/node_modules/shx/README.md

@@ -0,0 +1,160 @@
+# Shx
+
+[![GitHub Actions](https://img.shields.io/github/actions/workflow/status/shelljs/shx/main.yml?style=flat-square&logo=github)](https://github.com/shelljs/shx/actions/workflows/main.yml)
+[![Codecov](https://img.shields.io/codecov/c/github/shelljs/shx/main.svg?style=flat-square&label=coverage)](https://codecov.io/gh/shelljs/shx)
+[![npm version](https://img.shields.io/npm/v/shx.svg?style=flat-square)](https://www.npmjs.com/package/shx)
+[![npm downloads](https://img.shields.io/npm/dm/shx.svg?style=flat-square)](https://www.npmjs.com/package/shx)
+
+`shx` is a wrapper around [ShellJS](https://github.com/shelljs/shelljs) Unix
+commands, providing an easy solution for simple Unix-like, cross-platform
+commands in npm package scripts.
+
+`shx` is proudly tested on every LTS node release since <!-- start minVersion -->`v18`<!-- stop minVersion -->!
+
+## Difference Between ShellJS and shx
+
+- **ShellJS:** Good for writing long scripts, all in JS, running via NodeJS (e.g. `node myScript.js`).
+- **shx:** Good for writing one-off commands in npm package scripts (e.g. `"clean": "shx rm -rf out/"`).
+
+## Install
+
+```shell
+npm install shx --save-dev
+```
+This will allow using `shx` in your `package.json` scripts.
+
+## Usage
+
+### Command Line
+
+If you'd like to use `shx` on the command line, install it globally with the `-g` flag.
+The following code can be run *either a Unix or Windows* command line:
+
+```Bash
+$ shx pwd                       # ShellJS commands are supported automatically
+/home/username/path/to/dir
+
+$ shx ls                        # files are outputted one per line
+file.txt
+file2.txt
+
+$ shx rm *.txt                  # a cross-platform way to delete files!
+
+$ shx ls
+
+$ shx echo "Hi there!"
+Hi there!
+
+$ shx touch helloworld.txt
+
+$ shx cp helloworld.txt foobar.txt
+
+$ shx mkdir sub
+
+$ shx ls
+foobar.txt
+helloworld.txt
+sub
+
+$ shx rm -r sub                 # options work as well
+
+$ shx --silent ls fakeFileName  # silence error output
+
+$ shx --negate test -d dir      # Negate status code output (e.g., failed commands will now have status 0)
+```
+
+All commands internally call the ShellJS corresponding function, guaranteeing
+cross-platform compatibility.
+
+### package.json
+
+ShellJS is good for writing long scripts. If you want to write bash-like,
+platform-independent scripts, we recommend you go with that.
+
+However, `shx` is ideal for one-liners inside `package.json`:
+
+```json
+{
+  "scripts": {
+    "clean": "shx rm -rf \"build/**/*.js\" \"build/output\" && shx echo \"Done cleaning\""
+  }
+}
+```
+
+It's safe to use `&&` and `||` operators in npm package scripts. These will be
+interpreted by the operating system's shell (`sh` on Unix, `cmd.exe` on
+Windows). If you're using glob operators like `*` or `**`, then we recommend to
+**put these in double quotes**, which ensures that `shx` will expand the glob
+rather than the operating system shell.
+
+> [!IMPORTANT]
+> Windows treats single quotes (ex. `'some string'`) differently than double
+> quotes.
+> [We recommend](https://github.com/shelljs/shx/issues/165#issuecomment-563127983)
+> wrapping your arguments in **escaped double quotes** so that your code is
+> compatible cross platform (ex. `"clean": "shx echo \"some string\""`).
+
+## Command reference
+
+Shx exposes [most ShellJS
+commands](https://github.com/shelljs/shelljs#command-reference). If a command is
+not listed here, assume it's supported!
+
+### sed
+
+Shx provides unix-like syntax on top of `shell.sed()`. So ShellJS code like:
+
+```js
+shell.sed('-i', /original string/g, 'replacement', 'filename.txt');
+```
+
+would turn into the following Shx command:
+
+```sh
+shx sed -i "s/original string/replacement/g" filename.txt
+```
+
+**Note:** like unix `sed`, `shx sed` treats `/` as a special character, and
+[this must be
+escaped](https://github.com/shelljs/shx/issues/169#issuecomment-563013849) (as
+`\/` in the shell, or `\\/` in `package.json`) if you intend to use this
+character in either the regex or replacement string. Do **not** escape `/`
+characters in the file path.
+
+### Unsupported Commands
+
+As mentioned above, most ShellJS commands are supported in `shx`. Due to the
+differences in execution environments between ShellJS and `shx` (JS vs CLI) the
+following commands are not supported:
+
+| Unsupported command | Recommend workaround |
+| ------------------- | -------------------- |
+| `shx cd`            | Just use plain old `cd` (it's the same on windows too) |
+| `shx pushd`         | Just use plain old `pushd`. Use forward slashes and double-quote the path. (e.g. `pushd "../docs"`. This would fail on Windows without the quotes) |
+| `shx popd`          | Just use plain old `popd` |
+| `shx dirs`          | No workaround |
+| `shx set`           | See below |
+| `shx exit`          | Just use plain old `exit` |
+| `shx exec`          | Instead of `shx exec cmd`, just use plain old `cmd` |
+| `shx ShellString`   | No workaround (but why would you want this?) |
+
+### Shx options
+
+Shx allows you to modify its behavior by passing arguments. Here's a list of
+supported options:
+
+| [`set`](https://github.com/shelljs/shelljs#setoptions) flag | [`shell.config`](https://github.com/shelljs/shelljs#configuration) setting | shx command | Effect |
+|:---:| --- | --- | --- |
+| `-e` | `config.fatal = true` | Not supported | Exit upon first error. |
+| `-v` | `config.verbose = true` | `shx --verbose cd foo` | Log the command as it's run. |
+| `-f` | `config.noglob = true` | `shx --noglob cat '*.txt'` | Don't expand wildcards. |
+| N/A | `config.silent = true` | `shx --silent cd noexist` | Don't show error output. |
+| N/A | N/A | `shx --negate test -d dir` | Runs the specified command but negates the exit status. Failed command = status 0, successful command = status 1. |
+| N/A | N/A | `shx --help` | Show help text. |
+| N/A | N/A | `shx --version` | Print the shx version. |
+
+## Team
+
+| [![Nate Fischer](https://avatars.githubusercontent.com/u/5801521?s=130)](https://github.com/nfischer) | [![Ari Porad](https://avatars1.githubusercontent.com/u/1817508?v=3&s=130)](http://github.com/ariporad) | [![Levi Thomason](https://avatars1.githubusercontent.com/u/5067638?v=3&s=130)](https://github.com/levithomason) |
+|:---:|:---:|:---:|
+| [Nate Fischer](https://github.com/nfischer) | [Ari Porad](http://github.com/ariporad) | [Levi Thomason](https://github.com/levithomason) |

novas/novacore-zephyr/claude-code-router/node_modules/shx/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "shx",
+  "version": "0.4.0",
+  "description": "Portable Shell Commands for Node",
+  "bin": {
+    "shx": "lib/cli.js"
+  },
+  "files": [
+    "lib"
+  ],
+  "scripts": {
+    "check-node-support": "node scripts/check-node-support",
+    "prebuild": "rimraf lib",
+    "build": "babel src -d lib",
+    "lint": "eslint .",
+    "prepublish": "npm run build",
+    "posttest": "npm run lint",
+    "release:major": "shelljs-release major",
+    "release:minor": "shelljs-release minor",
+    "release:patch": "shelljs-release patch",
+    "changelog": "shelljs-changelog",
+    "test": "nyc --reporter=text --reporter=lcov mocha"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shelljs/shx.git"
+  },
+  "keywords": [
+    "shelljs",
+    "shell",
+    "unix",
+    "bash",
+    "sh",
+    "exec",
+    "cli",
+    "zsh"
+  ],
+  "contributors": [
+    "Ari Porad <ari@ariporad.com> (http://ariporad.com/)",
+    "Levi Thomason <me@levithomason.com> (https://github.com/levithomason)",
+    "Nate Fischer <ntfschr@gmail.com>"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/shelljs/shx/issues"
+  },
+  "homepage": "https://github.com/shelljs/shx#readme",
+  "devDependencies": {
+    "babel-cli": "^6.6.5",
+    "babel-preset-env": "^1.7.0",
+    "babel-register": "^6.7.2",
+    "eslint": "^8.57.1",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-import-resolver-node": "0.3.7",
+    "eslint-plugin-import": "^2.31.0",
+    "js-yaml": "^4.1.0",
+    "mocha": "^11.1.0",
+    "nyc": "^17.1.0",
+    "rimraf": "^5.0.10",
+    "shelljs-changelog": "^0.2.6",
+    "shelljs-plugin-open": "^0.3.0",
+    "shelljs-release": "^0.5.3",
+    "should": "^13.2.3"
+  },
+  "dependencies": {
+    "minimist": "^1.2.8",
+    "shelljs": "^0.9.2"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

novas/novacore-zephyr/claude-code-router/node_modules/string-width-cjs/index.d.ts

@@ -0,0 +1,29 @@
+declare const stringWidth: {
+	/**
+	Get the visual width of a string - the number of columns required to display it.
+
+	Some Unicode characters are [fullwidth](https://en.wikipedia.org/wiki/Halfwidth_and_fullwidth_forms) and use double the normal width. [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code) are stripped and doesn't affect the width.
+
+	@example
+	```
+	import stringWidth = require('string-width');
+
+	stringWidth('a');
+	//=> 1
+
+	stringWidth('古');
+	//=> 2
+
+	stringWidth('\u001B[1m古\u001B[22m');
+	//=> 2
+	```
+	*/
+	(string: string): number;
+
+	// TODO: remove this in the next major version, refactor the whole definition to:
+	// declare function stringWidth(string: string): number;
+	// export = stringWidth;
+	default: typeof stringWidth;
+}
+
+export = stringWidth;

novas/novacore-zephyr/claude-code-router/node_modules/string-width-cjs/index.js

@@ -0,0 +1,47 @@
+'use strict';
+const stripAnsi = require('strip-ansi');
+const isFullwidthCodePoint = require('is-fullwidth-code-point');
+const emojiRegex = require('emoji-regex');
+
+const stringWidth = string => {
+	if (typeof string !== 'string' || string.length === 0) {
+		return 0;
+	}
+
+	string = stripAnsi(string);
+
+	if (string.length === 0) {
+		return 0;
+	}
+
+	string = string.replace(emojiRegex(), '  ');
+
+	let width = 0;
+
+	for (let i = 0; i < string.length; i++) {
+		const code = string.codePointAt(i);
+
+		// Ignore control characters
+		if (code <= 0x1F || (code >= 0x7F && code <= 0x9F)) {
+			continue;
+		}
+
+		// Ignore combining characters
+		if (code >= 0x300 && code <= 0x36F) {
+			continue;
+		}
+
+		// Surrogates
+		if (code > 0xFFFF) {
+			i++;
+		}
+
+		width += isFullwidthCodePoint(code) ? 2 : 1;
+	}
+
+	return width;
+};
+
+module.exports = stringWidth;
+// TODO: remove this in the next major version
+module.exports.default = stringWidth;

novas/novacore-zephyr/claude-code-router/node_modules/string-width-cjs/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

novas/novacore-zephyr/claude-code-router/node_modules/string-width-cjs/package.json

@@ -0,0 +1,56 @@
+{
+	"name": "string-width",
+	"version": "4.2.3",
+	"description": "Get the visual width of a string - the number of columns required to display it",
+	"license": "MIT",
+	"repository": "sindresorhus/string-width",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "sindresorhus.com"
+	},
+	"engines": {
+		"node": ">=8"
+	},
+	"scripts": {
+		"test": "xo && ava && tsd"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts"
+	],
+	"keywords": [
+		"string",
+		"character",
+		"unicode",
+		"width",
+		"visual",
+		"column",
+		"columns",
+		"fullwidth",
+		"full-width",
+		"full",
+		"ansi",
+		"escape",
+		"codes",
+		"cli",
+		"command-line",
+		"terminal",
+		"console",
+		"cjk",
+		"chinese",
+		"japanese",
+		"korean",
+		"fixed-width"
+	],
+	"dependencies": {
+		"emoji-regex": "^8.0.0",
+		"is-fullwidth-code-point": "^3.0.0",
+		"strip-ansi": "^6.0.1"
+	},
+	"devDependencies": {
+		"ava": "^1.4.1",
+		"tsd": "^0.7.1",
+		"xo": "^0.24.0"
+	}
+}

novas/novacore-zephyr/claude-code-router/node_modules/string-width-cjs/readme.md

@@ -0,0 +1,50 @@
+# string-width
+
+> Get the visual width of a string - the number of columns required to display it
+
+Some Unicode characters are [fullwidth](https://en.wikipedia.org/wiki/Halfwidth_and_fullwidth_forms) and use double the normal width. [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code) are stripped and doesn't affect the width.
+
+Useful to be able to measure the actual width of command-line output.
+
+
+## Install
+
+```
+$ npm install string-width
+```
+
+
+## Usage
+
+```js
+const stringWidth = require('string-width');
+
+stringWidth('a');
+//=> 1
+
+stringWidth('古');
+//=> 2
+
+stringWidth('\u001B[1m古\u001B[22m');
+//=> 2
+```
+
+
+## Related
+
+- [string-width-cli](https://github.com/sindresorhus/string-width-cli) - CLI for this module
+- [string-length](https://github.com/sindresorhus/string-length) - Get the real length of a string
+- [widest-line](https://github.com/sindresorhus/widest-line) - Get the visual width of the widest line in a string
+
+
+---
+
+<div align="center">
+	<b>
+		<a href="https://tidelift.com/subscription/pkg/npm-string-width?utm_source=npm-string-width&utm_medium=referral&utm_campaign=readme">Get professional support for this package with a Tidelift subscription</a>
+	</b>
+	<br>
+	<sub>
+		Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.
+	</sub>
+</div>

novas/novacore-zephyr/claude-code-router/node_modules/tiktoken/README.md

@@ -0,0 +1,325 @@
+# ⏳ tiktoken
+
+tiktoken is a [BPE](https://en.wikipedia.org/wiki/Byte_pair_encoding) tokeniser for use with
+OpenAI's models, forked from the original tiktoken library to provide JS/WASM bindings for NodeJS and other JS runtimes.
+
+This repository contains the following packages:
+
+- `tiktoken` (formally hosted at `@dqbd/tiktoken`): WASM bindings for the original Python library, providing full 1-to-1 feature parity.
+- `js-tiktoken`: Pure JavaScript port of the original library with the core functionality, suitable for environments where WASM is not well supported or not desired (such as edge runtimes). 
+
+Documentation for `js-tiktoken` can be found in [here](https://github.com/dqbd/tiktoken/blob/main/js/README.md). Documentation for the `tiktoken` can be found here below.
+
+The WASM version of `tiktoken` can be installed from NPM:
+
+```
+npm install tiktoken
+```
+
+## Usage
+
+Basic usage follows, which includes all the OpenAI encoders and ranks:
+
+```typescript
+import assert from "node:assert";
+import { get_encoding, encoding_for_model } from "tiktoken";
+
+const enc = get_encoding("gpt2");
+assert(
+  new TextDecoder().decode(enc.decode(enc.encode("hello world"))) ===
+    "hello world"
+);
+
+// To get the tokeniser corresponding to a specific model in the OpenAI API:
+const enc = encoding_for_model("text-davinci-003");
+
+// Extend existing encoding with custom special tokens
+const enc = encoding_for_model("gpt2", {
+  "<|im_start|>": 100264,
+  "<|im_end|>": 100265,
+});
+
+// don't forget to free the encoder after it is not used
+enc.free();
+```
+
+In constrained environments (eg. Edge Runtime, Cloudflare Workers), where you don't want to load all the encoders at once, you can use the lightweight WASM binary via `tiktoken/lite`.
+
+```typescript
+const { Tiktoken } = require("tiktoken/lite");
+const cl100k_base = require("tiktoken/encoders/cl100k_base.json");
+
+const encoding = new Tiktoken(
+  cl100k_base.bpe_ranks,
+  cl100k_base.special_tokens,
+  cl100k_base.pat_str
+);
+const tokens = encoding.encode("hello world");
+encoding.free();
+```
+
+If you want to fetch the latest ranks, use the `load` function:
+
+```typescript
+const { Tiktoken } = require("tiktoken/lite");
+const { load } = require("tiktoken/load");
+const registry = require("tiktoken/registry.json");
+const models = require("tiktoken/model_to_encoding.json");
+
+async function main() {
+  const model = await load(registry[models["gpt-3.5-turbo"]]);
+  const encoder = new Tiktoken(
+    model.bpe_ranks,
+    model.special_tokens,
+    model.pat_str
+  );
+  const tokens = encoder.encode("hello world");
+  encoder.free();
+}
+
+main();
+```
+
+If desired, you can create a Tiktoken instance directly with custom ranks, special tokens and regex pattern:
+
+```typescript
+import { Tiktoken } from "../pkg";
+import { readFileSync } from "fs";
+
+const encoder = new Tiktoken(
+  readFileSync("./ranks/gpt2.tiktoken").toString("utf-8"),
+  { "<|endoftext|>": 50256, "<|im_start|>": 100264, "<|im_end|>": 100265 },
+  "'s|'t|'re|'ve|'m|'ll|'d| ?\\p{L}+| ?\\p{N}+| ?[^\\s\\p{L}\\p{N}]+|\\s+(?!\\S)|\\s+"
+);
+```
+
+Finally, you can a custom `init` function to override the WASM initialization logic for non-Node environments. This is useful if you are using a bundler that does not support WASM ESM integration.
+
+```typescript
+import { get_encoding, init } from "tiktoken/init";
+
+async function main() {
+  const wasm = "..."; // fetch the WASM binary somehow
+  await init((imports) => WebAssembly.instantiate(wasm, imports));
+
+  const encoding = get_encoding("cl100k_base");
+  const tokens = encoding.encode("hello world");
+  encoding.free();
+}
+
+main();
+```
+
+## Compatibility
+
+As this is a WASM library, there might be some issues with specific runtimes. If you encounter any issues, please open an issue.
+
+| Runtime                      | Status | Notes                                                                                      |
+| ---------------------------- | ------ | ------------------------------------------------------------------------------------------ |
+| Node.js                      | ✅     |                                                                                            |
+| Bun                          | ✅     |                                                                                            |
+| Vite                         | ✅     | See [here](#vite) for notes                                                                |
+| Next.js                      | ✅     | See [here](#nextjs) for notes                                                              |
+| Create React App (via Craco) | ✅     | See [here](#create-react-app) for notes                                                    |
+| Vercel Edge Runtime          | ✅     | See [here](#vercel-edge-runtime) for notes                                                 |
+| Cloudflare Workers           | ✅     | See [here](#cloudflare-workers) for notes                                                  |
+| Electron                     | ✅     | See [here](#electron) for notes                                                            |
+| Deno                         | ❌     | Currently unsupported (see [dqbd/tiktoken#22](https://github.com/dqbd/tiktoken/issues/22)) |
+| Svelte + Cloudflare Workers  | ❌     | Currently unsupported (see [dqbd/tiktoken#37](https://github.com/dqbd/tiktoken/issues/37)) |
+
+For unsupported runtimes, consider using [`js-tiktoken`](https://www.npmjs.com/package/js-tiktoken), which is a pure JS implementation of the tokeniser.
+
+### [Vite](#vite)
+
+If you are using Vite, you will need to add both the `vite-plugin-wasm` and `vite-plugin-top-level-await`. Add the following to your `vite.config.js`:
+
+```js
+import wasm from "vite-plugin-wasm";
+import topLevelAwait from "vite-plugin-top-level-await";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  plugins: [wasm(), topLevelAwait()],
+});
+```
+
+### [Next.js](#nextjs)
+
+Both API routes and `/pages` are supported with the following `next.config.js` configuration.
+
+```typescript
+// next.config.json
+const config = {
+  webpack(config, { isServer, dev }) {
+    config.experiments = {
+      asyncWebAssembly: true,
+      layers: true,
+    };
+
+    return config;
+  },
+};
+```
+
+Usage in pages:
+
+```tsx
+import { get_encoding } from "tiktoken";
+import { useState } from "react";
+
+const encoding = get_encoding("cl100k_base");
+
+export default function Home() {
+  const [input, setInput] = useState("hello world");
+  const tokens = encoding.encode(input);
+
+  return (
+    <div>
+      <input
+        type="text"
+        value={input}
+        onChange={(e) => setInput(e.target.value)}
+      />
+      <div>{tokens.toString()}</div>
+    </div>
+  );
+}
+```
+
+Usage in API routes:
+
+```typescript
+import { get_encoding } from "tiktoken";
+import { NextApiRequest, NextApiResponse } from "next";
+
+export default function handler(req: NextApiRequest, res: NextApiResponse) {
+  const encoding = get_encoding("cl100k_base");
+  const tokens = encoding.encode("hello world");
+  encoding.free();
+  return res.status(200).json({ tokens });
+}
+```
+
+### [Create React App](#create-react-app)
+
+By default, the Webpack configugration found in Create React App does not support WASM ESM modules. To add support, please do the following:
+
+1. Swap `react-scripts` with `craco`, using the guide found here: https://craco.js.org/docs/getting-started/.
+2. Add the following to `craco.config.js`:
+
+```js
+module.exports = {
+  webpack: {
+    configure: (config) => {
+      config.experiments = {
+        asyncWebAssembly: true,
+        layers: true,
+      };
+
+      // turn off static file serving of WASM files
+      // we need to let Webpack handle WASM import
+      config.module.rules
+        .find((i) => "oneOf" in i)
+        .oneOf.find((i) => i.type === "asset/resource")
+        .exclude.push(/\.wasm$/);
+
+      return config;
+    },
+  },
+};
+```
+
+### [Vercel Edge Runtime](#vercel-edge-runtime)
+
+Vercel Edge Runtime does support WASM modules by adding a `?module` suffix. Initialize the encoder with the following snippet:
+
+```typescript
+// @ts-expect-error
+import wasm from "tiktoken/lite/tiktoken_bg.wasm?module";
+import model from "tiktoken/encoders/cl100k_base.json";
+import { init, Tiktoken } from "tiktoken/lite/init";
+
+export const config = { runtime: "edge" };
+
+export default async function (req: Request) {
+  await init((imports) => WebAssembly.instantiate(wasm, imports));
+
+  const encoding = new Tiktoken(
+    model.bpe_ranks,
+    model.special_tokens,
+    model.pat_str
+  );
+
+  const tokens = encoding.encode("hello world");
+  encoding.free();
+
+  return new Response(`${tokens}`);
+}
+```
+
+### [Cloudflare Workers](#cloudflare-workers)
+
+Similar to Vercel Edge Runtime, Cloudflare Workers must import the WASM binary file manually and use the `tiktoken/lite` version to fit the 1 MB limit. However, users need to point directly at the WASM binary via a relative path (including `./node_modules/`).
+
+Add the following rule to the `wrangler.toml` to upload WASM during build:
+
+```toml
+[[rules]]
+globs = ["**/*.wasm"]
+type = "CompiledWasm"
+```
+
+Initialize the encoder with the following snippet:
+
+```javascript
+import { init, Tiktoken } from "tiktoken/lite/init";
+import wasm from "./node_modules/tiktoken/lite/tiktoken_bg.wasm";
+import model from "tiktoken/encoders/cl100k_base.json";
+
+export default {
+  async fetch() {
+    await init((imports) => WebAssembly.instantiate(wasm, imports));
+    const encoder = new Tiktoken(
+      model.bpe_ranks,
+      model.special_tokens,
+      model.pat_str
+    );
+    const tokens = encoder.encode("test");
+    encoder.free();
+    return new Response(`${tokens}`);
+  },
+};
+```
+
+### [Electron](#electron)
+
+To use tiktoken in your Electron main process, you need to make sure the WASM binary gets copied into your application package.
+
+Assuming a setup with [Electron Forge](https://www.electronforge.io) and [`@electron-forge/plugin-webpack`](https://www.npmjs.com/package/@electron-forge/plugin-webpack), add the following to your `webpack.main.config.js`:
+
+```javascript
+const CopyPlugin = require("copy-webpack-plugin");
+
+module.exports = {
+  // ...
+  plugins: [
+    new CopyPlugin({
+      patterns: [
+        { from: "./node_modules/tiktoken/tiktoken_bg.wasm" },
+      ],
+    }),
+  ],
+};
+```
+
+## Development
+
+To build the `tiktoken` library, make sure to have:
+- Rust and [`wasm-pack`](https://github.com/rustwasm/wasm-pack) installed.
+- Node.js 18+ is required to build the JS bindings and fetch the latest encoder ranks via `fetch`.
+
+Install all the dev-dependencies with `yarn install` and build both WASM binary and JS bindings with `yarn build`.
+
+## Acknowledgements
+
+- https://github.com/zurawiki/tiktoken-rs

novas/novacore-zephyr/claude-code-router/node_modules/tiktoken/init.cjs

@@ -0,0 +1,42 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) 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 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = void 0;
+// @ts-expect-error
+const imports = require("./tiktoken_bg.cjs");
+let isInitialized = false;
+async function init(callback) {
+    if (isInitialized)
+        return imports;
+    const result = await callback({ "./tiktoken_bg.js": imports });
+    const instance = "instance" in result && result.instance instanceof WebAssembly.Instance
+        ? result.instance
+        : result instanceof WebAssembly.Instance
+            ? result
+            : null;
+    if (instance == null)
+        throw new Error("Missing instance");
+    imports.__wbg_set_wasm(instance.exports);
+    isInitialized = true;
+    return imports;
+}
+exports.init = init;
+exports["get_encoding"] = imports["get_encoding"];
+exports["encoding_for_model"] = imports["encoding_for_model"];
+exports["get_encoding_name_for_model"] = imports["get_encoding_name_for_model"];
+exports["Tiktoken"] = imports["Tiktoken"];
+// @ts-expect-error
+__exportStar(require("./tiktoken_bg.cjs"), exports);

novas/novacore-zephyr/claude-code-router/node_modules/tiktoken/init.d.ts

@@ -0,0 +1,2 @@
+export declare function init(callback: (imports: WebAssembly.Imports) => Promise<WebAssembly.Instance | WebAssembly.WebAssemblyInstantiatedSource>): Promise<void>;
+export * from "./tiktoken_bg";

novas/novacore-zephyr/claude-code-router/node_modules/tiktoken/init.js

@@ -0,0 +1,20 @@
+// @ts-expect-error
+import * as imports from "./tiktoken_bg";
+let isInitialized = false;
+export async function init(callback) {
+    if (isInitialized)
+        return imports;
+    const result = await callback({ "./tiktoken_bg.js": imports });
+    const instance = "instance" in result && result.instance instanceof WebAssembly.Instance
+        ? result.instance
+        : result instanceof WebAssembly.Instance
+            ? result
+            : null;
+    if (instance == null)
+        throw new Error("Missing instance");
+    imports.__wbg_set_wasm(instance.exports);
+    isInitialized = true;
+    return imports;
+}
+// @ts-expect-error
+export * from "./tiktoken_bg";

novas/novacore-zephyr/claude-code-router/node_modules/tiktoken/lite.d.ts

@@ -0,0 +1 @@
+export * from "./lite/tiktoken";

novas/novacore-zephyr/claude-code-router/node_modules/tiktoken/load.cjs

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.load = void 0;
+/**
+Copyright (c) 2014 Jameson Little
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+ */
+const lookup = [];
+const revLookup = [];
+const code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+for (var i = 0, len = code.length; i < len; ++i) {
+    lookup[i] = code[i];
+    revLookup[code.charCodeAt(i)] = i;
+}
+// Support decoding URL-safe base64 strings, as Node.js does.
+// See: https://en.wikipedia.org/wiki/Base64#URL_applications
+revLookup["-".charCodeAt(0)] = 62;
+revLookup["_".charCodeAt(0)] = 63;
+function tripletToBase64(num) {
+    return (lookup[(num >> 18) & 0x3f] +
+        lookup[(num >> 12) & 0x3f] +
+        lookup[(num >> 6) & 0x3f] +
+        lookup[num & 0x3f]);
+}
+function encodeChunk(uint8, start, end) {
+    var tmp;
+    var output = [];
+    for (var i = start; i < end; i += 3) {
+        tmp =
+            ((uint8[i] << 16) & 0xff0000) +
+                ((uint8[i + 1] << 8) & 0xff00) +
+                (uint8[i + 2] & 0xff);
+        output.push(tripletToBase64(tmp));
+    }
+    return output.join("");
+}
+function fromByteArray(uint8) {
+    var tmp;
+    var len = uint8.length;
+    var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
+    var parts = [];
+    var maxChunkLength = 16383; // must be multiple of 3
+    // go through the array every three bytes, we'll deal with trailing stuff later
+    for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+        parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));
+    }
+    // pad the end with zeros, but make sure to not forget the extra bytes
+    if (extraBytes === 1) {
+        tmp = uint8[len - 1];
+        parts.push(lookup[tmp >> 2] + lookup[(tmp << 4) & 0x3f] + "==");
+    }
+    else if (extraBytes === 2) {
+        tmp = (uint8[len - 2] << 8) + uint8[len - 1];
+        parts.push(lookup[tmp >> 10] +
+            lookup[(tmp >> 4) & 0x3f] +
+            lookup[(tmp << 2) & 0x3f] +
+            "=");
+    }
+    return parts.join("");
+}
+function is_printable(u) {
+    // printable ascii characters according to python
+    return !(u <= 31 || (u >= 127 && u <= 160) || u == 173);
+}
+function data_gym_to_mergeable_bpe_ranks(vocal_bpe_contents, encoder_json_contents) {
+    const rank_to_intbyte = Array.from({ length: 2 ** 8 }, (_, i) => i).filter((i) => is_printable(i) && String.fromCharCode(i) !== " ");
+    const data_gym_byte_to_byte = rank_to_intbyte.reduce((memo, item) => {
+        memo[String.fromCharCode(item)] = item;
+        return memo;
+    }, {});
+    let n = 0;
+    for (let b = 0; b < 2 ** 8; b++) {
+        if (!rank_to_intbyte.includes(b)) {
+            rank_to_intbyte.push(b);
+            data_gym_byte_to_byte[String.fromCharCode(2 ** 8 + n)] = b;
+            n += 1;
+        }
+    }
+    if (rank_to_intbyte.length !== 2 ** 8) {
+        throw new Error("rank_to_intbyte.length must be 2**8");
+    }
+    // vocab_bpe contains the merges along with associated ranks
+    const bpe_merges = vocal_bpe_contents
+        .split("\n")
+        .slice(1, -1)
+        .map((merge_str) => merge_str.split(" "));
+    function decode_data_gym(value) {
+        return value.split("").map((b) => data_gym_byte_to_byte[b]);
+    }
+    // add the single byte tokens
+    const bpe_ranks = Object.fromEntries(rank_to_intbyte.map((b, i) => [b, i]));
+    // add the merged tokens
+    n = rank_to_intbyte.length;
+    for (const [first, second] of bpe_merges) {
+        bpe_ranks[[...decode_data_gym(first), ...decode_data_gym(second)].join(",")] = n;
+        n += 1;
+    }
+    // check that the encoder file matches the merges file
+    // this sanity check is important since tiktoken assumes that ranks are ordered the same
+    // as merge priority
+    const encoder_json = JSON.parse(encoder_json_contents);
+    const encoder_json_loaded = Object.fromEntries(Object.entries(encoder_json).map(([k, v]) => [
+        decode_data_gym(k).join(","),
+        v,
+    ]));
+    // drop these two special tokens if present, since they're not mergeable bpe tokens
+    delete encoder_json_loaded[decode_data_gym("<|endoftext|>").join(",")];
+    delete encoder_json_loaded[decode_data_gym("<|startoftext|>").join(",")];
+    function normalize_map(items) {
+        return JSON.stringify(Object.keys(items)
+            .sort()
+            .map((key) => [key, items[key]]));
+    }
+    if (normalize_map(bpe_ranks) !== normalize_map(encoder_json_loaded)) {
+        throw new Error("bpe_ranks !== encoder_json_loaded");
+    }
+    return bpe_ranks;
+}
+function dump_tiktoken_bpe(bpe_ranks) {
+    return (Object.entries(bpe_ranks)
+        .sort((a, b) => a[1] - b[1])
+        .map(([token_str, rank]) => [
+        fromByteArray(token_str.split(",").map((i) => Number.parseInt(i, 10))),
+        rank,
+    ].join(" "))
+        .join("\n") + "\n");
+}
+async function load(registry, customFetch) {
+    const ofetch = customFetch
+        ? customFetch
+        : (url) => fetch(url).then((r) => r.text());
+    if ("data_gym_to_mergeable_bpe_ranks" in registry) {
+        const [vocab_bpe, encoder_json] = await Promise.all([
+            ofetch(registry.data_gym_to_mergeable_bpe_ranks.vocab_bpe_file),
+            ofetch(registry.data_gym_to_mergeable_bpe_ranks.encoder_json_file),
+        ]);
+        return {
+            explicit_n_vocab: registry.explicit_n_vocab,
+            pat_str: registry.pat_str,
+            special_tokens: registry.special_tokens,
+            bpe_ranks: dump_tiktoken_bpe(data_gym_to_mergeable_bpe_ranks(vocab_bpe, encoder_json)),
+        };
+    }
+    else {
+        return {
+            explicit_n_vocab: registry.explicit_n_vocab,
+            pat_str: registry.pat_str,
+            special_tokens: registry.special_tokens,
+            bpe_ranks: await ofetch(registry.load_tiktoken_bpe),
+        };
+    }
+}
+exports.load = load;