Add files using upload-large-folder tool

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/ajv-compiler/.github/tests_checker.yml

@@ -0,0 +1,8 @@
+comment: |
+  Hello! Thank you for contributing!
+  It appears that you have changed the code, but the tests that verify your change are missing. Could you please add them?
+fileExtensions:
+  - '.ts'
+  - '.js'
+
+testDir: 'test'

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/ajv-compiler/.github/workflows/ci.yml

@@ -0,0 +1,26 @@
+name: CI
+
+on:
+  push:
+    branches:
+     - main
+     - master
+     - next
+     - 'v*'
+    paths-ignore:
+      - 'docs/**'
+      - '*.md'
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - '*.md'
+
+env:
+  TZ: 'UTC'
+
+jobs:
+  test:
+    uses: fastify/workflows/.github/workflows/plugins-ci.yml@v5
+    with:
+      lint: true
+      license-check: true

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/ajv-compiler/lib/default-ajv-options.js

@@ -0,0 +1,14 @@
+'use strict'
+
+const fastUri = require('fast-uri')
+
+module.exports = Object.freeze({
+  coerceTypes: 'array',
+  useDefaults: true,
+  removeAdditional: true,
+  uriResolver: fastUri,
+  addUsedSchema: false,
+  // Explicitly set allErrors to `false`.
+  // When set to `true`, a DoS attack is possible.
+  allErrors: false
+})

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/ajv-compiler/lib/serializer-compiler.js

@@ -0,0 +1,27 @@
+'use strict'
+
+const AjvJTD = require('ajv/dist/jtd')
+
+const defaultAjvOptions = require('./default-ajv-options')
+
+class SerializerCompiler {
+  constructor (_externalSchemas, options) {
+    this.ajv = new AjvJTD(Object.assign({}, defaultAjvOptions, options))
+
+    /**
+     * https://ajv.js.org/json-type-definition.html#ref-form
+     * Unlike JSON Schema, JTD does not allow to reference:
+     * - any schema fragment other than root level definitions member
+     * - root of the schema - there is another way to define a self-recursive schema (see Example 2)
+     * - another schema file (but you can still combine schemas from multiple files using JavaScript).
+     *
+     * So we ignore the externalSchemas parameter.
+     */
+  }
+
+  buildSerializerFunction ({ schema/*, method, url, httpStatus */ }) {
+    return this.ajv.compileSerializer(schema)
+  }
+}
+
+module.exports = SerializerCompiler

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/ajv-compiler/lib/validator-compiler.js

@@ -0,0 +1,58 @@
+'use strict'
+
+const Ajv = require('ajv').default
+const AjvJTD = require('ajv/dist/jtd')
+
+const defaultAjvOptions = require('./default-ajv-options')
+
+class ValidatorCompiler {
+  constructor (externalSchemas, options) {
+    // This instance of Ajv is private
+    // it should not be customized or used
+    if (options.mode === 'JTD') {
+      this.ajv = new AjvJTD(Object.assign({}, defaultAjvOptions, options.customOptions))
+    } else {
+      this.ajv = new Ajv(Object.assign({}, defaultAjvOptions, options.customOptions))
+    }
+
+    let addFormatPlugin = true
+    if (options.plugins && options.plugins.length > 0) {
+      for (const plugin of options.plugins) {
+        if (Array.isArray(plugin)) {
+          addFormatPlugin = addFormatPlugin && plugin[0].name !== 'formatsPlugin'
+          plugin[0](this.ajv, plugin[1])
+        } else {
+          addFormatPlugin = addFormatPlugin && plugin.name !== 'formatsPlugin'
+          plugin(this.ajv)
+        }
+      }
+    }
+
+    if (addFormatPlugin) {
+      require('ajv-formats')(this.ajv)
+    }
+
+    options.onCreate?.(this.ajv)
+
+    const sourceSchemas = Object.values(externalSchemas)
+    for (const extSchema of sourceSchemas) {
+      this.ajv.addSchema(extSchema)
+    }
+  }
+
+  buildValidatorFunction ({ schema/*, method, url, httpPart */ }) {
+    // Ajv does not support compiling two schemas with the same
+    // id inside the same instance. Therefore if we have already
+    // compiled the schema with the given id, we just return it.
+    if (schema.$id) {
+      const stored = this.ajv.getSchema(schema.$id)
+      if (stored) {
+        return stored
+      }
+    }
+
+    return this.ajv.compile(schema)
+  }
+}
+
+module.exports = ValidatorCompiler

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/ajv-compiler/test/duplicated-id-compile.test.js

@@ -0,0 +1,59 @@
+'use strict'
+
+const t = require('tap')
+const AjvCompiler = require('../index')
+
+const postSchema = Object.freeze({
+  $schema: 'http://json-schema.org/draft-07/schema#',
+  type: 'object',
+  $id: 'http://mydomain.com/user',
+  title: 'User schema',
+  description: 'Contains all user fields',
+  properties: {
+    username: { type: 'string', minLength: 4 },
+    firstName: { type: 'string', minLength: 1 },
+    lastName: { type: 'string', minLength: 1 },
+    email: { type: 'string' },
+    password: { type: 'string', minLength: 6 },
+    bio: { type: 'string' }
+  },
+  required: ['username', 'firstName', 'lastName', 'email', 'bio', 'password']
+})
+
+const patchSchema = Object.freeze({
+  $schema: 'http://json-schema.org/draft-07/schema#',
+  type: 'object',
+  $id: 'http://mydomain.com/user',
+  title: 'User schema',
+  description: 'Contains all user fields',
+  properties: {
+    firstName: { type: 'string', minLength: 1 },
+    lastName: { type: 'string', minLength: 1 },
+    bio: { type: 'string' }
+  }
+})
+
+const fastifyAjvOptionsDefault = Object.freeze({
+  customOptions: {}
+})
+
+t.test('must not store schema on compile', t => {
+  t.plan(4)
+  const factory = AjvCompiler()
+  const compiler = factory({}, fastifyAjvOptionsDefault)
+  const postFn = compiler({ schema: postSchema })
+  const patchFn = compiler({ schema: patchSchema })
+
+  const resultForPost = postFn({})
+  t.equal(resultForPost, false)
+  t.has(postFn.errors, [
+    {
+      keyword: 'required',
+      message: "must have required property 'username'"
+    }
+  ])
+
+  const resultForPatch = patchFn({})
+  t.ok(resultForPatch)
+  t.notOk(patchFn.errors)
+})

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/ajv-compiler/test/index.test.js

@@ -0,0 +1,307 @@
+'use strict'
+
+const t = require('tap')
+const fastify = require('fastify')
+const AjvCompiler = require('../index')
+
+const sym = Symbol.for('fastify.ajv-compiler.reference')
+
+const sampleSchema = Object.freeze({
+  $id: 'example1',
+  type: 'object',
+  properties: {
+    name: { type: 'string' }
+  }
+})
+
+const externalSchemas1 = Object.freeze({})
+const externalSchemas2 = Object.freeze({
+  foo: {
+    $id: 'foo',
+    type: 'object',
+    properties: {
+      name: { type: 'string' }
+    }
+  }
+})
+
+const fastifyAjvOptionsDefault = Object.freeze({
+  customOptions: {}
+})
+
+const fastifyJtdDefault = Object.freeze({
+  customOptions: { },
+  mode: 'JTD'
+})
+
+const fastifyAjvOptionsCustom = Object.freeze({
+  customOptions: {
+    allErrors: true,
+    removeAdditional: false
+  },
+  plugins: [
+    require('ajv-formats'),
+    [require('ajv-errors'), { singleError: false }]
+  ]
+})
+
+t.test('basic usage', t => {
+  t.plan(1)
+  const factory = AjvCompiler()
+  const compiler = factory(externalSchemas1, fastifyAjvOptionsDefault)
+  const validatorFunc = compiler({ schema: sampleSchema })
+  const result = validatorFunc({ name: 'hello' })
+  t.equal(result, true)
+})
+
+t.test('array coercion', t => {
+  t.plan(2)
+  const factory = AjvCompiler()
+  const compiler = factory(externalSchemas1, fastifyAjvOptionsDefault)
+
+  const arraySchema = {
+    $id: 'example1',
+    type: 'object',
+    properties: {
+      name: { type: 'array', items: { type: 'string' } }
+    }
+  }
+
+  const validatorFunc = compiler({ schema: arraySchema })
+
+  const inputObj = { name: 'hello' }
+  t.equal(validatorFunc(inputObj), true)
+  t.same(inputObj, { name: ['hello'] }, 'the name property should be coerced to an array')
+})
+
+t.test('nullable default', t => {
+  t.plan(2)
+  const factory = AjvCompiler()
+  const compiler = factory({}, fastifyAjvOptionsDefault)
+  const validatorFunc = compiler({
+    schema: {
+      type: 'object',
+      properties: {
+        nullable: { type: 'string', nullable: true },
+        notNullable: { type: 'string' }
+      }
+    }
+  })
+  const input = { nullable: null, notNullable: null }
+  const result = validatorFunc(input)
+  t.equal(result, true)
+  t.same(input, { nullable: null, notNullable: '' }, 'the notNullable field has been coerced')
+})
+
+t.test('plugin loading', t => {
+  t.plan(3)
+  const factory = AjvCompiler()
+  const compiler = factory(externalSchemas1, fastifyAjvOptionsCustom)
+  const validatorFunc = compiler({
+    schema: {
+      type: 'object',
+      properties: {
+        q: {
+          type: 'string',
+          format: 'date',
+          formatMinimum: '2016-02-06',
+          formatExclusiveMaximum: '2016-12-27'
+        }
+      },
+      required: ['q'],
+      errorMessage: 'hello world'
+    }
+  })
+  const result = validatorFunc({ q: '2016-10-02' })
+  t.equal(result, true)
+
+  const resultFail = validatorFunc({})
+  t.equal(resultFail, false)
+  t.equal(validatorFunc.errors[0].message, 'hello world')
+})
+
+t.test('optimization - cache ajv instance', t => {
+  t.plan(5)
+  const factory = AjvCompiler()
+  const compiler1 = factory(externalSchemas1, fastifyAjvOptionsDefault)
+  const compiler2 = factory(externalSchemas1, fastifyAjvOptionsDefault)
+  t.equal(compiler1, compiler2, 'same instance')
+  t.same(compiler1, compiler2, 'same instance')
+
+  const compiler3 = factory(externalSchemas2, fastifyAjvOptionsDefault)
+  t.not(compiler3, compiler1, 'new ajv instance when externa schema change')
+
+  const compiler4 = factory(externalSchemas1, fastifyAjvOptionsCustom)
+  t.not(compiler4, compiler1, 'new ajv instance when externa schema change')
+  t.not(compiler4, compiler3, 'new ajv instance when externa schema change')
+})
+
+t.test('the onCreate callback can enhance the ajv instance', t => {
+  t.plan(2)
+  const factory = AjvCompiler()
+
+  const fastifyAjvCustomOptionsFormats = Object.freeze({
+    onCreate (ajv) {
+      for (const [formatName, format] of Object.entries(this.customOptions.formats)) {
+        ajv.addFormat(formatName, format)
+      }
+    },
+    customOptions: {
+      formats: {
+        date: /foo/
+      }
+    }
+  })
+
+  const compiler1 = factory(externalSchemas1, fastifyAjvCustomOptionsFormats)
+  const validatorFunc = compiler1({
+    schema: {
+      type: 'string',
+      format: 'date'
+    }
+  })
+  const result = validatorFunc('foo')
+  t.equal(result, true)
+
+  const resultFail = validatorFunc('2016-10-02')
+  t.equal(resultFail, false)
+})
+
+// https://github.com/fastify/fastify/pull/2969
+t.test('compile same $id when in external schema', t => {
+  t.plan(3)
+  const factory = AjvCompiler()
+
+  const base = {
+    $id: 'urn:schema:base',
+    definitions: {
+      hello: { type: 'string' }
+    },
+    type: 'object',
+    properties: {
+      hello: { $ref: '#/definitions/hello' }
+    }
+  }
+
+  const refSchema = {
+    $id: 'urn:schema:ref',
+    type: 'object',
+    properties: {
+      hello: { $ref: 'urn:schema:base#/definitions/hello' }
+    }
+  }
+
+  const compiler = factory({
+    [base.$id]: base,
+    [refSchema.$id]: refSchema
+
+  }, fastifyAjvOptionsDefault)
+
+  t.notOk(compiler[sym], 'the ajv reference do not exists if code is not activated')
+
+  const validatorFunc1 = compiler({
+    schema: {
+      $id: 'urn:schema:ref'
+    }
+  })
+
+  const validatorFunc2 = compiler({
+    schema: {
+      $id: 'urn:schema:ref'
+    }
+  })
+
+  t.pass('the compile does not fail if the schema compiled is already in the external schemas')
+  t.equal(validatorFunc1, validatorFunc2, 'the returned function is the same')
+})
+
+t.test('JTD MODE', t => {
+  t.plan(2)
+
+  t.test('compile jtd schema', t => {
+    t.plan(4)
+    const factory = AjvCompiler()
+
+    const jtdSchema = {
+      discriminator: 'version',
+      mapping: {
+        1: {
+          properties: {
+            foo: { type: 'uint8' }
+          }
+        },
+        2: {
+          properties: {
+            foo: { type: 'string' }
+          }
+        }
+      }
+    }
+
+    const compiler = factory({}, fastifyJtdDefault)
+    const validatorFunc = compiler({ schema: jtdSchema })
+    t.pass('generated validation function for JTD SCHEMA')
+
+    const result = validatorFunc({
+      version: '2',
+      foo: []
+    })
+    t.notOk(result, 'failed validation')
+    t.type(validatorFunc.errors, 'Array')
+
+    const success = validatorFunc({
+      version: '1',
+      foo: 42
+    })
+    t.ok(success)
+  })
+
+  t.test('fastify integration', async t => {
+    const factory = AjvCompiler()
+
+    const app = fastify({
+      jsonShorthand: false,
+      ajv: {
+        customOptions: { },
+        mode: 'JTD'
+      },
+      schemaController: {
+        compilersFactory: {
+          buildValidator: factory
+        }
+      }
+    })
+
+    app.post('/', {
+      schema: {
+        body: {
+          discriminator: 'version',
+          mapping: {
+            1: {
+              properties: {
+                foo: { type: 'uint8' }
+              }
+            },
+            2: {
+              properties: {
+                foo: { type: 'string' }
+              }
+            }
+          }
+        }
+      }
+    }, () => {})
+
+    const res = await app.inject({
+      url: '/',
+      method: 'POST',
+      payload: {
+        version: '1',
+        foo: 'this is not a number'
+      }
+    })
+
+    t.equal(res.statusCode, 400)
+    t.equal(res.json().message, 'body/foo must be uint8')
+  })
+})

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/ajv-compiler/test/plugins.test.js

