Add files using upload-large-folder tool

novas/novacore-zephyr/claude-code-router/node_modules/avvio/.github/dependabot.yml

@@ -0,0 +1,13 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "monthly"
+    open-pull-requests-limit: 10
+
+  - package-ecosystem: "npm"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 10

novas/novacore-zephyr/claude-code-router/node_modules/avvio/.github/release-drafter.yml

@@ -0,0 +1,4 @@
+template: |
+    ## What’s Changed
+
+    $CHANGES

novas/novacore-zephyr/claude-code-router/node_modules/avvio/.github/tests_checker.yml

@@ -0,0 +1,3 @@
+comment: 'Could you please add tests to make sure this change works as expected?',
+fileExtensions: ['.php', '.ts', '.js', '.c', '.cs', '.cpp', '.rb', '.java']
+testDir: 'test'

novas/novacore-zephyr/claude-code-router/node_modules/avvio/.github/workflows/ci.yml

@@ -0,0 +1,24 @@
+name: CI
+
+on:
+  push:
+    branches:
+     - main
+     - master
+     - next
+     - 'v*'
+    paths-ignore:
+      - 'docs/**'
+      - '*.md'
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - '*.md'
+
+jobs:
+  test:
+    uses: fastify/workflows/.github/workflows/plugins-ci.yml@v5.0.0
+    with:
+      lint: true
+      license-check: true
+      node-versions: '["20", "22"]'

novas/novacore-zephyr/claude-code-router/node_modules/avvio/examples/example.js

@@ -0,0 +1,72 @@
+'use strict'
+
+const avvio = require('..')()
+
+function a (instance, opts, cb) {
+  (opts.use || []).forEach(_ => { instance.use(_, { use: opts.subUse || [] }) })
+  setTimeout(cb, 10)
+}
+const pointer = a
+
+function b (instance, opts, cb) {
+  (opts.use || []).forEach(_ => { instance.use(_, { use: opts.subUse || [] }) })
+  setTimeout(cb, 20)
+}
+
+function c (instance, opts, cb) {
+  (opts.use || []).forEach(_ => { instance.use(_, { use: opts.subUse || [] }) })
+  setTimeout(cb, 30)
+}
+
+avvio
+  .use(first, { hello: 'world' })
+  .use(duplicate, { count: 0 })
+  .use(function a (instance, opts, cb) {
+    instance.use(pointer, { use: [b], subUse: [c] })
+      .use(b)
+    setTimeout(cb, 42)
+  })
+  .after(function (err, cb) {
+    if (err) {
+      console.log('something bad happened')
+      console.log(err)
+    }
+    console.log('after first and second')
+    cb()
+  })
+  .use(duplicate, { count: 4 })
+  .use(third)
+  .ready(function (err) {
+    if (err) {
+      throw err
+    }
+    console.log('application booted!')
+  })
+
+avvio.on('preReady', () => {
+  console.log(avvio.prettyPrint())
+})
+
+function first (instance, opts, cb) {
+  console.log('first loaded', opts)
+  instance.use(second)
+  setTimeout(cb, 42)
+}
+
+function second (instance, opts, cb) {
+  console.log('second loaded')
+  process.nextTick(cb)
+}
+
+function third (instance, opts, cb) {
+  console.log('third loaded')
+  cb()
+}
+
+function duplicate (instance, opts, cb) {
+  console.log('duplicate loaded', opts.count)
+  if (opts.count > 0) {
+    instance.use(duplicate, { count: opts.count - 1 })
+  }
+  setTimeout(cb, 20)
+}

novas/novacore-zephyr/claude-code-router/node_modules/avvio/lib/create-promise.js

@@ -0,0 +1,45 @@
+'use strict'
+
+/**
+ * @callback PromiseResolve
+ * @param {any|PromiseLike<any>} value
+ * @returns {void}
+ */
+
+/**
+ * @callback PromiseReject
+ * @param {any} reason
+ * @returns {void}
+ */
+
+/**
+ * @typedef PromiseObject
+ * @property {Promise} promise
+ * @property {PromiseResolve} resolve
+ * @property {PromiseReject} reject
+ */
+
+/**
+ * @returns {PromiseObject}
+ */
+function createPromise () {
+  /**
+   * @type {PromiseObject}
+   */
+  const obj = {
+    resolve: null,
+    reject: null,
+    promise: null
+  }
+
+  obj.promise = new Promise((resolve, reject) => {
+    obj.resolve = resolve
+    obj.reject = reject
+  })
+
+  return obj
+}
+
+module.exports = {
+  createPromise
+}

novas/novacore-zephyr/claude-code-router/node_modules/avvio/lib/debug.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const { debuglog } = require('node:util')
+
+/**
+ * @callback DebugLogger
+ * @param {string} msg
+ * @param {...unknown} param
+ * @returns {void}
+ */
+
+/**
+ * @type {DebugLogger}
+ */
+const debug = debuglog('avvio')
+
+module.exports = {
+  debug
+}

novas/novacore-zephyr/claude-code-router/node_modules/avvio/lib/errors.js

@@ -0,0 +1,38 @@
+'use strict'
+
+const { createError } = require('@fastify/error')
+
+module.exports = {
+  AVV_ERR_EXPOSE_ALREADY_DEFINED: createError(
+    'AVV_ERR_EXPOSE_ALREADY_DEFINED',
+    "'%s' is already defined, specify an expose option for '%s'"
+  ),
+  AVV_ERR_ATTRIBUTE_ALREADY_DEFINED: createError(
+    'AVV_ERR_ATTRIBUTE_ALREADY_DEFINED',
+    "'%s' is already defined"
+  ),
+  AVV_ERR_CALLBACK_NOT_FN: createError(
+    'AVV_ERR_CALLBACK_NOT_FN',
+    "Callback for '%s' hook is not a function. Received: '%s'"
+  ),
+  AVV_ERR_PLUGIN_NOT_VALID: createError(
+    'AVV_ERR_PLUGIN_NOT_VALID',
+    "Plugin must be a function or a promise. Received: '%s'"
+  ),
+  AVV_ERR_ROOT_PLG_BOOTED: createError(
+    'AVV_ERR_ROOT_PLG_BOOTED',
+    'Root plugin has already booted'
+  ),
+  AVV_ERR_PARENT_PLG_LOADED: createError(
+    'AVV_ERR_PARENT_PLG_LOADED',
+    "Impossible to load '%s' plugin because the parent '%s' was already loaded"
+  ),
+  AVV_ERR_READY_TIMEOUT: createError(
+    'AVV_ERR_READY_TIMEOUT',
+    "Plugin did not start in time: '%s'. You may have forgotten to call 'done' function or to resolve a Promise"
+  ),
+  AVV_ERR_PLUGIN_EXEC_TIMEOUT: createError(
+    'AVV_ERR_PLUGIN_EXEC_TIMEOUT',
+    "Plugin did not start in time: '%s'. You may have forgotten to call 'done' function or to resolve a Promise"
+  )
+}

novas/novacore-zephyr/claude-code-router/node_modules/avvio/lib/execute-with-thenable.js

@@ -0,0 +1,28 @@
+'use strict'
+const { isPromiseLike } = require('./is-promise-like')
+const { kAvvio } = require('./symbols')
+
+/**
+ * @callback ExecuteWithThenableCallback
+ * @param {Error} error
+ * @returns {void}
+ */
+
+/**
+ * @param {Function} func
+ * @param {Array<any>} args
+ * @param {ExecuteWithThenableCallback} [callback]
+ */
+function executeWithThenable (func, args, callback) {
+  const result = func.apply(func, args)
+  if (isPromiseLike(result) && !result[kAvvio]) {
+    // process promise but not avvio mock thenable
+    result.then(() => process.nextTick(callback), (error) => process.nextTick(callback, error))
+  } else if (callback) {
+    process.nextTick(callback)
+  }
+}
+
+module.exports = {
+  executeWithThenable
+}

novas/novacore-zephyr/claude-code-router/node_modules/avvio/lib/get-plugin-name.js

@@ -0,0 +1,34 @@
+'use strict'
+
+// this symbol is assigned by fastify-plugin
+const { kPluginMeta } = require('./symbols')
+
+/**
+ * @param {function} plugin
+ * @param {object} [options]
+ * @param {string} [options.name]
+ * @returns {string}
+ */
+function getPluginName (plugin, options) {
+  // use explicit function metadata if set
+  if (plugin[kPluginMeta] && plugin[kPluginMeta].name) {
+    return plugin[kPluginMeta].name
+  }
+
+  // use explicit name option if set
+  if (options && options.name) {
+    return options.name
+  }
+
+  // determine from the function
+  if (plugin.name) {
+    return plugin.name
+  } else {
+    // takes the first two lines of the function if nothing else works
+    return plugin.toString().split('\n').slice(0, 2).map(s => s.trim()).join(' -- ')
+  }
+}
+
+module.exports = {
+  getPluginName
+}

novas/novacore-zephyr/claude-code-router/node_modules/avvio/lib/is-bundled-or-typescript-plugin.js

@@ -0,0 +1,23 @@
+'use strict'
+
+/**
+ * bundled or typescript plugin
+ * @typedef {object} BundledOrTypescriptPlugin
+ * @property {function} default
+ */
+
+/**
+ * @param {any} maybeBundledOrTypescriptPlugin
+ * @returns {plugin is BundledOrTypescriptPlugin}
+ */
+function isBundledOrTypescriptPlugin (maybeBundledOrTypescriptPlugin) {
+  return (
+    maybeBundledOrTypescriptPlugin !== null &&
+    typeof maybeBundledOrTypescriptPlugin === 'object' &&
+    typeof maybeBundledOrTypescriptPlugin.default === 'function'
+  )
+}
+
+module.exports = {
+  isBundledOrTypescriptPlugin
+}

novas/novacore-zephyr/claude-code-router/node_modules/avvio/lib/is-promise-like.js

@@ -0,0 +1,17 @@
+'use strict'
+
+/**
+ * @param {any} maybePromiseLike
+ * @returns {maybePromiseLike is PromiseLike}
+ */
+function isPromiseLike (maybePromiseLike) {
+  return (
+    maybePromiseLike !== null &&
+    typeof maybePromiseLike === 'object' &&
+    typeof maybePromiseLike.then === 'function'
+  )
+}
+
+module.exports = {
+  isPromiseLike
+}

novas/novacore-zephyr/claude-code-router/node_modules/avvio/lib/plugin.js

@@ -0,0 +1,279 @@
+'use strict'
+
+const { EventEmitter } = require('node:events')
+const { inherits } = require('node:util')
+const { debug } = require('./debug')
+const { createPromise } = require('./create-promise')
+const { AVV_ERR_PLUGIN_EXEC_TIMEOUT } = require('./errors')
+const { getPluginName } = require('./get-plugin-name')
+const { isPromiseLike } = require('./is-promise-like')
+
+/**
+ * @param {*} queue
+ * @param {*} func
+ * @param {*} options
+ * @param {boolean} isAfter
+ * @param {number} [timeout]
+ */
+function Plugin (queue, func, options, isAfter, timeout) {
+  this.queue = queue
+  this.func = func
+  this.options = options
+
+  /**
+   * @type {boolean}
+   */
+  this.isAfter = isAfter
+  /**
+   * @type {number}
+   */
+  this.timeout = timeout
+
+  /**
+   * @type {boolean}
+   */
+  this.started = false
+  /**
+   * @type {string}
+   */
+  this.name = getPluginName(func, options)
+
+  this.queue.pause()
+
+  /**
+   * @type {Error|null}
+   */
+  this._error = null
+  /**
+   * @type {boolean}
+   */
+  this.loaded = false
+
+  this._promise = null
+
+  this.startTime = null
+}
+
+inherits(Plugin, EventEmitter)
+
+/**
+ * @callback ExecCallback
+ * @param {Error|null} execErr
+ * @returns
+ */
+
+/**
+ *
+ * @param {*} server
+ * @param {ExecCallback} callback
+ * @returns
+ */
+Plugin.prototype.exec = function (server, callback) {
+  debug('exec', this.name)
+
+  this.server = server
+  const func = this.func
+  const name = this.name
+  let completed = false
+
+  this.options = typeof this.options === 'function' ? this.options(this.server) : this.options
+
+  let timer = null
+
+  /**
+   * @param {Error} [execErr]
+   */
+  const done = (execErr) => {
+    if (completed) {
+      debug('loading complete', name)
+      return
+    }
+
+    this._error = execErr
+
+    if (execErr) {
+      debug('exec errored', name)
+    } else {
+      debug('exec completed', name)
+    }
+
+    completed = true
+
+    if (timer) {
+      clearTimeout(timer)
+    }
+
+    callback(execErr)
+  }
+
+  if (this.timeout > 0) {
+    debug('setting up timeout', name, this.timeout)
+    timer = setTimeout(function () {
+      debug('timed out', name)
+      timer = null
+      const readyTimeoutErr = new AVV_ERR_PLUGIN_EXEC_TIMEOUT(name)
+      // TODO Remove reference to function
+      readyTimeoutErr.fn = func
+      done(readyTimeoutErr)
+    }, this.timeout)
+  }
+
+  this.started = true
+  this.startTime = Date.now()
+  this.emit('start', this.server ? this.server.name : null, this.name, Date.now())
+
+  const maybePromiseLike = func(this.server, this.options, done)
+
+  if (isPromiseLike(maybePromiseLike)) {
+    debug('exec: resolving promise', name)
+
+    maybePromiseLike.then(
+      () => process.nextTick(done),
+      (e) => process.nextTick(done, e))
+  } else if (func.length < 3) {
+    done()
+  }
+}
+
+/**
+ * @returns {Promise}
+ */
+Plugin.prototype.loadedSoFar = function () {
+  debug('loadedSoFar', this.name)
+
+  if (this.loaded) {
+    return Promise.resolve()
+  }
+
+  const setup = () => {
+    this.server.after((afterErr, callback) => {
+      this._error = afterErr
+      this.queue.pause()
+
+      if (this._promise) {
+        if (afterErr) {
+          debug('rejecting promise', this.name, afterErr)
+          this._promise.reject(afterErr)
+        } else {
+          debug('resolving promise', this.name)
+          this._promise.resolve()
+        }
+        this._promise = null
+      }
+
+      process.nextTick(callback, afterErr)
+    })
+    this.queue.resume()
+  }
+
+  let res
+
+  if (!this._promise) {
+    this._promise = createPromise()
+    res = this._promise.promise
+
+    if (!this.server) {
+      this.on('start', setup)
+    } else {
+      setup()
+    }
+  } else {
+    res = Promise.resolve()
+  }
+
+  return res
+}
+
+/**
+ * @callback EnqueueCallback
+ * @param {Error|null} enqueueErr
+ * @param {Plugin} result
+ */
+
+/**
+ *
+ * @param {Plugin} plugin
+ * @param {EnqueueCallback} callback
+ */
+Plugin.prototype.enqueue = function (plugin, callback) {
+  debug('enqueue', this.name, plugin.name)
+
+  this.emit('enqueue', this.server ? this.server.name : null, this.name, Date.now())
+  this.queue.push(plugin, callback)
+}
+
+/**
+ * @callback FinishCallback
+ * @param {Error|null} finishErr
+ * @returns
+ */
+/**
+ *
+ * @param {Error|null} err
+ * @param {FinishCallback} callback
+ * @returns
+ */
+Plugin.prototype.finish = function (err, callback) {
+  debug('finish', this.name, err)
+
+  const done = () => {
+    if (this.loaded) {
+      return
+    }
+
+    debug('loaded', this.name)
+    this.emit('loaded', this.server ? this.server.name : null, this.name, Date.now())
+    this.loaded = true
+
+    callback(err)
+  }
+
+  if (err) {
+    if (this._promise) {
+      this._promise.reject(err)
+      this._promise = null
+    }
+    done()
+    return
+  }
+
+  const check = () => {
+    debug('check', this.name, this.queue.length(), this.queue.running(), this._promise)
+    if (this.queue.length() === 0 && this.queue.running() === 0) {
+      if (this._promise) {
+        const wrap = () => {
+          debug('wrap')
+          queueMicrotask(check)
+        }
+        this._promise.resolve()
+        this._promise.promise.then(wrap, wrap)
+        this._promise = null
+      } else {
+        done()
+      }
+    } else {
+      debug('delayed', this.name)
+      // finish when the queue of nested plugins to load is empty
+      this.queue.drain = () => {
+        debug('drain', this.name)
+        this.queue.drain = noop
+
+        // we defer the check, as a safety net for things
+        // that might be scheduled in the loading callback
+        queueMicrotask(check)
+      }
+    }
+  }
+
+  queueMicrotask(check)
+
+  // we start loading the dependents plugins only once
+  // the current level is finished
+  this.queue.resume()
+}
+
+function noop () {}
+
+module.exports = {
+  Plugin
+}

novas/novacore-zephyr/claude-code-router/node_modules/avvio/lib/symbols.js