@@ -0,0 +1,264 @@
+'use strict'
+
+const t = require('tap')
+const fastify = require('fastify')
+const AjvCompiler = require('../index')
+
+const ajvFormats = require('ajv-formats')
+const ajvErrors = require('ajv-errors')
+const localize = require('ajv-i18n')
+
+t.test('Format Baseline test', async (t) => {
+  const app = buildApplication({
+    customOptions: {
+      validateFormats: false
+    }
+  })
+
+  const res = await app.inject({
+    url: '/hello',
+    headers: {
+      'x-foo': 'hello',
+      'x-date': 'not a date',
+      'x-email': 'not an email'
+    },
+    query: {
+      foo: 'hello',
+      date: 'not a date',
+      email: 'not an email'
+    }
+  })
+  t.equal(res.statusCode, 200, 'format validation does not apply as configured')
+  t.equal(res.payload, 'hello')
+})
+
+t.test('Custom Format plugin loading test', (t) => {
+  t.plan(6)
+  const app = buildApplication({
+    customOptions: {
+      validateFormats: true
+    },
+    plugins: [[ajvFormats, { mode: 'fast' }]]
+  })
+
+  app.inject('/hello', (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 400, 'format validation applies')
+  })
+
+  app.inject('/2ad0612c-7578-4b18-9a6f-579863f40e0b', (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 400, 'format validation applies')
+  })
+
+  app.inject({
+    url: '/2ad0612c-7578-4b18-9a6f-579863f40e0b',
+    headers: {
+      'x-foo': 'hello',
+      'x-date': new Date().toISOString(),
+      'x-email': 'foo@bar.baz'
+    },
+    query: {
+      foo: 'hello',
+      date: new Date().toISOString(),
+      email: 'foo@bar.baz'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 200)
+  })
+})
+
+t.test('Format plugin set by default test', (t) => {
+  t.plan(6)
+  const app = buildApplication({})
+
+  app.inject('/hello', (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 400, 'format validation applies')
+  })
+
+  app.inject('/2ad0612c-7578-4b18-9a6f-579863f40e0b', (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 400, 'format validation applies')
+  })
+
+  app.inject({
+    url: '/2ad0612c-7578-4b18-9a6f-579863f40e0b',
+    headers: {
+      'x-foo': 'hello',
+      'x-date': new Date().toISOString(),
+      'x-email': 'foo@bar.baz'
+    },
+    query: {
+      foo: 'hello',
+      date: new Date().toISOString(),
+      email: 'foo@bar.baz'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 200)
+  })
+})
+
+t.test('Custom error messages', (t) => {
+  t.plan(9)
+
+  const app = buildApplication({
+    customOptions: {
+      removeAdditional: false,
+      allErrors: true
+    },
+    plugins: [ajvFormats, ajvErrors]
+  })
+
+  const errorMessage = {
+    required: 'custom miss',
+    type: 'custom type', // will not replace internal "type" error for the property "foo"
+    _: 'custom type', // this prop will do it
+    additionalProperties: 'custom too many params'
+  }
+
+  app.post('/', {
+    handler: () => { t.fail('dont call me') },
+    schema: {
+      body: {
+        type: 'object',
+        required: ['foo'],
+        properties: {
+          foo: { type: 'integer' }
+        },
+        additionalProperties: false,
+        errorMessage
+      }
+    }
+  })
+
+  app.inject({
+    url: '/',
+    method: 'post',
+    payload: {}
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 400)
+    t.match(res.json().message, errorMessage.required)
+  })
+
+  app.inject({
+    url: '/',
+    method: 'post',
+    payload: { foo: 'not a number' }
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 400)
+    t.match(res.json().message, errorMessage.type)
+  })
+
+  app.inject({
+    url: '/',
+    method: 'post',
+    payload: { foo: 3, bar: 'ops' }
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 400)
+    t.match(res.json().message, errorMessage.additionalProperties)
+  })
+})
+
+t.test('Custom i18n error messages', (t) => {
+  t.plan(3)
+
+  const app = buildApplication({
+    customOptions: {
+      allErrors: true,
+      messages: false
+    },
+    plugins: [ajvFormats]
+  })
+
+  app.post('/', {
+    handler: () => { t.fail('dont call me') },
+    schema: {
+      body: {
+        type: 'object',
+        required: ['foo'],
+        properties: {
+          foo: { type: 'integer' }
+        }
+      }
+    }
+  })
+
+  app.setErrorHandler((error, request, reply) => {
+    t.pass('Error handler executed')
+    if (error.validation) {
+      localize.ru(error.validation)
+      reply.status(400).send(error.validation)
+      return
+    }
+    t.fail('not other errors')
+  })
+
+  app.inject({
+    method: 'POST',
+    url: '/',
+    payload: {
+      foo: 'string'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.json()[0].message, 'должно быть integer')
+  })
+})
+
+function buildApplication (ajvOptions) {
+  const factory = AjvCompiler()
+
+  const app = fastify({
+    ajv: ajvOptions,
+    schemaController: {
+      compilersFactory: {
+        buildValidator: factory
+      }
+    }
+  })
+
+  app.get('/:id', {
+    schema: {
+      headers: {
+        type: 'object',
+        required: [
+          'x-foo',
+          'x-date',
+          'x-email'
+        ],
+        properties: {
+          'x-foo': { type: 'string' },
+          'x-date': { type: 'string', format: 'date-time' },
+          'x-email': { type: 'string', format: 'email' }
+        }
+      },
+      query: {
+        type: 'object',
+        required: [
+          'foo',
+          'date',
+          'email'
+        ],
+        properties: {
+          foo: { type: 'string' },
+          date: { type: 'string', format: 'date-time' },
+          email: { type: 'string', format: 'email' }
+        }
+      },
+      params: {
+        type: 'object',
+        properties: {
+          id: { type: 'string', format: 'uuid' }
+        }
+      }
+    }
+  }, async () => 'hello')
+
+  return app
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/ajv-compiler/test/serialization.test.js

@@ -0,0 +1,279 @@
+'use strict'
+
+const t = require('tap')
+const fastify = require('fastify')
+const AjvCompiler = require('../index')
+
+const jtdSchema = {
+  discriminator: 'version',
+  mapping: {
+    1: {
+      properties: {
+        foo: { type: 'uint8' }
+      }
+    },
+    2: {
+      properties: {
+        foo: { type: 'string' }
+      }
+    }
+  }
+}
+
+const externalSchemas1 = Object.freeze({})
+const externalSchemas2 = Object.freeze({
+  foo: {
+    definitions: {
+      coordinates: {
+        properties: {
+          lat: { type: 'float32' },
+          lng: { type: 'float32' }
+        }
+      }
+    }
+  }
+})
+
+const fastifyAjvOptionsDefault = Object.freeze({
+  customOptions: {}
+})
+
+t.test('basic serializer usage', t => {
+  t.plan(4)
+  const factory = AjvCompiler({ jtdSerializer: true })
+  const compiler = factory(externalSchemas1, fastifyAjvOptionsDefault)
+  const serializeFunc = compiler({ schema: jtdSchema })
+  t.equal(serializeFunc({ version: '1', foo: 42 }), '{"version":"1","foo":42}')
+  t.equal(serializeFunc({ version: '2', foo: 'hello' }), '{"version":"2","foo":"hello"}')
+  t.equal(serializeFunc({ version: '3', foo: 'hello' }), '{"version":"3"}')
+  t.equal(serializeFunc({ version: '2', foo: ['not', 1, { string: 'string' }] }), '{"version":"2","foo":"not,1,[object Object]"}')
+})
+
+t.test('external schemas are ignored', t => {
+  t.plan(1)
+  const factory = AjvCompiler({ jtdSerializer: true })
+  const compiler = factory(externalSchemas2, fastifyAjvOptionsDefault)
+  const serializeFunc = compiler({
+    schema: {
+      definitions: {
+        coordinates: {
+          properties: {
+            lat: { type: 'float32' },
+            lng: { type: 'float32' }
+          }
+        }
+      },
+      properties: {
+        userLoc: { ref: 'coordinates' },
+        serverLoc: { ref: 'coordinates' }
+      }
+    }
+  })
+  t.equal(serializeFunc(
+    { userLoc: { lat: 50, lng: -90 }, serverLoc: { lat: -15, lng: 50 } }),
+  '{"userLoc":{"lat":50,"lng":-90},"serverLoc":{"lat":-15,"lng":50}}'
+  )
+})
+
+t.test('fastify integration within JTD serializer', async t => {
+  const factoryValidator = AjvCompiler()
+  const factorySerializer = AjvCompiler({ jtdSerializer: true })
+
+  const app = fastify({
+    jsonShorthand: false,
+    ajv: {
+      customOptions: { },
+      mode: 'JTD'
+    },
+    schemaController: {
+      compilersFactory: {
+        buildValidator: factoryValidator,
+        buildSerializer: factorySerializer
+      }
+    }
+  })
+
+  app.post('/', {
+    schema: {
+      body: jtdSchema,
+      response: {
+        200: {
+          properties: {
+            id: { type: 'string' },
+            createdAt: { type: 'timestamp' },
+            karma: { type: 'int32' },
+            isAdmin: { type: 'boolean' }
+          }
+        },
+        400: jtdSchema
+      }
+    }
+  }, async () => {
+    return {
+      id: '123',
+      createdAt: new Date('1999-01-31T23:00:00.000Z'),
+      karma: 42,
+      isAdmin: true,
+      remove: 'me'
+    }
+  })
+
+  {
+    const res = await app.inject({
+      url: '/',
+      method: 'POST',
+      payload: {
+        version: '1',
+        foo: 'not a number'
+      }
+    })
+
+    t.equal(res.statusCode, 400)
+    t.same(res.json(), { version: 'undefined' })
+  }
+
+  {
+    const res = await app.inject({
+      url: '/',
+      method: 'POST',
+      payload: {
+        version: '1',
+        foo: 32
+      }
+    })
+
+    t.equal(res.statusCode, 200)
+    t.same(res.json(), {
+      id: '123',
+      createdAt: '1999-01-31T23:00:00.000Z',
+      karma: 42,
+      isAdmin: true
+    })
+  }
+})
+
+t.test('fastify integration and cached serializer', async t => {
+  const factoryValidator = AjvCompiler()
+  const factorySerializer = AjvCompiler({ jtdSerializer: true })
+
+  const app = fastify({
+    jsonShorthand: false,
+    ajv: {
+      customOptions: { },
+      mode: 'JTD'
+    },
+    schemaController: {
+      compilersFactory: {
+        buildValidator: factoryValidator,
+        buildSerializer: factorySerializer
+      }
+    }
+  })
+
+  app.register(async function plugin (app, opts) {
+    app.post('/', {
+      schema: {
+        body: jtdSchema,
+        response: {
+          200: {
+            properties: {
+              id: { type: 'string' },
+              createdAt: { type: 'timestamp' },
+              karma: { type: 'int32' },
+              isAdmin: { type: 'boolean' }
+            }
+          },
+          400: jtdSchema
+        }
+      }
+    }, async () => {
+      return {
+        id: '123',
+        createdAt: new Date('1999-01-31T23:00:00.000Z'),
+        karma: 42,
+        isAdmin: true,
+        remove: 'me'
+      }
+    })
+  })
+
+  app.register(async function plugin (app, opts) {
+    app.post('/two', {
+      schema: {
+        body: jtdSchema,
+        response: {
+          400: jtdSchema
+        }
+      }
+    }, () => {})
+  })
+
+  {
+    const res = await app.inject({
+      url: '/',
+      method: 'POST',
+      payload: {
+        version: '1',
+        foo: 'not a number'
+      }
+    })
+
+    t.equal(res.statusCode, 400)
+    t.same(res.json(), { version: 'undefined' })
+  }
+
+  {
+    const res = await app.inject({
+      url: '/',
+      method: 'POST',
+      payload: {
+        version: '1',
+        foo: 32
+      }
+    })
+
+    t.equal(res.statusCode, 200)
+    t.same(res.json(), {
+      id: '123',
+      createdAt: '1999-01-31T23:00:00.000Z',
+      karma: 42,
+      isAdmin: true
+    })
+  }
+})
+
+t.test('fastify integration within JTD serializer and custom options', async t => {
+  const factorySerializer = AjvCompiler({ jtdSerializer: true })
+
+  const app = fastify({
+    jsonShorthand: false,
+    serializerOpts: {
+      allErrors: true,
+      logger: 'wrong-value'
+    },
+    schemaController: {
+      compilersFactory: {
+        buildSerializer: factorySerializer
+      }
+    }
+  })
+
+  app.post('/', {
+    schema: {
+      response: {
+        200: {
+          properties: {
+            test: { type: 'boolean' }
+          }
+        }
+      }
+    }
+  }, async () => { })
+
+  try {
+    await app.ready()
+    t.fail('should throw')
+  } catch (error) {
+    t.equal(error.message, 'logger must implement log, warn and error methods', 'the wrong setting is forwarded to ajv/jtd')
+  }
+})

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/ajv-compiler/test/standalone.test.js

@@ -0,0 +1,203 @@
+'use strict'
+
+const fs = require('node:fs')
+const path = require('node:path')
+const t = require('tap')
+const fastify = require('fastify')
+const sanitize = require('sanitize-filename')
+
+const { StandaloneValidator: AjvStandaloneValidator } = require('../')
+
+function generateFileName (routeOpts) {
+  return `/ajv-generated-${sanitize(routeOpts.schema.$id)}-${routeOpts.method}-${routeOpts.httpPart}-${sanitize(routeOpts.url)}.js`
+}
+
+const generatedFileNames = []
+
+t.test('standalone', t => {
+  t.plan(4)
+
+  t.teardown(async () => {
+    for (const fileName of generatedFileNames) {
+      await fs.promises.unlink(path.join(__dirname, fileName))
+    }
+  })
+
+  t.test('errors', t => {
+    t.plan(2)
+    t.throws(() => {
+      AjvStandaloneValidator()
+    }, 'missing restoreFunction')
+    t.throws(() => {
+      AjvStandaloneValidator({ readMode: false })
+    }, 'missing storeFunction')
+  })
+
+  t.test('generate standalone code', t => {
+    t.plan(5)
+
+    const base = {
+      $id: 'urn:schema:base',
+      definitions: {
+        hello: { type: 'string' }
+      },
+      type: 'object',
+      properties: {
+        hello: { $ref: '#/definitions/hello' }
+      }
+    }
+
+    const refSchema = {
+      $id: 'urn:schema:ref',
+      type: 'object',
+      properties: {
+        hello: { $ref: 'urn:schema:base#/definitions/hello' }
+      }
+    }
+
+    const endpointSchema = {
+      schema: {
+        $id: 'urn:schema:endpoint',
+        $ref: 'urn:schema:ref'
+      }
+    }
+
+    const schemaMap = {
+      [base.$id]: base,
+      [refSchema.$id]: refSchema
+    }
+
+    const factory = AjvStandaloneValidator({
+      readMode: false,
+      storeFunction (routeOpts, schemaValidationCode) {
+        t.same(routeOpts, endpointSchema)
+        t.type(schemaValidationCode, 'string')
+        fs.writeFileSync(path.join(__dirname, '/ajv-generated.js'), schemaValidationCode)
+        generatedFileNames.push('/ajv-generated.js')
+        t.pass('stored the validation function')
+      }
+    })
+
+    const compiler = factory(schemaMap)
+    compiler(endpointSchema)
+    t.pass('compiled the endpoint schema')
+
+    t.test('usage standalone code', t => {
+      t.plan(3)
+      const standaloneValidate = require('./ajv-generated')
+
+      const valid = standaloneValidate({ hello: 'world' })
+      t.ok(valid)
+
+      const invalid = standaloneValidate({ hello: [] })
+      t.notOk(invalid)
+
+      t.ok(standaloneValidate)
+    })
+  })
+
+  t.test('fastify integration - writeMode', async t => {
+    t.plan(6)
+
+    const factory = AjvStandaloneValidator({
+      readMode: false,
+      storeFunction (routeOpts, schemaValidationCode) {
+        const fileName = generateFileName(routeOpts)
+        t.ok(routeOpts)
+        fs.writeFileSync(path.join(__dirname, fileName), schemaValidationCode)
+        t.pass('stored the validation function')
+        generatedFileNames.push(fileName)
+      },
+      restoreFunction () {
+        t.fail('write mode ON')
+      }
+    })
+
+    const app = buildApp(factory)
+    await app.ready()
+  })
+
+  t.test('fastify integration - readMode', async t => {
+    t.plan(6)
+
+    const factory = AjvStandaloneValidator({
+      readMode: true,
+      storeFunction () {
+        t.fail('read mode ON')
+      },
+      restoreFunction (routeOpts) {
+        t.pass('restore the validation function')
+        const fileName = generateFileName(routeOpts)
+        return require(path.join(__dirname, fileName))
+      }
+    })
+
+    const app = buildApp(factory)
+    await app.ready()
+
+    let res = await app.inject({
+      url: '/foo',
+      method: 'POST',
+      payload: { hello: [] }
+    })
+    t.equal(res.statusCode, 400)
+
+    res = await app.inject({
+      url: '/bar?lang=invalid',
+      method: 'GET'
+    })
+    t.equal(res.statusCode, 400)
+
+    res = await app.inject({
+      url: '/bar?lang=it',
+      method: 'GET'
+    })
+    t.equal(res.statusCode, 200)
+  })
+
+  function buildApp (factory) {
+    const app = fastify({
+      jsonShorthand: false,
+      schemaController: {
+        compilersFactory: {
+          buildValidator: factory
+        }
+      }
+    })
+
+    app.addSchema({
+      $id: 'urn:schema:foo',
+      type: 'object',
+      properties: {
+        name: { type: 'string' },
+        id: { type: 'integer' }
+      }
+    })
+
+    app.post('/foo', {
+      schema: {
+        body: {
+          $id: 'urn:schema:body',
+          type: 'object',
+          properties: {
+            hello: { $ref: 'urn:schema:foo#/properties/name' }
+          }
+        }
+      }
+    }, () => { return 'ok' })
+
+    app.get('/bar', {
+      schema: {
+        query: {
+          $id: 'urn:schema:query',
+          type: 'object',
+          properties: {
+            lang: { type: 'string', enum: ['it', 'en'] }
+          }
+        }
+      }
+    }, () => { return 'ok' })
+
+    return app
+  }
+})

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/ajv-compiler/types/index.d.ts

@@ -0,0 +1,72 @@
+import _ajv, { AnySchema, Options as AjvOptions, ValidateFunction } from 'ajv'
+import AjvJTD, { JTDOptions } from 'ajv/dist/jtd'
+import type { Options, ErrorObject } from 'ajv'
+import { AnyValidateFunction } from 'ajv/dist/core'
+
+type Ajv = _ajv
+type AjvSerializerGenerator = typeof AjvCompiler
+
+type AjvJTDCompile = AjvJTD['compileSerializer']
+type AjvCompile = (schema: AnySchema, _meta?: boolean) => AnyValidateFunction
+
+declare function buildCompilerFromPool (externalSchemas: { [key: string]: AnySchema | AnySchema[] }, options?: { mode: 'JTD'; customOptions?: JTDOptions; onCreate?: (ajvInstance: Ajv) => void }): AjvCompile
+declare function buildCompilerFromPool (externalSchemas: { [key: string]: AnySchema | AnySchema[] }, options?: { mode?: never; customOptions?: AjvOptions; onCreate?: (ajvInstance: Ajv) => void }): AjvCompile
+
+declare function buildSerializerFromPool (externalSchemas: any, serializerOpts?: { mode?: never; } & JTDOptions): AjvJTDCompile
+
+declare function AjvCompiler (opts: { jtdSerializer: true }): AjvCompiler.BuildSerializerFromPool
+declare function AjvCompiler (opts?: { jtdSerializer?: false }): AjvCompiler.BuildCompilerFromPool
+
+declare function StandaloneValidator (options: AjvCompiler.StandaloneOptions): AjvCompiler.BuildCompilerFromPool
+
+declare namespace AjvCompiler {
+  export type { Options, ErrorObject }
+  export { Ajv }
+
+  export type BuildSerializerFromPool = typeof buildSerializerFromPool
+
+  export type BuildCompilerFromPool = typeof buildCompilerFromPool
+
+  export const AjvReference: Symbol
+
+  export enum HttpParts {
+    Body = 'body',
+    Headers = 'headers',
+    Params = 'params',
+    Query = 'querystring',
+  }
+
+  export type RouteDefinition = {
+    method: string,
+    url: string,
+    httpPart: HttpParts,
+    schema?: unknown,
+  }
+
+  export type StandaloneRestoreFunction = (opts: RouteDefinition) => ValidateFunction
+
+  export type StandaloneStoreFunction = (opts: RouteDefinition, schemaValidationCode: string) => void
+
+  export type StandaloneOptionsReadModeOn = {
+    readMode: true;
+    restoreFunction?: StandaloneRestoreFunction
+  }
+
+  export type StandaloneOptionsReadModeOff = {
+    readMode?: false | undefined;
+    storeFunction?: StandaloneStoreFunction;
+  }
+
+  export type StandaloneOptions = StandaloneOptionsReadModeOn | StandaloneOptionsReadModeOff
+
+  export type ValidatorFactory = BuildCompilerFromPool | BuildSerializerFromPool
+
+  export type ValidatorCompiler = ReturnType<ValidatorFactory>
+
+  export { StandaloneValidator }
+
+  export const AjvCompiler: AjvSerializerGenerator
+  export { AjvCompiler as default }
+}
+
+export = AjvCompiler

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/ajv-compiler/types/index.test-d.ts

@@ -0,0 +1,226 @@
+import { AnySchemaObject, ValidateFunction } from 'ajv'
+import { AnyValidateFunction } from 'ajv/dist/core'
+import { expectAssignable, expectType } from 'tsd'
+import AjvCompiler, { AjvReference, ValidatorFactory, StandaloneValidator, RouteDefinition, ErrorObject, BuildCompilerFromPool, BuildSerializerFromPool, ValidatorCompiler } from '..'
+
+{
+  const compiler = AjvCompiler({})
+  expectType<BuildCompilerFromPool>(compiler)
+}
+{
+  const compiler = AjvCompiler()
+  expectType<BuildCompilerFromPool>(compiler)
+}
+{
+  const compiler = AjvCompiler({ jtdSerializer: false })
+  expectType<BuildCompilerFromPool>(compiler)
+}
+
+{
+  const factory = AjvCompiler({ jtdSerializer: false })
+  expectType<BuildCompilerFromPool>(factory)
+  factory({}, {
+    onCreate (ajv) {
+      expectType<import('ajv').default>(ajv)
+    }
+  })
+}
+
+{
+  const compiler = AjvCompiler({ jtdSerializer: true })
+  expectType<BuildSerializerFromPool>(compiler)
+}
+const reader = StandaloneValidator({
+  readMode: true,
+  restoreFunction: (route: RouteDefinition) => {
+    expectAssignable<RouteDefinition>(route)
+    return {} as ValidateFunction
+  },
+})
+expectAssignable<ValidatorFactory>(reader)
+
+const writer = StandaloneValidator({
+  readMode: false,
+  storeFunction: (route: RouteDefinition, code: string) => {
+    expectAssignable<RouteDefinition>(route)
+    expectAssignable<string>(code)
+  },
+})
+expectAssignable<ValidatorFactory>(writer)
+
+expectType<unknown>(({} as ErrorObject).data)
+expectType<string>(({} as ErrorObject).instancePath)
+expectType<string>(({} as ErrorObject).keyword)
+expectType<string | undefined>(({} as ErrorObject).message)
+expectType<Record<string, any>>(({} as ErrorObject).params)
+expectType<AnySchemaObject | undefined>(({} as ErrorObject).parentSchema)
+expectType<string | undefined>(({} as ErrorObject).propertyName)
+expectType<unknown>(({} as ErrorObject).schema)
+expectType<string>(({} as ErrorObject).schemaPath)
+
+expectType<Symbol>(AjvReference)
+
+{
+  const jtdSchema = {
+    discriminator: 'version',
+    mapping: {
+      1: {
+        properties: {
+          foo: { type: 'uint8' }
+        }
+      },
+      2: {
+        properties: {
+          foo: { type: 'string' }
+        }
+      }
+    }
+  }
+
+  const externalSchemas1 = {
+    foo: {
+      definitions: {
+        coordinates: {
+          properties: {
+            lat: { type: 'float32' },
+            lng: { type: 'float32' }
+          }
+        }
+      }
+    }
+  }
+
+  const factory = AjvCompiler({ jtdSerializer: true })
+  expectType<BuildSerializerFromPool>(factory)
+  const compiler = factory(externalSchemas1, {})
+  expectAssignable<Function>(compiler)
+  const serializeFunc = compiler({ schema: jtdSchema })
+  expectType<(data: unknown) => string>(serializeFunc)
+  expectType<string>(serializeFunc({ version: '1', foo: 42 }))
+}
+// JTD
+{
+  const factory = AjvCompiler()
+  expectType<BuildCompilerFromPool>(factory)
+
+  const jtdSchema = {
+    discriminator: 'version',
+    mapping: {
+      1: {
+        properties: {
+          foo: { type: 'uint8' }
+        }
+      },
+      2: {
+        properties: {
+          foo: { type: 'string' }
+        }
+      }
+    }
+  }
+
+  const compiler = factory({}, {
+    customOptions: {},
+    mode: 'JTD'
+  })
+  expectAssignable<ValidatorCompiler>(compiler)
+  const validatorFunc = compiler({ schema: jtdSchema })
+  expectAssignable<ValidateFunction>(validatorFunc)
+
+  expectType<boolean | Promise<any>>(validatorFunc({
+    version: '2',
+    foo: []
+  }))
+}
+
+// generate standalone code
+{
+  const base = {
+    $id: 'urn:schema:base',
+    definitions: {
+      hello: { type: 'string' }
+    },
+    type: 'object',
+    properties: {
+      hello: { $ref: '#/definitions/hello' }
+    }
+  }
+
+  const refSchema = {
+    $id: 'urn:schema:ref',
+    type: 'object',
+    properties: {
+      hello: { $ref: 'urn:schema:base#/definitions/hello' }
+    }
+  }
+
+  const endpointSchema = {
+    schema: {
+      $id: 'urn:schema:endpoint',
+      $ref: 'urn:schema:ref'
+    }
+  }
+
+  const schemaMap = {
+    [base.$id]: base,
+    [refSchema.$id]: refSchema
+  }
+
+  const factory = StandaloneValidator({
+    readMode: false,
+    storeFunction (routeOpts, schemaValidationCode) {
+      expectType<RouteDefinition>(routeOpts)
+      expectType<string>(schemaValidationCode)
+    }
+  })
+  expectAssignable<ValidatorFactory>(factory)
+
+  const compiler = factory(schemaMap)
+  expectAssignable<ValidatorCompiler>(compiler)
+  expectAssignable<Function>(compiler(endpointSchema))
+}
+
+{
+  const base = {
+    $id: 'urn:schema:base',
+    definitions: {
+      hello: { type: 'string' }
+    },
+    type: 'object',
+    properties: {
+      hello: { $ref: '#/definitions/hello' }
+    }
+  }
+
+  const refSchema = {
+    $id: 'urn:schema:ref',
+    type: 'object',
+    properties: {
+      hello: { $ref: 'urn:schema:base#/definitions/hello' }
+    }
+  }
+
+  const endpointSchema = {
+    schema: {
+      $id: 'urn:schema:endpoint',
+      $ref: 'urn:schema:ref'
+    }
+  }
+
+  const schemaMap = {
+    [base.$id]: base,
+    [refSchema.$id]: refSchema
+  }
+  const factory = StandaloneValidator({
+    readMode: true,
+    restoreFunction (routeOpts) {
+      expectType<RouteDefinition>(routeOpts)
+      return {} as ValidateFunction
+    }
+  })
+  expectAssignable<ValidatorFactory>(factory)
+
+  const compiler = factory(schemaMap)
+  expectAssignable<ValidatorCompiler>(compiler)
+  expectType<AnyValidateFunction<any>>(compiler(endpointSchema))
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/cors/.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: "monthly"
+    open-pull-requests-limit: 10

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/cors/.github/stale.yml

@@ -0,0 +1,21 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 15
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 7
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - "discussion"
+  - "feature request"
+  - "bug"
+  - "help wanted"
+  - "plugin suggestion"
+  - "good first issue"
+# Label to use when marking an issue as stale
+staleLabel: stale
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs. Thank you
+  for your contributions.
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: false

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/cors/.github/workflows/ci.yml

@@ -0,0 +1,28 @@
+name: CI
+
+on:
+  push:
+    branches:
+     - main
+     - next
+     - 'v*'
+    paths-ignore:
+      - 'docs/**'
+      - '*.md'
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - '*.md'
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    permissions:
+      contents: write
+      pull-requests: write
+    uses: fastify/workflows/.github/workflows/plugins-ci.yml@v5
+    with:
+      license-check: true
+      lint: true

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/cors/benchmark/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "benchmark",
+  "version": "1.0.0",
+  "description": "",
+  "main": "vary.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "benchmark": "^2.1.4",
+    "vary": "^1.1.2"
+  }
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/cors/benchmark/vary.js

@@ -0,0 +1,34 @@
+'use strict'
+
+const benchmark = require('benchmark')
+const vary = require('vary')
+const createAddFieldnameToVary = require('../vary').createAddFieldnameToVary
+
+const replyMock = (header) => ({
+  getHeader () { return header },
+  setHeader () { },
+  header () { }
+})
+
+const addAcceptToVary = createAddFieldnameToVary('Accept')
+const addWildcardToVary = createAddFieldnameToVary('*')
+const addAcceptEncodingToVary = createAddFieldnameToVary('Accept-Encoding')
+const addXFooToVary = createAddFieldnameToVary('X-Foo')
+
+new benchmark.Suite()
+  .add('vary - field to undefined', function () { vary(replyMock(undefined), 'Accept-Encoding') }, { minSamples: 100 })
+  .add('vary - field to *', function () { vary(replyMock('*'), 'Accept-Encoding') }, { minSamples: 100 })
+  .add('vary - * to field', function () { vary(replyMock('Accept-Encoding'), '*') }, { minSamples: 100 })
+  .add('vary - field to empty', function () { vary(replyMock(''), 'Accept-Encoding') }, { minSamples: 100 })
+  .add('vary - fields string to empty', function () { vary(replyMock(''), 'Accept') }, { minSamples: 100 })
+  .add('vary - field to fields', function () { vary(replyMock('Accept, Accept-Encoding, Accept-Language'), 'X-Foo') }, { minSamples: 100 })
+
+  .add('cors - field to undefined', function () { addAcceptEncodingToVary(replyMock(undefined)) }, { minSamples: 100 })
+  .add('cors - field to *', function () { addAcceptEncodingToVary(replyMock('*')) }, { minSamples: 100 })
+  .add('cors - * to field', function () { addWildcardToVary(replyMock('Accept-Encoding')) }, { minSamples: 100 })
+  .add('cors - field to empty', function () { addAcceptEncodingToVary(replyMock('')) }, { minSamples: 100 })
+  .add('cors - fields string to empty', function () { addAcceptToVary(replyMock('')) }, { minSamples: 100 })
+  .add('cors - field to fields', function () { addXFooToVary(replyMock('Accept, Accept-Encoding, Accept-Language')) }, { minSamples: 100 })
+
+  .on('cycle', function onCycle (event) { console.log(String(event.target)) })
+  .run({ async: false })

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/cors/test/cors.test.js

@@ -0,0 +1,1052 @@
+'use strict'
+
+const { test } = require('node:test')
+const { createReadStream, statSync, readFileSync } = require('node:fs')
+const Fastify = require('fastify')
+const cors = require('../')
+const { resolve } = require('node:path')
+const { setTimeout: sleep } = require('node:timers/promises')
+
+test('Should add cors headers', async t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+  fastify.register(cors)
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  t.assert.deepStrictEqual(res.headers['access-control-allow-origin'],
+    '*'
+  )
+})
+
+test('Should add cors headers when payload is a stream', async t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+  fastify.register(cors)
+  const filePath = resolve(__dirname, __filename)
+
+  fastify.get('/', (_req, reply) => {
+    const stream = createReadStream(filePath)
+    reply
+      .type('application/json')
+      .header('Content-Length', statSync(filePath).size)
+      .send(stream)
+  })
+
+  const fileContent = readFileSync(filePath, 'utf-8')
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, fileContent)
+  const actualHeaders = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    'content-length': res.headers['content-length']
+
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'access-control-allow-origin': '*',
+    'content-length': statSync(filePath).size.toString()
+  })
+})
+
+test('Should add cors headers (custom values)', async t => {
+  t.plan(10)
+
+  const fastify = Fastify()
+  fastify.register(cors, {
+    origin: 'example.com',
+    methods: 'GET',
+    credentials: true,
+    exposedHeaders: ['foo', 'bar'],
+    allowedHeaders: ['baz', 'woo'],
+    maxAge: 123,
+    cacheControl: 321
+  })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  let res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 204)
+  t.assert.strictEqual(res.payload, '')
+  const actualHeaders = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    'access-control-allow-credentials': res.headers['access-control-allow-credentials'],
+    'access-control-expose-headers': res.headers['access-control-expose-headers'],
+    'access-control-allow-methods': res.headers['access-control-allow-methods'],
+    'access-control-allow-headers': res.headers['access-control-allow-headers'],
+    'access-control-max-age': res.headers['access-control-max-age'],
+    'cache-control': res.headers['cache-control'],
+    'content-length': res.headers['content-length']
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'access-control-allow-origin': 'example.com',
+    'access-control-allow-credentials': 'true',
+    'access-control-expose-headers': 'foo, bar',
+    'access-control-allow-methods': 'GET',
+    'access-control-allow-headers': 'baz, woo',
+    'access-control-max-age': '123',
+    'cache-control': 'max-age=321',
+    'content-length': '0'
+  })
+  t.assert.notDeepEqual(res.headers, { vary: 'Origin' })
+
+  res = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  const actualHeaders2 = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    'access-control-allow-credentials': res.headers['access-control-allow-credentials'],
+    'access-control-expose-headers': res.headers['access-control-expose-headers'],
+    'content-length': res.headers['content-length']
+  }
+  t.assert.deepStrictEqual(actualHeaders2, {
+    'access-control-allow-origin': 'example.com',
+    'access-control-allow-credentials': 'true',
+    'access-control-expose-headers': 'foo, bar',
+    'content-length': '2'
+  })
+  t.assert.notDeepEqual(res.headers, { vary: 'Origin' })
+})
+
+test('Should support dynamic config (callback)', async t => {
+  t.plan(16)
+
+  const configs = [{
+    origin: 'example.com',
+    methods: 'GET',
+    credentials: true,
+    exposedHeaders: ['foo', 'bar'],
+    allowedHeaders: ['baz', 'woo'],
+    maxAge: 123,
+    cacheControl: 456
+  }, {
+    origin: 'sample.com',
+    methods: 'GET',
+    credentials: true,
+    exposedHeaders: ['zoo', 'bar'],
+    allowedHeaders: ['baz', 'foo'],
+    maxAge: 321,
+    cacheControl: '456'
+  }]
+
+  const fastify = Fastify()
+  let requestId = 0
+  const configDelegation = async function (req, cb) {
+    // request should have id
+    t.assert.ok(req.id)
+    // request should not have send
+    t.assert.ifError(req.send)
+
+    const config = configs[requestId]
+    requestId++
+    if (config) {
+      cb(null, config)
+    } else {
+      cb(new Error('ouch'))
+    }
+  }
+  await fastify.register(cors, () => configDelegation)
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  let res = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  const actualHeaders = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    'access-control-allow-credentials': res.headers['access-control-allow-credentials'],
+    'access-control-expose-headers': res.headers['access-control-expose-headers'],
+    'content-length': res.headers['content-length'],
+    vary: res.headers.vary
+  }
+  // Sleep to wait for callback
+  sleep()
+  t.assert.deepStrictEqual(actualHeaders, {
+    'access-control-allow-origin': 'example.com',
+    'access-control-allow-credentials': 'true',
+    'access-control-expose-headers': 'foo, bar',
+    'content-length': '2',
+    vary: 'Origin'
+  })
+
+  res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 204)
+  t.assert.strictEqual(res.payload, '')
+  const actualHeaders2 = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    'access-control-allow-credentials': res.headers['access-control-allow-credentials'],
+    'access-control-expose-headers': res.headers['access-control-expose-headers'],
+    'access-control-allow-methods': res.headers['access-control-allow-methods'],
+    'access-control-allow-headers': res.headers['access-control-allow-headers'],
+    'access-control-max-age': res.headers['access-control-max-age'],
+    'cache-control': res.headers['cache-control'],
+    'content-length': res.headers['content-length'],
+    vary: res.headers.vary
+  }
+  // Sleep to wait for callback
+  sleep()
+  t.assert.deepStrictEqual(actualHeaders2, {
+    'access-control-allow-origin': 'sample.com',
+    'access-control-allow-credentials': 'true',
+    'access-control-expose-headers': 'zoo, bar',
+    'access-control-allow-methods': 'GET',
+    'access-control-allow-headers': 'baz, foo',
+    'access-control-max-age': '321',
+    'cache-control': '456',
+    'content-length': '0',
+    vary: 'Origin'
+  })
+
+  res = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  t.assert.strictEqual(res.statusCode, 500)
+})
+
+test('Should support dynamic config (Promise)', async t => {
+  t.plan(23)
+
+  const configs = [{
+    origin: 'example.com',
+    methods: 'GET',
+    credentials: true,
+    exposedHeaders: ['foo', 'bar'],
+    allowedHeaders: ['baz', 'woo'],
+    maxAge: 123,
+    cacheControl: 456
+  }, {
+    origin: 'sample.com',
+    methods: 'GET',
+    credentials: true,
+    exposedHeaders: ['zoo', 'bar'],
+    allowedHeaders: ['baz', 'foo'],
+    maxAge: 321,
+    cacheControl: true // Invalid value should be ignored
+  }, {
+    origin: 'sample.com',
+    methods: 'GET',
+    credentials: true,
+    exposedHeaders: ['zoo', 'bar'],
+    allowedHeaders: ['baz', 'foo'],
+    maxAge: 321,
+    cacheControl: 'public, max-age=456'
+  }]
+
+  const fastify = Fastify()
+  let requestId = 0
+  const configDelegation = async function (req) {
+    // request should have id
+    t.assert.ok(req.id)
+    // request should not have send
+    t.assert.ifError(req.send)
+    const config = configs[requestId]
+    requestId++
+    if (config) {
+      return Promise.resolve(config)
+    } else {
+      return Promise.reject(new Error('ouch'))
+    }
+  }
+  await fastify.register(cors, () => configDelegation)
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  let res = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  const actualHeaders = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    'access-control-allow-credentials': res.headers['access-control-allow-credentials'],
+    'access-control-expose-headers': res.headers['access-control-expose-headers'],
+    'content-length': res.headers['content-length'],
+    vary: res.headers.vary
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'access-control-allow-origin': 'example.com',
+    'access-control-allow-credentials': 'true',
+    'access-control-expose-headers': 'foo, bar',
+    'content-length': '2',
+    vary: 'Origin'
+  })
+
+  res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'sample.com'
+    }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 204)
+  t.assert.strictEqual(res.payload, '')
+  const acutalHeaders2 = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    'access-control-allow-credentials': res.headers['access-control-allow-credentials'],
+    'access-control-expose-headers': res.headers['access-control-expose-headers'],
+    'access-control-allow-methods': res.headers['access-control-allow-methods'],
+    'access-control-allow-headers': res.headers['access-control-allow-headers'],
+    'access-control-max-age': res.headers['access-control-max-age'],
+    'content-length': res.headers['content-length'],
+    vary: res.headers.vary
+  }
+  t.assert.deepStrictEqual(acutalHeaders2, {
+    'access-control-allow-origin': 'sample.com',
+    'access-control-allow-credentials': 'true',
+    'access-control-expose-headers': 'zoo, bar',
+    'access-control-allow-methods': 'GET',
+    'access-control-allow-headers': 'baz, foo',
+    'access-control-max-age': '321',
+    'content-length': '0',
+    vary: 'Origin'
+  })
+  t.assert.strictEqual(res.headers['cache-control'], undefined, 'cache-control omitted (invalid value)')
+
+  res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 204)
+  t.assert.strictEqual(res.payload, '')
+  const actualHeaders3 = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    'access-control-allow-credentials': res.headers['access-control-allow-credentials'],
+    'access-control-expose-headers': res.headers['access-control-expose-headers'],
+    'access-control-allow-methods': res.headers['access-control-allow-methods'],
+    'access-control-allow-headers': res.headers['access-control-allow-headers'],
+    'access-control-max-age': res.headers['access-control-max-age'],
+    'cache-control': res.headers['cache-control'],
+    'content-length': res.headers['content-length'],
+    vary: res.headers.vary
+  }
+  t.assert.deepStrictEqual(actualHeaders3, {
+    'access-control-allow-origin': 'sample.com',
+    'access-control-allow-credentials': 'true',
+    'access-control-expose-headers': 'zoo, bar',
+    'access-control-allow-methods': 'GET',
+    'access-control-allow-headers': 'baz, foo',
+    'access-control-max-age': '321',
+    'cache-control': 'public, max-age=456', // cache-control included (custom string)
+    'content-length': '0',
+    vary: 'Origin'
+  })
+
+  res = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  t.assert.strictEqual(res.statusCode, 500)
+})
+
+test('Should support dynamic config. (Invalid function)', async t => {
+  t.plan(2)
+
+  const fastify = Fastify()
+  fastify.register(cors, () => () => {})
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  t.assert.strictEqual(res.statusCode, 500)
+})
+
+test('Dynamic origin resolution (valid origin)', async t => {
+  t.plan(6)
+
+  const fastify = Fastify()
+  const origin = function (header, cb) {
+    t.assert.strictEqual(header, 'example.com')
+    t.assert.equal(this, fastify)
+    cb(null, true)
+  }
+  fastify.register(cors, { origin })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: { origin: 'example.com' }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  const actualHeaders = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    vary: res.headers.vary
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'access-control-allow-origin': 'example.com',
+    vary: 'Origin'
+  })
+})
+
+test('Dynamic origin resolution (not valid origin)', async t => {
+  t.plan(5)
+
+  const fastify = Fastify()
+  const origin = (header, cb) => {
+    t.assert.strictEqual(header, 'example.com')
+    cb(null, false)
+  }
+  fastify.register(cors, { origin })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: { origin: 'example.com' }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  const actualHeaders = {
+    'content-length': res.headers['content-length'],
+    'content-type': res.headers['content-type'],
+    connection: res.headers.connection,
+    vary: res.headers.vary
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'content-length': '2',
+    'content-type': 'text/plain; charset=utf-8',
+    connection: 'keep-alive',
+    vary: 'Origin'
+  })
+})
+
+test('Dynamic origin resolution (errored)', async t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  const origin = (header, cb) => {
+    t.assert.strictEqual(header, 'example.com')
+    cb(new Error('ouch'))
+  }
+  fastify.register(cors, { origin })
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: { origin: 'example.com' }
+  })
+  t.assert.ok(res)
+  t.assert.strictEqual(res.statusCode, 500)
+})
+
+test('Dynamic origin resolution (invalid result)', async t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  const origin = (header, cb) => {
+    t.assert.strictEqual(header, 'example.com')
+    cb(null, undefined)
+  }
+  fastify.register(cors, { origin })
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: { origin: 'example.com' }
+  })
+  t.assert.ok(res)
+  t.assert.strictEqual(res.statusCode, 500)
+})
+
+test('Dynamic origin resolution (valid origin - promises)', async t => {
+  t.plan(5)
+
+  const fastify = Fastify()
+  const origin = (header) => {
+    return new Promise((resolve) => {
+      t.assert.strictEqual(header, 'example.com')
+      resolve(true)
+    })
+  }
+  fastify.register(cors, { origin })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: { origin: 'example.com' }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  const actualHeaders = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    vary: res.headers.vary
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'access-control-allow-origin': 'example.com',
+    vary: 'Origin'
+  })
+})
+
+test('Dynamic origin resolution (not valid origin - promises)', async t => {
+  t.plan(5)
+
+  const fastify = Fastify()
+  const origin = (header) => {
+    return new Promise((resolve) => {
+      t.assert.strictEqual(header, 'example.com')
+      resolve(false)
+    })
+  }
+  fastify.register(cors, { origin })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: { origin: 'example.com' }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  const actualHeaders = {
+    'content-length': res.headers['content-length'],
+    'content-type': res.headers['content-type'],
+    connection: res.headers.connection,
+    vary: res.headers.vary
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'content-length': '2',
+    'content-type': 'text/plain; charset=utf-8',
+    connection: 'keep-alive',
+    vary: 'Origin'
+  })
+})
+
+test('Dynamic origin resolution (errored - promises)', async t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  const origin = (header) => {
+    return new Promise((_resolve, reject) => {
+      t.assert.strictEqual(header, 'example.com')
+      reject(new Error('ouch'))
+    })
+  }
+  fastify.register(cors, { origin })
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: { origin: 'example.com' }
+  })
+  t.assert.ok(res)
+  t.assert.strictEqual(res.statusCode, 500)
+})
+
+test('Should reply 404 without cors headers when origin is false', async t => {
+  t.plan(8)
+
+  const fastify = Fastify()
+  fastify.register(cors, {
+    origin: false,
+    methods: 'GET',
+    credentials: true,
+    exposedHeaders: ['foo', 'bar'],
+    allowedHeaders: ['baz', 'woo'],
+    maxAge: 123
+  })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  let res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/'
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 404)
+  t.assert.strictEqual(res.payload, '{"message":"Route OPTIONS:/ not found","error":"Not Found","statusCode":404}')
+  const actualHeaders = {
+    'content-length': res.headers['content-length'],
+    'content-type': res.headers['content-type'],
+    connection: res.headers.connection
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'content-length': '76',
+    'content-type': 'application/json; charset=utf-8',
+    connection: 'keep-alive'
+  })
+
+  res = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  t.assert.deepStrictEqual(res.headers, {
+    'content-length': '2',
+    'content-type': 'text/plain; charset=utf-8',
+    connection: 'keep-alive'
+  })
+})
+
+test('Server error if origin option is falsy but not false', async t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+  fastify.register(cors, { origin: '' })
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: { origin: 'example.com' }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 500)
+  t.assert.deepStrictEqual(res.json(), { statusCode: 500, error: 'Internal Server Error', message: 'Invalid CORS origin option' })
+  const actualHeaders = {
+    'content-length': res.headers['content-length'],
+    'content-type': res.headers['content-type'],
+    connection: res.headers.connection
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'content-length': '89',
+    'content-type': 'application/json; charset=utf-8',
+    connection: 'keep-alive'
+  })
+})
+
+test('Allow only request from a specific origin', async t => {
+  t.plan(5)
+
+  const fastify = Fastify()
+  fastify.register(cors, { origin: 'other.io' })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: { origin: 'example.com' }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  t.assert.deepStrictEqual(res.headers['access-control-allow-origin'],
+    'other.io'
+  )
+  t.assert.notDeepEqual(res.headers, { vary: 'Origin' })
+})
+
+test('Allow only request from multiple specific origin', async t => {
+  t.plan(9)
+
+  const fastify = Fastify()
+  fastify.register(cors, { origin: ['other.io', 'example.com'] })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  let res = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: { origin: 'other.io' }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  const actualHeaders = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    vary: res.headers.vary
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'access-control-allow-origin': 'other.io',
+    vary: 'Origin'
+  })
+
+  res = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: { origin: 'foo.com' }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  t.assert.deepStrictEqual(res.headers.vary,
+    'Origin'
+  )
+  t.assert.strictEqual(res.headers['access-control-allow-origin'], undefined)
+})
+
+test('Allow only request from a specific origin using regex', async t => {
+  t.plan(8)
+
+  const fastify = Fastify()
+  fastify.register(cors, { origin: /(?:example|other)\.com\/?$/giu })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  // .test was previously used, which caused 2 consecutive requests to return
+  // different results with global (e.g. /g) regexes. Therefore, check this
+  // twice to check consistency
+  for (let i = 0; i < 2; i++) {
+    const res = await fastify.inject({
+      method: 'GET',
+      url: '/',
+      headers: { origin: 'https://www.example.com/' }
+    })
+    t.assert.ok(res)
+    delete res.headers.date
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.payload, 'ok')
+    const actualHeaders = {
+      'access-control-allow-origin': res.headers['access-control-allow-origin'],
+      vary: res.headers.vary
+    }
+    t.assert.deepStrictEqual(actualHeaders, {
+      'access-control-allow-origin': 'https://www.example.com/',
+      vary: 'Origin'
+    })
+  }
+})
+
+test('Disable preflight', async t => {
+  t.plan(7)
+
+  const fastify = Fastify()
+  fastify.register(cors, { preflight: false })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  let res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/hello'
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 404)
+  t.assert.strictEqual(res.headers['access-control-allow-origin'],
+    '*'
+  )
+
+  res = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  t.assert.strictEqual(res.headers['access-control-allow-origin'],
+    '*'
+  )
+})
+
+test('Should always add vary header to `Origin` for reflected origin', async t => {
+  t.plan(12)
+
+  const fastify = Fastify()
+  fastify.register(cors, { origin: true })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  // Invalid Preflight
+  let res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/'
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 400)
+  t.assert.strictEqual(res.payload, 'Invalid Preflight Request')
+  t.assert.strictEqual(res.headers.vary,
+    'Origin'
+  )
+
+  // Valid Preflight
+  res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 204)
+  t.assert.strictEqual(res.payload, '')
+  t.assert.strictEqual(res.headers.vary,
+    'Origin, Access-Control-Request-Headers'
+  )
+
+  // Other Route
+  res = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  t.assert.strictEqual(res.headers.vary,
+    'Origin'
+  )
+})
+
+test('Should always add vary header to `Origin` for reflected origin (vary is array)', async t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+
+  // Mock getHeader function
+  fastify.decorateReply('getHeader', () => ['foo', 'bar'])
+
+  fastify.register(cors, { origin: true })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  t.assert.strictEqual(res.headers.vary,
+    'foo, bar, Origin'
+  )
+})
+
+test('Allow only request from with specific headers', async t => {
+  t.plan(8)
+
+  const fastify = Fastify()
+  fastify.register(cors, {
+    allowedHeaders: 'foo',
+    exposedHeaders: 'bar'
+  })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  let res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 204)
+  t.assert.deepStrictEqual(res.headers['access-control-allow-headers'],
+    'foo'
+  )
+  t.assert.notDeepEqual(res.headers.vary, 'Origin')
+
+  res = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  t.assert.strictEqual(res.headers['access-control-expose-headers'],
+    'bar'
+  )
+})
+
+test('Should support wildcard config /1', async t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+  fastify.register(cors, { origin: '*' })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  t.assert.ok(res)
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  t.assert.strictEqual(res.headers['access-control-allow-origin'], '*')
+})
+
+test('Should support wildcard config /2', async t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+  fastify.register(cors, { origin: ['*'] })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  t.assert.ok(res)
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  t.assert.strictEqual(res.headers['access-control-allow-origin'], '*')
+})
+
+test('Should allow routes to disable CORS individually', async t => {
+  t.plan(6)
+
+  const fastify = Fastify()
+  fastify.register(cors, { origin: '*' })
+
+  fastify.get('/cors-enabled', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  fastify.get('/cors-disabled', { config: { cors: false } }, (_req, reply) => {
+    reply.send('ok')
+  })
+
+  // Test CORS enabled route
+  let res = await fastify.inject({
+    method: 'GET',
+    url: '/cors-enabled',
+    headers: { origin: 'example.com' }
+  })
+  t.assert.ok(res)
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.headers['access-control-allow-origin'], '*')
+
+  // Test CORS disabled route
+  res = await fastify.inject({
+    method: 'GET',
+    url: '/cors-disabled',
+    headers: { origin: 'example.com' }
+  })
+  t.assert.ok(res)
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.headers['access-control-allow-origin'], undefined)
+})

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/cors/test/hooks.test.js

@@ -0,0 +1,787 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('fastify')
+const kFastifyContext = require('fastify/lib/symbols').kRouteContext
+const cors = require('..')
+const { setTimeout: sleep } = require('node:timers/promises')
+
+test('Should error on invalid hook option', async (t) => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  await t.assert.rejects(
+    async () => fastify.register(cors, { hook: 'invalid' }),
+    (err) => {
+      t.assert.strictEqual(err.name, 'TypeError')
+      t.assert.strictEqual(err.message, '@fastify/cors: Invalid hook option provided.')
+      return true
+    }
+  )
+})
+
+test('Should set hook onRequest if hook option is not set', async (t) => {
+  t.plan(10)
+
+  const fastify = Fastify()
+
+  fastify.register(cors)
+
+  fastify.addHook('onResponse', (request, _reply, done) => {
+    t.assert.strictEqual(request[kFastifyContext].onError, null)
+    t.assert.strictEqual(request[kFastifyContext].onRequest.length, 1)
+    t.assert.strictEqual(request[kFastifyContext].onSend, null)
+    t.assert.strictEqual(request[kFastifyContext].preHandler, null)
+    t.assert.strictEqual(request[kFastifyContext].preParsing, null)
+    t.assert.strictEqual(request[kFastifyContext].preSerialization, null)
+    t.assert.strictEqual(request[kFastifyContext].preValidation, null)
+    done()
+  })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  await fastify.ready()
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  const actualHeader = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin']
+  }
+  t.assert.deepStrictEqual(actualHeader, {
+    'access-control-allow-origin': '*'
+  })
+})
+
+test('Should set hook onRequest if hook option is set to onRequest', async (t) => {
+  t.plan(10)
+
+  const fastify = Fastify()
+
+  fastify.register(cors, {
+    hook: 'onRequest'
+  })
+
+  fastify.addHook('onResponse', (request, _reply, done) => {
+    t.assert.strictEqual(request[kFastifyContext].onError, null)
+    t.assert.strictEqual(request[kFastifyContext].onRequest.length, 1)
+    t.assert.strictEqual(request[kFastifyContext].onSend, null)
+    t.assert.strictEqual(request[kFastifyContext].preHandler, null)
+    t.assert.strictEqual(request[kFastifyContext].preParsing, null)
+    t.assert.strictEqual(request[kFastifyContext].preSerialization, null)
+    t.assert.strictEqual(request[kFastifyContext].preValidation, null)
+    done()
+  })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  await fastify.ready()
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  const actualHeader = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin']
+  }
+  t.assert.deepStrictEqual(actualHeader, {
+    'access-control-allow-origin': '*'
+  })
+})
+
+test('Should set hook preParsing if hook option is set to preParsing', async (t) => {
+  t.plan(11)
+
+  const fastify = Fastify()
+
+  fastify.register(cors, {
+    hook: 'preParsing'
+  })
+
+  fastify.addHook('onResponse', (request, _reply, done) => {
+    t.assert.strictEqual(request[kFastifyContext].onError, null)
+    t.assert.strictEqual(request[kFastifyContext].onRequest, null)
+    t.assert.strictEqual(request[kFastifyContext].onSend, null)
+    t.assert.strictEqual(request[kFastifyContext].preHandler, null)
+    t.assert.strictEqual(request[kFastifyContext].preParsing.length, 1)
+    t.assert.strictEqual(request[kFastifyContext].preSerialization, null)
+    t.assert.strictEqual(request[kFastifyContext].preValidation, null)
+    done()
+  })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  await fastify.ready()
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  const actualHeader = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin']
+  }
+  t.assert.deepStrictEqual(actualHeader, {
+    'access-control-allow-origin': '*'
+  })
+  t.assert.notStrictEqual(res.headers.vary, 'Origin')
+})
+
+test('Should set hook preValidation if hook option is set to preValidation', async (t) => {
+  t.plan(11)
+
+  const fastify = Fastify()
+
+  fastify.register(cors, {
+    hook: 'preValidation'
+  })
+
+  fastify.addHook('onResponse', (request, _reply, done) => {
+    t.assert.strictEqual(request[kFastifyContext].onError, null)
+    t.assert.strictEqual(request[kFastifyContext].onRequest, null)
+    t.assert.strictEqual(request[kFastifyContext].onSend, null)
+    t.assert.strictEqual(request[kFastifyContext].preHandler, null)
+    t.assert.strictEqual(request[kFastifyContext].preParsing, null)
+    t.assert.strictEqual(request[kFastifyContext].preSerialization, null)
+    t.assert.strictEqual(request[kFastifyContext].preValidation.length, 1)
+    done()
+  })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  await fastify.ready()
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  const actualHeader = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin']
+  }
+  t.assert.deepStrictEqual(actualHeader, {
+    'access-control-allow-origin': '*'
+  })
+  t.assert.notStrictEqual(res.headers.vary, 'Origin')
+})
+
+test('Should set hook preParsing if hook option is set to preParsing', async (t) => {
+  t.plan(11)
+
+  const fastify = Fastify()
+
+  fastify.register(cors, {
+    hook: 'preParsing'
+  })
+
+  fastify.addHook('onResponse', (request, _reply, done) => {
+    t.assert.strictEqual(request[kFastifyContext].onError, null)
+    t.assert.strictEqual(request[kFastifyContext].onRequest, null)
+    t.assert.strictEqual(request[kFastifyContext].onSend, null)
+    t.assert.strictEqual(request[kFastifyContext].preHandler, null)
+    t.assert.strictEqual(request[kFastifyContext].preParsing.length, 1)
+    t.assert.strictEqual(request[kFastifyContext].preSerialization, null)
+    t.assert.strictEqual(request[kFastifyContext].preValidation, null)
+    done()
+  })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  await fastify.ready()
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  const actualHeader = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin']
+  }
+  t.assert.deepStrictEqual(actualHeader, {
+    'access-control-allow-origin': '*'
+  })
+  t.assert.notStrictEqual(res.headers.vary, 'Origin')
+})
+
+test('Should set hook preHandler if hook option is set to preHandler', async (t) => {
+  t.plan(11)
+
+  const fastify = Fastify()
+
+  fastify.register(cors, {
+    hook: 'preHandler'
+  })
+
+  fastify.addHook('onResponse', (request, _reply, done) => {
+    t.assert.strictEqual(request[kFastifyContext].onError, null)
+    t.assert.strictEqual(request[kFastifyContext].onRequest, null)
+    t.assert.strictEqual(request[kFastifyContext].onSend, null)
+    t.assert.strictEqual(request[kFastifyContext].preHandler.length, 1)
+    t.assert.strictEqual(request[kFastifyContext].preParsing, null)
+    t.assert.strictEqual(request[kFastifyContext].preSerialization, null)
+    t.assert.strictEqual(request[kFastifyContext].preValidation, null)
+    done()
+  })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  await fastify.ready()
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  const actualHeader = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin']
+  }
+  t.assert.deepStrictEqual(actualHeader, {
+    'access-control-allow-origin': '*'
+  })
+  t.assert.notStrictEqual(res.headers.vary, 'Origin')
+})
+
+test('Should set hook onSend if hook option is set to onSend', async (t) => {
+  t.plan(11)
+
+  const fastify = Fastify()
+
+  fastify.register(cors, {
+    hook: 'onSend'
+  })
+
+  fastify.addHook('onResponse', (request, _reply, done) => {
+    t.assert.strictEqual(request[kFastifyContext].onError, null)
+    t.assert.strictEqual(request[kFastifyContext].onRequest, null)
+    t.assert.strictEqual(request[kFastifyContext].onSend.length, 1)
+    t.assert.strictEqual(request[kFastifyContext].preHandler, null)
+    t.assert.strictEqual(request[kFastifyContext].preParsing, null)
+    t.assert.strictEqual(request[kFastifyContext].preSerialization, null)
+    t.assert.strictEqual(request[kFastifyContext].preValidation, null)
+    done()
+  })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  await fastify.ready()
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  const actualHeader = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin']
+  }
+  t.assert.deepStrictEqual(actualHeader, {
+    'access-control-allow-origin': '*'
+  })
+  t.assert.notStrictEqual(res.headers.vary, 'Origin')
+})
+
+test('Should set hook preSerialization if hook option is set to preSerialization', async (t) => {
+  t.plan(11)
+
+  const fastify = Fastify()
+
+  fastify.register(cors, {
+    hook: 'preSerialization'
+  })
+
+  fastify.addHook('onResponse', (request, _reply, done) => {
+    t.assert.strictEqual(request[kFastifyContext].onError, null)
+    t.assert.strictEqual(request[kFastifyContext].onRequest, null)
+    t.assert.strictEqual(request[kFastifyContext].onSend, null)
+    t.assert.strictEqual(request[kFastifyContext].preHandler, null)
+    t.assert.strictEqual(request[kFastifyContext].preParsing, null)
+    t.assert.strictEqual(request[kFastifyContext].preSerialization.length, 1)
+    t.assert.strictEqual(request[kFastifyContext].preValidation, null)
+    done()
+  })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send({ nonString: true })
+  })
+
+  await fastify.ready()
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, '{"nonString":true}')
+  const actualHeader = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin']
+  }
+  t.assert.deepStrictEqual(actualHeader, {
+    'access-control-allow-origin': '*'
+  })
+  t.assert.notStrictEqual(res.headers.vary, 'Origin')
+})
+
+test('Should support custom hook with dynamic config', async t => {
+  t.plan(16)
+
+  const configs = [{
+    origin: 'example.com',
+    methods: 'GET',
+    credentials: true,
+    exposedHeaders: ['foo', 'bar'],
+    allowedHeaders: ['baz', 'woo'],
+    maxAge: 123
+  }, {
+    origin: 'sample.com',
+    methods: 'GET',
+    credentials: true,
+    exposedHeaders: ['zoo', 'bar'],
+    allowedHeaders: ['baz', 'foo'],
+    maxAge: 321
+  }]
+
+  const fastify = Fastify()
+  let requestId = 0
+  const configDelegation = async function (req) {
+    // request should have id
+    t.assert.ok(req.id)
+    // request should not have send
+    t.assert.ifError(req.send)
+    const config = configs[requestId]
+    requestId++
+    if (config) {
+      return Promise.resolve(config)
+    } else {
+      return Promise.reject(new Error('ouch'))
+    }
+  }
+  await fastify.register(cors, {
+    hook: 'preHandler',
+    delegator: configDelegation
+  })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  let res = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  let actualHeaders = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    'access-control-allow-credentials': res.headers['access-control-allow-credentials'],
+    'access-control-expose-headers': res.headers['access-control-expose-headers'],
+    'content-length': res.headers['content-length'],
+    vary: res.headers.vary
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'access-control-allow-origin': 'example.com',
+    'access-control-allow-credentials': 'true',
+    'access-control-expose-headers': 'foo, bar',
+    'content-length': '2',
+    vary: 'Origin'
+  })
+
+  res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 204)
+  t.assert.strictEqual(res.payload, '')
+  actualHeaders = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    'access-control-allow-credentials': res.headers['access-control-allow-credentials'],
+    'access-control-expose-headers': res.headers['access-control-expose-headers'],
+    'access-control-allow-methods': res.headers['access-control-allow-methods'],
+    'access-control-allow-headers': res.headers['access-control-allow-headers'],
+    'access-control-max-age': res.headers['access-control-max-age'],
+    'content-length': res.headers['content-length'],
+    vary: res.headers.vary
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'access-control-allow-origin': 'sample.com',
+    'access-control-allow-credentials': 'true',
+    'access-control-expose-headers': 'zoo, bar',
+    'access-control-allow-methods': 'GET',
+    'access-control-allow-headers': 'baz, foo',
+    'access-control-max-age': '321',
+    'content-length': '0',
+    vary: 'Origin'
+  })
+
+  res = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  t.assert.strictEqual(res.statusCode, 500)
+})
+
+test('Should support custom hook with dynamic config (callback)', async t => {
+  t.plan(16)
+
+  const configs = [{
+    origin: 'example.com',
+    methods: 'GET',
+    credentials: true,
+    exposedHeaders: ['foo', 'bar'],
+    allowedHeaders: ['baz', 'woo'],
+    maxAge: 123
+  }, {
+    origin: 'sample.com',
+    methods: 'GET',
+    credentials: true,
+    exposedHeaders: ['zoo', 'bar'],
+    allowedHeaders: ['baz', 'foo'],
+    maxAge: 321
+  }]
+
+  const fastify = Fastify()
+  let requestId = 0
+  const configDelegation = function (req, cb) {
+    // request should have id
+    t.assert.ok(req.id)
+    // request should not have send
+    t.assert.ifError(req.send)
+    const config = configs[requestId]
+    requestId++
+    if (config) {
+      cb(null, config)
+    } else {
+      cb(new Error('ouch'))
+    }
+  }
+  fastify.register(cors, {
+    hook: 'preParsing',
+    delegator: configDelegation
+  })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    delete res.headers.date
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.payload, 'ok')
+    const actualHeaders = {
+      'access-control-allow-origin': res.headers['access-control-allow-origin'],
+      'access-control-allow-credentials': res.headers['access-control-allow-credentials'],
+      'access-control-expose-headers': res.headers['access-control-expose-headers'],
+      'content-length': res.headers['content-length'],
+      vary: res.headers.vary
+    }
+    t.assert.deepStrictEqual(actualHeaders, {
+      'access-control-allow-origin': 'example.com',
+      'access-control-allow-credentials': 'true',
+      'access-control-expose-headers': 'foo, bar',
+      'content-length': '2',
+      vary: 'Origin'
+    })
+  })
+
+  fastify.inject({
+    method: 'OPTIONS',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  }, (err, res) => {
+    t.assert.ifError(err)
+    delete res.headers.date
+    t.assert.strictEqual(res.statusCode, 204)
+    t.assert.strictEqual(res.payload, '')
+    const actualHeaders = {
+      'access-control-allow-origin': res.headers['access-control-allow-origin'],
+      'access-control-allow-credentials': res.headers['access-control-allow-credentials'],
+      'access-control-expose-headers': res.headers['access-control-expose-headers'],
+      'access-control-allow-methods': res.headers['access-control-allow-methods'],
+      'access-control-allow-headers': res.headers['access-control-allow-headers'],
+      'access-control-max-age': res.headers['access-control-max-age'],
+      'content-length': res.headers['content-length'],
+      vary: res.headers.vary
+    }
+    t.assert.deepStrictEqual(actualHeaders, {
+      'access-control-allow-origin': 'sample.com',
+      'access-control-allow-credentials': 'true',
+      'access-control-expose-headers': 'zoo, bar',
+      'access-control-allow-methods': 'GET',
+      'access-control-allow-headers': 'baz, foo',
+      'access-control-max-age': '321',
+      'content-length': '0',
+      vary: 'Origin'
+    })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 500)
+  })
+  await sleep()
+})
+
+test('Should support custom hook with dynamic config (Promise)', async t => {
+  t.plan(16)
+
+  const configs = [{
+    origin: 'example.com',
+    methods: 'GET',
+    credentials: true,
+    exposedHeaders: ['foo', 'bar'],
+    allowedHeaders: ['baz', 'woo'],
+    maxAge: 123
+  }, {
+    origin: 'sample.com',
+    methods: 'GET',
+    credentials: true,
+    exposedHeaders: ['zoo', 'bar'],
+    allowedHeaders: ['baz', 'foo'],
+    maxAge: 321
+  }]
+
+  const fastify = Fastify()
+  let requestId = 0
+  const configDelegation = async function (req) {
+    // request should have id
+    t.assert.ok(req.id)
+    // request should not have send
+    t.assert.ifError(req.send)
+    const config = configs[requestId]
+    requestId++
+    if (config) {
+      return Promise.resolve(config)
+    } else {
+      return Promise.reject(new Error('ouch'))
+    }
+  }
+
+  await fastify.register(cors, {
+    hook: 'preParsing',
+    delegator: configDelegation
+  })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  let res = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  let actualHeaders = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    'access-control-allow-credentials': res.headers['access-control-allow-credentials'],
+    'access-control-expose-headers': res.headers['access-control-expose-headers'],
+    'content-length': res.headers['content-length'],
+    vary: res.headers.vary
+  }
+
+  t.assert.deepStrictEqual(actualHeaders, {
+    'access-control-allow-origin': 'example.com',
+    'access-control-allow-credentials': 'true',
+    'access-control-expose-headers': 'foo, bar',
+    'content-length': '2',
+    vary: 'Origin'
+  })
+
+  res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 204)
+  t.assert.strictEqual(res.payload, '')
+  actualHeaders = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    'access-control-allow-credentials': res.headers['access-control-allow-credentials'],
+    'access-control-expose-headers': res.headers['access-control-expose-headers'],
+    'access-control-allow-methods': res.headers['access-control-allow-methods'],
+    'access-control-allow-headers': res.headers['access-control-allow-headers'],
+    'access-control-max-age': res.headers['access-control-max-age'],
+    'content-length': res.headers['content-length'],
+    vary: res.headers.vary
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'access-control-allow-origin': 'sample.com',
+    'access-control-allow-credentials': 'true',
+    'access-control-expose-headers': 'zoo, bar',
+    'access-control-allow-methods': 'GET',
+    'access-control-allow-headers': 'baz, foo',
+    'access-control-max-age': '321',
+    'content-length': '0',
+    vary: 'Origin'
+  })
+
+  res = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  t.assert.strictEqual(res.statusCode, 500)
+})
+
+test('Should support custom hook with dynamic config (Promise), but should error /1', async t => {
+  t.plan(6)
+
+  const fastify = Fastify()
+  const configDelegation = function () {
+    return false
+  }
+
+  await fastify.register(cors, {
+    hook: 'preParsing',
+    delegator: configDelegation
+  })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  let res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 500)
+  t.assert.strictEqual(res.payload, '{"statusCode":500,"error":"Internal Server Error","message":"Invalid CORS origin option"}')
+  const actualHeaders = {
+    'content-length': res.headers['content-length']
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'content-length': '89'
+  })
+
+  res = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  t.assert.strictEqual(res.statusCode, 500)
+})
+
+test('Should support custom hook with dynamic config (Promise), but should error /2', async t => {
+  t.plan(6)
+
+  const fastify = Fastify()
+  const configDelegation = function () {
+    return false
+  }
+
+  await fastify.register(cors, {
+    delegator: configDelegation
+  })
+
+  fastify.get('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  let res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 500)
+  t.assert.strictEqual(res.payload, '{"statusCode":500,"error":"Internal Server Error","message":"Invalid CORS origin option"}')
+  const actualHeaders = {
+    'content-length': res.headers['content-length']
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'content-length': '89'
+  })
+
+  res = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  t.assert.strictEqual(res.statusCode, 500)
+})

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/cors/test/preflight.test.js