@@ -0,0 +1,26 @@
+'use strict'
+
+// Internal Symbols
+const kAvvio = Symbol('avvio.Boot')
+const kIsOnCloseHandler = Symbol('isOnCloseHandler')
+const kThenifyDoNotWrap = Symbol('avvio.ThenifyDoNotWrap')
+const kUntrackNode = Symbol('avvio.TimeTree.untrackNode')
+const kTrackNode = Symbol('avvio.TimeTree.trackNode')
+const kGetParent = Symbol('avvio.TimeTree.getParent')
+const kGetNode = Symbol('avvio.TimeTree.getNode')
+const kAddNode = Symbol('avvio.TimeTree.addNode')
+
+// Public Symbols
+const kPluginMeta = Symbol.for('plugin-meta')
+
+module.exports = {
+  kAvvio,
+  kIsOnCloseHandler,
+  kThenifyDoNotWrap,
+  kUntrackNode,
+  kTrackNode,
+  kGetParent,
+  kGetNode,
+  kAddNode,
+  kPluginMeta
+}

novas/novacore-zephyr/claude-code-router/node_modules/avvio/lib/thenify.js

@@ -0,0 +1,60 @@
+'use strict'
+
+const { debug } = require('./debug')
+const { kThenifyDoNotWrap } = require('./symbols')
+
+/**
+ * @callback PromiseConstructorLikeResolve
+ * @param {any} value
+ * @returns {void}
+ */
+
+/**
+ * @callback PromiseConstructorLikeReject
+ * @param {reason} error
+ * @returns {void}
+ */
+
+/**
+ * @callback PromiseConstructorLike
+ * @param {PromiseConstructorLikeResolve} resolve
+ * @param {PromiseConstructorLikeReject} reject
+ * @returns {void}
+ */
+
+/**
+ * @returns {PromiseConstructorLike}
+ */
+function thenify () {
+  // If the instance is ready, then there is
+  // nothing to await. This is true during
+  // await server.ready() as ready() resolves
+  // with the server, end we will end up here
+  // because of automatic promise chaining.
+  if (this.booted) {
+    debug('thenify returning undefined because we are already booted')
+    return
+  }
+
+  // Calling resolve(this._server) would fetch the then
+  // property on the server, which will lead it here.
+  // If we do not break the recursion, we will loop
+  // forever.
+  if (this[kThenifyDoNotWrap]) {
+    this[kThenifyDoNotWrap] = false
+    return
+  }
+
+  debug('thenify')
+  return (resolve, reject) => {
+    const p = this._loadRegistered()
+    return p.then(() => {
+      this[kThenifyDoNotWrap] = true
+      return resolve(this._server)
+    }, reject)
+  }
+}
+
+module.exports = {
+  thenify
+}

novas/novacore-zephyr/claude-code-router/node_modules/avvio/lib/time-tree.js

@@ -0,0 +1,200 @@
+'use strict'
+
+const {
+  kUntrackNode,
+  kTrackNode,
+  kGetParent,
+  kGetNode,
+  kAddNode
+} = require('./symbols')
+
+/**
+ * Node of the TimeTree
+ * @typedef {object} TimeTreeNode
+ * @property {string} id
+ * @property {string|null} parent
+ * @property {string} label
+ * @property {Array<TimeTreeNode>} nodes
+ * @property {number} start
+ * @property {number|undefined} stop
+ * @property {number|undefined} diff
+ */
+
+class TimeTree {
+  constructor () {
+    /**
+     * @type {TimeTreeNode|null} root
+     * @public
+     */
+    this.root = null
+
+    /**
+     * @type {Map<string, TimeTreeNode>} tableId
+     * @public
+     */
+    this.tableId = new Map()
+
+    /**
+     * @type {Map<string, Array<TimeTreeNode>>} tableLabel
+     * @public
+     */
+    this.tableLabel = new Map()
+  }
+
+  /**
+   * @param {TimeTreeNode} node
+   */
+  [kTrackNode] (node) {
+    this.tableId.set(node.id, node)
+    if (this.tableLabel.has(node.label)) {
+      this.tableLabel.get(node.label).push(node)
+    } else {
+      this.tableLabel.set(node.label, [node])
+    }
+  }
+
+  /**
+   * @param {TimeTreeNode} node
+   */
+  [kUntrackNode] (node) {
+    this.tableId.delete(node.id)
+
+    const labelNode = this.tableLabel.get(node.label)
+    labelNode.pop()
+
+    if (labelNode.length === 0) {
+      this.tableLabel.delete(node.label)
+    }
+  }
+
+  /**
+   * @param {string} parent
+   * @returns {TimeTreeNode}
+   */
+  [kGetParent] (parent) {
+    if (parent === null) {
+      return null
+    } else if (this.tableLabel.has(parent)) {
+      const parentNode = this.tableLabel.get(parent)
+      return parentNode[parentNode.length - 1]
+    } else {
+      return null
+    }
+  }
+
+  /**
+   *
+   * @param {string} nodeId
+   * @returns {TimeTreeNode}
+   */
+  [kGetNode] (nodeId) {
+    return this.tableId.get(nodeId)
+  }
+
+  /**
+   * @param {string} parent
+   * @param {string} label
+   * @param {number} start
+   * @returns {TimeTreeNode["id"]}
+   */
+  [kAddNode] (parent, label, start) {
+    const parentNode = this[kGetParent](parent)
+    const isRoot = parentNode === null
+
+    if (isRoot) {
+      this.root = {
+        parent: null,
+        id: 'root',
+        label,
+        nodes: [],
+        start,
+        stop: null,
+        diff: -1
+      }
+      this[kTrackNode](this.root)
+      return this.root.id
+    }
+
+    const nodeId = `${label}-${Math.random()}`
+    /**
+     * @type {TimeTreeNode}
+     */
+    const childNode = {
+      parent,
+      id: nodeId,
+      label,
+      nodes: [],
+      start,
+      stop: null,
+      diff: -1
+    }
+    parentNode.nodes.push(childNode)
+    this[kTrackNode](childNode)
+    return nodeId
+  }
+
+  /**
+   * @param {string} parent
+   * @param {string} label
+   * @param {number|undefined} start
+   * @returns {TimeTreeNode["id"]}
+   */
+  start (parent, label, start = Date.now()) {
+    return this[kAddNode](parent, label, start)
+  }
+
+  /**
+   * @param {string} nodeId
+   * @param {number|undefined} stop
+   */
+  stop (nodeId, stop = Date.now()) {
+    const node = this[kGetNode](nodeId)
+    if (node) {
+      node.stop = stop
+      node.diff = (node.stop - node.start) || 0
+      this[kUntrackNode](node)
+    }
+  }
+
+  /**
+   * @returns {TimeTreeNode}
+   */
+  toJSON () {
+    return Object.assign({}, this.root)
+  }
+
+  /**
+   * @returns {string}
+   */
+  prettyPrint () {
+    return prettyPrintTimeTree(this.toJSON())
+  }
+}
+
+/**
+ * @param {TimeTreeNode} obj
+ * @param {string|undefined} prefix
+ * @returns {string}
+ */
+function prettyPrintTimeTree (obj, prefix = '') {
+  let result = prefix
+
+  const nodesCount = obj.nodes.length
+  const lastIndex = nodesCount - 1
+  result += `${obj.label} ${obj.diff} ms\n`
+
+  for (let i = 0; i < nodesCount; ++i) {
+    const node = obj.nodes[i]
+    const prefix_ = prefix + (i === lastIndex ? '  ' : '│ ')
+
+    result += prefix
+    result += (i === lastIndex ? '└─' : '├─')
+    result += (node.nodes.length === 0 ? '─ ' : '┬ ')
+    result += prettyPrintTimeTree(node, prefix_).slice(prefix.length + 2)
+  }
+  return result
+}
+
+module.exports = {
+  TimeTree
+}

novas/novacore-zephyr/claude-code-router/node_modules/avvio/lib/validate-plugin.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const { AVV_ERR_PLUGIN_NOT_VALID } = require('./errors')
+
+/**
+ * @param {any} maybePlugin
+ * @throws {AVV_ERR_PLUGIN_NOT_VALID}
+ *
+ * @returns {asserts plugin is Function|PromiseLike}
+ */
+function validatePlugin (maybePlugin) {
+  // validate if plugin is a function or Promise
+  if (!(maybePlugin && (typeof maybePlugin === 'function' || typeof maybePlugin.then === 'function'))) {
+    if (Array.isArray(maybePlugin)) {
+      throw new AVV_ERR_PLUGIN_NOT_VALID('array')
+    } else if (maybePlugin === null) {
+      throw new AVV_ERR_PLUGIN_NOT_VALID('null')
+    } else {
+      throw new AVV_ERR_PLUGIN_NOT_VALID(typeof maybePlugin)
+    }
+  }
+}
+
+module.exports = {
+  validatePlugin
+}

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/after-and-ready.test.js