@@ -0,0 +1,590 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('fastify')
+const cors = require('../')
+
+test('Should reply to preflight requests', async t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+  await fastify.register(cors)
+
+  const res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 204)
+  t.assert.strictEqual(res.payload, '')
+  const actualHeaders = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    'access-control-allow-methods': res.headers['access-control-allow-methods'],
+    vary: res.headers.vary,
+    'content-length': res.headers['content-length']
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'access-control-allow-origin': '*',
+    'access-control-allow-methods': 'GET,HEAD,POST',
+    vary: 'Access-Control-Request-Headers',
+    'content-length': '0'
+  })
+})
+
+test('Should add access-control-allow-headers to response if preflight req has access-control-request-headers', async t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+  await fastify.register(cors)
+
+  const res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/',
+    headers: {
+      'access-control-request-headers': 'x-requested-with',
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 204)
+  t.assert.strictEqual(res.payload, '')
+  const actualHeaders = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    'access-control-allow-methods': res.headers['access-control-allow-methods'],
+    'access-control-allow-headers': res.headers['access-control-allow-headers'],
+    vary: res.headers.vary,
+    'content-length': res.headers['content-length']
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'access-control-allow-origin': '*',
+    'access-control-allow-methods': 'GET,HEAD,POST',
+    'access-control-allow-headers': 'x-requested-with',
+    vary: 'Access-Control-Request-Headers',
+    'content-length': '0'
+  })
+})
+
+test('Should reply to preflight requests with custom status code', async t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+  await fastify.register(cors, { optionsSuccessStatus: 200 })
+
+  const res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, '')
+  const actualHeaders = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    'access-control-allow-methods': res.headers['access-control-allow-methods'],
+    vary: res.headers.vary,
+    'content-length': res.headers['content-length']
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'access-control-allow-origin': '*',
+    'access-control-allow-methods': 'GET,HEAD,POST',
+    vary: 'Access-Control-Request-Headers',
+    'content-length': '0'
+  })
+})
+
+test('Should be able to override preflight response with a route', async t => {
+  t.plan(5)
+
+  const fastify = Fastify()
+  await fastify.register(cors, { preflightContinue: true })
+
+  fastify.options('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  const res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  const actualHeaders = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin']
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    // Only the base cors headers and no preflight headers
+    'access-control-allow-origin': '*'
+  })
+  t.assert.notStrictEqual(res.headers.vary, 'Origin')
+})
+
+test('Should reply to all options requests', async t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+  await fastify.register(cors)
+
+  const res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/hello',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 204)
+  t.assert.strictEqual(res.payload, '')
+  const actualHeaders = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    'access-control-allow-methods': res.headers['access-control-allow-methods'],
+    vary: res.headers.vary,
+    'content-length': res.headers['content-length']
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'access-control-allow-origin': '*',
+    'access-control-allow-methods': 'GET,HEAD,POST',
+    vary: 'Access-Control-Request-Headers',
+    'content-length': '0'
+  })
+})
+
+test('Should support a prefix for preflight requests', async t => {
+  t.plan(6)
+
+  const fastify = Fastify()
+  await fastify.register((instance, _opts, next) => {
+    instance.register(cors)
+    next()
+  }, { prefix: '/subsystem' })
+
+  let res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/hello'
+  })
+  t.assert.ok(res)
+  t.assert.strictEqual(res.statusCode, 404)
+
+  res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/subsystem/hello',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 204)
+  t.assert.strictEqual(res.payload, '')
+  const actualHeaders = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    'access-control-allow-methods': res.headers['access-control-allow-methods'],
+    vary: res.headers.vary,
+    'content-length': res.headers['content-length']
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'access-control-allow-origin': '*',
+    'access-control-allow-methods': 'GET,HEAD,POST',
+    vary: 'Access-Control-Request-Headers',
+    'content-length': '0'
+  })
+})
+
+test('hide options route by default', async t => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  fastify.addHook('onRoute', (route) => {
+    if (route.method === 'OPTIONS' && route.url === '*') {
+      t.assert.strictEqual(route.schema.hide, true)
+    }
+  })
+  await fastify.register(cors)
+
+  const ready = await fastify.ready()
+  t.assert.ok(ready)
+})
+
+test('show options route', async t => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  fastify.addHook('onRoute', (route) => {
+    if (route.method === 'OPTIONS' && route.url === '*') {
+      t.assert.strictEqual(route.schema.hide, false)
+    }
+  })
+  await fastify.register(cors, { hideOptionsRoute: false })
+
+  const ready = await fastify.ready()
+  t.assert.ok(ready)
+})
+
+test('Allow only request from with specific methods', async t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+  await fastify.register(cors, { methods: ['GET', 'POST'] })
+
+  const res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 204)
+  const actualHeaders = {
+    'access-control-allow-methods': res.headers['access-control-allow-methods']
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'access-control-allow-methods': 'GET, POST'
+  })
+  t.assert.notStrictEqual(res.headers.vary, 'Origin')
+})
+
+test('Should reply with 400 error to OPTIONS requests missing origin header when default strictPreflight', async t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  await fastify.register(cors)
+
+  const res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET'
+    }
+  })
+  t.assert.ok(res)
+  t.assert.strictEqual(res.statusCode, 400)
+  t.assert.strictEqual(res.payload, 'Invalid Preflight Request')
+})
+
+test('Should reply with 400 to OPTIONS requests when missing Access-Control-Request-Method header when default strictPreflight', async t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  await fastify.register(cors, {
+    strictPreflight: true
+  })
+
+  const res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/',
+    headers: {
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  t.assert.strictEqual(res.statusCode, 400)
+  t.assert.strictEqual(res.payload, 'Invalid Preflight Request')
+})
+
+test('Should reply to all preflight requests when strictPreflight is disabled', async t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+  await fastify.register(cors, { strictPreflight: false })
+
+  const res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/'
+    // No access-control-request-method or origin headers
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 204)
+  t.assert.strictEqual(res.payload, '')
+  const actualHeaders = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    'access-control-allow-methods': res.headers['access-control-allow-methods'],
+    vary: res.headers.vary,
+    'content-length': res.headers['content-length']
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'access-control-allow-origin': '*',
+    'access-control-allow-methods': 'GET,HEAD,POST',
+    vary: 'Access-Control-Request-Headers',
+    'content-length': '0'
+  })
+})
+
+test('Default empty 200 response with preflightContinue on OPTIONS routes', async t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+  await fastify.register(cors, { preflightContinue: true })
+
+  const res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/doesnotexist',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, '')
+  const actualHeaders = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    'access-control-allow-methods': res.headers['access-control-allow-methods'],
+    vary: res.headers.vary
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'access-control-allow-origin': '*',
+    'access-control-allow-methods': 'GET,HEAD,POST',
+    vary: 'Access-Control-Request-Headers'
+  })
+})
+
+test('Can override preflight response with preflightContinue', async t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+  await fastify.register(cors, { preflightContinue: true })
+
+  fastify.options('/', (_req, reply) => {
+    reply.send('ok')
+  })
+
+  const res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload, 'ok')
+  const actualHeaders = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    'access-control-allow-methods': res.headers['access-control-allow-methods'],
+    vary: res.headers.vary
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'access-control-allow-origin': '*',
+    'access-control-allow-methods': 'GET,HEAD,POST',
+    vary: 'Access-Control-Request-Headers'
+  })
+})
+
+test('Should support ongoing prefix ', async t => {
+  t.plan(12)
+
+  const fastify = Fastify()
+
+  await fastify.register(async (instance) => {
+    instance.register(cors)
+  }, { prefix: '/prefix' })
+
+  // support prefixed route
+  let res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/prefix',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 204)
+  t.assert.strictEqual(res.payload, '')
+  let actualHeaders = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    'access-control-allow-methods': res.headers['access-control-allow-methods'],
+    vary: res.headers.vary,
+    'content-length': res.headers['content-length']
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'access-control-allow-origin': '*',
+    'access-control-allow-methods': 'GET,HEAD,POST',
+    vary: 'Access-Control-Request-Headers',
+    'content-length': '0'
+  })
+
+  // support prefixed route without / continue
+  res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/prefixfoo',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 204)
+  t.assert.strictEqual(res.payload, '')
+  actualHeaders = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    'access-control-allow-methods': res.headers['access-control-allow-methods'],
+    vary: res.headers.vary,
+    'content-length': res.headers['content-length']
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'access-control-allow-origin': '*',
+    'access-control-allow-methods': 'GET,HEAD,POST',
+    vary: 'Access-Control-Request-Headers',
+    'content-length': '0'
+  })
+
+  // support prefixed route with / continue
+  res = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/prefix/foo',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'example.com'
+    }
+  })
+  t.assert.ok(res)
+  delete res.headers.date
+  t.assert.strictEqual(res.statusCode, 204)
+  t.assert.strictEqual(res.payload, '')
+  actualHeaders = {
+    'access-control-allow-origin': res.headers['access-control-allow-origin'],
+    'access-control-allow-methods': res.headers['access-control-allow-methods'],
+    vary: res.headers.vary,
+    'content-length': res.headers['content-length']
+  }
+  t.assert.deepStrictEqual(actualHeaders, {
+    'access-control-allow-origin': '*',
+    'access-control-allow-methods': 'GET,HEAD,POST',
+    vary: 'Access-Control-Request-Headers',
+    'content-length': '0'
+  })
+})
+
+test('Silences preflight logs when logLevel is "silent"', async t => {
+  const logs = []
+  const fastify = Fastify({
+    logger: {
+      level: 'info',
+      stream: {
+        write (line) {
+          try {
+            logs.push(JSON.parse(line))
+          } catch {
+          }
+        }
+      }
+    }
+  })
+
+  await fastify.register(cors, { logLevel: 'silent' })
+
+  fastify.get('/', async () => ({ ok: true }))
+
+  await fastify.ready()
+  t.assert.ok(fastify)
+
+  await fastify.inject({
+    method: 'OPTIONS',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'https://example.com'
+    }
+  })
+
+  await fastify.inject({ method: 'GET', url: '/' })
+
+  const hasOptionsLog = logs.some(l => l.req && l.req.method === 'OPTIONS')
+  const hasGetLog = logs.some(l => l.req && l.req.method === 'GET')
+
+  t.assert.strictEqual(hasOptionsLog, false)
+  t.assert.strictEqual(hasGetLog, true)
+
+  await fastify.close()
+})
+test('delegator + logLevel:"silent" → OPTIONS logs are suppressed', async t => {
+  t.plan(3)
+
+  const logs = []
+  const app = Fastify({
+    logger: {
+      level: 'info',
+      stream: { write: l => { try { logs.push(JSON.parse(l)) } catch {} } }
+    }
+  })
+
+  await app.register(cors, {
+    delegator: () => ({ origin: '*' }),
+    logLevel: 'silent'
+  })
+
+  app.get('/', () => ({ ok: true }))
+  await app.ready()
+  t.assert.ok(app)
+
+  await app.inject({
+    method: 'OPTIONS',
+    url: '/',
+    headers: {
+      'access-control-request-method': 'GET',
+      origin: 'https://example.com'
+    }
+  })
+
+  await app.inject({ method: 'GET', url: '/' })
+
+  const hasOptionsLog = logs.some(l => l.req?.method === 'OPTIONS')
+  const hasGetLog = logs.some(l => l.req?.method === 'GET')
+
+  t.assert.strictEqual(hasOptionsLog, false)
+  t.assert.strictEqual(hasGetLog, true)
+
+  await app.close()
+})
+test('delegator + hideOptionsRoute:false → OPTIONS route is visible', async t => {
+  t.plan(2)
+
+  const app = Fastify()
+
+  app.addHook('onRoute', route => {
+    if (route.method === 'OPTIONS' && route.url === '*') {
+      t.assert.strictEqual(route.schema.hide, false)
+    }
+  })
+
+  await app.register(cors, {
+    delegator: () => ({ origin: '*' }),
+    hideOptionsRoute: false
+  })
+
+  await app.ready()
+  t.assert.ok(app)
+  await app.close()
+})

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/cors/test/vary.test.js

@@ -0,0 +1,237 @@
+'use strict'
+
+const { test } = require('node:test')
+const { createAddFieldnameToVary } = require('../vary')
+const { parse } = require('../vary')
+
+test('Should set * even if we set a specific field', async t => {
+  t.plan(1)
+
+  const addOriginToVary = createAddFieldnameToVary('Origin')
+  const replyMock = {
+    getHeader () {
+      return '*'
+    },
+    header () {
+      t.fail('Should not be here')
+    }
+  }
+
+  addOriginToVary(replyMock)
+  t.assert.ok(true) // equalivant to tap t.pass()
+})
+
+test('Should set * even if we set a specific field', t => {
+  t.plan(2)
+
+  const addWildcardToVary = createAddFieldnameToVary('*')
+  const replyMock = {
+    getHeader () {
+      return 'Origin'
+    },
+    header (name, value) {
+      t.assert.deepStrictEqual(name, 'Vary')
+      t.assert.deepStrictEqual(value, '*')
+    }
+  }
+
+  addWildcardToVary(replyMock)
+})
+
+test('Should set * when field contains a *', t => {
+  t.plan(3)
+
+  const addOriginToVary = createAddFieldnameToVary('Origin')
+  const replyMock = {
+    getHeader () {
+      return ['Origin', '*', 'Access-Control-Request-Headers']
+    },
+    header (name, value) {
+      t.assert.deepStrictEqual(name, 'Vary')
+      t.assert.deepStrictEqual(value, '*')
+    }
+  }
+
+  addOriginToVary(replyMock)
+  t.assert.ok(true) // equalivant to tap t.pass()
+})
+
+test('Should concat vary values', t => {
+  t.plan(3)
+
+  const addOriginToVary = createAddFieldnameToVary('Origin')
+  const replyMock = {
+    getHeader () {
+      return 'Access-Control-Request-Headers'
+    },
+    header (name, value) {
+      t.assert.deepStrictEqual(name, 'Vary')
+      t.assert.deepStrictEqual(value, 'Access-Control-Request-Headers, Origin')
+    }
+  }
+
+  addOriginToVary(replyMock)
+  t.assert.ok(true) // equalivant to tap t.pass()
+})
+
+test('Should concat vary values ignoring consecutive commas', t => {
+  t.plan(3)
+
+  const addOriginToVary = createAddFieldnameToVary('Origin')
+  const replyMock = {
+    getHeader () {
+      return ' Access-Control-Request-Headers,Access-Control-Request-Method'
+    },
+    header (name, value) {
+      t.assert.deepStrictEqual(name, 'Vary')
+      t.assert.deepStrictEqual(value, ' Access-Control-Request-Headers,Access-Control-Request-Method, Origin')
+    }
+  }
+
+  addOriginToVary(replyMock)
+  t.assert.ok(true) // equalivant to tap t.pass()
+})
+
+test('Should concat vary values ignoring whitespace', t => {
+  t.plan(3)
+
+  const addOriginToVary = createAddFieldnameToVary('Origin')
+  const replyMock = {
+    getHeader () {
+      return ' Access-Control-Request-Headers ,Access-Control-Request-Method'
+    },
+    header (name, value) {
+      t.assert.deepStrictEqual(name, 'Vary')
+      t.assert.deepStrictEqual(value, ' Access-Control-Request-Headers ,Access-Control-Request-Method, Origin')
+    }
+  }
+
+  addOriginToVary(replyMock)
+  t.assert.ok(true) // equalivant to tap t.pass()
+})
+
+test('Should set the field as value for vary if no vary is defined', t => {
+  t.plan(2)
+
+  const addOriginToVary = createAddFieldnameToVary('Origin')
+  const replyMock = {
+    getHeader () {
+      return undefined
+    },
+    header (name, value) {
+      t.assert.deepStrictEqual(name, 'Vary')
+      t.assert.deepStrictEqual(value, 'Origin')
+    }
+  }
+
+  addOriginToVary(replyMock)
+})
+
+test('Should set * as value for vary if vary contains *', t => {
+  t.plan(2)
+
+  const addOriginToVary = createAddFieldnameToVary('Origin')
+  const replyMock = {
+    getHeader () {
+      return 'Accept,*'
+    },
+    header (name, value) {
+      t.assert.deepStrictEqual(name, 'Vary')
+      t.assert.deepStrictEqual(value, '*')
+    }
+  }
+
+  addOriginToVary(replyMock)
+})
+
+test('Should set Accept-Encoding as value for vary if vary is empty string', t => {
+  t.plan(2)
+
+  const addAcceptEncodingToVary = createAddFieldnameToVary('Accept-Encoding')
+  const replyMock = {
+    getHeader () {
+      return ''
+    },
+    header (name, value) {
+      t.assert.deepStrictEqual(name, 'Vary')
+      t.assert.deepStrictEqual(value, 'Accept-Encoding')
+    }
+  }
+
+  addAcceptEncodingToVary(replyMock)
+})
+
+test('Should have no issues with values containing dashes', t => {
+  t.plan(2)
+
+  const addXFooToVary = createAddFieldnameToVary('X-Foo')
+  const replyMock = {
+    value: 'Accept-Encoding',
+    getHeader () {
+      return this.value
+    },
+    header (name, value) {
+      t.assert.deepStrictEqual(name, 'Vary')
+      t.assert.deepStrictEqual(value, 'Accept-Encoding, X-Foo')
+      this.value = value
+    }
+  }
+
+  addXFooToVary(replyMock)
+  addXFooToVary(replyMock)
+})
+
+test('Should ignore the header as value for vary if it is already in vary', t => {
+  t.plan(1)
+
+  const addOriginToVary = createAddFieldnameToVary('Origin')
+  const replyMock = {
+    getHeader () {
+      return 'Origin'
+    },
+    header () {
+      t.fail('Should not be here')
+    }
+  }
+  addOriginToVary(replyMock)
+  addOriginToVary(replyMock)
+
+  t.assert.ok(true) // equalivant to tap t.pass()
+})
+
+test('parse', t => {
+  t.plan(18)
+  t.assert.deepStrictEqual(parse(''), [])
+  t.assert.deepStrictEqual(parse('a'), ['a'])
+  t.assert.deepStrictEqual(parse('a,b'), ['a', 'b'])
+  t.assert.deepStrictEqual(parse('  a,b'), ['a', 'b'])
+  t.assert.deepStrictEqual(parse('a,b  '), ['a', 'b'])
+  t.assert.deepStrictEqual(parse('a,b,c'), ['a', 'b', 'c'])
+  t.assert.deepStrictEqual(parse('A,b,c'), ['a', 'b', 'c'])
+  t.assert.deepStrictEqual(parse('a,b,c,'), ['a', 'b', 'c'])
+  t.assert.deepStrictEqual(parse('a,b,c, '), ['a', 'b', 'c'])
+  t.assert.deepStrictEqual(parse(',a,b,c'), ['a', 'b', 'c'])
+  t.assert.deepStrictEqual(parse(' ,a,b,c'), ['a', 'b', 'c'])
+  t.assert.deepStrictEqual(parse('a,,b,c'), ['a', 'b', 'c'])
+  t.assert.deepStrictEqual(parse('a,,,b,,c'), ['a', 'b', 'c'])
+  t.assert.deepStrictEqual(parse('a, b,c'), ['a', 'b', 'c'])
+  t.assert.deepStrictEqual(parse('a,   b,c'), ['a', 'b', 'c'])
+  t.assert.deepStrictEqual(parse('a, , b,c'), ['a', 'b', 'c'])
+  t.assert.deepStrictEqual(parse('a,  , b,c'), ['a', 'b', 'c'])
+
+  // one for the cache
+  t.assert.deepStrictEqual(parse('A,b,c'), ['a', 'b', 'c'])
+})
+
+test('createAddFieldnameToVary', async t => {
+  t.plan(4)
+  t.assert.strictEqual(typeof createAddFieldnameToVary('valid-header'), 'function')
+  await t.assert.rejects(
+    async () => createAddFieldnameToVary('invalid:header'),
+    (err) => {
+      t.assert.strictEqual(err.name, 'TypeError')
+      t.assert.strictEqual(err.message, 'Fieldname contains invalid characters.')
+      return true
+    }
+  )
+})

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/cors/types/index.d.ts

@@ -0,0 +1,126 @@
+/// <reference types="node" />
+
+import { FastifyInstance, FastifyPluginCallback, FastifyRequest, LogLevel } from 'fastify'
+
+type OriginCallback = (err: Error | null, origin: ValueOrArray<OriginType>) => void
+type OriginType = string | boolean | RegExp
+type ValueOrArray<T> = T | ArrayOfValueOrArray<T>
+
+interface ArrayOfValueOrArray<T> extends Array<ValueOrArray<T>> {
+}
+
+type FastifyCorsPlugin = FastifyPluginCallback<
+  NonNullable<fastifyCors.FastifyCorsOptions> | fastifyCors.FastifyCorsOptionsDelegate
+>
+
+type FastifyCorsHook =
+  | 'onRequest'
+  | 'preParsing'
+  | 'preValidation'
+  | 'preHandler'
+  | 'preSerialization'
+  | 'onSend'
+
+declare namespace fastifyCors {
+  export type OriginFunction = (origin: string | undefined, callback: OriginCallback) => void
+  export type AsyncOriginFunction = (origin: string | undefined) => Promise<ValueOrArray<OriginType>>
+
+  export interface FastifyCorsOptions {
+    /**
+     * Configures the Lifecycle Hook.
+     */
+    hook?: FastifyCorsHook;
+
+    /**
+     * Configures the delegate function.
+     */
+    delegator?: FastifyCorsOptionsDelegate;
+
+    /**
+     * Configures the Access-Control-Allow-Origin CORS header.
+     */
+    origin?: ValueOrArray<OriginType> | fastifyCors.AsyncOriginFunction | fastifyCors.OriginFunction;
+    /**
+     * Configures the Access-Control-Allow-Credentials CORS header.
+     * Set to true to pass the header, otherwise it is omitted.
+     */
+    credentials?: boolean;
+    /**
+     * Configures the Access-Control-Expose-Headers CORS header.
+     * Expects a comma-delimited string (ex: 'Content-Range,X-Content-Range')
+     * or an array (ex: ['Content-Range', 'X-Content-Range']).
+     * If not specified, no custom headers are exposed.
+     */
+    exposedHeaders?: string | string[];
+    /**
+     * Configures the Access-Control-Allow-Headers CORS header.
+     * Expects a comma-delimited string (ex: 'Content-Type,Authorization')
+     * or an array (ex: ['Content-Type', 'Authorization']). If not
+     * specified, defaults to reflecting the headers specified in the
+     * request's Access-Control-Request-Headers header.
+     */
+    allowedHeaders?: string | string[];
+    /**
+     * Configures the Access-Control-Allow-Methods CORS header.
+     * Expects a comma-delimited string (ex: 'GET,PUT,POST') or an array (ex: ['GET', 'PUT', 'POST']).
+     */
+    methods?: string | string[];
+    /**
+     * Configures the Access-Control-Max-Age CORS header.
+     * Set to an integer to pass the header, otherwise it is omitted.
+     */
+    maxAge?: number;
+    /**
+     * Configures the Cache-Control header for CORS preflight responses.
+     * Set to an integer to pass the header as `Cache-Control: max-age=${cacheControl}`,
+     * or set to a string to pass the header as `Cache-Control: ${cacheControl}` (fully define
+     * the header value), otherwise the header is omitted.
+     */
+    cacheControl?: number | string;
+    /**
+     * Pass the CORS preflight response to the route handler (default: false).
+     */
+    preflightContinue?: boolean;
+    /**
+     * Provides a status code to use for successful OPTIONS requests,
+     * since some legacy browsers (IE11, various SmartTVs) choke on 204.
+     */
+    optionsSuccessStatus?: number;
+    /**
+     * Pass the CORS preflight response to the route handler (default: true).
+     */
+    preflight?: boolean;
+    /**
+     * Enforces strict requirement of the CORS preflight request headers (Access-Control-Request-Method and Origin).
+     * Preflight requests without the required headers will result in 400 errors when set to `true` (default: `true`).
+     */
+    strictPreflight?: boolean;
+    /**
+     * Hide options route from the documentation built using fastify-swagger (default: true).
+     */
+    hideOptionsRoute?: boolean;
+
+    /**
+     * Sets the Fastify log level specifically for the internal OPTIONS route
+     * used to handle CORS preflight requests. For example, setting this to `'silent'`
+     * will prevent these requests from being logged.
+     * Useful for reducing noise in application logs.
+     * Default: inherits Fastify's global log level.
+      */
+    logLevel?: LogLevel;
+  }
+
+  export interface FastifyCorsOptionsDelegateCallback { (req: FastifyRequest, cb: (error: Error | null, corsOptions?: FastifyCorsOptions) => void): void }
+  export interface FastifyCorsOptionsDelegatePromise { (req: FastifyRequest): Promise<FastifyCorsOptions> }
+  export type FastifyCorsOptionsDelegate = FastifyCorsOptionsDelegateCallback | FastifyCorsOptionsDelegatePromise
+  export type FastifyPluginOptionsDelegate<T = FastifyCorsOptionsDelegate> = (instance: FastifyInstance) => T
+
+  export const fastifyCors: FastifyCorsPlugin
+  export { fastifyCors as default }
+}
+
+declare function fastifyCors (
+  ...params: Parameters<FastifyCorsPlugin>
+): ReturnType<FastifyCorsPlugin>
+
+export = fastifyCors

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/cors/types/index.test-d.ts