@@ -0,0 +1,864 @@
+'use strict'
+
+const { test } = require('tap')
+const boot = require('..')
+
+test('boot a plugin and then execute a call after that', (t) => {
+  t.plan(5)
+
+  const app = boot()
+  let pluginLoaded = false
+  let afterCalled = false
+
+  app.use(function (s, opts, done) {
+    t.notOk(afterCalled, 'after not called')
+    pluginLoaded = true
+    done()
+  })
+
+  app.after(function (err, cb) {
+    t.error(err)
+    t.ok(pluginLoaded, 'afterred!')
+    afterCalled = true
+    cb()
+  })
+
+  app.on('start', () => {
+    t.ok(afterCalled, 'after called')
+    t.ok(pluginLoaded, 'plugin loaded')
+  })
+})
+
+test('after without a done callback', (t) => {
+  t.plan(5)
+
+  const app = boot()
+  let pluginLoaded = false
+  let afterCalled = false
+
+  app.use(function (s, opts, done) {
+    t.notOk(afterCalled, 'after not called')
+    pluginLoaded = true
+    done()
+  })
+
+  app.after(function (err) {
+    t.error(err)
+    t.ok(pluginLoaded, 'afterred!')
+    afterCalled = true
+  })
+
+  app.on('start', () => {
+    t.ok(afterCalled, 'after called')
+    t.ok(pluginLoaded, 'plugin loaded')
+  })
+})
+
+test('verify when a afterred call happens', (t) => {
+  t.plan(3)
+
+  const app = boot()
+
+  app.use(function (s, opts, done) {
+    done()
+  })
+
+  app.after(function (err, cb) {
+    t.error(err)
+    t.pass('afterred finished')
+    cb()
+  })
+
+  app.on('start', () => {
+    t.pass('booted')
+  })
+})
+
+test('internal after', (t) => {
+  t.plan(18)
+
+  const app = boot()
+  let firstLoaded = false
+  let secondLoaded = false
+  let thirdLoaded = false
+  let afterCalled = false
+
+  app.use(first)
+  app.use(third)
+
+  function first (s, opts, done) {
+    t.notOk(firstLoaded, 'first is not loaded')
+    t.notOk(secondLoaded, 'second is not loaded')
+    t.notOk(thirdLoaded, 'third is not loaded')
+    firstLoaded = true
+    s.use(second)
+    s.after(function (err, cb) {
+      t.error(err)
+      t.notOk(afterCalled, 'after was not called')
+      afterCalled = true
+      cb()
+    })
+    done()
+  }
+
+  function second (s, opts, done) {
+    t.ok(firstLoaded, 'first is loaded')
+    t.notOk(secondLoaded, 'second is not loaded')
+    t.notOk(thirdLoaded, 'third is not loaded')
+    t.notOk(afterCalled, 'after was not called')
+    secondLoaded = true
+    done()
+  }
+
+  function third (s, opts, done) {
+    t.ok(firstLoaded, 'first is loaded')
+    t.ok(secondLoaded, 'second is loaded')
+    t.ok(afterCalled, 'after was called')
+    t.notOk(thirdLoaded, 'third is not loaded')
+    thirdLoaded = true
+    done()
+  }
+
+  app.on('start', () => {
+    t.ok(firstLoaded, 'first is loaded')
+    t.ok(secondLoaded, 'second is loaded')
+    t.ok(thirdLoaded, 'third is loaded')
+    t.ok(afterCalled, 'after was called')
+    t.pass('booted')
+  })
+})
+
+test('ready adds at the end of the queue', (t) => {
+  t.plan(14)
+
+  const app = boot()
+  let pluginLoaded = false
+  let afterCalled = false
+  let readyCalled = false
+
+  app.ready(function (err, cb) {
+    t.error(err)
+    t.ok(pluginLoaded, 'after the plugin')
+    t.ok(afterCalled, 'after after')
+    readyCalled = true
+    process.nextTick(cb)
+  })
+
+  app.use(function (s, opts, done) {
+    t.notOk(afterCalled, 'after not called')
+    t.notOk(readyCalled, 'ready not called')
+    pluginLoaded = true
+
+    app.ready(function (err) {
+      t.error(err)
+      t.ok(readyCalled, 'after the first ready')
+      t.ok(afterCalled, 'after the after callback')
+    })
+
+    done()
+  })
+
+  app.after(function (err, cb) {
+    t.error(err)
+    t.ok(pluginLoaded, 'executing after!')
+    t.notOk(readyCalled, 'ready not called')
+    afterCalled = true
+    cb()
+  })
+
+  app.on('start', () => {
+    t.ok(afterCalled, 'after called')
+    t.ok(pluginLoaded, 'plugin loaded')
+    t.ok(readyCalled, 'ready called')
+  })
+})
+
+test('if the after/ready callback has two parameters, the first one must be the context', (t) => {
+  t.plan(4)
+
+  const server = { my: 'server' }
+  const app = boot(server)
+
+  app.use(function (s, opts, done) {
+    done()
+  })
+
+  app.after(function (err, context, cb) {
+    t.error(err)
+    t.equal(server, context)
+    cb()
+  })
+
+  app.ready(function (err, context, cb) {
+    t.error(err)
+    t.equal(server, context)
+    cb()
+  })
+})
+
+test('if the after/ready async, the returns must be the context generated', (t) => {
+  t.plan(3)
+
+  const server = { my: 'server', index: 0 }
+  const app = boot(server)
+  app.override = function (old) {
+    return { ...old, index: old.index + 1 }
+  }
+
+  app.use(function (s, opts, done) {
+    s.use(function (s, opts, done) {
+      s.ready().then(itself => t.same(itself, s, 'deep deep'))
+      done()
+    })
+    s.ready().then(itself => t.same(itself, s, 'deep'))
+    done()
+  })
+
+  app.ready().then(itself => t.same(itself, server, 'outer'))
+})
+
+test('if the after/ready callback, the returns must be the context generated', (t) => {
+  t.plan(3)
+
+  const server = { my: 'server', index: 0 }
+  const app = boot(server)
+  app.override = function (old) {
+    return { ...old, index: old.index + 1 }
+  }
+
+  app.use(function (s, opts, done) {
+    s.use(function (s, opts, done) {
+      s.ready((_, itself, done) => {
+        t.same(itself, s, 'deep deep')
+        done()
+      })
+      done()
+    })
+    s.ready((_, itself, done) => {
+      t.same(itself, s, 'deep')
+      done()
+    })
+    done()
+  })
+
+  app.ready((_, itself, done) => {
+    t.same(itself, server, 'outer')
+    done()
+  })
+})
+
+test('error should come in the first after - one parameter', (t) => {
+  t.plan(3)
+
+  const server = { my: 'server' }
+  const app = boot(server)
+
+  app.use(function (s, opts, done) {
+    done(new Error('err'))
+  })
+
+  app.after(function (err) {
+    t.ok(err instanceof Error)
+    t.equal(err.message, 'err')
+  })
+
+  app.ready(function (err) {
+    t.error(err)
+  })
+})
+
+test('error should come in the first after - two parameters', (t) => {
+  t.plan(3)
+
+  const server = { my: 'server' }
+  const app = boot(server)
+
+  app.use(function (s, opts, done) {
+    done(new Error('err'))
+  })
+
+  app.after(function (err, cb) {
+    t.ok(err instanceof Error)
+    t.equal(err.message, 'err')
+    cb()
+  })
+
+  app.ready(function (err) {
+    t.error(err)
+  })
+})
+
+test('error should come in the first after - three parameter', (t) => {
+  t.plan(4)
+
+  const server = { my: 'server' }
+  const app = boot(server)
+
+  app.use(function (s, opts, done) {
+    done(new Error('err'))
+  })
+
+  app.after(function (err, context, cb) {
+    t.ok(err instanceof Error)
+    t.equal(err.message, 'err')
+    t.equal(context, server)
+    cb()
+  })
+
+  app.ready(function (err) {
+    t.error(err)
+  })
+})
+
+test('error should come in the first ready - one parameter', (t) => {
+  t.plan(2)
+
+  const server = { my: 'server' }
+  const app = boot(server)
+
+  app.use(function (s, opts, done) {
+    done(new Error('err'))
+  })
+
+  app.ready(function (err) {
+    t.ok(err instanceof Error)
+    t.equal(err.message, 'err')
+  })
+})
+
+test('error should come in the first ready - two parameters', (t) => {
+  t.plan(2)
+
+  const server = { my: 'server' }
+  const app = boot(server)
+
+  app.use(function (s, opts, done) {
+    done(new Error('err'))
+  })
+
+  app.ready(function (err, cb) {
+    t.ok(err instanceof Error)
+    t.equal(err.message, 'err')
+    cb()
+  })
+})
+
+test('error should come in the first ready - three parameters', (t) => {
+  t.plan(3)
+
+  const server = { my: 'server' }
+  const app = boot(server)
+
+  app.use(function (s, opts, done) {
+    done(new Error('err'))
+  })
+
+  app.ready(function (err, context, cb) {
+    t.ok(err instanceof Error)
+    t.equal(err.message, 'err')
+    t.equal(context, server)
+    cb()
+  })
+})
+
+test('if `use` has a callback with more then one parameter, the error must not reach ready', (t) => {
+  t.plan(1)
+
+  const server = { my: 'server' }
+  const app = boot(server)
+
+  app.use(function (s, opts, done) {
+    done(new Error('err'))
+  })
+
+  app.ready(function (err) {
+    t.ok(err)
+  })
+})
+
+test('if `use` has a callback without parameters, the error must reach ready', (t) => {
+  t.plan(1)
+
+  const server = { my: 'server' }
+  const app = boot(server)
+
+  app.use(function (s, opts, done) {
+    done(new Error('err'))
+  }, () => {})
+
+  app.ready(function (err) {
+    t.ok(err)
+  })
+})
+
+test('should pass the errors from after to ready', (t) => {
+  t.plan(6)
+
+  const server = {}
+  const app = boot(server, {})
+
+  server.use(function (s, opts, done) {
+    t.equal(s, server, 'the first argument is the server')
+    t.same(opts, {}, 'no options')
+    done()
+  }).after((err, done) => {
+    t.error(err)
+    done(new Error('some error'))
+  })
+
+  server.onClose(() => {
+    t.ok('onClose called')
+  })
+
+  server.ready(err => {
+    t.equal(err.message, 'some error')
+  })
+
+  app.on('start', () => {
+    server.close(() => {
+      t.pass('booted')
+    })
+  })
+})
+
+test('after no encapsulation', t => {
+  t.plan(4)
+
+  const app = boot()
+  app.override = function (s, fn, opts) {
+    s = Object.create(s)
+    return s
+  }
+
+  app.use(function (instance, opts, next) {
+    instance.test = true
+    instance.after(function (err, i, done) {
+      t.error(err)
+      t.notOk(i.test)
+      done()
+    })
+    next()
+  })
+
+  app.after(function (err, i, done) {
+    t.error(err)
+    t.notOk(i.test)
+    done()
+  })
+})
+
+test('ready no encapsulation', t => {
+  t.plan(4)
+
+  const app = boot()
+  app.override = function (s, fn, opts) {
+    s = Object.create(s)
+    return s
+  }
+
+  app.use(function (instance, opts, next) {
+    instance.test = true
+    instance.ready(function (err, i, done) {
+      t.error(err)
+      t.notOk(i.test)
+      done()
+    })
+    next()
+  })
+
+  app.ready(function (err, i, done) {
+    t.error(err)
+    t.notOk(i.test)
+    done()
+  })
+})
+
+test('after encapsulation with a server', t => {
+  t.plan(4)
+
+  const server = { my: 'server' }
+  const app = boot(server)
+  app.override = function (s, fn, opts) {
+    s = Object.create(s)
+    return s
+  }
+
+  app.use(function (instance, opts, next) {
+    instance.test = true
+    instance.after(function (err, i, done) {
+      t.error(err)
+      t.ok(i.test)
+      done()
+    })
+    next()
+  })
+
+  app.after(function (err, i, done) {
+    t.error(err)
+    t.notOk(i.test)
+    done()
+  })
+})
+
+test('ready encapsulation with a server', t => {
+  t.plan(4)
+
+  const server = { my: 'server' }
+  const app = boot(server)
+  app.override = function (s, fn, opts) {
+    s = Object.create(s)
+    return s
+  }
+
+  app.use(function (instance, opts, next) {
+    instance.test = true
+    instance.ready(function (err, i, done) {
+      t.error(err)
+      t.ok(i.test)
+      done()
+    })
+    next()
+  })
+
+  app.ready(function (err, i, done) {
+    t.error(err)
+    t.notOk(i.test)
+    done()
+  })
+})
+
+test('after should passthrough the errors', (t) => {
+  t.plan(5)
+
+  const app = boot()
+  let pluginLoaded = false
+  let afterCalled = false
+
+  app.use(function (s, opts, done) {
+    t.notOk(afterCalled, 'after not called')
+    pluginLoaded = true
+    done(new Error('kaboom'))
+  })
+
+  app.after(function () {
+    t.ok(pluginLoaded, 'afterred!')
+    afterCalled = true
+  })
+
+  app.ready(function (err) {
+    t.ok(err)
+    t.ok(afterCalled, 'after called')
+    t.ok(pluginLoaded, 'plugin loaded')
+  })
+})
+
+test('stop loading plugins if it errors', (t) => {
+  t.plan(2)
+
+  const app = boot()
+
+  app.use(function first (server, opts, done) {
+    t.pass('first called')
+    done(new Error('kaboom'))
+  })
+
+  app.use(function second (server, opts, done) {
+    t.fail('this should never be called')
+  })
+
+  app.ready((err) => {
+    t.equal(err.message, 'kaboom')
+  })
+})
+
+test('keep loading if there is an .after', (t) => {
+  t.plan(4)
+
+  const app = boot()
+
+  app.use(function first (server, opts, done) {
+    t.pass('first called')
+    done(new Error('kaboom'))
+  })
+
+  app.after(function (err) {
+    t.equal(err.message, 'kaboom')
+  })
+
+  app.use(function second (server, opts, done) {
+    t.pass('second called')
+    done()
+  })
+
+  app.ready((err) => {
+    t.error(err)
+  })
+})
+
+test('do not load nested plugin if parent errors', (t) => {
+  t.plan(4)
+
+  const app = boot()
+
+  app.use(function first (server, opts, done) {
+    t.pass('first called')
+
+    server.use(function second (_, opts, done) {
+      t.fail('this should never be called')
+    })
+
+    done(new Error('kaboom'))
+  })
+
+  app.after(function (err) {
+    t.equal(err.message, 'kaboom')
+  })
+
+  app.use(function third (server, opts, done) {
+    t.pass('third called')
+    done()
+  })
+
+  app.ready((err) => {
+    t.error(err)
+  })
+})
+
+test('.after nested', (t) => {
+  t.plan(4)
+
+  const app = boot()
+
+  app.use(function outer (app, opts, done) {
+    app.use(function first (app, opts, done) {
+      t.pass('first called')
+      done(new Error('kaboom'))
+    })
+
+    app.after(function (err) {
+      t.equal(err.message, 'kaboom')
+    })
+
+    app.use(function second (app, opts, done) {
+      t.pass('second called')
+      done()
+    })
+
+    done()
+  })
+
+  app.ready((err) => {
+    t.error(err)
+  })
+})
+
+test('nested error', (t) => {
+  t.plan(4)
+
+  const app = boot()
+
+  app.use(function outer (app, opts, done) {
+    app.use(function first (app, opts, done) {
+      t.pass('first called')
+      done(new Error('kaboom'))
+    })
+
+    app.use(function second (app, opts, done) {
+      t.fail('this should never be called')
+    })
+
+    done()
+  })
+
+  app.after(function (err) {
+    t.equal(err.message, 'kaboom')
+  })
+
+  app.use(function third (server, opts, done) {
+    t.pass('third called')
+    done()
+  })
+
+  app.ready((err) => {
+    t.error(err)
+  })
+})
+
+test('preReady event', (t) => {
+  t.plan(4)
+
+  const app = boot()
+  const order = [1, 2]
+
+  app.use(function first (server, opts, done) {
+    t.pass('first called')
+    done()
+  })
+
+  app.use(function second (server, opts, done) {
+    t.pass('second called')
+    done()
+  })
+
+  app.on('preReady', () => {
+    t.equal(order.shift(), 1)
+  })
+
+  app.ready(() => {
+    t.equal(order.shift(), 2)
+  })
+})
+
+test('preReady event (multiple)', (t) => {
+  t.plan(6)
+
+  const app = boot()
+  const order = [1, 2, 3, 4]
+
+  app.use(function first (server, opts, done) {
+    t.pass('first called')
+    done()
+  })
+
+  app.use(function second (server, opts, done) {
+    t.pass('second called')
+    done()
+  })
+
+  app.on('preReady', () => {
+    t.equal(order.shift(), 1)
+  })
+
+  app.on('preReady', () => {
+    t.equal(order.shift(), 2)
+  })
+
+  app.on('preReady', () => {
+    t.equal(order.shift(), 3)
+  })
+
+  app.ready(() => {
+    t.equal(order.shift(), 4)
+  })
+})
+
+test('preReady event (nested)', (t) => {
+  t.plan(6)
+
+  const app = boot()
+  const order = [1, 2, 3, 4]
+
+  app.use(function first (server, opts, done) {
+    t.pass('first called')
+    done()
+  })
+
+  app.use(function second (server, opts, done) {
+    t.pass('second called')
+
+    server.on('preReady', () => {
+      t.equal(order.shift(), 3)
+    })
+
+    done()
+  })
+
+  app.on('preReady', () => {
+    t.equal(order.shift(), 1)
+  })
+
+  app.on('preReady', () => {
+    t.equal(order.shift(), 2)
+  })
+
+  app.ready(() => {
+    t.equal(order.shift(), 4)
+  })
+})
+
+test('preReady event (errored)', (t) => {
+  t.plan(5)
+
+  const app = boot()
+  const order = [1, 2, 3]
+
+  app.use(function first (server, opts, done) {
+    t.pass('first called')
+    done(new Error('kaboom'))
+  })
+
+  app.use(function second (server, opts, done) {
+    t.fail('We should not be here')
+  })
+
+  app.on('preReady', () => {
+    t.equal(order.shift(), 1)
+  })
+
+  app.on('preReady', () => {
+    t.equal(order.shift(), 2)
+  })
+
+  app.ready((err) => {
+    t.ok(err)
+    t.equal(order.shift(), 3)
+  })
+})
+
+test('after return self', (t) => {
+  t.plan(6)
+
+  const app = boot()
+  let pluginLoaded = false
+  let afterCalled = false
+  let second = false
+
+  app.use(function (s, opts, done) {
+    t.notOk(afterCalled, 'after not called')
+    pluginLoaded = true
+    done()
+  })
+
+  app.after(function () {
+    t.ok(pluginLoaded, 'afterred!')
+    afterCalled = true
+    // happens with after(() => app.use(..))
+    return app
+  })
+
+  app.use(function (s, opts, done) {
+    t.ok(afterCalled, 'after called')
+    second = true
+    done()
+  })
+
+  app.on('start', () => {
+    t.ok(afterCalled, 'after called')
+    t.ok(pluginLoaded, 'plugin loaded')
+    t.ok(second, 'second plugin loaded')
+  })
+})
+
+test('after 1 param swallows errors with server and timeout', (t) => {
+  t.plan(3)
+
+  const server = {}
+  boot(server, { autostart: false, timeout: 1000 })
+
+  server.use(function first (server, opts, done) {
+    t.pass('first called')
+    done(new Error('kaboom'))
+  })
+
+  server.use(function second (server, opts, done) {
+    t.fail('We should not be here')
+  })
+
+  server.after(function (err) {
+    t.ok(err)
+  })
+
+  server.ready(function (err) {
+    t.error(err)
+  })
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/after-pass-through.test.js

@@ -0,0 +1,32 @@
+'use strict'
+
+const { test } = require('tap')
+const boot = require('..')
+
+test('proper support for after with a passed async function in wrapped mode', (t) => {
+  const app = {}
+  boot(app)
+
+  t.plan(5)
+
+  const e = new Error('kaboom')
+
+  app.use(function (f, opts) {
+    return Promise.reject(e)
+  }).after(function (err, cb) {
+    t.equal(err, e)
+    cb(err)
+  }).after(function () {
+    t.pass('this is just called')
+  }).after(function (err, cb) {
+    t.equal(err, e)
+    cb(err)
+  })
+
+  app.ready().then(() => {
+    t.fail('this should not be called')
+  }).catch(err => {
+    t.ok(err)
+    t.equal(err.message, 'kaboom')
+  })
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/after-self-promise.test.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const { test } = require('tap')
+const boot = require('..')
+
+test('after does not await itself', async (t) => {
+  t.plan(3)
+
+  const app = {}
+  boot(app)
+
+  app.use(async (app) => {
+    t.pass('plugin init')
+  })
+  app.after(() => app)
+  t.pass('reachable')
+
+  await app.ready()
+  t.pass('reachable')
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/after-throw.test.js

@@ -0,0 +1,24 @@
+'use strict'
+
+const { test } = require('tap')
+const boot = require('..')
+
+test('catched error by Promise.reject', (t) => {
+  const app = boot()
+  t.plan(2)
+
+  t.threw = function (err) {
+    t.equal(err.message, 'kaboom2')
+  }
+
+  app.use(function (f, opts) {
+    return Promise.reject(new Error('kaboom'))
+  }).after(function (err) {
+    t.equal(err.message, 'kaboom')
+    throw new Error('kaboom2')
+  })
+
+  app.ready(function () {
+    t.fail('the ready callback should never be called')
+  })
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/after-use-after.test.js

@@ -0,0 +1,90 @@
+'use strict'
+
+const { test } = require('tap')
+const boot = require('..')
+const app = {}
+
+boot(app)
+
+test('multi after', (t) => {
+  t.plan(6)
+
+  app.use(function (f, opts, cb) {
+    cb()
+  }).after(() => {
+    t.pass('this is just called')
+
+    app.use(function (f, opts, cb) {
+      t.pass('this is just called')
+      cb()
+    })
+  }).after(function () {
+    t.pass('this is just called')
+    app.use(function (f, opts, cb) {
+      t.pass('this is just called')
+      cb()
+    })
+  }).after(function (err, cb) {
+    t.pass('this is just called')
+    cb(err)
+  })
+
+  app.ready().then(() => {
+    t.pass('ready')
+  }).catch(() => {
+    t.fail('this should not be called')
+  })
+})
+
+test('after grouping - use called after after called', (t) => {
+  t.plan(9)
+  const app = {}
+  boot(app)
+
+  const TEST_VALUE = {}
+  const OTHER_TEST_VALUE = {}
+  const NEW_TEST_VALUE = {}
+
+  const sO = (fn) => {
+    fn[Symbol.for('skip-override')] = true
+    return fn
+  }
+
+  app.use(sO(function (f, options, next) {
+    f.test = TEST_VALUE
+
+    next()
+  }))
+
+  app.after(function (err, f, done) {
+    t.error(err)
+    t.equal(f.test, TEST_VALUE)
+
+    f.test2 = OTHER_TEST_VALUE
+    done()
+  })
+
+  app.use(sO(function (f, options, next) {
+    t.equal(f.test, TEST_VALUE)
+    t.equal(f.test2, OTHER_TEST_VALUE)
+
+    f.test3 = NEW_TEST_VALUE
+
+    next()
+  }))
+
+  app.after(function (err, f, done) {
+    t.error(err)
+    t.equal(f.test, TEST_VALUE)
+    t.equal(f.test2, OTHER_TEST_VALUE)
+    t.equal(f.test3, NEW_TEST_VALUE)
+    done()
+  })
+
+  app.ready().then(() => {
+    t.pass('ready')
+  }).catch((e) => {
+    console.log(e)
+    t.fail('this should not be called')
+  })
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/async-await.test.js

@@ -0,0 +1,325 @@
+'use strict'
+
+/* eslint no-prototype-builtins: off */
+
+const { test } = require('tap')
+const sleep = function (ms) {
+  return new Promise(function (resolve) {
+    setTimeout(resolve, ms)
+  })
+}
+
+const boot = require('..')
+
+test('one level', async (t) => {
+  t.plan(14)
+
+  const app = boot()
+  let firstLoaded = false
+  let secondLoaded = false
+  let thirdLoaded = false
+
+  app.use(first)
+  app.use(third)
+
+  async function first (s, opts) {
+    t.notOk(firstLoaded, 'first is not loaded')
+    t.notOk(secondLoaded, 'second is not loaded')
+    t.notOk(thirdLoaded, 'third is not loaded')
+    firstLoaded = true
+    s.use(second)
+  }
+
+  async function second (s, opts) {
+    t.ok(firstLoaded, 'first is loaded')
+    t.notOk(secondLoaded, 'second is not loaded')
+    t.notOk(thirdLoaded, 'third is not loaded')
+    secondLoaded = true
+  }
+
+  async function third (s, opts) {
+    t.ok(firstLoaded, 'first is loaded')
+    t.ok(secondLoaded, 'second is loaded')
+    t.notOk(thirdLoaded, 'third is not loaded')
+    thirdLoaded = true
+  }
+
+  const readyContext = await app.ready()
+
+  t.equal(app, readyContext)
+  t.ok(firstLoaded, 'first is loaded')
+  t.ok(secondLoaded, 'second is loaded')
+  t.ok(thirdLoaded, 'third is loaded')
+  t.pass('booted')
+})
+
+test('multiple reentrant plugin loading', async (t) => {
+  t.plan(31)
+
+  const app = boot()
+  let firstLoaded = false
+  let secondLoaded = false
+  let thirdLoaded = false
+  let fourthLoaded = false
+  let fifthLoaded = false
+
+  app.use(first)
+  app.use(fifth)
+
+  async function first (s, opts) {
+    t.notOk(firstLoaded, 'first is not loaded')
+    t.notOk(secondLoaded, 'second is not loaded')
+    t.notOk(thirdLoaded, 'third is not loaded')
+    t.notOk(fourthLoaded, 'fourth is not loaded')
+    t.notOk(fifthLoaded, 'fifth is not loaded')
+    firstLoaded = true
+    s.use(second)
+  }
+
+  async function second (s, opts) {
+    t.ok(firstLoaded, 'first is loaded')
+    t.notOk(secondLoaded, 'second is not loaded')
+    t.notOk(thirdLoaded, 'third is not loaded')
+    t.notOk(fourthLoaded, 'fourth is not loaded')
+    t.notOk(fifthLoaded, 'fifth is not loaded')
+    secondLoaded = true
+    s.use(third)
+    await sleep(10)
+    s.use(fourth)
+  }
+
+  async function third (s, opts) {
+    t.ok(firstLoaded, 'first is loaded')
+    t.ok(secondLoaded, 'second is loaded')
+    t.notOk(thirdLoaded, 'third is not loaded')
+    t.notOk(fourthLoaded, 'fourth is not loaded')
+    t.notOk(fifthLoaded, 'fifth is not loaded')
+    thirdLoaded = true
+  }
+
+  async function fourth (s, opts) {
+    t.ok(firstLoaded, 'first is loaded')
+    t.ok(secondLoaded, 'second is loaded')
+    t.ok(thirdLoaded, 'third is loaded')
+    t.notOk(fourthLoaded, 'fourth is not loaded')
+    t.notOk(fifthLoaded, 'fifth is not loaded')
+    fourthLoaded = true
+  }
+
+  async function fifth (s, opts) {
+    t.ok(firstLoaded, 'first is loaded')
+    t.ok(secondLoaded, 'second is loaded')
+    t.ok(thirdLoaded, 'third is loaded')
+    t.ok(fourthLoaded, 'fourth is loaded')
+    t.notOk(fifthLoaded, 'fifth is not loaded')
+    fifthLoaded = true
+  }
+
+  await app.ready()
+  t.ok(firstLoaded, 'first is loaded')
+  t.ok(secondLoaded, 'second is loaded')
+  t.ok(thirdLoaded, 'third is loaded')
+  t.ok(fourthLoaded, 'fourth is loaded')
+  t.ok(fifthLoaded, 'fifth is loaded')
+  t.pass('booted')
+})
+
+test('async ready plugin registration (errored)', async (t) => {
+  t.plan(1)
+
+  const app = boot()
+
+  app.use(async (server, opts) => {
+    await sleep(10)
+    throw new Error('kaboom')
+  })
+
+  try {
+    await app.ready()
+    t.fail('we should not be here')
+  } catch (err) {
+    t.equal(err.message, 'kaboom')
+  }
+})
+
+test('after', async (t) => {
+  t.plan(15)
+
+  const app = boot()
+  let firstLoaded = false
+  let secondLoaded = false
+  let thirdLoaded = false
+
+  app.use(first)
+
+  async function first (s, opts) {
+    t.notOk(firstLoaded, 'first is not loaded')
+    t.notOk(secondLoaded, 'second is not loaded')
+    t.notOk(thirdLoaded, 'third is not loaded')
+    firstLoaded = true
+    s.after(second)
+    s.after(third)
+  }
+
+  async function second (err) {
+    t.error(err)
+    t.ok(firstLoaded, 'first is loaded')
+    t.notOk(secondLoaded, 'second is not loaded')
+    t.notOk(thirdLoaded, 'third is not loaded')
+    await sleep(10)
+    secondLoaded = true
+  }
+
+  async function third () {
+    t.ok(firstLoaded, 'first is loaded')
+    t.ok(secondLoaded, 'second is loaded')
+    t.notOk(thirdLoaded, 'third is not loaded')
+    await sleep(10)
+    thirdLoaded = true
+  }
+
+  const readyContext = await app.ready()
+
+  t.equal(app, readyContext)
+  t.ok(firstLoaded, 'first is loaded')
+  t.ok(secondLoaded, 'second is loaded')
+  t.ok(thirdLoaded, 'third is loaded')
+  t.pass('booted')
+})
+
+test('after wrapped', async (t) => {
+  t.plan(15)
+
+  const app = {}
+  boot(app)
+  let firstLoaded = false
+  let secondLoaded = false
+  let thirdLoaded = false
+
+  app.use(first)
+
+  async function first (s, opts) {
+    t.notOk(firstLoaded, 'first is not loaded')
+    t.notOk(secondLoaded, 'second is not loaded')
+    t.notOk(thirdLoaded, 'third is not loaded')
+    firstLoaded = true
+    s.after(second)
+    s.after(third)
+  }
+
+  async function second (err) {
+    t.error(err)
+    t.ok(firstLoaded, 'first is loaded')
+    t.notOk(secondLoaded, 'second is not loaded')
+    t.notOk(thirdLoaded, 'third is not loaded')
+    await sleep(10)
+    secondLoaded = true
+  }
+
+  async function third () {
+    t.ok(firstLoaded, 'first is loaded')
+    t.ok(secondLoaded, 'second is loaded')
+    t.notOk(thirdLoaded, 'third is not loaded')
+    await sleep(10)
+    thirdLoaded = true
+  }
+
+  const readyContext = await app.ready()
+
+  t.equal(app, readyContext)
+  t.ok(firstLoaded, 'first is loaded')
+  t.ok(secondLoaded, 'second is loaded')
+  t.ok(thirdLoaded, 'third is loaded')
+  t.pass('booted')
+})
+
+test('promise plugins', async (t) => {
+  t.plan(14)
+
+  const app = boot()
+  let firstLoaded = false
+  let secondLoaded = false
+  let thirdLoaded = false
+
+  app.use(first())
+  app.use(third())
+
+  async function first () {
+    return async function (s, opts) {
+      t.notOk(firstLoaded, 'first is not loaded')
+      t.notOk(secondLoaded, 'second is not loaded')
+      t.notOk(thirdLoaded, 'third is not loaded')
+      firstLoaded = true
+      s.use(second())
+    }
+  }
+
+  async function second () {
+    return async function (s, opts) {
+      t.ok(firstLoaded, 'first is loaded')
+      t.notOk(secondLoaded, 'second is not loaded')
+      t.notOk(thirdLoaded, 'third is not loaded')
+      secondLoaded = true
+    }
+  }
+
+  async function third () {
+    return async function (s, opts) {
+      t.ok(firstLoaded, 'first is loaded')
+      t.ok(secondLoaded, 'second is loaded')
+      t.notOk(thirdLoaded, 'third is not loaded')
+      thirdLoaded = true
+    }
+  }
+
+  const readyContext = await app.ready()
+
+  t.equal(app, readyContext)
+  t.ok(firstLoaded, 'first is loaded')
+  t.ok(secondLoaded, 'second is loaded')
+  t.ok(thirdLoaded, 'third is loaded')
+  t.pass('booted')
+})
+
+test('skip override with promise', (t) => {
+  t.plan(3)
+
+  const server = { my: 'server' }
+  const app = boot(server)
+
+  app.override = function (s, func) {
+    t.pass('override called')
+
+    if (func[Symbol.for('skip-override')]) {
+      return s
+    }
+    return Object.create(s)
+  }
+
+  app.use(first())
+
+  async function first () {
+    async function fn (s, opts) {
+      t.equal(s, server)
+      t.notOk(Object.prototype.isPrototypeOf.call(server, s))
+    }
+
+    fn[Symbol.for('skip-override')] = true
+
+    return fn
+  }
+})
+
+test('ready queue error', async (t) => {
+  const app = boot()
+  app.use(first)
+
+  async function first (s, opts) {}
+
+  app.ready(function (_, worker, done) {
+    const error = new Error('kaboom')
+    done(error)
+  })
+
+  await t.rejects(app.ready(), { message: 'kaboom' })
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/await-after.test.js

@@ -0,0 +1,449 @@
+'use strict'
+
+const { test } = require('tap')
+const boot = require('..')
+const { promisify } = require('node:util')
+const sleep = promisify(setTimeout)
+const fs = require('node:fs').promises
+const path = require('node:path')
+
+test('await after - nested plugins with same tick callbacks', async (t) => {
+  const app = {}
+  boot(app)
+
+  let secondLoaded = false
+
+  app.use(async (app) => {
+    t.pass('plugin init')
+    app.use(async () => {
+      t.pass('plugin2 init')
+      await sleep(1)
+      secondLoaded = true
+    })
+  })
+  await app.after()
+  t.pass('reachable')
+  t.equal(secondLoaded, true)
+
+  await app.ready()
+  t.pass('reachable')
+})
+
+test('await after without server', async (t) => {
+  const app = boot()
+
+  let secondLoaded = false
+
+  app.use(async (app) => {
+    t.pass('plugin init')
+    app.use(async () => {
+      t.pass('plugin2 init')
+      await sleep(1)
+      secondLoaded = true
+    })
+  })
+  await app.after()
+  t.pass('reachable')
+  t.equal(secondLoaded, true)
+
+  await app.ready()
+  t.pass('reachable')
+})
+
+test('await after with cb functions', async (t) => {
+  const app = boot()
+  let secondLoaded = false
+  let record = ''
+
+  app.use(async (app) => {
+    t.pass('plugin init')
+    record += 'plugin|'
+    app.use(async () => {
+      t.pass('plugin2 init')
+      record += 'plugin2|'
+      await sleep(1)
+      secondLoaded = true
+    })
+  })
+  await app.after(() => {
+    record += 'after|'
+  })
+  t.pass('reachable')
+  t.equal(secondLoaded, true)
+  record += 'ready'
+  await app.ready()
+  t.pass('reachable')
+  t.equal(record, 'plugin|plugin2|after|ready')
+})
+
+test('await after - nested plugins with future tick callbacks', async (t) => {
+  const app = {}
+  boot(app)
+
+  t.plan(4)
+
+  app.use((f, opts, cb) => {
+    t.pass('plugin init')
+    app.use((f, opts, cb) => {
+      t.pass('plugin2 init')
+      setImmediate(cb)
+    })
+    setImmediate(cb)
+  })
+  await app.after()
+  t.pass('reachable')
+
+  await app.ready()
+  t.pass('reachable')
+})
+
+test('await after - nested async function plugins', async (t) => {
+  const app = {}
+  boot(app)
+
+  t.plan(5)
+
+  app.use(async (f, opts) => {
+    t.pass('plugin init')
+    await app.use(async (f, opts) => {
+      t.pass('plugin2 init')
+    })
+    t.pass('reachable')
+  })
+  await app.after()
+  t.pass('reachable')
+
+  await app.ready()
+  t.pass('reachable')
+})
+
+test('await after - promise resolves to undefined', async (t) => {
+  const app = {}
+  boot(app)
+
+  t.plan(4)
+
+  app.use(async (f, opts, cb) => {
+    app.use((f, opts, cb) => {
+      t.pass('plugin init')
+      cb()
+    })
+    const instance = await app.after()
+    t.equal(instance, undefined)
+  })
+  t.pass('reachable')
+
+  await app.ready()
+  t.pass('reachable')
+})
+
+test('await after - promise returning function plugins + promise chaining', async (t) => {
+  const app = {}
+  boot(app)
+
+  t.plan(6)
+
+  app.use((f, opts) => {
+    t.pass('plugin init')
+    return app.use((f, opts) => {
+      t.pass('plugin2 init')
+      return Promise.resolve()
+    }).then((f2) => {
+      t.equal(f2, f)
+      return 'test'
+    }).then((val) => {
+      t.equal(val, 'test')
+    })
+  })
+  await app.after()
+  t.pass('reachable')
+
+  await app.ready()
+  t.pass('reachable')
+})
+
+test('await after - error handling, async throw', async (t) => {
+  const app = {}
+  boot(app)
+
+  t.plan(2)
+
+  const e = new Error('kaboom')
+
+  app.use(async (f, opts) => {
+    throw Error('kaboom')
+  })
+
+  await t.rejects(app.after(), e)
+
+  await t.rejects(() => app.ready(), Error('kaboom'))
+})
+
+test('await after - error handling, async throw, nested', async (t) => {
+  const app = {}
+  boot(app)
+
+  t.plan(2)
+
+  const e = new Error('kaboom')
+
+  app.use(async (f, opts) => {
+    app.use(async (f, opts) => {
+      throw e
+    })
+  })
+
+  await t.rejects(app.after())
+  await t.rejects(() => app.ready(), e)
+})
+
+test('await after - error handling, same tick cb err', async (t) => {
+  const app = {}
+  boot(app)
+
+  t.plan(2)
+
+  app.use((f, opts, cb) => {
+    cb(Error('kaboom'))
+  })
+  await t.rejects(app.after())
+  await t.rejects(app.ready(), Error('kaboom'))
+})
+
+test('await after - error handling, same tick cb err, nested', async (t) => {
+  const app = {}
+  boot(app)
+
+  t.plan(2)
+
+  app.use((f, opts, cb) => {
+    app.use((f, opts, cb) => {
+      cb(Error('kaboom'))
+    })
+    cb()
+  })
+
+  await t.rejects(app.after())
+  await t.rejects(app.ready(), Error('kaboom'))
+})
+
+test('await after - error handling, future tick cb err', async (t) => {
+  const app = {}
+  boot(app)
+
+  t.plan(2)
+
+  app.use((f, opts, cb) => {
+    setImmediate(() => { cb(Error('kaboom')) })
+  })
+
+  await t.rejects(app.after())
+  await t.rejects(app.ready(), Error('kaboom'))
+})
+
+test('await after - error handling, future tick cb err, nested', async (t) => {
+  const app = {}
+  boot(app)
+
+  t.plan(2)
+
+  app.use((f, opts, cb) => {
+    app.use((f, opts, cb) => {
+      setImmediate(() => { cb(Error('kaboom')) })
+    })
+    cb()
+  })
+  await t.rejects(app.after(), Error('kaboom'))
+  await t.rejects(app.ready(), Error('kaboom'))
+})
+
+test('await after complex scenario', async (t) => {
+  const app = {}
+  boot(app)
+  t.plan(16)
+
+  let firstLoaded = false
+  let secondLoaded = false
+  let thirdLoaded = false
+  let fourthLoaded = false
+
+  app.use(first)
+  await app.after()
+  t.ok(firstLoaded, 'first is loaded')
+  t.notOk(secondLoaded, 'second is not loaded')
+  t.notOk(thirdLoaded, 'third is not loaded')
+  t.notOk(fourthLoaded, 'fourth is not loaded')
+  app.use(second)
+  t.ok(firstLoaded, 'first is loaded')
+  t.notOk(secondLoaded, 'second is not loaded')
+  t.notOk(thirdLoaded, 'third is not loaded')
+  t.notOk(fourthLoaded, 'fourth is not loaded')
+  app.use(third)
+  await app.after()
+  t.ok(firstLoaded, 'first is loaded')
+  t.ok(secondLoaded, 'second is loaded')
+  t.ok(thirdLoaded, 'third is loaded')
+  t.ok(fourthLoaded, 'fourth is loaded')
+  await app.ready()
+  t.ok(firstLoaded, 'first is loaded')
+  t.ok(secondLoaded, 'second is loaded')
+  t.ok(thirdLoaded, 'third is loaded')
+  t.ok(fourthLoaded, 'fourth is loaded')
+
+  async function first () {
+    firstLoaded = true
+  }
+
+  async function second () {
+    secondLoaded = true
+  }
+
+  async function third (app) {
+    thirdLoaded = true
+    app.use(fourth)
+  }
+
+  async function fourth () {
+    fourthLoaded = true
+  }
+})
+
+test('without autostart and sync/async plugin mix', async (t) => {
+  const app = {}
+  boot(app, { autostart: false })
+  t.plan(21)
+
+  let firstLoaded = false
+  let secondLoaded = false
+  let thirdLoaded = false
+  let fourthLoaded = false
+
+  app.use(first)
+  await app.after()
+  t.ok(firstLoaded, 'first is loaded')
+  t.notOk(secondLoaded, 'second is not loaded')
+  t.notOk(thirdLoaded, 'third is not loaded')
+  t.notOk(fourthLoaded, 'fourth is not loaded')
+
+  app.use(second)
+  await app.after()
+  t.ok(firstLoaded, 'first is loaded')
+  t.ok(secondLoaded, 'second is loaded')
+  t.notOk(thirdLoaded, 'third is not loaded')
+  t.notOk(fourthLoaded, 'fourth is not loaded')
+
+  await sleep(10)
+
+  app.use(third)
+  await app.after()
+  t.ok(firstLoaded, 'first is loaded')
+  t.ok(secondLoaded, 'second is loaded')
+  t.ok(thirdLoaded, 'third is loaded')
+  t.notOk(fourthLoaded, 'fourth is not loaded')
+
+  app.use(fourth)
+  t.ok(firstLoaded, 'first is loaded')
+  t.ok(secondLoaded, 'second is loaded')
+  t.ok(thirdLoaded, 'third is loaded')
+  t.notOk(fourthLoaded, 'fourth is not loaded')
+
+  await app.after()
+  t.ok(firstLoaded, 'first is loaded')
+  t.ok(secondLoaded, 'second is loaded')
+  t.ok(thirdLoaded, 'third is loaded')
+  t.ok(fourthLoaded, 'fourth is loaded')
+
+  await app.ready()
+
+  async function first () {
+    firstLoaded = true
+  }
+
+  async function second () {
+    const contents = await fs.readFile(path.join(__dirname, 'fixtures', 'dummy.txt'), 'utf-8')
+    t.equal(contents, 'hello, world!')
+    secondLoaded = true
+  }
+
+  async function third () {
+    await sleep(10)
+    thirdLoaded = true
+  }
+
+  function fourth (server, opts, done) {
+    fourthLoaded = true
+    done()
+  }
+})
+
+test('without autostart', async (t) => {
+  const app = {}
+  boot(app, { autostart: false })
+  let firstLoaded = false
+  let secondLoaded = false
+  let thirdLoaded = false
+
+  app.use(async function first (app) {
+    firstLoaded = true
+    app.use(async () => {
+      await sleep(1)
+      secondLoaded = true
+    })
+  })
+
+  await app.after()
+  t.equal(firstLoaded, true)
+  t.equal(secondLoaded, true)
+
+  await app.use(async () => {
+    thirdLoaded = true
+  })
+
+  t.equal(thirdLoaded, true)
+
+  await app.ready()
+})
+
+test('without autostart and with override', async (t) => {
+  const app = {}
+  const _ = boot(app, { autostart: false })
+  let count = 0
+
+  _.override = function (s) {
+    const res = Object.create(s)
+    res.count = ++count
+
+    return res
+  }
+
+  app.use(async function first (app) {
+    t.equal(app.count, 1)
+    app.use(async (app) => {
+      t.equal(app.count, 2)
+      await app.after()
+    })
+  })
+
+  await app.after()
+
+  await app.use(async (app) => {
+    t.equal(app.count, 3)
+  })
+
+  await app.ready()
+})
+
+test('stop processing after errors', async (t) => {
+  t.plan(2)
+
+  const app = boot()
+
+  try {
+    await app.use(async function first (app) {
+      t.pass('first should be loaded')
+      throw new Error('kaboom')
+    })
+  } catch (e) {
+    t.equal(e.message, 'kaboom')
+  }
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/await-self.test.js

@@ -0,0 +1,31 @@
+'use strict'
+
+const { test } = require('tap')
+const boot = require('..')
+
+test('await self', async (t) => {
+  const app = {}
+  boot(app)
+
+  t.equal(await app, app)
+})
+
+test('await self three times', async (t) => {
+  const app = {}
+  boot(app)
+
+  t.equal(await app, app)
+  t.equal(await app, app)
+  t.equal(await app, app)
+})
+
+test('await self within plugin', async (t) => {
+  const app = {}
+  boot(app)
+
+  app.use(async (f) => {
+    t.equal(await f, f)
+  })
+
+  t.equal(await app, app)
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/await-use.test.js

@@ -0,0 +1,294 @@
+'use strict'
+
+const { test } = require('tap')
+const { promisify } = require('node:util')
+const sleep = promisify(setTimeout)
+const boot = require('..')
+
+test('await use - nested plugins with same tick callbacks', async (t) => {
+  const app = {}
+  boot(app)
+
+  t.plan(4)
+
+  await app.use((f, opts, cb) => {
+    t.pass('plugin init')
+    app.use((f, opts, cb) => {
+      t.pass('plugin2 init')
+      cb()
+    })
+    cb()
+  })
+  t.pass('reachable')
+
+  await app.ready()
+  t.pass('reachable')
+})
+
+test('await use - nested plugins with future tick callbacks', async (t) => {
+  const app = {}
+  boot(app)
+
+  t.plan(4)
+
+  await app.use((f, opts, cb) => {
+    t.pass('plugin init')
+    app.use((f, opts, cb) => {
+      t.pass('plugin2 init')
+      setImmediate(cb)
+    })
+    setImmediate(cb)
+  })
+  t.pass('reachable')
+
+  await app.ready()
+  t.pass('reachable')
+})
+
+test('await use - nested async function plugins', async (t) => {
+  const app = {}
+  boot(app)
+
+  t.plan(5)
+
+  await app.use(async (f, opts) => {
+    t.pass('plugin init')
+    await app.use(async (f, opts) => {
+      t.pass('plugin2 init')
+    })
+    t.pass('reachable')
+  })
+  t.pass('reachable')
+
+  await app.ready()
+  t.pass('reachable')
+})
+
+test('await use - promise returning function plugins + promise chaining', async (t) => {
+  const app = {}
+  boot(app)
+
+  t.plan(6)
+
+  await app.use((f, opts) => {
+    t.pass('plugin init')
+    return app.use((f, opts) => {
+      t.pass('plugin2 init')
+      return Promise.resolve()
+    }).then(() => {
+      t.pass('reachable')
+      return 'test'
+    }).then((val) => {
+      t.equal(val, 'test')
+    })
+  })
+  t.pass('reachable')
+
+  await app.ready()
+  t.pass('reachable')
+})
+
+test('await use - await and use chaining', async (t) => {
+  const app = {}
+  boot(app)
+
+  t.plan(3)
+
+  app.use(async (f, opts, cb) => {
+    await app.use(async (f, opts) => {
+      t.pass('plugin init')
+    }).use(async (f, opts) => {
+      t.pass('plugin2 init')
+    })
+  })
+
+  await app.ready()
+  t.pass('reachable')
+})
+
+function thenableRejects (t, thenable, err, msg) {
+  return t.rejects(async () => { await thenable }, err, msg)
+}
+
+test('await use - error handling, async throw', async (t) => {
+  const app = {}
+  boot(app)
+
+  t.plan(2)
+
+  await thenableRejects(t, app.use(async (f, opts) => {
+    throw Error('kaboom')
+  }), Error('kaboom'))
+
+  await t.rejects(app.ready(), Error('kaboom'))
+})
+
+test('await use - error handling, async throw, nested', async (t) => {
+  const app = {}
+  boot(app)
+
+  t.plan(2)
+
+  await thenableRejects(t, app.use(async function a (f, opts) {
+    await app.use(async function b (f, opts) {
+      throw Error('kaboom')
+    })
+  }, Error('kaboom')), 'b')
+
+  t.rejects(() => app.ready(), Error('kaboom'))
+})
+
+test('await use - error handling, same tick cb err', async (t) => {
+  const app = {}
+  boot(app)
+
+  t.plan(2)
+
+  await thenableRejects(t, app.use((f, opts, cb) => {
+    cb(Error('kaboom'))
+  }), Error('kaboom'))
+
+  t.rejects(() => app.ready(), Error('kaboom'))
+})
+
+test('await use - error handling, same tick cb err, nested', async (t) => {
+  const app = {}
+  boot(app)
+
+  t.plan(2)
+
+  await thenableRejects(t, app.use((f, opts, cb) => {
+    app.use((f, opts, cb) => {
+      cb(Error('kaboom'))
+    })
+    cb()
+  }), Error('kaboom'))
+
+  t.rejects(() => app.ready(), Error('kaboom'))
+})
+
+test('await use - error handling, future tick cb err', async (t) => {
+  const app = {}
+  boot(app)
+
+  t.plan(2)
+
+  await thenableRejects(t, app.use((f, opts, cb) => {
+    setImmediate(() => { cb(Error('kaboom')) })
+  }), Error('kaboom'))
+
+  t.rejects(() => app.ready(), Error('kaboom'))
+})
+
+test('await use - error handling, future tick cb err, nested', async (t) => {
+  const app = {}
+  boot(app)
+
+  t.plan(2)
+
+  await thenableRejects(t, app.use((f, opts, cb) => {
+    app.use((f, opts, cb) => {
+      setImmediate(() => { cb(Error('kaboom')) })
+    })
+    cb()
+  }), Error('kaboom'))
+
+  t.rejects(() => app.ready(), Error('kaboom'))
+})
+
+test('mixed await use and non-awaited use ', async (t) => {
+  const app = {}
+  boot(app)
+  t.plan(16)
+
+  let firstLoaded = false
+  let secondLoaded = false
+  let thirdLoaded = false
+  let fourthLoaded = false
+
+  await app.use(first)
+  t.ok(firstLoaded, 'first is loaded')
+  t.notOk(secondLoaded, 'second is not loaded')
+  t.notOk(thirdLoaded, 'third is not loaded')
+  t.notOk(fourthLoaded, 'fourth is not loaded')
+  app.use(second)
+  t.ok(firstLoaded, 'first is loaded')
+  t.notOk(secondLoaded, 'second is not loaded')
+  t.notOk(thirdLoaded, 'third is not loaded')
+  t.notOk(fourthLoaded, 'fourth is not loaded')
+  await app.use(third)
+  t.ok(firstLoaded, 'first is loaded')
+  t.ok(secondLoaded, 'second is loaded')
+  t.ok(thirdLoaded, 'third is loaded')
+  t.ok(fourthLoaded, 'fourth is loaded')
+  await app.ready()
+  t.ok(firstLoaded, 'first is loaded')
+  t.ok(secondLoaded, 'second is loaded')
+  t.ok(thirdLoaded, 'third is loaded')
+  t.ok(fourthLoaded, 'fourth is loaded')
+
+  async function first () {
+    firstLoaded = true
+  }
+
+  async function second () {
+    secondLoaded = true
+  }
+
+  async function third (app) {
+    thirdLoaded = true
+    app.use(fourth)
+  }
+
+  async function fourth () {
+    fourthLoaded = true
+  }
+})
+
+test('await use - mix of same and future tick callbacks', async (t) => {
+  const app = {}
+  boot(app, { autostart: false })
+  let record = ''
+
+  t.plan(4)
+
+  await app.use(async function plugin0 () {
+    t.pass('plugin0 init')
+    record += 'plugin0|'
+  })
+  await app.use(async function plugin1 () {
+    t.pass('plugin1 init')
+    await sleep(500)
+    record += 'plugin1|'
+  })
+  await sleep(1)
+  await app.use(async function plugin2 () {
+    t.pass('plugin2 init')
+    await sleep(500)
+    record += 'plugin2|'
+  })
+  record += 'ready'
+  t.equal(record, 'plugin0|plugin1|plugin2|ready')
+})
+
+test('await use - fork the promise chain', (t) => {
+  t.plan(3)
+  const app = {}
+  boot(app, { autostart: false })
+
+  async function setup () {
+    let set = false
+    await app.use(async function plugin0 () {
+      t.pass('plugin0 init')
+      await sleep(500)
+      set = true
+    })
+    t.equal(set, true)
+  }
+  setup()
+
+  app.ready((err, done) => {
+    t.error(err)
+    done()
+  })
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/basic.test.js

@@ -0,0 +1,439 @@
+'use strict'
+
+const { test } = require('tap')
+const boot = require('..')
+
+test('boot an empty app', (t) => {
+  t.plan(1)
+  const app = boot()
+  app.on('start', () => {
+    t.pass('booted')
+  })
+})
+
+test('start returns app', (t) => {
+  t.plan(1)
+  const app = boot({}, { autostart: false })
+  app
+    .start()
+    .ready((err) => {
+      t.error(err)
+    })
+})
+
+test('boot an app with a plugin', (t) => {
+  t.plan(4)
+
+  const app = boot()
+  let after = false
+
+  app.use(function (server, opts, done) {
+    t.equal(server, app, 'the first argument is the server')
+    t.same(opts, {}, 'no options')
+    t.ok(after, 'delayed execution')
+    done()
+  })
+
+  after = true
+
+  app.on('start', () => {
+    t.pass('booted')
+  })
+})
+
+test('boot an app with a promisified plugin', (t) => {
+  t.plan(4)
+
+  const app = boot()
+  let after = false
+
+  app.use(function (server, opts) {
+    t.equal(server, app, 'the first argument is the server')
+    t.same(opts, {}, 'no options')
+    t.ok(after, 'delayed execution')
+    return Promise.resolve()
+  })
+
+  after = true
+
+  app.on('start', () => {
+    t.pass('booted')
+  })
+})
+
+test('boot an app with a plugin and a callback /1', (t) => {
+  t.plan(2)
+
+  const app = boot(() => {
+    t.pass('booted')
+  })
+
+  app.use(function (server, opts, done) {
+    t.pass('plugin loaded')
+    done()
+  })
+})
+
+test('boot an app with a plugin and a callback /2', (t) => {
+  t.plan(2)
+
+  const app = boot({}, () => {
+    t.pass('booted')
+  })
+
+  app.use(function (server, opts, done) {
+    t.pass('plugin loaded')
+    done()
+  })
+})
+
+test('boot a plugin with a custom server', (t) => {
+  t.plan(4)
+
+  const server = {}
+  const app = boot(server)
+
+  app.use(function (s, opts, done) {
+    t.equal(s, server, 'the first argument is the server')
+    t.same(opts, {}, 'no options')
+    done()
+  })
+
+  app.onClose(() => {
+    t.ok('onClose called')
+  })
+
+  app.on('start', () => {
+    app.close(() => {
+      t.pass('booted')
+    })
+  })
+})
+
+test('custom instance should inherits avvio methods /1', (t) => {
+  t.plan(6)
+
+  const server = {}
+  const app = boot(server, {})
+
+  server.use(function (s, opts, done) {
+    t.equal(s, server, 'the first argument is the server')
+    t.same(opts, {}, 'no options')
+    done()
+  }).after(() => {
+    t.ok('after called')
+  })
+
+  server.onClose(() => {
+    t.ok('onClose called')
+  })
+
+  server.ready(() => {
+    t.ok('ready called')
+  })
+
+  app.on('start', () => {
+    server.close(() => {
+      t.pass('booted')
+    })
+  })
+})
+
+test('custom instance should inherits avvio methods /2', (t) => {
+  t.plan(6)
+
+  const server = {}
+  const app = new boot(server, {}) // eslint-disable-line new-cap
+
+  server.use(function (s, opts, done) {
+    t.equal(s, server, 'the first argument is the server')
+    t.same(opts, {}, 'no options')
+    done()
+  }).after(() => {
+    t.ok('after called')
+  })
+
+  server.onClose(() => {
+    t.ok('onClose called')
+  })
+
+  server.ready(() => {
+    t.ok('ready called')
+  })
+
+  app.on('start', () => {
+    server.close(() => {
+      t.pass('booted')
+    })
+  })
+})
+
+test('boot a plugin with options', (t) => {
+  t.plan(3)
+
+  const server = {}
+  const app = boot(server)
+  const myOpts = {
+    hello: 'world'
+  }
+
+  app.use(function (s, opts, done) {
+    t.equal(s, server, 'the first argument is the server')
+    t.same(opts, myOpts, 'passed options')
+    done()
+  }, myOpts)
+
+  app.on('start', () => {
+    t.pass('booted')
+  })
+})
+
+test('boot a plugin with a function that returns the options', (t) => {
+  t.plan(4)
+
+  const server = {}
+  const app = boot(server)
+  const myOpts = {
+    hello: 'world'
+  }
+  const myOptsAsFunc = parent => {
+    t.equal(parent, server)
+    return parent.myOpts
+  }
+
+  app.use(function (s, opts, done) {
+    s.myOpts = opts
+    done()
+  }, myOpts)
+
+  app.use(function (s, opts, done) {
+    t.equal(s, server, 'the first argument is the server')
+    t.same(opts, myOpts, 'passed options via function accessing parent injected variable')
+    done()
+  }, myOptsAsFunc)
+
+  app.on('start', () => {
+    t.pass('booted')
+  })
+})
+
+test('throw on non-function use', (t) => {
+  t.plan(1)
+  const app = boot()
+  t.throws(() => {
+    app.use({})
+  })
+})
+
+// https://github.com/mcollina/avvio/issues/20
+test('ready and nextTick', (t) => {
+  const app = boot()
+  process.nextTick(() => {
+    app.ready(() => {
+      t.end()
+    })
+  })
+})
+
+// https://github.com/mcollina/avvio/issues/20
+test('promises and microtask', (t) => {
+  const app = boot()
+  Promise.resolve()
+    .then(() => {
+      app.ready(function () {
+        t.end()
+      })
+    })
+})
+
+test('always loads nested plugins after the current one', (t) => {
+  t.plan(2)
+
+  const server = {}
+  const app = boot(server)
+
+  let second = false
+
+  app.use(function (s, opts, done) {
+    app.use(function (s, opts, done) {
+      second = true
+      done()
+    })
+    t.notOk(second)
+
+    done()
+  })
+
+  app.on('start', () => {
+    t.ok(second)
+  })
+})
+
+test('promise long resolve', (t) => {
+  t.plan(2)
+
+  const app = boot()
+
+  setTimeout(function () {
+    t.throws(() => {
+      app.use((s, opts, done) => {
+        done()
+      })
+    }, 'root plugin has already booted')
+  })
+
+  app.ready(function (err) {
+    t.notOk(err)
+  })
+})
+
+test('do not autostart', (t) => {
+  const app = boot(null, {
+    autostart: false
+  })
+  app.on('start', () => {
+    t.fail()
+  })
+  t.end()
+})
+
+test('start with ready', (t) => {
+  t.plan(2)
+
+  const app = boot(null, {
+    autostart: false
+  })
+
+  app.on('start', () => {
+    t.pass()
+  })
+
+  app.ready(function (err) {
+    t.error(err)
+  })
+})
+
+test('load a plugin after start()', (t) => {
+  t.plan(1)
+
+  let startCalled = false
+  const app = boot(null, {
+    autostart: false
+  })
+
+  app.use((s, opts, done) => {
+    t.ok(startCalled)
+    done()
+  })
+
+  // we use a timer because
+  // it is more reliable than
+  // nextTick and setImmediate
+  // this almost always will come
+  // after those are completed
+  setTimeout(() => {
+    app.start()
+    startCalled = true
+  }, 2)
+})
+
+test('booted should be set before ready', (t) => {
+  t.plan(2)
+
+  const app = boot()
+
+  app.ready(function (err) {
+    t.error(err)
+    t.equal(app.booted, true)
+  })
+})
+
+test('start should be emitted after ready resolves', (t) => {
+  t.plan(1)
+
+  const app = boot()
+  let ready = false
+
+  app.ready().then(function () {
+    ready = true
+  })
+
+  app.on('start', function () {
+    t.equal(ready, true)
+  })
+})
+
+test('throws correctly if registering after ready', (t) => {
+  t.plan(1)
+
+  const app = boot()
+
+  app.ready(function () {
+    t.throws(() => {
+      app.use((a, b, done) => done())
+    }, 'root plugin has already booted')
+  })
+})
+
+test('preReady errors must be managed', (t) => {
+  t.plan(2)
+
+  const app = boot()
+
+  app.use((f, opts, cb) => {
+    cb()
+  })
+
+  app.on('preReady', () => {
+    throw new Error('boom')
+  })
+
+  app.ready(err => {
+    t.pass('ready function is called')
+    t.equal(err.message, 'boom')
+  })
+})
+
+test('preReady errors do not override plugin\'s errors', (t) => {
+  t.plan(3)
+
+  const app = boot()
+
+  app.use((f, opts, cb) => {
+    cb(new Error('baam'))
+  })
+
+  app.on('preReady', () => {
+    t.pass('preReady is executed')
+    throw new Error('boom')
+  })
+
+  app.ready(err => {
+    t.pass('ready function is called')
+    t.equal(err.message, 'baam')
+  })
+})
+
+test('support faux modules', (t) => {
+  t.plan(4)
+
+  const app = boot()
+  let after = false
+
+  // Faux modules are modules built with TypeScript
+  // or Babel that they export a .default property.
+  app.use({
+    default: function (server, opts, done) {
+      t.equal(server, app, 'the first argument is the server')
+      t.same(opts, {}, 'no options')
+      t.ok(after, 'delayed execution')
+      done()
+    }
+  })
+
+  after = true
+
+  app.on('start', () => {
+    t.pass('booted')
+  })
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/callbacks.test.js

@@ -0,0 +1,113 @@
+'use strict'
+
+const { test } = require('tap')
+const boot = require('..')
+
+test('reentrant', (t) => {
+  t.plan(7)
+
+  const app = boot()
+  let firstLoaded = false
+  let secondLoaded = false
+
+  app
+    .use(first)
+    .after(() => {
+      t.ok(firstLoaded, 'first is loaded')
+      t.ok(secondLoaded, 'second is loaded')
+      t.pass('booted')
+    })
+
+  function first (s, opts, done) {
+    t.notOk(firstLoaded, 'first is not loaded')
+    t.notOk(secondLoaded, 'second is not loaded')
+    firstLoaded = true
+    s.use(second)
+    done()
+  }
+
+  function second (s, opts, done) {
+    t.ok(firstLoaded, 'first is loaded')
+    t.notOk(secondLoaded, 'second is not loaded')
+    secondLoaded = true
+    done()
+  }
+})
+
+test('reentrant with callbacks deferred', (t) => {
+  t.plan(11)
+
+  const app = boot()
+  let firstLoaded = false
+  let secondLoaded = false
+  let thirdLoaded = false
+
+  app.use(first)
+
+  function first (s, opts, done) {
+    t.notOk(firstLoaded, 'first is not loaded')
+    t.notOk(secondLoaded, 'second is not loaded')
+    t.notOk(thirdLoaded, 'third is not loaded')
+    firstLoaded = true
+    s.use(second)
+    setTimeout(() => {
+      try {
+        s.use(third)
+      } catch (err) {
+        t.equal(err.message, 'Root plugin has already booted')
+      }
+    }, 500)
+    done()
+  }
+
+  function second (s, opts, done) {
+    t.ok(firstLoaded, 'first is loaded')
+    t.notOk(secondLoaded, 'second is not loaded')
+    t.notOk(thirdLoaded, 'third is not loaded')
+    secondLoaded = true
+    done()
+  }
+
+  function third (s, opts, done) {
+    thirdLoaded = true
+    done()
+  }
+
+  app.on('start', () => {
+    t.ok(firstLoaded, 'first is loaded')
+    t.ok(secondLoaded, 'second is loaded')
+    t.notOk(thirdLoaded, 'third is not loaded')
+    t.pass('booted')
+  })
+})
+
+test('multiple loading time', t => {
+  t.plan(1)
+  const app = boot()
+
+  function a (instance, opts, done) {
+    (opts.use || []).forEach(_ => { instance.use(_, { use: opts.subUse || [] }) })
+    setTimeout(done, 10)
+  }
+  const pointer = a
+
+  function b (instance, opts, done) {
+    (opts.use || []).forEach(_ => { instance.use(_, { use: opts.subUse || [] }) })
+    setTimeout(done, 20)
+  }
+
+  function c (instance, opts, done) {
+    (opts.use || []).forEach(_ => { instance.use(_, { use: opts.subUse || [] }) })
+    setTimeout(done, 30)
+  }
+
+  app
+    .use(function a (instance, opts, done) {
+      instance.use(pointer, { use: [b], subUse: [c] })
+        .use(b)
+      setTimeout(done, 0)
+    })
+    .after(() => {
+      t.pass('booted')
+    })
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/catch-override-exception.test.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const { test } = require('tap')
+const boot = require('..')
+
+test('catch exceptions in parent.override', (t) => {
+  t.plan(2)
+
+  const server = {}
+
+  const app = boot(server, {
+    autostart: false
+  })
+  app.override = function () {
+    throw Error('catch it')
+  }
+
+  app
+    .use(function () {})
+    .start()
+
+  app.ready(function (err) {
+    t.type(err, Error)
+    t.match(err, /catch it/)
+  })
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/chainable.test.js

@@ -0,0 +1,67 @@
+'use strict'
+
+const { test } = require('tap')
+const boot = require('..')
+
+test('chainable standalone', (t) => {
+  t.plan(5)
+
+  const readyResult = boot()
+    .use(function (ctx, opts, done) {
+      t.pass('1st plugin')
+      done()
+    }).after(function (err, done) {
+      t.error(err)
+      t.pass('2nd after')
+      done()
+    }).ready(function () {
+      t.pass('we are ready')
+    })
+  t.equal(readyResult, undefined)
+})
+
+test('chainable automatically binded', (t) => {
+  t.plan(5)
+
+  const app = {}
+  boot(app)
+
+  const readyResult = app
+    .use(function (ctx, opts, done) {
+      t.pass('1st plugin')
+      done()
+    }).after(function (err, done) {
+      t.error(err)
+      t.pass('2nd after')
+      done()
+    }).ready(function () {
+      t.pass('we are ready')
+    })
+  t.equal(readyResult, undefined)
+})
+
+test('chainable standalone with server', (t) => {
+  t.plan(6)
+
+  const server = {}
+  boot(server, {
+    expose: {
+      use: 'register'
+    }
+  })
+
+  const readyResult = server.register(function (ctx, opts, done) {
+    t.pass('1st plugin')
+    done()
+  }).after(function (err, done) {
+    t.error(err)
+    t.pass('2nd after')
+    done()
+  }).register(function (ctx, opts, done) {
+    t.pass('3rd plugin')
+    done()
+  }).ready(function () {
+    t.pass('we are ready')
+  })
+  t.equal(readyResult, undefined)
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/close.test.js

@@ -0,0 +1,544 @@
+'use strict'
+
+const { test } = require('tap')
+const boot = require('..')
+const { AVV_ERR_CALLBACK_NOT_FN } = require('../lib/errors')
+
+test('boot an app with a plugin', (t) => {
+  t.plan(4)
+
+  const app = boot()
+  let last = false
+
+  app.use(function (server, opts, done) {
+    app.onClose(() => {
+      t.ok('onClose called')
+      t.notOk(last)
+      last = true
+    })
+    done()
+  })
+
+  app.on('start', () => {
+    app.close(() => {
+      t.ok(last)
+      t.pass('Closed in the correct order')
+    })
+  })
+})
+
+test('onClose arguments', (t) => {
+  t.plan(5)
+
+  const app = boot()
+
+  app.use(function (server, opts, next) {
+    server.onClose((instance, done) => {
+      t.ok('called')
+      t.equal(server, instance)
+      done()
+    })
+    next()
+  })
+
+  app.use(function (server, opts, next) {
+    server.onClose((instance) => {
+      t.ok('called')
+      t.equal(server, instance)
+    })
+    next()
+  })
+
+  app.on('start', () => {
+    app.close(() => {
+      t.pass('Closed in the correct order')
+    })
+  })
+})
+
+test('onClose arguments - fastify encapsulation test case', (t) => {
+  t.plan(5)
+
+  const server = { my: 'server' }
+  const app = boot(server)
+
+  app.override = function (s, fn, opts) {
+    s = Object.create(s)
+    return s
+  }
+
+  app.use(function (instance, opts, next) {
+    instance.test = true
+    instance.onClose((i, done) => {
+      t.ok(i.test)
+      done()
+    })
+    next()
+  })
+
+  app.use(function (instance, opts, next) {
+    t.notOk(instance.test)
+    instance.onClose((i, done) => {
+      t.notOk(i.test)
+      done()
+    })
+    next()
+  })
+
+  app.on('start', () => {
+    t.notOk(app.test)
+    app.close(() => {
+      t.pass('Closed in the correct order')
+    })
+  })
+})
+
+test('onClose arguments - fastify encapsulation test case / 2', (t) => {
+  t.plan(5)
+
+  const server = { my: 'server' }
+  const app = boot(server)
+
+  app.override = function (s, fn, opts) {
+    s = Object.create(s)
+    return s
+  }
+
+  server.use(function (instance, opts, next) {
+    instance.test = true
+    instance.onClose((i, done) => {
+      t.ok(i.test)
+      done()
+    })
+    next()
+  })
+
+  server.use(function (instance, opts, next) {
+    t.notOk(instance.test)
+    instance.onClose((i, done) => {
+      t.notOk(i.test)
+      done()
+    })
+    next()
+  })
+
+  app.on('start', () => {
+    t.notOk(server.test)
+    try {
+      server.close()
+      t.pass()
+    } catch (err) {
+      t.fail(err)
+    }
+  })
+})
+
+test('onClose arguments - encapsulation test case no server', (t) => {
+  t.plan(5)
+
+  const app = boot()
+
+  app.override = function (s, fn, opts) {
+    s = Object.create(s)
+    return s
+  }
+
+  app.use(function (instance, opts, next) {
+    instance.test = true
+    instance.onClose((i, done) => {
+      t.notOk(i.test)
+      done()
+    })
+    next()
+  })
+
+  app.use(function (instance, opts, next) {
+    t.notOk(instance.test)
+    instance.onClose((i) => {
+      t.notOk(i.test)
+    })
+    next()
+  })
+
+  app.on('start', () => {
+    t.notOk(app.test)
+    app.close(() => {
+      t.pass('Closed in the correct order')
+    })
+  })
+})
+
+test('onClose should handle errors', (t) => {
+  t.plan(3)
+
+  const app = boot()
+
+  app.use(function (server, opts, done) {
+    app.onClose((instance, done) => {
+      t.ok('called')
+      done(new Error('some error'))
+    })
+    done()
+  })
+
+  app.on('start', () => {
+    app.close(err => {
+      t.equal(err.message, 'some error')
+      t.pass('Closed in the correct order')
+    })
+  })
+})
+
+test('#54 close handlers should receive same parameters when queue is not empty', (t) => {
+  t.plan(6)
+
+  const context = { test: true }
+  const app = boot(context)
+
+  app.use(function (server, opts, done) {
+    done()
+  })
+  app.on('start', () => {
+    app.close((err, done) => {
+      t.equal(err, null)
+      t.pass('Closed in the correct order')
+      setImmediate(done)
+    })
+    app.close(err => {
+      t.equal(err, null)
+      t.pass('Closed in the correct order')
+    })
+    app.close(err => {
+      t.equal(err, null)
+      t.pass('Closed in the correct order')
+    })
+  })
+})
+
+test('onClose should handle errors / 2', (t) => {
+  t.plan(4)
+
+  const app = boot()
+
+  app.onClose((instance, done) => {
+    t.ok('called')
+    done(new Error('some error'))
+  })
+
+  app.use(function (server, opts, done) {
+    app.onClose((instance, done) => {
+      t.ok('called')
+      done()
+    })
+    done()
+  })
+
+  app.on('start', () => {
+    app.close(err => {
+      t.equal(err.message, 'some error')
+      t.pass('Closed in the correct order')
+    })
+  })
+})
+
+test('close arguments', (t) => {
+  t.plan(4)
+
+  const app = boot()
+
+  app.use(function (server, opts, done) {
+    app.onClose((instance, done) => {
+      t.ok('called')
+      done()
+    })
+    done()
+  })
+
+  app.on('start', () => {
+    app.close((err, instance, done) => {
+      t.error(err)
+      t.equal(instance, app)
+      done()
+      t.pass('Closed in the correct order')
+    })
+  })
+})
+
+test('close event', (t) => {
+  t.plan(3)
+
+  const app = boot()
+  let last = false
+
+  app.on('start', () => {
+    app.close(() => {
+      t.notOk(last)
+      last = true
+    })
+  })
+
+  app.on('close', () => {
+    t.ok(last)
+    t.pass('event fired')
+  })
+})
+
+test('close order', (t) => {
+  t.plan(5)
+
+  const app = boot()
+  const order = [1, 2, 3, 4]
+
+  app.use(function (server, opts, done) {
+    app.onClose(() => {
+      t.equal(order.shift(), 3)
+    })
+
+    app.use(function (server, opts, done) {
+      app.onClose(() => {
+        t.equal(order.shift(), 2)
+      })
+      done()
+    })
+    done()
+  })
+
+  app.use(function (server, opts, done) {
+    app.onClose(() => {
+      t.equal(order.shift(), 1)
+    })
+    done()
+  })
+
+  app.on('start', () => {
+    app.close(() => {
+      t.equal(order.shift(), 4)
+      t.pass('Closed in the correct order')
+    })
+  })
+})
+
+test('close without a cb', (t) => {
+  t.plan(1)
+
+  const app = boot()
+
+  app.onClose((instance, done) => {
+    t.ok('called')
+    done()
+  })
+
+  app.close()
+})
+
+test('onClose with 0 parameters', (t) => {
+  t.plan(4)
+
+  const server = { my: 'server' }
+  const app = boot(server)
+
+  app.use(function (instance, opts, next) {
+    instance.onClose(function () {
+      t.ok('called')
+      t.equal(arguments.length, 0)
+    })
+    next()
+  })
+
+  app.close(err => {
+    t.error(err)
+    t.pass('Closed')
+  })
+})
+
+test('onClose with 1 parameter', (t) => {
+  t.plan(3)
+
+  const server = { my: 'server' }
+  const app = boot(server)
+
+  app.use(function (instance, opts, next) {
+    instance.onClose(function (context) {
+      t.equal(arguments.length, 1)
+    })
+    next()
+  })
+
+  app.close(err => {
+    t.error(err)
+    t.pass('Closed')
+  })
+})
+
+test('close passing not a function', (t) => {
+  t.plan(1)
+
+  const app = boot()
+
+  app.onClose((instance, done) => {
+    t.ok('called')
+    done()
+  })
+
+  t.throws(() => app.close({}), { message: 'not a function' })
+})
+
+test('close passing not a function', (t) => {
+  t.plan(1)
+
+  const app = boot()
+
+  app.onClose((instance, done) => {
+    t.ok('called')
+    done()
+  })
+
+  t.throws(() => app.close({}), { message: 'not a function' })
+})
+
+test('close passing not a function when wrapping', (t) => {
+  t.plan(1)
+
+  const app = {}
+  boot(app)
+
+  app.onClose((instance, done) => {
+    t.ok('called')
+    done()
+  })
+
+  t.throws(() => app.close({}), { message: 'not a function' })
+})
+
+test('close should trigger ready()', (t) => {
+  t.plan(2)
+
+  const app = boot(null, {
+    autostart: false
+  })
+
+  app.on('start', () => {
+    // this will be emitted after the
+    // callback in close() is fired
+    t.pass('started')
+  })
+
+  app.close(() => {
+    t.pass('closed')
+  })
+})
+
+test('close without a cb returns a promise', (t) => {
+  t.plan(1)
+
+  const app = boot()
+  app.close().then(() => {
+    t.pass('promise resolves')
+  })
+})
+
+test('close without a cb returns a promise when attaching to a server', (t) => {
+  t.plan(1)
+
+  const server = {}
+  boot(server)
+  server.close().then(() => {
+    t.pass('promise resolves')
+  })
+})
+
+test('close with async onClose handlers', t => {
+  t.plan(7)
+
+  const app = boot()
+  const order = [1, 2, 3, 4, 5, 6]
+
+  app.onClose(() => {
+    return new Promise(resolve => setTimeout(resolve, 500)).then(() => {
+      t.equal(order.shift(), 5)
+    })
+  })
+
+  app.onClose(() => {
+    t.equal(order.shift(), 4)
+  })
+
+  app.onClose(instance => {
+    return new Promise(resolve => setTimeout(resolve, 500)).then(() => {
+      t.equal(order.shift(), 3)
+    })
+  })
+
+  app.onClose(async instance => {
+    return new Promise(resolve => setTimeout(resolve, 500)).then(() => {
+      t.equal(order.shift(), 2)
+    })
+  })
+
+  app.onClose(async () => {
+    return new Promise(resolve => setTimeout(resolve, 500)).then(() => {
+      t.equal(order.shift(), 1)
+    })
+  })
+
+  app.on('start', () => {
+    app.close(() => {
+      t.equal(order.shift(), 6)
+      t.pass('Closed in the correct order')
+    })
+  })
+})
+
+test('onClose callback must be a function', (t) => {
+  t.plan(1)
+
+  const app = boot()
+
+  app.use(function (server, opts, done) {
+    t.throws(() => app.onClose({}), new AVV_ERR_CALLBACK_NOT_FN('onClose', 'object'))
+    done()
+  })
+})
+
+test('close custom server with async onClose handlers', t => {
+  t.plan(7)
+
+  const server = {}
+  const app = boot(server)
+  const order = [1, 2, 3, 4, 5, 6]
+
+  server.onClose(() => {
+    return new Promise(resolve => setTimeout(resolve, 500)).then(() => {
+      t.equal(order.shift(), 5)
+    })
+  })
+
+  server.onClose(() => {
+    t.equal(order.shift(), 4)
+  })
+
+  server.onClose(instance => {
+    return new Promise(resolve => setTimeout(resolve, 500)).then(() => {
+      t.equal(order.shift(), 3)
+    })
+  })
+
+  server.onClose(async instance => {
+    return new Promise(resolve => setTimeout(resolve, 500)).then(() => {
+      t.equal(order.shift(), 2)
+    })
+  })
+
+  server.onClose(async () => {
+    return new Promise(resolve => setTimeout(resolve, 500)).then(() => {
+      t.equal(order.shift(), 1)
+    })
+  })
+
+  app.on('start', () => {
+    app.close(() => {
+      t.equal(order.shift(), 6)
+      t.pass('Closed in the correct order')
+    })
+  })
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/errors.test.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const { test } = require('tap')
+const errors = require('../lib/errors')
+
+test('Correct codes of AvvioErrors', t => {
+  const testcases = [
+    'AVV_ERR_EXPOSE_ALREADY_DEFINED',
+    'AVV_ERR_ATTRIBUTE_ALREADY_DEFINED',
+    'AVV_ERR_CALLBACK_NOT_FN',
+    'AVV_ERR_PLUGIN_NOT_VALID',
+    'AVV_ERR_ROOT_PLG_BOOTED',
+    'AVV_ERR_PARENT_PLG_LOADED',
+    'AVV_ERR_READY_TIMEOUT',
+    'AVV_ERR_PLUGIN_EXEC_TIMEOUT'
+  ]
+
+  t.plan(testcases.length + 1)
+  // errors.js exposes errors and the createError fn
+  t.equal(testcases.length, Object.keys(errors).length)
+
+  for (const testcase of testcases) {
+    const error = new errors[testcase]()
+    t.equal(error.code, testcase)
+  }
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/esm.mjs

@@ -0,0 +1,12 @@
+import { test } from 'tap'
+import boot from '../boot.js'
+
+test('support import', async (t) => {
+  const app = boot()
+
+  app.use(import('./fixtures/esm.mjs'))
+
+  await app.ready()
+
+  t.equal(app.loaded, true)
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/esm.test.js

@@ -0,0 +1,14 @@
+'use strict'
+
+const { test } = require('tap')
+
+test('support esm import', (t) => {
+  import('./esm.mjs').then(() => {
+    t.pass('esm is supported')
+    t.end()
+  }).catch((err) => {
+    process.nextTick(() => {
+      throw err
+    })
+  })
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/events-listeners.test.js

@@ -0,0 +1,23 @@
+'use strict'
+
+const { test } = require('tap')
+const boot = require('..')
+const noop = () => {}
+
+test('boot a plugin and then execute a call after that', (t) => {
+  t.plan(1)
+
+  process.on('warning', (warning) => {
+    t.fail('we should not get a warning', warning)
+  })
+
+  const app = boot()
+  // eslint-disable-next-line no-var
+  for (var i = 0; i < 12; i++) {
+    app.on('preReady', noop)
+  }
+
+  setTimeout(() => {
+    t.pass('Everything ok')
+  }, 500)
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/expose.test.js

@@ -0,0 +1,80 @@
+'use strict'
+
+const { test } = require('tap')
+const boot = require('..')
+const { AVV_ERR_EXPOSE_ALREADY_DEFINED, AVV_ERR_ATTRIBUTE_ALREADY_DEFINED } = require('../lib/errors')
+const { kAvvio } = require('../lib/symbols')
+
+for (const key of ['use', 'after', 'ready', 'onClose', 'close']) {
+  test('throws if ' + key + ' is by default already there', (t) => {
+    t.plan(1)
+
+    const app = {}
+    app[key] = () => { }
+
+    t.throws(() => boot(app), new AVV_ERR_EXPOSE_ALREADY_DEFINED(key, key))
+  })
+
+  test('throws if ' + key + ' is already there', (t) => {
+    t.plan(1)
+
+    const app = {}
+    app['cust' + key] = () => { }
+
+    t.throws(() => boot(app, { expose: { [key]: 'cust' + key } }), new AVV_ERR_EXPOSE_ALREADY_DEFINED('cust' + key, key))
+  })
+
+  test('support expose for ' + key, (t) => {
+    const app = {}
+    app[key] = () => { }
+
+    const expose = {}
+    expose[key] = 'muahah'
+
+    boot(app, {
+      expose
+    })
+
+    t.end()
+  })
+}
+
+test('set the kAvvio to true on the server', (t) => {
+  t.plan(1)
+
+  const server = {}
+  boot(server)
+
+  t.ok(server[kAvvio])
+})
+
+test('.then()', t => {
+  t.plan(3)
+
+  t.test('.then() can not be overwritten', (t) => {
+    t.plan(1)
+
+    const server = {
+      then: () => {}
+    }
+    t.throws(() => boot(server), AVV_ERR_ATTRIBUTE_ALREADY_DEFINED('then'))
+  })
+
+  t.test('.then() is a function', (t) => {
+    t.plan(1)
+
+    const server = {}
+    boot(server)
+
+    t.type(server.then, 'function')
+  })
+
+  t.test('.then() can not be overwritten', (t) => {
+    t.plan(1)
+
+    const server = {}
+    boot(server)
+
+    t.throws(() => { server.then = 'invalid' }, TypeError('Cannot set property then of #<Object> which has only a getter'))
+  })
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/fixtures/dummy.txt

@@ -0,0 +1 @@
+hello, world!

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/fixtures/esm.mjs

@@ -0,0 +1,3 @@
+export default async function (app) {
+  app.loaded = true
+}

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/fixtures/plugin-no-next.js

@@ -0,0 +1,5 @@
+'use strict'
+
+module.exports = function noNext (app, opts, next) {
+  // no call to next
+}

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/gh-issues/bug-205.test.js

@@ -0,0 +1,16 @@
+'use strict'
+
+const { test } = require('tap')
+const boot = require('../..')
+
+test('should print the time tree', (t) => {
+  t.plan(2)
+  const app = boot()
+
+  app.use(function first (instance, opts, cb) {
+    const out = instance.prettyPrint().split('\n')
+    t.equal(out[0], 'root -1 ms')
+    t.equal(out[1], '└── first -1 ms')
+    cb()
+  })
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/lib/create-promise.test.js

@@ -0,0 +1,55 @@
+'use strict'
+
+const { test } = require('tap')
+const { createPromise } = require('../../lib/create-promise')
+
+test('createPromise() returns an object', (t) => {
+  t.plan(3)
+  t.type(createPromise(), 'object')
+  t.equal(Array.isArray(createPromise()), false)
+  t.notOk(Array.isArray(createPromise() !== null))
+})
+
+test('createPromise() returns an attribute with attribute resolve', (t) => {
+  t.plan(1)
+  t.ok('resolve' in createPromise())
+})
+
+test('createPromise() returns an attribute with attribute reject', (t) => {
+  t.plan(1)
+  t.ok('reject' in createPromise())
+})
+
+test('createPromise() returns an attribute with attribute createPromise', (t) => {
+  t.plan(1)
+  t.ok('promise' in createPromise())
+})
+
+test('when resolve is called, createPromise attribute is resolved', (t) => {
+  t.plan(1)
+  const p = createPromise()
+
+  p.promise
+    .then(() => {
+      t.pass()
+    })
+    .catch(() => {
+      t.fail()
+    })
+  p.resolve()
+})
+
+test('when reject is called, createPromise attribute is rejected', (t) => {
+  t.plan(1)
+  const p = createPromise()
+
+  p.promise
+    .then(() => {
+      t.fail()
+    })
+    .catch(() => {
+      t.pass()
+    })
+
+  p.reject()
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/lib/execute-with-thenable.test.js

@@ -0,0 +1,82 @@
+'use strict'
+
+const { test } = require('tap')
+const { executeWithThenable } = require('../../lib/execute-with-thenable')
+const { kAvvio } = require('../../lib/symbols')
+
+test('executeWithThenable', (t) => {
+  t.plan(6)
+
+  t.test('passes the arguments to the function', (t) => {
+    t.plan(5)
+
+    executeWithThenable((...args) => {
+      t.equal(args.length, 3)
+      t.equal(args[0], 1)
+      t.equal(args[1], 2)
+      t.equal(args[2], 3)
+    }, [1, 2, 3], (err) => {
+      t.error(err)
+    })
+  })
+
+  t.test('function references this to itself', (t) => {
+    t.plan(2)
+
+    const func = function () {
+      t.equal(this, func)
+    }
+    executeWithThenable(func, [], (err) => {
+      t.error(err)
+    })
+  })
+
+  t.test('handle resolving Promise of func', (t) => {
+    t.plan(1)
+
+    const fn = function () {
+      return Promise.resolve(42)
+    }
+
+    executeWithThenable(fn, [], (err) => {
+      t.error(err)
+    })
+  })
+
+  t.test('handle rejecting Promise of func', (t) => {
+    t.plan(1)
+
+    const fn = function () {
+      return Promise.reject(new Error('Arbitrary Error'))
+    }
+
+    executeWithThenable(fn, [], (err) => {
+      t.equal(err.message, 'Arbitrary Error')
+    })
+  })
+
+  t.test('dont handle avvio mocks PromiseLike results but use callback if provided', (t) => {
+    t.plan(1)
+
+    const fn = function () {
+      const result = Promise.resolve(42)
+      result[kAvvio] = true
+    }
+
+    executeWithThenable(fn, [], (err) => {
+      t.error(err)
+    })
+  })
+
+  t.test('dont handle avvio mocks Promises and if no callback is provided', (t) => {
+    t.plan(1)
+
+    const fn = function () {
+      t.pass(1)
+      const result = Promise.resolve(42)
+      result[kAvvio] = true
+    }
+
+    executeWithThenable(fn, [])
+  })
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/lib/get-plugin-name.test.js

@@ -0,0 +1,67 @@
+'use strict'
+
+const { test } = require('tap')
+const { getPluginName } = require('../../lib/get-plugin-name')
+const { kPluginMeta } = require('../../lib/symbols')
+
+test('getPluginName of function', (t) => {
+  t.plan(1)
+
+  t.equal(getPluginName(function aPlugin () { }), 'aPlugin')
+})
+
+test('getPluginName of async function', (t) => {
+  t.plan(1)
+
+  t.equal(getPluginName(async function aPlugin () { }), 'aPlugin')
+})
+
+test('getPluginName of arrow function without name', (t) => {
+  t.plan(2)
+
+  t.equal(getPluginName(() => { }), '() => { }')
+  t.equal(getPluginName(() => { return 'random' }), '() => { return \'random\' }')
+})
+
+test('getPluginName of arrow function assigned to variable', (t) => {
+  t.plan(1)
+
+  const namedArrowFunction = () => { }
+  t.equal(getPluginName(namedArrowFunction), 'namedArrowFunction')
+})
+
+test("getPluginName based on Symbol 'plugin-meta' /1", (t) => {
+  t.plan(1)
+
+  function plugin () {
+
+  }
+
+  plugin[kPluginMeta] = {}
+  t.equal(getPluginName(plugin), 'plugin')
+})
+
+test("getPluginName based on Symbol 'plugin-meta' /2", (t) => {
+  t.plan(1)
+
+  function plugin () {
+
+  }
+
+  plugin[kPluginMeta] = {
+    name: 'fastify-non-existent'
+  }
+  t.equal(getPluginName(plugin), 'fastify-non-existent')
+})
+
+test('getPluginName if null is provided as options', (t) => {
+  t.plan(1)
+
+  t.equal(getPluginName(function a () {}, null), 'a')
+})
+
+test('getPluginName if name is provided in options', (t) => {
+  t.plan(1)
+
+  t.equal(getPluginName(function defaultName () {}, { name: 'providedName' }), 'providedName')
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/lib/is-bundled-or-typescript-plugin.test.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const { test } = require('tap')
+const { isBundledOrTypescriptPlugin } = require('../../lib/is-bundled-or-typescript-plugin')
+
+test('isBundledOrTypescriptPlugin', (t) => {
+  t.plan(9)
+
+  t.equal(isBundledOrTypescriptPlugin(1), false)
+  t.equal(isBundledOrTypescriptPlugin('function'), false)
+  t.equal(isBundledOrTypescriptPlugin({}), false)
+  t.equal(isBundledOrTypescriptPlugin([]), false)
+  t.equal(isBundledOrTypescriptPlugin(null), false)
+
+  t.equal(isBundledOrTypescriptPlugin(function () {}), false)
+  t.equal(isBundledOrTypescriptPlugin(new Promise((resolve) => resolve)), false)
+  t.equal(isBundledOrTypescriptPlugin(Promise.resolve()), false)
+
+  t.equal(isBundledOrTypescriptPlugin({ default: () => {} }), true)
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/lib/is-promise-like.test.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const { test } = require('tap')
+const { isPromiseLike } = require('../../lib/is-promise-like')
+
+test('isPromiseLike', (t) => {
+  t.plan(9)
+
+  t.equal(isPromiseLike(1), false)
+  t.equal(isPromiseLike('function'), false)
+  t.equal(isPromiseLike({}), false)
+  t.equal(isPromiseLike([]), false)
+  t.equal(isPromiseLike(null), false)
+
+  t.equal(isPromiseLike(function () {}), false)
+  t.equal(isPromiseLike(new Promise((resolve) => resolve)), true)
+  t.equal(isPromiseLike(Promise.resolve()), true)
+
+  t.equal(isPromiseLike({ then: () => {} }), true)
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/lib/thenify.test.js

@@ -0,0 +1,123 @@
+'use strict'
+
+const { test, mockRequire } = require('tap')
+const { kThenifyDoNotWrap } = require('../../lib/symbols')
+
+test('thenify', (t) => {
+  t.plan(7)
+
+  t.test('return undefined if booted', (t) => {
+    t.plan(2)
+
+    const { thenify } = mockRequire('../../lib/thenify', {
+      '../../lib/debug': {
+        debug: (message) => { t.equal(message, 'thenify returning undefined because we are already booted') }
+      }
+    })
+    const result = thenify.call({
+      booted: true
+    })
+    t.equal(result, undefined)
+  })
+
+  t.test('return undefined if kThenifyDoNotWrap is true', (t) => {
+    t.plan(1)
+
+    const { thenify } = require('../../lib/thenify')
+    const result = thenify.call({
+      [kThenifyDoNotWrap]: true
+    })
+    t.equal(result, undefined)
+  })
+
+  t.test('return PromiseConstructorLike if kThenifyDoNotWrap is false', (t) => {
+    t.plan(3)
+
+    const { thenify } = mockRequire('../../lib/thenify', {
+      '../../lib/debug': {
+        debug: (message) => { t.equal(message, 'thenify') }
+      }
+    })
+    const promiseContructorLike = thenify.call({
+      [kThenifyDoNotWrap]: false
+    })
+
+    t.type(promiseContructorLike, 'function')
+    t.equal(promiseContructorLike.length, 2)
+  })
+
+  t.test('return PromiseConstructorLike', (t) => {
+    t.plan(3)
+
+    const { thenify } = mockRequire('../../lib/thenify', {
+      '../../lib/debug': {
+        debug: (message) => { t.equal(message, 'thenify') }
+      }
+    })
+    const promiseContructorLike = thenify.call({})
+
+    t.type(promiseContructorLike, 'function')
+    t.equal(promiseContructorLike.length, 2)
+  })
+
+  t.test('resolve should return _server', async (t) => {
+    t.plan(1)
+
+    const { thenify } = require('../../lib/thenify')
+
+    const server = {
+      _loadRegistered: () => {
+        return Promise.resolve()
+      },
+      _server: 'server'
+    }
+    const promiseContructorLike = thenify.call(server)
+
+    promiseContructorLike(function (value) {
+      t.equal(value, 'server')
+    }, function (reason) {
+      t.error(reason)
+    })
+  })
+
+  t.test('resolving should set kThenifyDoNotWrap to true', async (t) => {
+    t.plan(1)
+
+    const { thenify } = require('../../lib/thenify')
+
+    const server = {
+      _loadRegistered: () => {
+        return Promise.resolve()
+      },
+      [kThenifyDoNotWrap]: false,
+      _server: 'server'
+    }
+    const promiseContructorLike = thenify.call(server)
+
+    promiseContructorLike(function (value) {
+      t.equal(server[kThenifyDoNotWrap], true)
+    }, function (reason) {
+      t.error(reason)
+    })
+  })
+
+  t.test('rejection should pass through to reject', async (t) => {
+    t.plan(1)
+
+    const { thenify } = require('../../lib/thenify')
+
+    const server = {
+      _loadRegistered: () => {
+        return Promise.reject(new Error('Arbitrary rejection'))
+      },
+      _server: 'server'
+    }
+    const promiseContructorLike = thenify.call(server)
+
+    promiseContructorLike(function (value) {
+      t.error(value)
+    }, function (reason) {
+      t.equal(reason.message, 'Arbitrary rejection')
+    })
+  })
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/lib/time-tree.test.js

@@ -0,0 +1,391 @@
+'use strict'
+
+const { test } = require('tap')
+const { TimeTree } = require('../../lib/time-tree')
+
+test('TimeTree is constructed with a root attribute, set to null', t => {
+  t.plan(1)
+
+  const tree = new TimeTree()
+  t.equal(tree.root, null)
+})
+
+test('TimeTree is constructed with an empty tableId-Map', t => {
+  t.plan(2)
+
+  const tree = new TimeTree()
+  t.ok(tree.tableId instanceof Map)
+  t.equal(tree.tableId.size, 0)
+})
+
+test('TimeTree is constructed with an empty tableLabel-Map', t => {
+  t.plan(2)
+
+  const tree = new TimeTree()
+  t.ok(tree.tableLabel instanceof Map)
+  t.equal(tree.tableLabel.size, 0)
+})
+
+test('TimeTree#toJSON dumps the content of the TimeTree', t => {
+  t.plan(1)
+
+  const tree = new TimeTree()
+  t.same(tree.toJSON(), {})
+})
+
+test('TimeTree#toJSON is creating new instances of its content, ensuring being immutable', t => {
+  t.plan(1)
+
+  const tree = new TimeTree()
+  t.not(tree.toJSON(), tree.toJSON())
+})
+
+test('TimeTree#start is adding a node with correct shape, root-node', t => {
+  t.plan(15)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+
+  const rootNode = tree.root
+
+  t.equal(Object.keys(rootNode).length, 7)
+  t.ok('parent' in rootNode)
+  t.equal(rootNode.parent, null)
+  t.ok('id' in rootNode)
+  t.type(rootNode.id, 'string')
+  t.ok('label' in rootNode)
+  t.type(rootNode.label, 'string')
+  t.ok('nodes' in rootNode)
+  t.ok(Array.isArray(rootNode.nodes))
+  t.ok('start' in rootNode)
+  t.ok(Number.isInteger(rootNode.start))
+  t.ok('stop' in rootNode)
+  t.type(rootNode.stop, 'null')
+  t.ok('diff' in rootNode)
+  t.type(rootNode.diff, 'number')
+})
+
+test('TimeTree#start is adding a node with correct shape, child-node', t => {
+  t.plan(16)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+
+  const rootNode = tree.root
+
+  t.equal(rootNode.nodes.length, 1)
+
+  const childNode = rootNode.nodes[0]
+
+  t.equal(Object.keys(childNode).length, 7)
+  t.ok('parent' in childNode)
+  t.type(childNode.parent, 'string')
+  t.ok('id' in childNode)
+  t.type(childNode.id, 'string')
+  t.ok('label' in childNode)
+  t.type(childNode.label, 'string')
+  t.ok('nodes' in childNode)
+  t.ok(Array.isArray(childNode.nodes))
+  t.ok('start' in childNode)
+  t.ok(Number.isInteger(childNode.start))
+  t.ok('stop' in childNode)
+  t.type(childNode.stop, 'null')
+  t.ok('diff' in childNode)
+  t.type(childNode.diff, 'number')
+})
+
+test('TimeTree#start is adding a root element when parent is null', t => {
+  t.plan(9)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+
+  const rootNode = tree.root
+
+  t.type(rootNode, 'object')
+  t.equal(Object.keys(rootNode).length, 7)
+  t.equal(rootNode.parent, null)
+  t.equal(rootNode.id, 'root')
+  t.equal(rootNode.label, 'root')
+  t.ok(Array.isArray(rootNode.nodes))
+  t.equal(rootNode.nodes.length, 0)
+  t.ok(Number.isInteger(rootNode.start))
+  t.type(rootNode.diff, 'number')
+})
+
+test('TimeTree#start is adding a root element when parent does not exist', t => {
+  t.plan(9)
+
+  const tree = new TimeTree()
+  tree.start('invalid', 'root')
+
+  const rootNode = tree.root
+
+  t.type(rootNode, 'object')
+  t.equal(Object.keys(rootNode).length, 7)
+  t.equal(rootNode.parent, null)
+  t.equal(rootNode.id, 'root')
+  t.equal(rootNode.label, 'root')
+  t.ok(Array.isArray(rootNode.nodes))
+  t.equal(rootNode.nodes.length, 0)
+  t.ok(Number.isInteger(rootNode.start))
+  t.type(rootNode.diff, 'number')
+})
+
+test('TimeTree#start parameter start can override automatically generated start time', t => {
+  t.plan(1)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root', 1337)
+
+  t.ok(tree.root.start, 1337)
+})
+
+test('TimeTree#start returns id of root, when adding a root node /1', t => {
+  t.plan(1)
+
+  const tree = new TimeTree()
+  t.equal(tree.start(null, 'root'), 'root')
+})
+
+test('TimeTree#start returns id of root, when adding a root node /2', t => {
+  t.plan(1)
+
+  const tree = new TimeTree()
+  t.equal(tree.start(null, '/'), 'root')
+})
+
+test('TimeTree#start returns id of child, when adding a child node', t => {
+  t.plan(1)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  t.match(tree.start('root', 'child'), /^child-[0-9.]+$/)
+})
+
+test('TimeTree tracks node ids /1', t => {
+  t.plan(3)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+
+  t.equal(tree.tableId.size, 2)
+  t.ok(tree.tableId.has('root'))
+  t.ok(tree.tableId.has(tree.root.nodes[0].id))
+})
+
+test('TimeTree tracks node ids /2', t => {
+  t.plan(4)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+  tree.start('child', 'grandchild')
+
+  t.equal(tree.tableId.size, 3)
+  t.ok(tree.tableId.has('root'))
+  t.ok(tree.tableId.has(tree.root.nodes[0].id))
+  t.ok(tree.tableId.has(tree.root.nodes[0].nodes[0].id))
+})
+
+test('TimeTree tracks node ids /3', t => {
+  t.plan(4)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+  tree.start('root', 'child')
+
+  t.equal(tree.tableId.size, 3)
+  t.ok(tree.tableId.has('root'))
+  t.ok(tree.tableId.has(tree.root.nodes[0].id))
+  t.ok(tree.tableId.has(tree.root.nodes[1].id))
+})
+
+test('TimeTree tracks node labels /1', t => {
+  t.plan(4)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+  tree.start('root', 'sibling')
+
+  t.equal(tree.tableLabel.size, 3)
+  t.ok(tree.tableLabel.has('root'))
+  t.ok(tree.tableLabel.has('child'))
+  t.ok(tree.tableLabel.has('sibling'))
+})
+
+test('TimeTree tracks node labels /2', t => {
+  t.plan(3)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+  tree.start('root', 'child')
+
+  t.equal(tree.tableLabel.size, 2)
+  t.ok(tree.tableLabel.has('root'))
+  t.ok(tree.tableLabel.has('child'))
+})
+
+test('TimeTree#stop returns undefined', t => {
+  t.plan(1)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+
+  t.type(tree.stop('root'), 'undefined')
+})
+
+test('TimeTree#stop sets stop value of node', t => {
+  t.plan(3)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  t.type(tree.root.stop, 'null')
+
+  tree.stop('root')
+  t.type(tree.root.stop, 'number')
+  t.ok(Number.isInteger(tree.root.stop))
+})
+
+test('TimeTree#stop parameter stop is used as stop value of node', t => {
+  t.plan(3)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  t.type(tree.root.stop, 'null')
+
+  tree.stop('root', 1337)
+  t.type(tree.root.stop, 'number')
+  t.equal(tree.root.stop, 1337)
+})
+
+test('TimeTree#stop calculates the diff', t => {
+  t.plan(4)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root', 1)
+  t.type(tree.root.diff, 'number')
+  t.equal(tree.root.diff, -1)
+  tree.stop('root', 5)
+
+  t.type(tree.root.diff, 'number')
+  t.equal(tree.root.diff, 4)
+})
+
+test('TimeTree#stop does nothing when node is not found', t => {
+  t.plan(2)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  t.type(tree.root.stop, 'null')
+
+  tree.stop('invalid')
+  t.type(tree.root.stop, 'null')
+})
+
+test('TimeTree untracks node ids /1', t => {
+  t.plan(2)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+
+  tree.stop(tree.root.nodes[0].id)
+  t.equal(tree.tableId.size, 1)
+  t.ok(tree.tableId.has('root'))
+})
+
+test('TimeTree untracks node ids /2', t => {
+  t.plan(3)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+  tree.start('child', 'grandchild')
+
+  tree.stop(tree.root.nodes[0].nodes[0].id)
+
+  t.equal(tree.tableId.size, 2)
+  t.ok(tree.tableId.has('root'))
+  t.ok(tree.tableId.has(tree.root.nodes[0].id))
+})
+
+test('TimeTree untracks node ids /3', t => {
+  t.plan(3)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+  tree.start('root', 'child')
+
+  tree.stop(tree.root.nodes[0].id)
+
+  t.equal(tree.tableId.size, 2)
+  t.ok(tree.tableId.has('root'))
+  t.ok(tree.tableId.has(tree.root.nodes[1].id))
+})
+
+test('TimeTree untracks node ids /4', t => {
+  t.plan(3)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+  tree.start('root', 'child')
+
+  tree.stop(tree.root.nodes[1].id)
+
+  t.equal(tree.tableId.size, 2)
+  t.ok(tree.tableId.has('root'))
+  t.ok(tree.tableId.has(tree.root.nodes[0].id))
+})
+
+test('TimeTree untracks node labels /1', t => {
+  t.plan(3)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+  tree.start('root', 'sibling')
+
+  tree.stop(tree.root.nodes[1].id)
+
+  t.equal(tree.tableLabel.size, 2)
+  t.ok(tree.tableLabel.has('root'))
+  t.ok(tree.tableLabel.has('child'))
+})
+
+test('TimeTree untracks node labels /2', t => {
+  t.plan(3)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+  tree.start('root', 'sibling')
+
+  tree.stop(tree.root.nodes[0].id)
+
+  t.equal(tree.tableLabel.size, 2)
+  t.ok(tree.tableLabel.has('root'))
+  t.ok(tree.tableLabel.has('sibling'))
+})
+
+test('TimeTree does not untrack label if used by other node', t => {
+  t.plan(3)
+
+  const tree = new TimeTree()
+  tree.start(null, 'root')
+  tree.start('root', 'child')
+  tree.start('root', 'child')
+
+  tree.stop(tree.root.nodes[0].id)
+
+  t.equal(tree.tableLabel.size, 2)
+  t.ok(tree.tableLabel.has('root'))
+  t.ok(tree.tableLabel.has('child'))
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/lib/validate-plugin.test.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const { test } = require('tap')
+const { validatePlugin } = require('../../lib/validate-plugin')
+const { AVV_ERR_PLUGIN_NOT_VALID } = require('../../lib/errors')
+
+test('validatePlugin', (t) => {
+  t.plan(8)
+
+  t.throws(() => validatePlugin(1), new AVV_ERR_PLUGIN_NOT_VALID('number'))
+  t.throws(() => validatePlugin('function'), new AVV_ERR_PLUGIN_NOT_VALID('string'))
+  t.throws(() => validatePlugin({}), new AVV_ERR_PLUGIN_NOT_VALID('object'))
+  t.throws(() => validatePlugin([]), new AVV_ERR_PLUGIN_NOT_VALID('array'))
+  t.throws(() => validatePlugin(null), new AVV_ERR_PLUGIN_NOT_VALID('null'))
+
+  t.doesNotThrow(() => validatePlugin(function () {}))
+  t.doesNotThrow(() => validatePlugin(new Promise((resolve) => resolve)))
+  t.doesNotThrow(() => validatePlugin(Promise.resolve()))
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/load-plugin.test.js

@@ -0,0 +1,123 @@
+'use strict'
+
+const fastq = require('fastq')
+const boot = require('..')
+const { test } = require('tap')
+const { Plugin } = require('../lib/plugin')
+
+test('successfully load a plugin with sync function', (t) => {
+  t.plan(1)
+  const app = boot({})
+
+  const plugin = new Plugin(fastq(app, app._loadPluginNextTick, 1), function (instance, opts, done) {
+    done()
+  }, false, 0)
+
+  app._loadPlugin(plugin, function (err) {
+    t.equal(err, undefined)
+  })
+})
+
+test('catch an error when loading a plugin with sync function', (t) => {
+  t.plan(1)
+  const app = boot({})
+
+  const plugin = new Plugin(fastq(app, app._loadPluginNextTick, 1), function (instance, opts, done) {
+    done(Error('ArbitraryError'))
+  }, false, 0)
+
+  app._loadPlugin(plugin, function (err) {
+    t.equal(err.message, 'ArbitraryError')
+  })
+})
+
+test('successfully load a plugin with sync function without done as a parameter', (t) => {
+  t.plan(1)
+  const app = boot({})
+
+  const plugin = new Plugin(fastq(app, app._loadPluginNextTick, 1), function (instance, opts) { }, false, 0)
+
+  app._loadPlugin(plugin, function (err) {
+    t.equal(err, undefined)
+  })
+})
+
+test('successfully load a plugin with async function', (t) => {
+  t.plan(1)
+  const app = boot({})
+
+  const plugin = new Plugin(fastq(app, app._loadPluginNextTick, 1), async function (instance, opts) { }, false, 0)
+
+  app._loadPlugin(plugin, function (err) {
+    t.equal(err, undefined)
+  })
+})
+
+test('catch an error when loading a plugin with async function', (t) => {
+  t.plan(1)
+  const app = boot({})
+
+  const plugin = new Plugin(fastq(app, app._loadPluginNextTick, 1), async function (instance, opts) {
+    throw Error('ArbitraryError')
+  }, false, 0)
+
+  app._loadPlugin(plugin, function (err) {
+    t.equal(err.message, 'ArbitraryError')
+  })
+})
+
+test('successfully load a plugin when function is a Promise, which resolves to a function', (t) => {
+  t.plan(1)
+  const app = boot({})
+
+  const plugin = new Plugin(fastq(app, app._loadPluginNextTick, 1), new Promise(resolve => resolve(function (instance, opts, done) {
+    done()
+  })), false, 0)
+
+  app._loadPlugin(plugin, function (err) {
+    t.equal(err, undefined)
+  })
+})
+
+test('catch an error when loading a plugin when function is a Promise, which resolves to a function', (t) => {
+  t.plan(1)
+  const app = boot({})
+
+  const plugin = new Plugin(fastq(app, app._loadPluginNextTick, 1), new Promise(resolve => resolve(function (instance, opts, done) {
+    done(Error('ArbitraryError'))
+  })), false, 0)
+
+  app._loadPlugin(plugin, function (err) {
+    t.equal(err.message, 'ArbitraryError')
+  })
+})
+
+test('successfully load a plugin when function is a Promise, which resolves to a function, which is wrapped in default', (t) => {
+  t.plan(1)
+  const app = boot({})
+
+  const plugin = new Plugin(fastq(app, app._loadPluginNextTick, 1), new Promise(resolve => resolve({
+    default: function (instance, opts, done) {
+      done()
+    }
+  })), false, 0)
+
+  app._loadPlugin(plugin, function (err) {
+    t.equal(err, undefined)
+  })
+})
+
+test('catch an error when loading a plugin when function is a Promise, which resolves to a function, which is wrapped in default', (t) => {
+  t.plan(1)
+  const app = boot({})
+
+  const plugin = new Plugin(fastq(app, app._loadPluginNextTick, 1), new Promise(resolve => resolve({
+    default: function (instance, opts, done) {
+      done(Error('ArbitraryError'))
+    }
+  })), false, 0)
+
+  app._loadPlugin(plugin, function (err) {
+    t.equal(err.message, 'ArbitraryError')
+  })
+})

novas/novacore-zephyr/claude-code-router/node_modules/avvio/test/no-done.test.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const { test } = require('tap')
+const boot = require('..')
+
+test('not taking done does not throw error.', (t) => {
+  t.plan(2)
+
+  const app = boot()
+
+  app.use(noDone).ready((err) => {
+    t.notOk(err, 'no error')
+  })
+
+  function noDone (s, opts) {
+    t.pass('did not throw')
+  }
+})