@@ -0,0 +1,388 @@
+import fastify, { FastifyRequest } from 'fastify'
+import { expectType } from 'tsd'
+import fastifyCors, {
+  AsyncOriginFunction,
+  FastifyCorsOptions,
+  FastifyCorsOptionsDelegate,
+  FastifyCorsOptionsDelegatePromise,
+  FastifyPluginOptionsDelegate,
+  OriginFunction
+} from '..'
+
+const app = fastify()
+
+app.register(fastifyCors)
+
+app.register(fastifyCors, {
+  origin: true,
+  allowedHeaders: 'authorization,content-type',
+  methods: 'GET,POST,PUT,PATCH,DELETE,OPTIONS',
+  credentials: true,
+  exposedHeaders: 'authorization',
+  maxAge: 13000,
+  cacheControl: 13000,
+  preflightContinue: false,
+  optionsSuccessStatus: 200,
+  preflight: false,
+  strictPreflight: false
+})
+
+app.register(fastifyCors, {
+  origin: true,
+  allowedHeaders: ['authorization', 'content-type'],
+  methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+  credentials: true,
+  exposedHeaders: ['authorization'],
+  maxAge: 13000,
+  cacheControl: 'public, max-age=3500',
+  preflightContinue: false,
+  optionsSuccessStatus: 200,
+  preflight: false,
+  strictPreflight: false
+})
+
+app.register(fastifyCors, {
+  origin: '*',
+  allowedHeaders: ['authorization', 'content-type'],
+  methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+  credentials: true,
+  exposedHeaders: ['authorization'],
+  maxAge: 13000,
+  cacheControl: 13000,
+  preflightContinue: false,
+  optionsSuccessStatus: 200,
+  preflight: false,
+  strictPreflight: false
+})
+
+app.register(fastifyCors, {
+  origin: /\*/,
+  allowedHeaders: ['authorization', 'content-type'],
+  methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+  credentials: true,
+  exposedHeaders: ['authorization'],
+  maxAge: 13000,
+  cacheControl: 13000,
+  preflightContinue: false,
+  optionsSuccessStatus: 200,
+  preflight: false,
+  strictPreflight: false
+})
+
+app.register(fastifyCors, {
+  origin: ['*', 'something'],
+  allowedHeaders: ['authorization', 'content-type'],
+  methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+  credentials: true,
+  exposedHeaders: ['authorization'],
+  maxAge: 13000,
+  cacheControl: 13000,
+  preflightContinue: false,
+  optionsSuccessStatus: 200,
+  preflight: false,
+  strictPreflight: false
+})
+
+app.register(fastifyCors, {
+  origin: [/\*/, /something/],
+  allowedHeaders: ['authorization', 'content-type'],
+  methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+  credentials: true,
+  exposedHeaders: ['authorization'],
+  maxAge: 13000,
+  cacheControl: 13000,
+  preflightContinue: false,
+  optionsSuccessStatus: 200,
+  preflight: false,
+  strictPreflight: false
+})
+
+const corsDelegate: OriginFunction = (origin, cb) => {
+  if (origin === undefined || /localhost/.test(origin)) {
+    cb(null, true)
+    return
+  }
+  cb(new Error(), false)
+}
+
+app.register(fastifyCors, {
+  origin: corsDelegate,
+  allowedHeaders: ['authorization', 'content-type'],
+  methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+  credentials: true,
+  exposedHeaders: ['authorization'],
+  maxAge: 13000,
+  cacheControl: 13000,
+  optionsSuccessStatus: 200,
+  preflight: false,
+  strictPreflight: false
+})
+
+const asyncCorsDelegate: OriginFunction = async (origin) => {
+  if (origin === undefined || /localhost/.test(origin)) {
+    return true
+  }
+  return false
+}
+
+app.register(fastifyCors, {
+  origin: asyncCorsDelegate,
+  allowedHeaders: ['authorization', 'content-type'],
+  methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+  credentials: true,
+  exposedHeaders: ['authorization'],
+  maxAge: 13000,
+  cacheControl: 13000,
+  optionsSuccessStatus: 200,
+  preflight: false,
+  strictPreflight: false
+})
+
+app.register(fastifyCors, {
+  origin: (_origin, cb) => cb(null, true)
+})
+
+app.register(fastifyCors, {
+  origin: (_origin, cb) => cb(null, '*')
+})
+
+app.register(fastifyCors, {
+  origin: (_origin, cb) => cb(null, /\*/)
+})
+
+const appHttp2 = fastify({ http2: true })
+
+appHttp2.register(fastifyCors)
+
+appHttp2.register(fastifyCors, {
+  origin: true,
+  allowedHeaders: 'authorization,content-type',
+  methods: 'GET,POST,PUT,PATCH,DELETE,OPTIONS',
+  credentials: true,
+  exposedHeaders: 'authorization',
+  maxAge: 13000,
+  cacheControl: 13000,
+  preflightContinue: false,
+  optionsSuccessStatus: 200,
+  preflight: false,
+  strictPreflight: false,
+  logLevel: 'silent'
+})
+
+appHttp2.register(fastifyCors, {
+  origin: true,
+  allowedHeaders: ['authorization', 'content-type'],
+  methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+  credentials: true,
+  exposedHeaders: ['authorization'],
+  maxAge: 13000,
+  cacheControl: 13000,
+  preflightContinue: false,
+  optionsSuccessStatus: 200,
+  preflight: false,
+  strictPreflight: false
+})
+
+appHttp2.register(fastifyCors, {
+  origin: '*',
+  allowedHeaders: ['authorization', 'content-type'],
+  methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+  credentials: true,
+  exposedHeaders: ['authorization'],
+  maxAge: 13000,
+  cacheControl: 13000,
+  preflightContinue: false,
+  optionsSuccessStatus: 200,
+  preflight: false,
+  strictPreflight: false
+})
+
+appHttp2.register(fastifyCors, {
+  origin: /\*/,
+  allowedHeaders: ['authorization', 'content-type'],
+  methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+  credentials: true,
+  exposedHeaders: ['authorization'],
+  maxAge: 13000,
+  cacheControl: 13000,
+  preflightContinue: false,
+  optionsSuccessStatus: 200,
+  preflight: false,
+  strictPreflight: false
+})
+
+appHttp2.register(fastifyCors, {
+  origin: ['*', 'something'],
+  allowedHeaders: ['authorization', 'content-type'],
+  methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+  credentials: true,
+  exposedHeaders: ['authorization'],
+  maxAge: 13000,
+  cacheControl: 13000,
+  preflightContinue: false,
+  optionsSuccessStatus: 200,
+  preflight: false,
+  strictPreflight: false
+})
+
+appHttp2.register(fastifyCors, {
+  origin: [/\*/, /something/],
+  allowedHeaders: ['authorization', 'content-type'],
+  methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+  credentials: true,
+  exposedHeaders: ['authorization'],
+  maxAge: 13000,
+  cacheControl: 13000,
+  preflightContinue: false,
+  optionsSuccessStatus: 200,
+  preflight: false,
+  strictPreflight: false
+})
+
+appHttp2.register(fastifyCors, {
+  origin: (origin: string | undefined, cb: (err: Error | null, allow: boolean) => void) => {
+    if (origin === undefined || /localhost/.test(origin)) {
+      cb(null, true)
+      return
+    }
+    cb(new Error(), false)
+  },
+  allowedHeaders: ['authorization', 'content-type'],
+  methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+  credentials: true,
+  exposedHeaders: ['authorization'],
+  maxAge: 13000,
+  cacheControl: 13000,
+  preflightContinue: false,
+  optionsSuccessStatus: 200,
+  preflight: false,
+  strictPreflight: false
+})
+
+appHttp2.register(fastifyCors, (): FastifyCorsOptionsDelegate => (_req, cb) => {
+  cb(null, {
+    origin: [/\*/, /something/],
+    allowedHeaders: ['authorization', 'content-type'],
+    methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+    credentials: true,
+    exposedHeaders: ['authorization'],
+    maxAge: 13000,
+    cacheControl: 13000,
+    preflightContinue: false,
+    optionsSuccessStatus: 200,
+    preflight: false,
+    strictPreflight: false
+  })
+})
+
+appHttp2.register(fastifyCors, (): FastifyCorsOptionsDelegatePromise => () => {
+  return Promise.resolve({
+    origin: [/\*/, /something/],
+    allowedHeaders: ['authorization', 'content-type'],
+    methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+    credentials: true,
+    exposedHeaders: ['authorization'],
+    maxAge: 13000,
+    cacheControl: 13000,
+    preflightContinue: false,
+    optionsSuccessStatus: 200,
+    preflight: false,
+    strictPreflight: false
+  })
+})
+
+const delegate: FastifyPluginOptionsDelegate<FastifyCorsOptionsDelegatePromise> = () => async () => {
+  return {
+    origin: [/\*/, /something/],
+    allowedHeaders: ['authorization', 'content-type'],
+    methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+    credentials: true,
+    exposedHeaders: ['authorization'],
+    maxAge: 13000,
+    cacheControl: 13000,
+    preflightContinue: false,
+    optionsSuccessStatus: 200,
+    preflight: false,
+    strictPreflight: false
+  }
+}
+
+appHttp2.register(fastifyCors, {
+  hook: 'onRequest'
+})
+appHttp2.register(fastifyCors, {
+  hook: 'preParsing'
+})
+appHttp2.register(fastifyCors, {
+  hook: 'preValidation'
+})
+appHttp2.register(fastifyCors, {
+  hook: 'preHandler'
+})
+appHttp2.register(fastifyCors, {
+  hook: 'preSerialization'
+})
+appHttp2.register(fastifyCors, {
+  hook: 'onSend'
+})
+
+appHttp2.register(fastifyCors, {
+  hook: 'preParsing',
+  delegator: (req, cb) => {
+    if (req.url.startsWith('/some-value')) {
+      cb(new Error())
+    }
+    cb(null, {
+      origin: [/\*/, /something/],
+      allowedHeaders: ['authorization', 'content-type'],
+      methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+      credentials: true,
+      exposedHeaders: ['authorization'],
+      maxAge: 13000,
+      cacheControl: 12000,
+      preflightContinue: false,
+      optionsSuccessStatus: 200,
+      preflight: false,
+      strictPreflight: false
+    })
+  }
+})
+
+appHttp2.register(fastifyCors, {
+  hook: 'preParsing',
+  delegator: async (_req: FastifyRequest): Promise<FastifyCorsOptions> => {
+    return {
+      origin: [/\*/, /something/],
+      allowedHeaders: ['authorization', 'content-type'],
+      methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+      credentials: true,
+      exposedHeaders: ['authorization'],
+      maxAge: 13000,
+      cacheControl: 'public, max-age=3500',
+      preflightContinue: false,
+      optionsSuccessStatus: 200,
+      preflight: false,
+      strictPreflight: false
+    }
+  }
+})
+
+appHttp2.register(fastifyCors, delegate)
+
+appHttp2.register(fastifyCors, {
+  hook: 'preParsing',
+  origin: function (origin, cb) {
+    expectType<string | undefined>(origin)
+    cb(null, false)
+  },
+})
+
+const asyncOriginFn: AsyncOriginFunction = async function (origin): Promise<boolean> {
+  expectType<string | undefined>(origin)
+  return false
+}
+
+appHttp2.register(fastifyCors, {
+  hook: 'preParsing',
+  origin: asyncOriginFn,
+})

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/error/.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: "monthly"
+    open-pull-requests-limit: 10

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/error/.github/workflows/ci.yml

@@ -0,0 +1,28 @@
+name: CI
+
+on:
+  push:
+    branches:
+     - main
+     - next
+     - 'v*'
+    paths-ignore:
+      - 'docs/**'
+      - '*.md'
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - '*.md'
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    permissions:
+      contents: write
+      pull-requests: write
+    uses: fastify/workflows/.github/workflows/plugins-ci.yml@v5
+    with:
+      license-check: true
+      lint: true

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/error/benchmarks/create.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const benchmark = require('benchmark')
+const createError = require('..')
+
+new benchmark.Suite()
+  .add('create FastifyError', function () { createError('CODE', 'Not available') }, { minSamples: 100 })
+  .on('cycle', function onCycle (event) { console.log(String(event.target)) })
+  .run({ async: false })

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/error/benchmarks/instantiate.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const benchmark = require('benchmark')
+const createError = require('..')
+
+const FastifyError = createError('CODE', 'Not available')
+const FastifyError1 = createError('CODE', 'Not %s available')
+const FastifyError2 = createError('CODE', 'Not %s available %s')
+
+const cause = new Error('cause')
+new benchmark.Suite()
+  .add('instantiate Error', function () { new Error() }, { minSamples: 100 }) // eslint-disable-line no-new
+  .add('instantiate FastifyError', function () { new FastifyError() }, { minSamples: 100 }) // eslint-disable-line no-new
+  .add('instantiate FastifyError arg 1', function () { new FastifyError1('q') }, { minSamples: 100 }) // eslint-disable-line no-new
+  .add('instantiate FastifyError arg 2', function () { new FastifyError2('qq', 'ss') }, { minSamples: 100 }) // eslint-disable-line no-new
+  .add('instantiate FastifyError cause', function () { new FastifyError2({ cause }) }, { minSamples: 100 }) // eslint-disable-line no-new
+  .on('cycle', function onCycle (event) { console.log(String(event.target)) })
+  .run({ async: false })

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/error/benchmarks/no-stack.js

@@ -0,0 +1,13 @@
+'use strict'
+
+const benchmark = require('benchmark')
+const createError = require('..')
+
+const FastifyError = createError('CODE', 'Not available')
+Error.stackTraceLimit = 0
+
+new benchmark.Suite()
+  .add('no-stack instantiate Error', function () { new Error() }, { minSamples: 100 }) // eslint-disable-line no-new
+  .add('no-stack instantiate FastifyError', function () { new FastifyError() }, { minSamples: 100 }) // eslint-disable-line no-new
+  .on('cycle', function onCycle (event) { console.log(String(event.target)) })
+  .run({ async: false })

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/error/benchmarks/toString.js

@@ -0,0 +1,11 @@
+'use strict'
+
+const benchmark = require('benchmark')
+const createError = require('..')
+
+const FastifyError = createError('CODE', 'Not available')
+
+new benchmark.Suite()
+  .add('FastifyError toString', function () { new FastifyError().toString() }, { minSamples: 100 })
+  .on('cycle', function onCycle (event) { console.log(String(event.target)) })
+  .run({ async: false })

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/error/test/index.test.js

@@ -0,0 +1,232 @@
+'use strict'
+
+const test = require('node:test')
+const { createError, FastifyError } = require('..')
+
+test('Create error with zero parameter', (t) => {
+  t.plan(6)
+
+  const NewError = createError('CODE', 'Not available')
+  const err = new NewError()
+  t.assert.ok(err instanceof Error)
+  t.assert.equal(err.name, 'FastifyError')
+  t.assert.equal(err.message, 'Not available')
+  t.assert.equal(err.code, 'CODE')
+  t.assert.equal(err.statusCode, 500)
+  t.assert.ok(err.stack)
+})
+
+test('Create error with 1 parameter', (t) => {
+  t.plan(6)
+
+  const NewError = createError('CODE', 'hey %s')
+  const err = new NewError('alice')
+  t.assert.equal(err.name, 'FastifyError')
+  t.assert.ok(err instanceof Error)
+  t.assert.equal(err.message, 'hey alice')
+  t.assert.equal(err.code, 'CODE')
+  t.assert.equal(err.statusCode, 500)
+  t.assert.ok(err.stack)
+})
+
+test('Create error with 1 parameter set to undefined', (t) => {
+  t.plan(1)
+
+  const NewError = createError('CODE', 'hey %s')
+  const err = new NewError(undefined)
+  t.assert.equal(err.message, 'hey undefined')
+})
+
+test('Create error with 2 parameters', (t) => {
+  t.plan(6)
+
+  const NewError = createError('CODE', 'hey %s, I like your %s')
+  const err = new NewError('alice', 'attitude')
+  t.assert.ok(err instanceof Error)
+  t.assert.equal(err.name, 'FastifyError')
+  t.assert.equal(err.message, 'hey alice, I like your attitude')
+  t.assert.equal(err.code, 'CODE')
+  t.assert.equal(err.statusCode, 500)
+  t.assert.ok(err.stack)
+})
+
+test('Create error with 2 parameters set to undefined', (t) => {
+  t.plan(1)
+
+  const NewError = createError('CODE', 'hey %s, I like your %s')
+  const err = new NewError(undefined, undefined)
+  t.assert.equal(err.message, 'hey undefined, I like your undefined')
+})
+
+test('Create error with 3 parameters', (t) => {
+  t.plan(6)
+
+  const NewError = createError('CODE', 'hey %s, I like your %s %s')
+  const err = new NewError('alice', 'attitude', 'see you')
+  t.assert.ok(err instanceof Error)
+  t.assert.equal(err.name, 'FastifyError')
+  t.assert.equal(err.message, 'hey alice, I like your attitude see you')
+  t.assert.equal(err.code, 'CODE')
+  t.assert.equal(err.statusCode, 500)
+  t.assert.ok(err.stack)
+})
+
+test('Create error with 3 parameters set to undefined', (t) => {
+  t.plan(4)
+
+  const NewError = createError('CODE', 'hey %s, I like your %s %s')
+  const err = new NewError(undefined, undefined, undefined)
+  t.assert.equal(err.message, 'hey undefined, I like your undefined undefined')
+  t.assert.equal(err.code, 'CODE')
+  t.assert.equal(err.statusCode, 500)
+  t.assert.ok(err.stack)
+})
+
+test('Create error with 4 parameters set to undefined', (t) => {
+  t.plan(4)
+
+  const NewError = createError('CODE', 'hey %s, I like your %s %s and %s')
+  const err = new NewError(undefined, undefined, undefined, undefined)
+  t.assert.equal(
+    err.message,
+    'hey undefined, I like your undefined undefined and undefined'
+  )
+  t.assert.equal(err.code, 'CODE')
+  t.assert.equal(err.statusCode, 500)
+  t.assert.ok(err.stack)
+})
+
+test('Create error with no statusCode property', (t) => {
+  t.plan(6)
+
+  const NewError = createError('CODE', 'hey %s', 0)
+  const err = new NewError('dude')
+  t.assert.ok(err instanceof Error)
+  t.assert.equal(err.name, 'FastifyError')
+  t.assert.equal(err.message, 'hey dude')
+  t.assert.equal(err.code, 'CODE')
+  t.assert.equal(err.statusCode, undefined)
+  t.assert.ok(err.stack)
+})
+
+test('Should throw when error code has no fastify code', (t) => {
+  t.plan(1)
+  t.assert.throws(
+    () => createError(),
+    new Error('Fastify error code must not be empty')
+  )
+})
+
+test('Should throw when error code has no message', (t) => {
+  t.assert.throws(
+    () => createError('code'),
+    new Error('Fastify error message must not be empty')
+  )
+})
+
+test('Create error with different base', (t) => {
+  t.plan(7)
+
+  const NewError = createError('CODE', 'hey %s', 500, TypeError)
+  const err = new NewError('dude')
+  t.assert.ok(err instanceof Error)
+  t.assert.ok(err instanceof TypeError)
+  t.assert.equal(err.name, 'FastifyError')
+  t.assert.equal(err.message, 'hey dude')
+  t.assert.equal(err.code, 'CODE')
+  t.assert.equal(err.statusCode, 500)
+  t.assert.ok(err.stack)
+})
+
+test('Create error with different base (no stack) (global)', (t) => {
+  t.plan(7)
+
+  createError.captureStackTrace = false
+  const NewError = createError('CODE', 'hey %s', 500, TypeError)
+  const err = new NewError('dude')
+  t.assert.ok(err instanceof Error)
+  t.assert.ok(err instanceof TypeError)
+  t.assert.equal(err.name, 'FastifyError')
+  t.assert.equal(err.message, 'hey dude')
+  t.assert.equal(err.code, 'CODE')
+  t.assert.equal(err.statusCode, 500)
+  t.assert.equal(err.stack, undefined)
+  createError.captureStackTrace = true
+})
+
+test('Create error with different base (no stack) (parameter)', (t) => {
+  t.plan(7)
+
+  const NewError = createError('CODE', 'hey %s', 500, TypeError, false)
+  const err = new NewError('dude')
+  t.assert.ok(err instanceof Error)
+  t.assert.ok(err instanceof TypeError)
+  t.assert.equal(err.name, 'FastifyError')
+  t.assert.equal(err.message, 'hey dude')
+  t.assert.equal(err.code, 'CODE')
+  t.assert.equal(err.statusCode, 500)
+  t.assert.equal(err.stack, undefined)
+})
+
+test('FastifyError.toString returns code', (t) => {
+  t.plan(1)
+
+  const NewError = createError('CODE', 'foo')
+  const err = new NewError()
+  t.assert.equal(err.toString(), 'FastifyError [CODE]: foo')
+})
+
+test('Create the error without the new keyword', (t) => {
+  t.plan(6)
+
+  const NewError = createError('CODE', 'Not available')
+  const err = NewError()
+  t.assert.ok(err instanceof Error)
+  t.assert.equal(err.name, 'FastifyError')
+  t.assert.equal(err.message, 'Not available')
+  t.assert.equal(err.code, 'CODE')
+  t.assert.equal(err.statusCode, 500)
+  t.assert.ok(err.stack)
+})
+
+test('Create an error with cause', (t) => {
+  t.plan(2)
+
+  const cause = new Error('HEY')
+  const NewError = createError('CODE', 'Not available')
+  const err = NewError({ cause })
+
+  t.assert.ok(err instanceof Error)
+  t.assert.equal(err.cause, cause)
+})
+
+test('Create an error with cause and message', (t) => {
+  t.plan(2)
+
+  const cause = new Error('HEY')
+  const NewError = createError('CODE', 'Not available: %s')
+  const err = NewError('foo', { cause })
+
+  t.assert.ok(err instanceof Error)
+  t.assert.equal(err.cause, cause)
+})
+
+test('Create an error with last argument null', (t) => {
+  t.plan(2)
+
+  const cause = new Error('HEY')
+  const NewError = createError('CODE', 'Not available')
+  const err = NewError({ cause }, null)
+
+  t.assert.ok(err instanceof Error)
+  t.assert.ifError(err.cause)
+})
+
+test('check if FastifyError is instantiable', (t) => {
+  t.plan(2)
+
+  const err = new FastifyError()
+
+  t.assert.ok(err instanceof FastifyError)
+  t.assert.ok(err instanceof Error)
+})

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/error/test/instanceof.test.js

@@ -0,0 +1,263 @@
+'use strict'
+
+const cp = require('node:child_process')
+const fs = require('node:fs')
+const path = require('node:path')
+const os = require('node:os')
+const test = require('node:test')
+const { createError, FastifyError } = require('..')
+
+test('Readme: All errors created with `createError` will be instances of the base error constructor you provided, or `Error` if none was provided.', (t) => {
+  t.plan(3)
+
+  const CustomError = createError('ERROR_CODE', 'Hello %s', 500, TypeError)
+  const customError = new CustomError('world')
+
+  t.assert.ok(customError instanceof CustomError)
+  t.assert.ok(customError instanceof TypeError)
+  t.assert.ok(customError instanceof Error)
+})
+
+test('Readme: All instantiated errors will be instances of the `FastifyError` class. The `FastifyError` class can be required from the module directly.', (t) => {
+  t.plan(1)
+
+  const CustomError = createError('ERROR_CODE', 'Hello %s', 500, TypeError)
+  const customError = new CustomError('world')
+
+  t.assert.ok(customError instanceof FastifyError)
+})
+
+test('Readme: It is possible to create a `FastifyError` that extends another `FastifyError`, created by `createError`, while instanceof working correctly.', (t) => {
+  t.plan(5)
+
+  const CustomError = createError('ERROR_CODE', 'Hello %s', 500, TypeError)
+  const ChildCustomError = createError('CHILD_ERROR_CODE', 'Hello %s', 500, CustomError)
+
+  const customError = new ChildCustomError('world')
+
+  t.assert.ok(customError instanceof ChildCustomError)
+  t.assert.ok(customError instanceof CustomError)
+  t.assert.ok(customError instanceof FastifyError)
+  t.assert.ok(customError instanceof TypeError)
+  t.assert.ok(customError instanceof Error)
+})
+
+test('Readme: Changing the code of an instantiated Error will not change the result of the `instanceof` operator.', (t) => {
+  t.plan(3)
+
+  const CustomError = createError('ERROR_CODE', 'Hello %s', 500, TypeError)
+  const AnotherCustomError = createError('ANOTHER_ERROR_CODE', 'Hello %s', 500, CustomError)
+
+  const customError = new CustomError('world')
+  customError.code = 'ANOTHER_ERROR_CODE'
+
+  t.assert.ok(customError instanceof CustomError)
+  t.assert.ok(customError instanceof AnotherCustomError === false)
+  t.assert.ok(customError instanceof FastifyError)
+})
+
+test('check if createError creates an Error which is instanceof Error', (t) => {
+  t.plan(3)
+
+  const CustomFastifyError = createError('CODE', 'Not available')
+  const err = CustomFastifyError()
+
+  t.assert.ok(err instanceof Error)
+  t.assert.ok(err instanceof SyntaxError === false)
+  t.assert.ok(err instanceof TypeError === false)
+})
+
+test('check if createError creates an Error which is instanceof FastifyError', (t) => {
+  t.plan(4)
+
+  const CustomFastifyError = createError('CODE', 'Not available')
+  const err = CustomFastifyError()
+
+  t.assert.ok(err instanceof Error)
+  t.assert.ok(err instanceof FastifyError)
+  t.assert.ok(err instanceof SyntaxError === false)
+  t.assert.ok(err instanceof TypeError === false)
+})
+
+test('check if createError creates an Error with the right BaseConstructor', (t) => {
+  t.plan(2)
+
+  const CustomFastifyError = createError('CODE', 'Not available', 500, TypeError)
+  const err = CustomFastifyError()
+
+  t.assert.ok(err instanceof Error)
+  t.assert.ok(err instanceof TypeError)
+})
+
+test('check if createError creates an Error with the right BaseConstructor, which is a FastifyError', (t) => {
+  t.plan(6)
+
+  const BaseFastifyError = createError('CODE', 'Not available', 500, TypeError)
+  const CustomFastifyError = createError('CODE', 'Not available', 500, BaseFastifyError)
+  const err = CustomFastifyError()
+
+  t.assert.ok(err instanceof Error)
+  t.assert.ok(err instanceof TypeError)
+  t.assert.ok(err instanceof FastifyError)
+  t.assert.ok(err instanceof BaseFastifyError)
+  t.assert.ok(err instanceof CustomFastifyError)
+  t.assert.ok(err instanceof SyntaxError === false)
+})
+
+// for more information see https://github.com/fastify/fastify-error/pull/86#issuecomment-1301466407
+test('ensure that instanceof works accross different installations of the fastify-error module', async (t) => {
+  const assertsPlanned = 5
+  t.plan(assertsPlanned)
+
+  // We need to create a test environment where fastify-error is installed in two different locations
+  // and then we will check if the error created in one location is instanceof the error created in the other location
+  // This is done by creating a test directory with the following structure:
+
+  // /
+  // ├── index.js
+  // └── node_modules/
+  //     ├── fastify-error/
+  //     │   └── index.js
+  //     └── dep/
+  //         ├── index.js
+  //         └── node_modules/
+  //             └── fastify-error/
+  //                 └── index.js
+
+  const testDirectoryPrefix = 'fastify-error-instanceof-test-'
+
+  const testCwd = path.resolve(os.tmpdir(), `${testDirectoryPrefix}${Math.random().toString(36).substring(2, 15)}`)
+  fs.mkdirSync(testCwd, { recursive: true })
+
+  // Create the index.js. It will be executed as a forked process, so we need to
+  // use process.send to send messages back to the parent process.
+  fs.writeFileSync(path.resolve(testCwd, 'index.js'), `
+    'use strict'
+
+    const path = require('node:path')
+    const { createError, FastifyError } = require('fastify-error')
+    const { foo } = require('dep')
+
+    const actualPathOfFastifyError = require.resolve('fastify-error')
+    const expectedPathOfFastifyError = path.resolve('node_modules', 'fastify-error', 'index.js')
+
+    // Ensure that fastify-error is required from the node_modules directory of the test-project
+    if (actualPathOfFastifyError !== expectedPathOfFastifyError) {
+      console.error('actualPathOfFastifyError', actualPathOfFastifyError)
+      console.error('expectedPathOfFastifyError', expectedPathOfFastifyError)
+      throw new Error('fastify-error should be required from the node_modules directory of the test-project')
+    }
+    
+    const Boom = createError('Boom', 'Boom', 500)
+    const ChildBoom = createError('ChildBoom', 'Boom', 500, Boom)
+    const NotChildBoom = createError('NotChildBoom', 'NotChildBoom', 500, Boom)
+
+    try {
+        foo()
+    } catch (err) {
+        process.send(err instanceof Error)
+        process.send(err instanceof FastifyError)
+        process.send(err instanceof NotChildBoom)
+        process.send(err instanceof Boom)
+        process.send(err instanceof ChildBoom)
+    }
+    `)
+
+  // Create /node_modules/fastify-error directory
+  // Copy the index.js file to the fastify-error directory
+  fs.mkdirSync(path.resolve(testCwd, 'node_modules', 'fastify-error'), { recursive: true })
+  fs.copyFileSync(path.resolve(process.cwd(), 'index.js'), path.resolve(testCwd, 'node_modules', 'fastify-error', 'index.js'))
+
+  // Create /node_modules/dep/node_modules/fastify-error directory
+  // Copy the index.js to the fastify-error directory
+  fs.mkdirSync(path.resolve(testCwd, 'node_modules', 'dep', 'node_modules', 'fastify-error'), { recursive: true })
+  fs.copyFileSync(path.resolve(process.cwd(), 'index.js'), path.resolve(testCwd, 'node_modules', 'dep', 'node_modules', 'fastify-error', 'index.js'))
+
+  // Create /node_modules/dep/index.js. It will export a function foo which will
+  // throw an error when called. The error will be an instance of ChildBoom, created
+  // by the fastify-error module in the node_modules directory of dep.
+  fs.writeFileSync(path.resolve(testCwd, 'node_modules', 'dep', 'index.js'), `
+    'use strict'
+
+    const path = require('node:path')
+    const { createError } = require('fastify-error')
+
+    const actualPathOfFastifyError = require.resolve('fastify-error')
+    const expectedPathOfFastifyError = path.resolve('node_modules', 'dep', 'node_modules', 'fastify-error', 'index.js')
+
+    // Ensure that fastify-error is required from the node_modules directory of the test-project
+    if (actualPathOfFastifyError !== expectedPathOfFastifyError) {
+      console.error('actualPathOfFastifyError', actualPathOfFastifyError)
+      console.error('expectedPathOfFastifyError', expectedPathOfFastifyError)
+      throw new Error('fastify-error should be required from the node_modules directory of dep')
+    }
+    
+    const Boom = createError('Boom', 'Boom', 500)
+    const ChildBoom = createError('ChildBoom', 'Boom', 500, Boom)
+
+    module.exports.foo = function foo () {
+        throw new ChildBoom('foo go Boom')
+    }
+    `)
+
+  const finishedPromise = {
+    promise: undefined,
+    reject: undefined,
+    resolve: undefined,
+  }
+
+  finishedPromise.promise = new Promise((resolve, reject) => {
+    finishedPromise.resolve = resolve
+    finishedPromise.reject = reject
+  })
+
+  const child = cp.fork(path.resolve(testCwd, 'index.js'), {
+    cwd: testCwd,
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      NODE_OPTIONS: '--no-warnings'
+    },
+  })
+
+  let messageCount = 0
+  child.on('message', message => {
+    try {
+      switch (messageCount) {
+        case 0:
+          t.assert.strictEqual(message, true, 'instanceof Error')
+          break
+        case 1:
+          t.assert.strictEqual(message, true, 'instanceof FastifyError')
+          break
+        case 2:
+          t.assert.strictEqual(message, false, 'instanceof NotChildBoom')
+          break
+        case 3:
+          t.assert.strictEqual(message, true, 'instanceof Boom')
+          break
+        case 4:
+          t.assert.strictEqual(message, true, 'instanceof ChildBoom')
+          break
+      }
+      if (++messageCount === assertsPlanned) {
+        finishedPromise.resolve()
+      }
+    } catch (err) {
+      finishedPromise.reject(err)
+    }
+  })
+
+  child.on('error', err => {
+    finishedPromise.reject(err)
+  })
+
+  await finishedPromise.promise
+
+  // Cleanup
+  // As we are creating the test-setup on the fly in the /tmp directory, we can remove it
+  // safely when we are done. It is not relevant for the test if the deletion fails.
+  try {
+    fs.rmSync(testCwd, { recursive: true, force: true })
+  } catch {}
+})

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/error/types/index.d.ts

@@ -0,0 +1,49 @@
+declare function createError<C extends string, SC extends number, Arg extends unknown[] = [any?, any?, any?]> (
+  code: C,
+  message: string,
+  statusCode: SC,
+  Base?: ErrorConstructor,
+  captureStackTrace?: boolean
+): createError.FastifyErrorConstructor<{ code: C, statusCode: SC }, Arg>
+
+declare function createError<C extends string, Arg extends unknown[] = [any?, any?, any?]> (
+  code: C,
+  message: string,
+  statusCode?: number,
+  Base?: ErrorConstructor,
+  captureStackTrace?: boolean
+): createError.FastifyErrorConstructor<{ code: C }, Arg>
+
+declare function createError<Arg extends unknown[] = [any?, any?, any?]> (
+  code: string,
+  message: string,
+  statusCode?: number,
+  Base?: ErrorConstructor,
+  captureStackTrace?: boolean
+): createError.FastifyErrorConstructor<{ code: string }, Arg>
+
+type CreateError = typeof createError
+
+declare namespace createError {
+  export interface FastifyError extends Error {
+    code: string
+    name: string
+    statusCode?: number
+  }
+
+  export interface FastifyErrorConstructor<
+    E extends { code: string, statusCode?: number } = { code: string, statusCode?: number },
+    T extends unknown[] = [any?, any?, any?]
+  > {
+    new(...arg: T): FastifyError & E
+    (...arg: T): FastifyError & E
+    readonly prototype: FastifyError & E
+  }
+
+  export const FastifyError: FastifyErrorConstructor
+
+  export const createError: CreateError
+  export { createError as default }
+}
+
+export = createError

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/error/types/index.test-d.ts

@@ -0,0 +1,92 @@
+import createError, { FastifyError, FastifyErrorConstructor } from '..'
+import { expectType, expectError } from 'tsd'
+
+const CustomError = createError('ERROR_CODE', 'message')
+expectType<FastifyErrorConstructor<{ code: 'ERROR_CODE' }>>(CustomError)
+const err = new CustomError()
+expectType<FastifyError & { code: 'ERROR_CODE' }>(err)
+expectType<'ERROR_CODE'>(err.code)
+expectType<string>(err.message)
+expectType<number | undefined>(err.statusCode)
+
+const CustomErrorNoStackTrace = createError('ERROR_CODE', 'message', undefined, undefined, false)
+expectType<FastifyErrorConstructor<{ code: 'ERROR_CODE' }>>(CustomErrorNoStackTrace)
+const errNoStackTrace = new CustomErrorNoStackTrace()
+expectType<FastifyError & { code: 'ERROR_CODE' }>(errNoStackTrace)
+expectType<'ERROR_CODE'>(errNoStackTrace.code)
+expectType<string>(errNoStackTrace.message)
+expectType<number | undefined>(errNoStackTrace.statusCode)
+
+const CustomTypedError = createError('OTHER_CODE', 'message', 400)
+expectType<FastifyErrorConstructor<{ code: 'OTHER_CODE', statusCode: 400 }>>(CustomTypedError)
+const typed = new CustomTypedError()
+expectType<FastifyError & { code: 'OTHER_CODE', statusCode: 400 }>(typed)
+expectType<'OTHER_CODE'>(typed.code)
+expectType<string>(typed.message)
+expectType<400>(typed.statusCode)
+
+/* eslint-disable no-new */
+const CustomTypedArgError = createError<[string]>('OTHER_CODE', 'expect %s message', 400)
+CustomTypedArgError('a')
+expectError(CustomTypedArgError('a', 'b'))
+expectError(new CustomTypedArgError('a', 'b'))
+expectError(CustomTypedArgError(1))
+expectError(new CustomTypedArgError(1))
+
+const CustomTypedArgError2 = createError<string, number, [string]>('OTHER_CODE', 'expect %s message', 400)
+CustomTypedArgError2('a')
+expectError(CustomTypedArgError2('a', 'b'))
+expectError(new CustomTypedArgError2('a', 'b'))
+expectError(CustomTypedArgError2(1))
+expectError(new CustomTypedArgError2(1))
+
+const CustomTypedArgError3 = createError<string, number, [string, string]>('OTHER_CODE', 'expect %s message but got %s', 400)
+expectError(CustomTypedArgError3('a'))
+CustomTypedArgError3('a', 'b')
+new CustomTypedArgError3('a', 'b')
+expectError(CustomTypedArgError3(1))
+expectError(new CustomTypedArgError3(1))
+expectError(new CustomTypedArgError3(1, 2))
+expectError(new CustomTypedArgError3('1', 2))
+expectError(new CustomTypedArgError3(1, '2'))
+
+const CustomTypedArgError4 = createError<string, number, [string, string]>('OTHER_CODE', 'expect %s message but got %s', 400)
+expectError(CustomTypedArgError4('a'))
+CustomTypedArgError4('a', 'b')
+new CustomTypedArgError4('a', 'b')
+expectError(CustomTypedArgError4(1))
+expectError(new CustomTypedArgError4(1))
+expectError(new CustomTypedArgError4(1, 2))
+expectError(new CustomTypedArgError4('1', 2))
+expectError(new CustomTypedArgError4(1, '2'))
+
+const CustomTypedArgError5 = createError<[string, string, string, string]>('OTHER_CODE', 'expect %s message but got %s. Please contact %s by emailing to %s', 400)
+expectError(CustomTypedArgError5('a'))
+expectError(new CustomTypedArgError5('a', 'b'))
+expectError(new CustomTypedArgError5('a', 'b', 'c'))
+CustomTypedArgError5('a', 'b', 'c', 'd')
+expectError(new CustomTypedArgError5('a', 'b', 'c', 'd', 'e'))
+
+const CustomTypedArgError6 = createError<string, number, [string, string, string, string]>('OTHER_CODE', 'expect %s message but got %s. Please contact %s by emailing to %s', 400)
+expectError(CustomTypedArgError6('a'))
+expectError(new CustomTypedArgError6('a', 'b'))
+expectError(new CustomTypedArgError6('a', 'b', 'c'))
+CustomTypedArgError6('a', 'b', 'c', 'd')
+expectError(new CustomTypedArgError6('a', 'b', 'c', 'd', 'e'))
+
+const CustomErrorWithErrorConstructor = createError('ERROR_CODE', 'message', 500, TypeError)
+expectType<FastifyErrorConstructor<{ code: 'ERROR_CODE', statusCode: 500 }>>(CustomErrorWithErrorConstructor)
+CustomErrorWithErrorConstructor({ cause: new Error('Error') })
+const customErrorWithErrorConstructor = CustomErrorWithErrorConstructor()
+if (customErrorWithErrorConstructor instanceof FastifyError) {
+  expectType<'ERROR_CODE'>(customErrorWithErrorConstructor.code)
+  expectType<string>(customErrorWithErrorConstructor.message)
+  expectType<500>(customErrorWithErrorConstructor.statusCode)
+}
+
+const error = new FastifyError('ERROR_CODE', 'message', 500)
+if (error instanceof FastifyError) {
+  expectType<string>(error.code)
+  expectType<string>(error.message)
+  expectType<number | undefined>(error.statusCode)
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/fast-json-stringify-compiler/.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: "monthly"
+    open-pull-requests-limit: 10

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/fast-json-stringify-compiler/.github/workflows/ci.yml

@@ -0,0 +1,28 @@
+name: CI
+
+on:
+  push:
+    branches:
+     - main
+     - next
+     - 'v*'
+    paths-ignore:
+      - 'docs/**'
+      - '*.md'
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - '*.md'
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    permissions:
+      contents: write
+      pull-requests: write
+    uses: fastify/workflows/.github/workflows/plugins-ci.yml@v5
+    with:
+      license-check: true
+      lint: true

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/fast-json-stringify-compiler/test/duplicate-schema.test.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const { test } = require('node:test')
+const FjsCompiler = require('../index')
+
+test('Use input schema duplicate in the externalSchemas', async t => {
+  t.plan(1)
+  const externalSchemas = {
+    schema1: {
+      $id: 'schema1',
+      type: 'number'
+    },
+    schema2: {
+      $id: 'schema2',
+      type: 'string'
+    }
+  }
+
+  const factory = FjsCompiler()
+  const compiler = factory(externalSchemas)
+
+  compiler({ schema: externalSchemas.schema1 })
+  compiler({ schema: externalSchemas.schema2 })
+
+  t.assert.ok(true)
+})

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/fast-json-stringify-compiler/test/plugin.test.js

@@ -0,0 +1,78 @@
+'use strict'
+
+const { test } = require('node:test')
+const fastify = require('fastify')
+const FjsCompiler = require('../index')
+
+const echo = async (req) => { return req.body }
+
+const sampleSchema = Object.freeze({
+  $id: 'example1',
+  type: 'object',
+  properties: {
+    name: { type: 'string' }
+  }
+})
+
+const externalSchemas1 = Object.freeze({})
+const externalSchemas2 = Object.freeze({
+  foo: {
+    $id: 'foo',
+    type: 'object',
+    properties: {
+      name: { type: 'string' }
+    }
+  }
+})
+
+const fastifyFjsOptionsDefault = Object.freeze({})
+
+test('basic usage', t => {
+  t.plan(1)
+  const factory = FjsCompiler()
+  const compiler = factory(externalSchemas1, fastifyFjsOptionsDefault)
+  const serializeFunc = compiler({ schema: sampleSchema })
+  const result = serializeFunc({ name: 'hello' })
+  t.assert.equal(result, '{"name":"hello"}')
+})
+
+test('fastify integration', async t => {
+  const factory = FjsCompiler()
+
+  const app = fastify({
+    serializerOpts: {
+      rounding: 'ceil'
+    },
+    schemaController: {
+      compilersFactory: {
+        buildSerializer: factory
+      }
+    }
+  })
+
+  app.addSchema(externalSchemas2.foo)
+
+  app.post('/', {
+    handler: echo,
+    schema: {
+      response: {
+        200: {
+          $ref: 'foo#'
+        }
+      }
+    }
+  })
+
+  const res = await app.inject({
+    url: '/',
+    method: 'POST',
+    payload: {
+      version: '1',
+      foo: 'this is not a number',
+      name: 'serialize me'
+    }
+  })
+
+  t.assert.equal(res.statusCode, 200)
+  t.assert.deepStrictEqual(res.json(), { name: 'serialize me' })
+})

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/fast-json-stringify-compiler/test/standalone.test.js

@@ -0,0 +1,230 @@
+'use strict'
+
+const fs = require('node:fs')
+const path = require('node:path')
+const { test } = require('node:test')
+const fastify = require('fastify')
+const sanitize = require('sanitize-filename')
+
+const { StandaloneSerializer: FjsStandaloneCompiler } = require('../')
+
+const generatedFileNames = []
+
+function generateFileName (routeOpts) {
+  const fileName = `/fjs-generated-${sanitize(routeOpts.schema.$id)}-${routeOpts.method}-${routeOpts.httpPart}-${sanitize(routeOpts.url)}.js`
+  generatedFileNames.push(fileName)
+  return fileName
+}
+
+test('standalone', async t => {
+  t.plan(5)
+
+  t.after(async () => {
+    for (const fileName of generatedFileNames) {
+      try {
+        await fs.promises.unlink(path.join(__dirname, fileName))
+      } catch {}
+    }
+  })
+
+  t.test('errors', t => {
+    t.plan(2)
+    t.assert.throws(() => {
+      FjsStandaloneCompiler()
+    }, 'missing restoreFunction')
+    t.assert.throws(() => {
+      FjsStandaloneCompiler({ readMode: false })
+    }, 'missing storeFunction')
+  })
+
+  t.test('generate standalone code', t => {
+    t.plan(5)
+
+    const base = {
+      $id: 'urn:schema:base',
+      definitions: {
+        hello: { type: 'string' }
+      },
+      type: 'object',
+      properties: {
+        hello: { $ref: '#/definitions/hello' }
+      }
+    }
+
+    const refSchema = {
+      $id: 'urn:schema:ref',
+      type: 'object',
+      properties: {
+        hello: { $ref: 'urn:schema:base#/definitions/hello' }
+      }
+    }
+
+    const endpointSchema = {
+      schema: {
+        $id: 'urn:schema:endpoint',
+        $ref: 'urn:schema:ref'
+      }
+    }
+
+    const schemaMap = {
+      [base.$id]: base,
+      [refSchema.$id]: refSchema
+    }
+
+    const factory = FjsStandaloneCompiler({
+      readMode: false,
+      storeFunction (routeOpts, schemaSerializerCode) {
+        t.assert.deepStrictEqual(routeOpts, endpointSchema)
+        t.assert.ok(typeof schemaSerializerCode === 'string')
+        fs.writeFileSync(path.join(__dirname, '/fjs-generated.js'), schemaSerializerCode)
+        generatedFileNames.push('/fjs-generated.js')
+        t.assert.ok('stored the serializer function')
+      }
+    })
+
+    const compiler = factory(schemaMap)
+    compiler(endpointSchema)
+    t.assert.ok('compiled the endpoint schema')
+
+    t.test('usage standalone code', t => {
+      t.plan(3)
+      const standaloneSerializer = require('./fjs-generated')
+      t.assert.ok(standaloneSerializer)
+
+      const valid = standaloneSerializer({ hello: 'world' })
+      t.assert.deepStrictEqual(valid, JSON.stringify({ hello: 'world' }))
+
+      const invalid = standaloneSerializer({ hello: [] })
+      t.assert.deepStrictEqual(invalid, '{"hello":""}')
+    })
+  })
+
+  t.test('fastify integration - writeMode', async t => {
+    t.plan(4)
+
+    const factory = FjsStandaloneCompiler({
+      readMode: false,
+      storeFunction (routeOpts, schemaSerializationCode) {
+        const fileName = generateFileName(routeOpts)
+        t.assert.ok(routeOpts)
+        fs.writeFileSync(path.join(__dirname, fileName), schemaSerializationCode)
+        t.assert.ok(`stored the serializer function ${fileName}`)
+      },
+      restoreFunction () {
+        t.fail('write mode ON')
+      }
+    })
+
+    const app = buildApp(factory)
+    await app.ready()
+  })
+
+  await t.test('fastify integration - writeMode forces standalone', async t => {
+    t.plan(4)
+
+    const factory = FjsStandaloneCompiler({
+      readMode: false,
+      storeFunction (routeOpts, schemaSerializationCode) {
+        const fileName = generateFileName(routeOpts)
+        t.assert.ok(routeOpts)
+        fs.writeFileSync(path.join(__dirname, fileName), schemaSerializationCode)
+        t.assert.ok(`stored the serializer function ${fileName}`)
+      },
+      restoreFunction () {
+        t.fail('write mode ON')
+      }
+    })
+
+    const app = buildApp(factory, {
+      mode: 'not-standalone',
+      rounding: 'ceil'
+    })
+
+    await app.ready()
+  })
+
+  await t.test('fastify integration - readMode', async t => {
+    t.plan(6)
+
+    const factory = FjsStandaloneCompiler({
+      readMode: true,
+      storeFunction () {
+        t.fail('read mode ON')
+      },
+      restoreFunction (routeOpts) {
+        const fileName = generateFileName(routeOpts)
+        t.assert.ok(`restore the serializer function ${fileName}}`)
+        return require(path.join(__dirname, fileName))
+      }
+    })
+
+    const app = buildApp(factory)
+    await app.ready()
+
+    let res = await app.inject({
+      url: '/foo',
+      method: 'POST'
+    })
+    t.assert.equal(res.statusCode, 200)
+    t.assert.equal(res.payload, JSON.stringify({ hello: 'world' }))
+
+    res = await app.inject({
+      url: '/bar?lang=it',
+      method: 'GET'
+    })
+    t.assert.equal(res.statusCode, 200)
+    t.assert.equal(res.payload, JSON.stringify({ lang: 'en' }))
+  })
+
+  function buildApp (factory, serializerOpts) {
+    const app = fastify({
+      exposeHeadRoutes: false,
+      jsonShorthand: false,
+      schemaController: {
+        compilersFactory: {
+          buildSerializer: factory
+        }
+      },
+      serializerOpts
+    })
+
+    app.addSchema({
+      $id: 'urn:schema:foo',
+      type: 'object',
+      properties: {
+        name: { type: 'string' },
+        id: { type: 'integer' }
+      }
+    })
+
+    app.post('/foo', {
+      schema: {
+        response: {
+          200: {
+            $id: 'urn:schema:response',
+            type: 'object',
+            properties: {
+              hello: { $ref: 'urn:schema:foo#/properties/name' }
+            }
+          }
+        }
+      }
+    }, () => { return { hello: 'world' } })
+
+    app.get('/bar', {
+      schema: {
+        response: {
+          200: {
+            $id: 'urn:schema:response:bar',
+            type: 'object',
+            properties: {
+              lang: { type: 'string', enum: ['it', 'en'] }
+            }
+          }
+        }
+      }
+    }, () => { return { lang: 'en' } })
+
+    return app
+  }
+})

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/fast-json-stringify-compiler/types/index.d.ts

@@ -0,0 +1,41 @@
+import { Options } from 'fast-json-stringify'
+
+type FastJsonStringifyFactory = () => SerializerSelector.SerializerFactory
+
+declare namespace SerializerSelector {
+  export type SerializerFactory = (
+    externalSchemas?: unknown,
+    options?: Options
+  ) => SerializerCompiler
+
+  export type SerializerCompiler = (routeDef: RouteDefinition) => Serializer
+  export type Serializer = (doc: any) => string
+
+  export type RouteDefinition = {
+    method: string;
+    url: string;
+    httpStatus: string;
+    schema?: unknown;
+  }
+
+  export type StandaloneOptions = StandaloneOptionsReadModeOn | StandaloneOptionsReadModeOff
+
+  export type StandaloneOptionsReadModeOn = {
+    readMode: true;
+    restoreFunction?(opts: RouteDefinition): Serializer;
+  }
+
+  export type StandaloneOptionsReadModeOff = {
+    readMode?: false | undefined;
+    storeFunction?(opts: RouteDefinition, schemaSerializationCode: string): void;
+  }
+
+  export type { Options }
+  export const SerializerSelector: FastJsonStringifyFactory
+  export function StandaloneSerializer (options: StandaloneOptions): SerializerFactory
+
+  export { SerializerSelector as default }
+}
+
+declare function SerializerSelector (...params: Parameters<FastJsonStringifyFactory>): ReturnType<FastJsonStringifyFactory>
+export = SerializerSelector

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/fast-json-stringify-compiler/types/index.test-d.ts

@@ -0,0 +1,142 @@
+import { expectAssignable, expectError, expectType } from 'tsd'
+import SerializerSelector, {
+  RouteDefinition,
+  Serializer,
+  SerializerCompiler,
+  SerializerFactory,
+  SerializerSelector as SerializerSelectorNamed,
+  StandaloneSerializer,
+} from '..'
+
+/**
+ * SerializerSelector
+ */
+
+{
+  const compiler = SerializerSelector()
+  expectType<SerializerFactory>(compiler)
+}
+
+{
+  const compiler = SerializerSelectorNamed()
+  expectType<SerializerFactory>(compiler)
+}
+
+{
+  const sampleSchema = {
+    $id: 'example1',
+    type: 'object',
+    properties: {
+      name: { type: 'string' }
+    }
+  }
+
+  const externalSchemas1 = {}
+
+  const factory = SerializerSelector()
+  expectType<SerializerFactory>(factory)
+  const compiler = factory(externalSchemas1, {})
+  expectType<SerializerCompiler>(compiler)
+  const serializeFunc = compiler({ schema: sampleSchema, method: '', url: '', httpStatus: '' })
+  expectType<Serializer>(serializeFunc)
+
+  expectType<string>(serializeFunc({ name: 'hello' }))
+}
+
+/**
+ * StandaloneSerializer
+ */
+
+const reader = StandaloneSerializer({
+  readMode: true,
+  restoreFunction: (route: RouteDefinition) => {
+    expectAssignable<RouteDefinition>(route)
+    return {} as Serializer
+  },
+})
+expectType<SerializerFactory>(reader)
+
+const writer = StandaloneSerializer({
+  readMode: false,
+  storeFunction: (route: RouteDefinition, code: string) => {
+    expectAssignable<RouteDefinition>(route)
+    expectAssignable<string>(code)
+  },
+})
+expectType<SerializerFactory>(writer)
+
+{
+  const base = {
+    $id: 'urn:schema:base',
+    definitions: {
+      hello: { type: 'string' }
+    },
+    type: 'object',
+    properties: {
+      hello: { $ref: '#/definitions/hello' }
+    }
+  }
+
+  const refSchema = {
+    $id: 'urn:schema:ref',
+    type: 'object',
+    properties: {
+      hello: { $ref: 'urn:schema:base#/definitions/hello' }
+    }
+  }
+
+  const endpointSchema = {
+    method: '',
+    url: '',
+    httpStatus: '',
+    schema: {
+      $id: 'urn:schema:endpoint',
+      $ref: 'urn:schema:ref'
+    }
+  }
+
+  const schemaMap = {
+    [base.$id]: base,
+    [refSchema.$id]: refSchema
+  }
+
+  expectError(StandaloneSerializer({
+    readMode: true,
+    storeFunction () { }
+  }))
+  expectError(StandaloneSerializer({
+    readMode: false,
+    restoreFunction () {}
+  }))
+  expectError(StandaloneSerializer({
+    restoreFunction () {}
+  }))
+
+  expectType<SerializerFactory>(StandaloneSerializer({
+    storeFunction (routeOpts, schemaSerializerCode) {
+      expectType<RouteDefinition>(routeOpts)
+      expectType<string>(schemaSerializerCode)
+    }
+  }))
+
+  expectType<SerializerFactory>(StandaloneSerializer({
+    readMode: true,
+    restoreFunction (routeOpts) {
+      expectType<RouteDefinition>(routeOpts)
+      return {} as Serializer
+    }
+  }))
+
+  const factory = StandaloneSerializer({
+    readMode: false,
+    storeFunction (routeOpts, schemaSerializerCode) {
+      expectType<RouteDefinition>(routeOpts)
+      expectType<string>(schemaSerializerCode)
+    }
+  })
+  expectType<SerializerFactory>(factory)
+
+  const compiler = factory(schemaMap)
+  expectType<SerializerCompiler>(compiler)
+  expectType<Serializer>(compiler(endpointSchema))
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/forwarded/types/index.d.ts

@@ -0,0 +1,14 @@
+import { IncomingMessage } from 'http';
+
+type Forwarded = (req: IncomingMessage) => string[]
+
+declare namespace forwarded {
+  export const forwarded: Forwarded
+  export { forwarded as default }
+}
+
+/**
+ * Get all addresses in the request used in the `X-Forwarded-For` header.
+ */
+declare function forwarded(...params: Parameters<Forwarded>): ReturnType<Forwarded>
+export = forwarded

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/merge-json-schemas/.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

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/merge-json-schemas/.github/workflows/ci.yml

@@ -0,0 +1,23 @@
+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
+    with:
+      license-check: true
+      lint: true

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/merge-json-schemas/lib/errors.js

@@ -0,0 +1,36 @@
+'use strict'
+
+class MergeError extends Error {
+  constructor (keyword, schemas) {
+    super()
+    this.name = 'JsonSchemaMergeError'
+    this.code = 'JSON_SCHEMA_MERGE_ERROR'
+    this.message = `Failed to merge "${keyword}" keyword schemas.`
+    this.schemas = schemas
+  }
+}
+
+class ResolverNotFoundError extends Error {
+  constructor (keyword, schemas) {
+    super()
+    this.name = 'JsonSchemaMergeError'
+    this.code = 'JSON_SCHEMA_MERGE_ERROR'
+    this.message = `Resolver for "${keyword}" keyword not found.`
+    this.schemas = schemas
+  }
+}
+
+class InvalidOnConflictOptionError extends Error {
+  constructor (onConflict) {
+    super()
+    this.name = 'JsonSchemaMergeError'
+    this.code = 'JSON_SCHEMA_MERGE_ERROR'
+    this.message = `Invalid "onConflict" option: "${onConflict}".`
+  }
+}
+
+module.exports = {
+  MergeError,
+  ResolverNotFoundError,
+  InvalidOnConflictOptionError
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/merge-json-schemas/lib/resolvers.js

@@ -0,0 +1,127 @@
+'use strict'
+
+const { dequal: deepEqual } = require('dequal')
+const { MergeError } = require('./errors')
+
+function _arraysIntersection (arrays) {
+  let intersection = arrays[0]
+  for (let i = 1; i < arrays.length; i++) {
+    intersection = intersection.filter(
+      value => arrays[i].includes(value)
+    )
+  }
+  return intersection
+}
+
+function arraysIntersection (keyword, values, mergedSchema) {
+  const intersection = _arraysIntersection(values)
+  if (intersection.length === 0) {
+    throw new MergeError(keyword, values)
+  }
+  mergedSchema[keyword] = intersection
+}
+
+function hybridArraysIntersection (keyword, values, mergedSchema) {
+  for (let i = 0; i < values.length; i++) {
+    if (!Array.isArray(values[i])) {
+      values[i] = [values[i]]
+    }
+  }
+
+  const intersection = _arraysIntersection(values)
+  if (intersection.length === 0) {
+    throw new MergeError(keyword, values)
+  }
+
+  if (intersection.length === 1) {
+    mergedSchema[keyword] = intersection[0]
+  } else {
+    mergedSchema[keyword] = intersection
+  }
+}
+
+function arraysUnion (keyword, values, mergedSchema) {
+  const union = []
+
+  for (const array of values) {
+    for (const value of array) {
+      if (!union.includes(value)) {
+        union.push(value)
+      }
+    }
+  }
+
+  mergedSchema[keyword] = union
+}
+
+function minNumber (keyword, values, mergedSchema) {
+  mergedSchema[keyword] = Math.min(...values)
+}
+
+function maxNumber (keyword, values, mergedSchema) {
+  mergedSchema[keyword] = Math.max(...values)
+}
+
+function commonMultiple (keyword, values, mergedSchema) {
+  const gcd = (a, b) => (!b ? a : gcd(b, a % b))
+  const lcm = (a, b) => (a * b) / gcd(a, b)
+
+  let scale = 1
+  for (const value of values) {
+    while (value * scale % 1 !== 0) {
+      scale *= 10
+    }
+  }
+
+  let multiple = values[0] * scale
+  for (const value of values) {
+    multiple = lcm(multiple, value * scale)
+  }
+
+  mergedSchema[keyword] = multiple / scale
+}
+
+function allEqual (keyword, values, mergedSchema) {
+  const firstValue = values[0]
+  for (let i = 1; i < values.length; i++) {
+    if (!deepEqual(values[i], firstValue)) {
+      throw new MergeError(keyword, values)
+    }
+  }
+  mergedSchema[keyword] = firstValue
+}
+
+function skip () {}
+
+function booleanAnd (keyword, values, mergedSchema) {
+  for (const value of values) {
+    if (value === false) {
+      mergedSchema[keyword] = false
+      return
+    }
+  }
+  mergedSchema[keyword] = true
+}
+
+function booleanOr (keyword, values, mergedSchema) {
+  for (const value of values) {
+    if (value === true) {
+      mergedSchema[keyword] = true
+      return
+    }
+  }
+  mergedSchema[keyword] = false
+}
+
+module.exports = {
+  arraysIntersection,
+  hybridArraysIntersection,
+  arraysUnion,
+  minNumber,
+  maxNumber,
+  commonMultiple,
+  allEqual,
+  booleanAnd,
+  booleanOr,
+  skip
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/merge-json-schemas/test/additional-items.test.js

@@ -0,0 +1,164 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and additionalItems = false keyword', () => {
+  const schema1 = { type: 'array' }
+  const schema2 = {
+    type: 'array',
+    additionalItems: false
+  }
+
+  const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+  assert.deepStrictEqual(mergedSchema, {
+    type: 'array',
+    additionalItems: false
+  })
+})
+
+test('should merge two schemas with boolean additionalItems', () => {
+  const schema1 = {
+    type: 'array',
+    additionalItems: true
+  }
+  const schema2 = {
+    type: 'array',
+    additionalItems: false
+  }
+
+  const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+  assert.deepStrictEqual(mergedSchema, {
+    type: 'array',
+    additionalItems: false
+  })
+})
+
+test('should merge additionalItems schema with false value', () => {
+  const schema1 = {
+    type: 'array',
+    additionalItems: {
+      type: 'string'
+    }
+  }
+  const schema2 = {
+    type: 'array',
+    additionalItems: false
+  }
+
+  const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+  assert.deepStrictEqual(mergedSchema, {
+    type: 'array',
+    additionalItems: false
+  })
+})
+
+test('should merge additionalItems schema with true value', () => {
+  const schema1 = {
+    type: 'array',
+    additionalItems: {
+      type: 'string'
+    }
+  }
+  const schema2 = {
+    type: 'array',
+    additionalItems: true
+  }
+
+  const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+  assert.deepStrictEqual(mergedSchema, {
+    type: 'array',
+    additionalItems: {
+      type: 'string'
+    }
+  })
+})
+
+test('should merge two additionalItems schemas', () => {
+  const schema1 = {
+    type: 'array',
+    additionalItems: {
+      type: 'string'
+    }
+  }
+  const schema2 = {
+    type: 'array',
+    additionalItems: {
+      type: 'string', minLength: 1
+    }
+  }
+
+  const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+  assert.deepStrictEqual(mergedSchema, {
+    type: 'array',
+    additionalItems: {
+      type: 'string', minLength: 1
+    }
+  })
+})
+
+test('should merge additionalItems with items array', () => {
+  const schema1 = {
+    type: 'array',
+    items: [
+      { type: 'string', const: 'foo1' },
+      { type: 'string', const: 'foo2' },
+      { type: 'string', const: 'foo3' }
+    ]
+  }
+  const schema2 = {
+    type: 'array',
+    additionalItems: {
+      type: 'string', minLength: 42
+    }
+  }
+
+  const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+  assert.deepStrictEqual(mergedSchema, {
+    type: 'array',
+    items: [
+      { type: 'string', const: 'foo1', minLength: 42 },
+      { type: 'string', const: 'foo2', minLength: 42 },
+      { type: 'string', const: 'foo3', minLength: 42 }
+    ],
+    additionalItems: {
+      type: 'string', minLength: 42
+    }
+  })
+})
+
+test('should merge items array and additionalItems with items array', () => {
+  const schema1 = {
+    type: 'array',
+    items: [
+      { type: 'string', const: 'foo1' },
+      { type: 'string', const: 'foo2' },
+      { type: 'string', const: 'foo3' }
+    ]
+  }
+  const schema2 = {
+    type: 'array',
+    items: [
+      { type: 'string', minLength: 1 },
+      { type: 'string', minLength: 2 }
+    ],
+    additionalItems: {
+      type: 'string', minLength: 3
+    }
+  }
+
+  const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+  assert.deepStrictEqual(mergedSchema, {
+    type: 'array',
+    items: [
+      { type: 'string', const: 'foo1', minLength: 1 },
+      { type: 'string', const: 'foo2', minLength: 2 },
+      { type: 'string', const: 'foo3', minLength: 3 }
+    ],
+    additionalItems: {
+      type: 'string', minLength: 3
+    }
+  })
+})

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/merge-json-schemas/test/additional-properties.test.js

@@ -0,0 +1,129 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and additionalProperties=false keyword', () => {
+  const schema1 = { type: 'object' }
+  const schema2 = {
+    type: 'object',
+    additionalProperties: false
+  }
+
+  const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+  assert.deepStrictEqual(mergedSchema, {
+    type: 'object',
+    additionalProperties: false
+  })
+})
+
+test('should merge two schemas with boolean additionalProperties', () => {
+  const schema1 = {
+    type: 'object',
+    additionalProperties: true
+  }
+  const schema2 = {
+    type: 'object',
+    additionalProperties: false
+  }
+
+  const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+  assert.deepStrictEqual(mergedSchema, {
+    type: 'object',
+    additionalProperties: false
+  })
+})
+
+test('should merge additionalProperties schema with false value', () => {
+  const schema1 = {
+    type: 'object',
+    additionalProperties: {
+      type: 'string'
+    }
+  }
+  const schema2 = {
+    type: 'object',
+    additionalProperties: false
+  }
+
+  const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+  assert.deepStrictEqual(mergedSchema, {
+    type: 'object',
+    additionalProperties: false
+  })
+})
+
+test('should merge additionalProperties schema with true value', () => {
+  const schema1 = {
+    type: 'object',
+    additionalProperties: {
+      type: 'string'
+    }
+  }
+  const schema2 = {
+    type: 'object',
+    additionalProperties: true
+  }
+
+  const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+  assert.deepStrictEqual(mergedSchema, {
+    type: 'object',
+    additionalProperties: {
+      type: 'string'
+    }
+  })
+})
+
+test('should merge two additionalProperties schemas', () => {
+  const schema1 = {
+    type: 'object',
+    additionalProperties: {
+      type: 'string'
+    }
+  }
+  const schema2 = {
+    type: 'object',
+    additionalProperties: {
+      type: 'string', minLength: 1
+    }
+  }
+
+  const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+  assert.deepStrictEqual(mergedSchema, {
+    type: 'object',
+    additionalProperties: {
+      type: 'string', minLength: 1
+    }
+  })
+})
+
+test('should merge two additionalProperties and properties schemas', () => {
+  const schema1 = {
+    type: 'object',
+    additionalProperties: {
+      type: 'string'
+    }
+  }
+  const schema2 = {
+    type: 'object',
+    properties: {
+      foo: { type: ['string', 'number'] }
+    },
+    additionalProperties: {
+      type: 'string', minLength: 1
+    }
+  }
+
+  const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+  assert.deepStrictEqual(mergedSchema, {
+    type: 'object',
+    properties: {
+      foo: { type: 'string' }
+    },
+    additionalProperties: {
+      type: 'string', minLength: 1
+    }
+  })
+})

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/merge-json-schemas/test/all-of.test.js

@@ -0,0 +1,43 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and allOf keyword', () => {
+  const schema1 = {}
+  const schema2 = {
+    allOf: [
+      { type: 'string', const: 'foo' }
+    ]
+  }
+
+  const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+  assert.deepStrictEqual(mergedSchema, {
+    allOf: [
+      { type: 'string', const: 'foo' }
+    ]
+  })
+})
+
+test('should merge schemas with allOfs schemas', () => {
+  const schema1 = {
+    allOf: [
+      { type: 'number', minimum: 0 }
+    ]
+  }
+  const schema2 = {
+    allOf: [
+      { type: 'string', const: 'foo' }
+    ]
+  }
+
+  const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+  assert.deepStrictEqual(mergedSchema, {
+    allOf: [
+      { type: 'number', minimum: 0 },
+      { type: 'string', const: 'foo' }
+    ]
+  })
+})

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/@fastify/merge-json-schemas/test/any-of.test.js

@@ -0,0 +1,81 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and anyOf keyword', () => {
+  const schema1 = {}
+  const schema2 = {
+    anyOf: [
+      { type: 'string', const: 'foo' }
+    ]
+  }
+
+  const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+  assert.deepStrictEqual(mergedSchema, {
+    anyOf: [
+      { type: 'string', const: 'foo' }
+    ]
+  })
+})
+
+test('should merge two schemas with anyOfs schemas', () => {
+  const schema1 = {
+    anyOf: [
+      { type: 'string', enum: ['foo1', 'foo2', 'foo3'] },
+      { type: 'string', enum: ['foo3', 'foo4', 'foo5'] }
+    ]
+  }
+  const schema2 = {
+    anyOf: [
+      { type: 'string', enum: ['foo2', 'foo3', 'foo4'] },
+      { type: 'string', enum: ['foo3', 'foo6', 'foo7'] }
+    ]
+  }
+
+  const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+  assert.deepStrictEqual(mergedSchema, {
+    anyOf: [
+      { type: 'string', enum: ['foo2', 'foo3'] },
+      { type: 'string', enum: ['foo3'] },
+      { type: 'string', enum: ['foo3', 'foo4'] },
+      { type: 'string', enum: ['foo3'] }
+    ]
+  })
+})
+
+test('should merge three schemas with anyOfs schemas', () => {
+  const schema1 = {
+    anyOf: [
+      { type: 'string', enum: ['foo1', 'foo2', 'foo3', 'foo4'] },
+      { type: 'string', enum: ['foo3', 'foo4', 'foo5', 'foo7'] }
+    ]
+  }
+  const schema2 = {
+    anyOf: [
+      { type: 'string', enum: ['foo2', 'foo3', 'foo4', 'foo5'] },
+      { type: 'string', enum: ['foo3', 'foo6', 'foo7', 'foo8'] }
+    ]
+  }
+
+  const schema3 = {
+    anyOf: [
+      { type: 'string', enum: ['foo1', 'foo3', 'foo5', 'foo7'] },
+      { type: 'string', enum: ['foo2', 'foo4', 'foo6', 'foo8'] }
+    ]
+  }
+
+  const mergedSchema = mergeSchemas([schema1, schema2, schema3], { defaultResolver })
+  assert.deepStrictEqual(mergedSchema, {
+    anyOf: [
+      { type: 'string', enum: ['foo3'] },
+      { type: 'string', enum: ['foo2', 'foo4'] },
+      { type: 'string', enum: ['foo3'] },
+      { type: 'string', enum: ['foo3', 'foo5'] },
+      { type: 'string', enum: ['foo4'] },
+      { type: 'string', enum: ['foo3', 'foo7'] }
+    ]
+  })
+})