Add files using upload-large-folder tool

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/@anthropic-ai/sdk/resources/beta/index.d.ts

@@ -0,0 +1,5 @@
+export { Beta, type AnthropicBeta, type BetaAPIError, type BetaAuthenticationError, type BetaBillingError, type BetaError, type BetaErrorResponse, type BetaGatewayTimeoutError, type BetaInvalidRequestError, type BetaNotFoundError, type BetaOverloadedError, type BetaPermissionError, type BetaRateLimitError, } from "./beta.js";
+export { Files, type DeletedFile, type FileMetadata, type FileListParams, type FileDeleteParams, type FileDownloadParams, type FileRetrieveMetadataParams, type FileUploadParams, type FileMetadataPage, } from "./files.js";
+export { Messages, type BetaBase64ImageSource, type BetaBase64PDFSource, type BetaCacheControlEphemeral, type BetaCacheCreation, type BetaCitationCharLocation, type BetaCitationCharLocationParam, type BetaCitationContentBlockLocation, type BetaCitationContentBlockLocationParam, type BetaCitationPageLocation, type BetaCitationPageLocationParam, type BetaCitationWebSearchResultLocationParam, type BetaCitationsConfigParam, type BetaCitationsDelta, type BetaCitationsWebSearchResultLocation, type BetaCodeExecutionOutputBlock, type BetaCodeExecutionOutputBlockParam, type BetaCodeExecutionResultBlock, type BetaCodeExecutionResultBlockParam, type BetaCodeExecutionTool20250522, type BetaCodeExecutionToolResultBlock, type BetaCodeExecutionToolResultBlockContent, type BetaCodeExecutionToolResultBlockParam, type BetaCodeExecutionToolResultBlockParamContent, type BetaCodeExecutionToolResultError, type BetaCodeExecutionToolResultErrorCode, type BetaCodeExecutionToolResultErrorParam, type BetaContainer, type BetaContainerUploadBlock, type BetaContainerUploadBlockParam, type BetaContentBlock, type BetaContentBlockParam, type BetaContentBlockSource, type BetaContentBlockSourceContent, type BetaFileDocumentSource, type BetaFileImageSource, type BetaImageBlockParam, type BetaInputJSONDelta, type BetaMCPToolResultBlock, type BetaMCPToolUseBlock, type BetaMCPToolUseBlockParam, type BetaMessage, type BetaMessageDeltaUsage, type BetaMessageParam, type BetaMessageTokensCount, type BetaMetadata, type BetaPlainTextSource, type BetaRawContentBlockDelta, type BetaRawContentBlockDeltaEvent, type BetaRawContentBlockStartEvent, type BetaRawContentBlockStopEvent, type BetaRawMessageDeltaEvent, type BetaRawMessageStartEvent, type BetaRawMessageStopEvent, type BetaRawMessageStreamEvent, type BetaRedactedThinkingBlock, type BetaRedactedThinkingBlockParam, type BetaRequestDocumentBlock, type BetaRequestMCPServerToolConfiguration, type BetaRequestMCPServerURLDefinition, type BetaRequestMCPToolResultBlockParam, type BetaServerToolUsage, type BetaServerToolUseBlock, type BetaServerToolUseBlockParam, type BetaSignatureDelta, type BetaStopReason, type BetaTextBlock, type BetaTextBlockParam, type BetaTextCitation, type BetaTextCitationParam, type BetaTextDelta, type BetaThinkingBlock, type BetaThinkingBlockParam, type BetaThinkingConfigDisabled, type BetaThinkingConfigEnabled, type BetaThinkingConfigParam, type BetaThinkingDelta, type BetaTool, type BetaToolBash20241022, type BetaToolBash20250124, type BetaToolChoice, type BetaToolChoiceAny, type BetaToolChoiceAuto, type BetaToolChoiceNone, type BetaToolChoiceTool, type BetaToolComputerUse20241022, type BetaToolComputerUse20250124, type BetaToolResultBlockParam, type BetaToolTextEditor20241022, type BetaToolTextEditor20250124, type BetaToolTextEditor20250429, type BetaToolUnion, type BetaToolUseBlock, type BetaToolUseBlockParam, type BetaURLImageSource, type BetaURLPDFSource, type BetaUsage, type BetaWebSearchResultBlock, type BetaWebSearchResultBlockParam, type BetaWebSearchTool20250305, type BetaWebSearchToolRequestError, type BetaWebSearchToolResultBlock, type BetaWebSearchToolResultBlockContent, type BetaWebSearchToolResultBlockParam, type BetaWebSearchToolResultBlockParamContent, type BetaWebSearchToolResultError, type BetaWebSearchToolResultErrorCode, type BetaBase64PDFBlock, type MessageCreateParams, type MessageCreateParamsNonStreaming, type MessageCreateParamsStreaming, type MessageCountTokensParams, } from "./messages/index.js";
+export { Models, type BetaModelInfo, type ModelRetrieveParams, type ModelListParams, type BetaModelInfosPage, } from "./models.js";
+//# sourceMappingURL=index.d.ts.map

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/@anthropic-ai/sdk/resources/beta/messages/batches.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"batches.js","sourceRoot":"","sources":["../../../src/resources/beta/messages/batches.ts"],"names":[],"mappings":";AAAA,sFAAsF;;;AAEtF,wDAAqD;AAIrD,4DAA8E;AAC9E,0DAAyD;AAEzD,+DAAgE;AAChE,6CAAgD;AAChD,0DAAoD;AAEpD,MAAa,OAAQ,SAAQ,sBAAW;IACtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,MAAM,CAAC,MAAyB,EAAE,OAAwB;QACxD,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,EAAE,GAAG,MAAM,CAAC;QAClC,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,gCAAgC,EAAE;YACzD,IAAI;YACJ,GAAG,OAAO;YACV,OAAO,EAAE,IAAA,sBAAY,EAAC;gBACpB,EAAE,gBAAgB,EAAE,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC,EAAE,4BAA4B,CAAC,CAAC,QAAQ,EAAE,EAAE;gBACjF,OAAO,EAAE,OAAO;aACjB,CAAC;SACH,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CACN,cAAsB,EACtB,SAAiD,EAAE,EACnD,OAAwB;QAExB,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,EAAE,CAAC;QAC/B,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAA,WAAI,EAAA,wBAAwB,cAAc,YAAY,EAAE;YAC9E,GAAG,OAAO;YACV,OAAO,EAAE,IAAA,sBAAY,EAAC;gBACpB,EAAE,gBAAgB,EAAE,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC,EAAE,4BAA4B,CAAC,CAAC,QAAQ,EAAE,EAAE;gBACjF,OAAO,EAAE,OAAO;aACjB,CAAC;SACH,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,IAAI,CACF,SAA6C,EAAE,EAC/C,OAAwB;QAExB,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,EAAE,GAAG,MAAM,IAAI,EAAE,CAAC;QACzC,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,gCAAgC,EAAE,CAAA,iBAAsB,CAAA,EAAE;YACvF,KAAK;YACL,GAAG,OAAO;YACV,OAAO,EAAE,IAAA,sBAAY,EAAC;gBACpB,EAAE,gBAAgB,EAAE,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC,EAAE,4BAA4B,CAAC,CAAC,QAAQ,EAAE,EAAE;gBACjF,OAAO,EAAE,OAAO;aACjB,CAAC;SACH,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CACJ,cAAsB,EACtB,SAA+C,EAAE,EACjD,OAAwB;QAExB,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,EAAE,CAAC;QAC/B,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAA,WAAI,EAAA,wBAAwB,cAAc,YAAY,EAAE;YACjF,GAAG,OAAO;YACV,OAAO,EAAE,IAAA,sBAAY,EAAC;gBACpB,EAAE,gBAAgB,EAAE,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC,EAAE,4BAA4B,CAAC,CAAC,QAAQ,EAAE,EAAE;gBACjF,OAAO,EAAE,OAAO;aACjB,CAAC;SACH,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,MAAM,CACJ,cAAsB,EACtB,SAA+C,EAAE,EACjD,OAAwB;QAExB,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,EAAE,CAAC;QAC/B,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAA,WAAI,EAAA,wBAAwB,cAAc,mBAAmB,EAAE;YACtF,GAAG,OAAO;YACV,OAAO,EAAE,IAAA,sBAAY,EAAC;gBACpB,EAAE,gBAAgB,EAAE,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC,EAAE,4BAA4B,CAAC,CAAC,QAAQ,EAAE,EAAE;gBACjF,OAAO,EAAE,OAAO;aACjB,CAAC;SACH,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,KAAK,CAAC,OAAO,CACX,cAAsB,EACtB,SAAyC,EAAE,EAC3C,OAAwB;QAExB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;QAClD,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;YACvB,MAAM,IAAI,sBAAc,CACtB,yDAAyD,KAAK,CAAC,iBAAiB,MAAM,KAAK,CAAC,EAAE,EAAE,CACjG,CAAC;QACJ,CAAC;QAED,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,EAAE,CAAC;QAC/B,OAAO,IAAI,CAAC,OAAO;aAChB,GAAG,CAAC,KAAK,CAAC,WAAW,EAAE;YACtB,GAAG,OAAO;YACV,OAAO,EAAE,IAAA,sBAAY,EAAC;gBACpB;oBACE,gBAAgB,EAAE,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC,EAAE,4BAA4B,CAAC,CAAC,QAAQ,EAAE;oBAC7E,MAAM,EAAE,oBAAoB;iBAC7B;gBACD,OAAO,EAAE,OAAO;aACjB,CAAC;YACF,MAAM,EAAE,IAAI;YACZ,gBAAgB,EAAE,IAAI;SACvB,CAAC;aACD,WAAW,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,oBAAY,CAAC,YAAY,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,UAAU,CAAC,CAEvF,CAAC;IACJ,CAAC;CACF;AA5ND,0BA4NC"}

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/@anthropic-ai/sdk/resources/beta/messages/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/resources/beta/messages/index.ts"],"names":[],"mappings":";AAAA,sFAAsF;;;AAEtF,wCAkBmB;AAjBjB,kGAAA,OAAO,OAAA;AAkBT,0CAkHoB;AAjHlB,oGAAA,QAAQ,OAAA"}

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/@anthropic-ai/sdk/src/_vendor/partial-json-parser/README.md

@@ -0,0 +1,3 @@
+# Partial JSON Parser
+
+Vendored from https://www.npmjs.com/package/partial-json-parser and updated to use TypeScript.

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/@anthropic-ai/sdk/src/internal/builtin-types.ts

@@ -0,0 +1,93 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export type Fetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+
+/**
+ * An alias to the builtin `RequestInit` type so we can
+ * easily alias it in import statements if there are name clashes.
+ *
+ * https://developer.mozilla.org/docs/Web/API/RequestInit
+ */
+type _RequestInit = RequestInit;
+
+/**
+ * An alias to the builtin `Response` type so we can
+ * easily alias it in import statements if there are name clashes.
+ *
+ * https://developer.mozilla.org/docs/Web/API/Response
+ */
+type _Response = Response;
+
+/**
+ * The type for the first argument to `fetch`.
+ *
+ * https://developer.mozilla.org/docs/Web/API/Window/fetch#resource
+ */
+type _RequestInfo = Request | URL | string;
+
+/**
+ * The type for constructing `RequestInit` Headers.
+ *
+ * https://developer.mozilla.org/docs/Web/API/RequestInit#setting_headers
+ */
+type _HeadersInit = RequestInit['headers'];
+
+/**
+ * The type for constructing `RequestInit` body.
+ *
+ * https://developer.mozilla.org/docs/Web/API/RequestInit#body
+ */
+type _BodyInit = RequestInit['body'];
+
+/**
+ * An alias to the builtin `Array<T>` type so we can
+ * easily alias it in import statements if there are name clashes.
+ */
+type _Array<T> = Array<T>;
+
+/**
+ * An alias to the builtin `Record<K, T>` type so we can
+ * easily alias it in import statements if there are name clashes.
+ */
+type _Record<K extends keyof any, T> = Record<K, T>;
+
+export type {
+  _Array as Array,
+  _BodyInit as BodyInit,
+  _HeadersInit as HeadersInit,
+  _Record as Record,
+  _RequestInfo as RequestInfo,
+  _RequestInit as RequestInit,
+  _Response as Response,
+};
+
+/**
+ * A copy of the builtin `EndingType` type as it isn't fully supported in certain
+ * environments and attempting to reference the global version will error.
+ *
+ * https://github.com/microsoft/TypeScript/blob/49ad1a3917a0ea57f5ff248159256e12bb1cb705/src/lib/dom.generated.d.ts#L27941
+ */
+type EndingType = 'native' | 'transparent';
+
+/**
+ * A copy of the builtin `BlobPropertyBag` type as it isn't fully supported in certain
+ * environments and attempting to reference the global version will error.
+ *
+ * https://github.com/microsoft/TypeScript/blob/49ad1a3917a0ea57f5ff248159256e12bb1cb705/src/lib/dom.generated.d.ts#L154
+ * https://developer.mozilla.org/en-US/docs/Web/API/Blob/Blob#options
+ */
+export interface BlobPropertyBag {
+  endings?: EndingType;
+  type?: string;
+}
+
+/**
+ * A copy of the builtin `FilePropertyBag` type as it isn't fully supported in certain
+ * environments and attempting to reference the global version will error.
+ *
+ * https://github.com/microsoft/TypeScript/blob/49ad1a3917a0ea57f5ff248159256e12bb1cb705/src/lib/dom.generated.d.ts#L503
+ * https://developer.mozilla.org/en-US/docs/Web/API/File/File#options
+ */
+export interface FilePropertyBag extends BlobPropertyBag {
+  lastModified?: number;
+}

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/@anthropic-ai/sdk/src/internal/decoders/jsonl.ts

@@ -0,0 +1,48 @@
+import { AnthropicError } from '../../core/error';
+import { ReadableStreamToAsyncIterable } from '../shims';
+import { LineDecoder, type Bytes } from './line';
+
+export class JSONLDecoder<T> {
+  controller: AbortController;
+
+  constructor(
+    private iterator: AsyncIterableIterator<Bytes>,
+    controller: AbortController,
+  ) {
+    this.controller = controller;
+  }
+
+  private async *decoder(): AsyncIterator<T, any, undefined> {
+    const lineDecoder = new LineDecoder();
+    for await (const chunk of this.iterator) {
+      for (const line of lineDecoder.decode(chunk)) {
+        yield JSON.parse(line);
+      }
+    }
+
+    for (const line of lineDecoder.flush()) {
+      yield JSON.parse(line);
+    }
+  }
+
+  [Symbol.asyncIterator](): AsyncIterator<T> {
+    return this.decoder();
+  }
+
+  static fromResponse<T>(response: Response, controller: AbortController): JSONLDecoder<T> {
+    if (!response.body) {
+      controller.abort();
+      if (
+        typeof (globalThis as any).navigator !== 'undefined' &&
+        (globalThis as any).navigator.product === 'ReactNative'
+      ) {
+        throw new AnthropicError(
+          `The default react-native fetch implementation does not support streaming. Please use expo/fetch: https://docs.expo.dev/versions/latest/sdk/expo/#expofetch-api`,
+        );
+      }
+      throw new AnthropicError(`Attempted to iterate over a response with no body`);
+    }
+
+    return new JSONLDecoder(ReadableStreamToAsyncIterable<Bytes>(response.body), controller);
+  }
+}

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/@anthropic-ai/sdk/src/internal/types.ts

@@ -0,0 +1,92 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export type PromiseOrValue<T> = T | Promise<T>;
+export type HTTPMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
+
+export type KeysEnum<T> = { [P in keyof Required<T>]: true };
+
+export type FinalizedRequestInit = RequestInit & { headers: Headers };
+
+type NotAny<T> = [unknown] extends [T] ? never : T;
+
+/**
+ * Some environments overload the global fetch function, and Parameters<T> only gets the last signature.
+ */
+type OverloadedParameters<T> =
+  T extends (
+    {
+      (...args: infer A): unknown;
+      (...args: infer B): unknown;
+      (...args: infer C): unknown;
+      (...args: infer D): unknown;
+    }
+  ) ?
+    A | B | C | D
+  : T extends (
+    {
+      (...args: infer A): unknown;
+      (...args: infer B): unknown;
+      (...args: infer C): unknown;
+    }
+  ) ?
+    A | B | C
+  : T extends (
+    {
+      (...args: infer A): unknown;
+      (...args: infer B): unknown;
+    }
+  ) ?
+    A | B
+  : T extends (...args: infer A) => unknown ? A
+  : never;
+
+/* eslint-disable */
+/**
+ * These imports attempt to get types from a parent package's dependencies.
+ * Unresolved bare specifiers can trigger [automatic type acquisition][1] in some projects, which
+ * would cause typescript to show types not present at runtime. To avoid this, we import
+ * directly from parent node_modules folders.
+ *
+ * We need to check multiple levels because we don't know what directory structure we'll be in.
+ * For example, pnpm generates directories like this:
+ * ```
+ * node_modules
+ * ├── .pnpm
+ * │   └── pkg@1.0.0
+ * │       └── node_modules
+ * │           └── pkg
+ * │               └── internal
+ * │                   └── types.d.ts
+ * ├── pkg -> .pnpm/pkg@1.0.0/node_modules/pkg
+ * └── undici
+ * ```
+ *
+ * [1]: https://www.typescriptlang.org/tsconfig/#typeAcquisition
+ */
+/** @ts-ignore For users with \@types/node */
+type UndiciTypesRequestInit = NotAny<import('../node_modules/undici-types').RequestInit> | NotAny<import('../../node_modules/undici-types').RequestInit> | NotAny<import('../../../node_modules/undici-types').RequestInit> | NotAny<import('../../../../node_modules/undici-types').RequestInit> | NotAny<import('../../../../../node_modules/undici-types').RequestInit> | NotAny<import('../../../../../../node_modules/undici-types').RequestInit> | NotAny<import('../../../../../../../node_modules/undici-types').RequestInit> | NotAny<import('../../../../../../../../node_modules/undici-types').RequestInit> | NotAny<import('../../../../../../../../../node_modules/undici-types').RequestInit> | NotAny<import('../../../../../../../../../../node_modules/undici-types').RequestInit>;
+/** @ts-ignore For users with undici */
+type UndiciRequestInit = NotAny<import('../node_modules/undici').RequestInit> | NotAny<import('../../node_modules/undici').RequestInit> | NotAny<import('../../../node_modules/undici').RequestInit> | NotAny<import('../../../../node_modules/undici').RequestInit> | NotAny<import('../../../../../node_modules/undici').RequestInit> | NotAny<import('../../../../../../node_modules/undici').RequestInit> | NotAny<import('../../../../../../../node_modules/undici').RequestInit> | NotAny<import('../../../../../../../../node_modules/undici').RequestInit> | NotAny<import('../../../../../../../../../node_modules/undici').RequestInit> | NotAny<import('../../../../../../../../../../node_modules/undici').RequestInit>;
+/** @ts-ignore For users with \@types/bun */
+type BunRequestInit = globalThis.FetchRequestInit;
+/** @ts-ignore For users with node-fetch */
+type NodeFetchRequestInit = NotAny<import('../node_modules/node-fetch').RequestInit> | NotAny<import('../../node_modules/node-fetch').RequestInit> | NotAny<import('../../../node_modules/node-fetch').RequestInit> | NotAny<import('../../../../node_modules/node-fetch').RequestInit> | NotAny<import('../../../../../node_modules/node-fetch').RequestInit> | NotAny<import('../../../../../../node_modules/node-fetch').RequestInit> | NotAny<import('../../../../../../../node_modules/node-fetch').RequestInit> | NotAny<import('../../../../../../../../node_modules/node-fetch').RequestInit> | NotAny<import('../../../../../../../../../node_modules/node-fetch').RequestInit> | NotAny<import('../../../../../../../../../../node_modules/node-fetch').RequestInit>;
+/** @ts-ignore For users who use Deno */
+type FetchRequestInit = NonNullable<OverloadedParameters<typeof fetch>[1]>;
+/* eslint-enable */
+
+type RequestInits =
+  | NotAny<UndiciTypesRequestInit>
+  | NotAny<UndiciRequestInit>
+  | NotAny<BunRequestInit>
+  | NotAny<NodeFetchRequestInit>
+  | NotAny<RequestInit>
+  | NotAny<FetchRequestInit>;
+
+/**
+ * This type contains `RequestInit` options that may be available on the current runtime,
+ * including per-platform extensions like `dispatcher`, `agent`, `client`, etc.
+ */
+export type MergedRequestInit = RequestInits &
+  /** We don't include these in the types as they'll be overridden for every request. */
+  Partial<Record<'body' | 'headers' | 'method' | 'signal', never>>;

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/@anthropic-ai/sdk/src/internal/utils.ts

@@ -0,0 +1,8 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export * from './utils/values';
+export * from './utils/base64';
+export * from './utils/env';
+export * from './utils/log';
+export * from './utils/uuid';
+export * from './utils/sleep';

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/@anthropic-ai/sdk/src/internal/utils/bytes.ts

@@ -0,0 +1,32 @@
+export function concatBytes(buffers: Uint8Array[]): Uint8Array {
+  let length = 0;
+  for (const buffer of buffers) {
+    length += buffer.length;
+  }
+  const output = new Uint8Array(length);
+  let index = 0;
+  for (const buffer of buffers) {
+    output.set(buffer, index);
+    index += buffer.length;
+  }
+
+  return output;
+}
+
+let encodeUTF8_: (str: string) => Uint8Array;
+export function encodeUTF8(str: string) {
+  let encoder;
+  return (
+    encodeUTF8_ ??
+    ((encoder = new (globalThis as any).TextEncoder()), (encodeUTF8_ = encoder.encode.bind(encoder)))
+  )(str);
+}
+
+let decodeUTF8_: (bytes: Uint8Array) => string;
+export function decodeUTF8(bytes: Uint8Array) {
+  let decoder;
+  return (
+    decodeUTF8_ ??
+    ((decoder = new (globalThis as any).TextDecoder()), (decodeUTF8_ = decoder.decode.bind(decoder)))
+  )(bytes);
+}

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/@anthropic-ai/sdk/src/internal/utils/path.ts

@@ -0,0 +1,65 @@
+import { AnthropicError } from '../../core/error';
+
+/**
+ * Percent-encode everything that isn't safe to have in a path without encoding safe chars.
+ *
+ * Taken from https://datatracker.ietf.org/doc/html/rfc3986#section-3.3:
+ * > unreserved  = ALPHA / DIGIT / "-" / "." / "_" / "~"
+ * > sub-delims  = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+ * > pchar       = unreserved / pct-encoded / sub-delims / ":" / "@"
+ */
+export function encodeURIPath(str: string) {
+  return str.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent);
+}
+
+export const createPathTagFunction = (pathEncoder = encodeURIPath) =>
+  function path(statics: readonly string[], ...params: readonly unknown[]): string {
+    // If there are no params, no processing is needed.
+    if (statics.length === 1) return statics[0]!;
+
+    let postPath = false;
+    const path = statics.reduce((previousValue, currentValue, index) => {
+      if (/[?#]/.test(currentValue)) {
+        postPath = true;
+      }
+      return (
+        previousValue +
+        currentValue +
+        (index === params.length ? '' : (postPath ? encodeURIComponent : pathEncoder)(String(params[index])))
+      );
+    }, '');
+
+    const pathOnly = path.split(/[?#]/, 1)[0]!;
+    const invalidSegments = [];
+    const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;
+    let match;
+
+    // Find all invalid segments
+    while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) {
+      invalidSegments.push({
+        start: match.index,
+        length: match[0].length,
+      });
+    }
+
+    if (invalidSegments.length > 0) {
+      let lastEnd = 0;
+      const underline = invalidSegments.reduce((acc, segment) => {
+        const spaces = ' '.repeat(segment.start - lastEnd);
+        const arrows = '^'.repeat(segment.length);
+        lastEnd = segment.start + segment.length;
+        return acc + spaces + arrows;
+      }, '');
+
+      throw new AnthropicError(
+        `Path parameters result in path with invalid segments:\n${path}\n${underline}`,
+      );
+    }
+
+    return path;
+  };
+
+/**
+ * URI-encodes path params and ensures no unsafe /./ or /../ path segments are introduced.
+ */
+export const path = createPathTagFunction(encodeURIPath);

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/@anthropic-ai/sdk/src/resources/beta/messages/batches.ts

@@ -0,0 +1,502 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../core/resource';
+import * as BetaAPI from '../beta';
+import { APIPromise } from '../../../core/api-promise';
+import * as BetaMessagesAPI from './messages';
+import { Page, type PageParams, PagePromise } from '../../../core/pagination';
+import { buildHeaders } from '../../../internal/headers';
+import { RequestOptions } from '../../../internal/request-options';
+import { JSONLDecoder } from '../../../internal/decoders/jsonl';
+import { AnthropicError } from '../../../error';
+import { path } from '../../../internal/utils/path';
+
+export class Batches extends APIResource {
+  /**
+   * Send a batch of Message creation requests.
+   *
+   * The Message Batches API can be used to process multiple Messages API requests at
+   * once. Once a Message Batch is created, it begins processing immediately. Batches
+   * can take up to 24 hours to complete.
+   *
+   * Learn more about the Message Batches API in our
+   * [user guide](/en/docs/build-with-claude/batch-processing)
+   *
+   * @example
+   * ```ts
+   * const betaMessageBatch =
+   *   await client.beta.messages.batches.create({
+   *     requests: [
+   *       {
+   *         custom_id: 'my-custom-id-1',
+   *         params: {
+   *           max_tokens: 1024,
+   *           messages: [
+   *             { content: 'Hello, world', role: 'user' },
+   *           ],
+   *           model: 'claude-3-7-sonnet-20250219',
+   *         },
+   *       },
+   *     ],
+   *   });
+   * ```
+   */
+  create(params: BatchCreateParams, options?: RequestOptions): APIPromise<BetaMessageBatch> {
+    const { betas, ...body } = params;
+    return this._client.post('/v1/messages/batches?beta=true', {
+      body,
+      ...options,
+      headers: buildHeaders([
+        { 'anthropic-beta': [...(betas ?? []), 'message-batches-2024-09-24'].toString() },
+        options?.headers,
+      ]),
+    });
+  }
+
+  /**
+   * This endpoint is idempotent and can be used to poll for Message Batch
+   * completion. To access the results of a Message Batch, make a request to the
+   * `results_url` field in the response.
+   *
+   * Learn more about the Message Batches API in our
+   * [user guide](/en/docs/build-with-claude/batch-processing)
+   *
+   * @example
+   * ```ts
+   * const betaMessageBatch =
+   *   await client.beta.messages.batches.retrieve(
+   *     'message_batch_id',
+   *   );
+   * ```
+   */
+  retrieve(
+    messageBatchID: string,
+    params: BatchRetrieveParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<BetaMessageBatch> {
+    const { betas } = params ?? {};
+    return this._client.get(path`/v1/messages/batches/${messageBatchID}?beta=true`, {
+      ...options,
+      headers: buildHeaders([
+        { 'anthropic-beta': [...(betas ?? []), 'message-batches-2024-09-24'].toString() },
+        options?.headers,
+      ]),
+    });
+  }
+
+  /**
+   * List all Message Batches within a Workspace. Most recently created batches are
+   * returned first.
+   *
+   * Learn more about the Message Batches API in our
+   * [user guide](/en/docs/build-with-claude/batch-processing)
+   *
+   * @example
+   * ```ts
+   * // Automatically fetches more pages as needed.
+   * for await (const betaMessageBatch of client.beta.messages.batches.list()) {
+   *   // ...
+   * }
+   * ```
+   */
+  list(
+    params: BatchListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): PagePromise<BetaMessageBatchesPage, BetaMessageBatch> {
+    const { betas, ...query } = params ?? {};
+    return this._client.getAPIList('/v1/messages/batches?beta=true', Page<BetaMessageBatch>, {
+      query,
+      ...options,
+      headers: buildHeaders([
+        { 'anthropic-beta': [...(betas ?? []), 'message-batches-2024-09-24'].toString() },
+        options?.headers,
+      ]),
+    });
+  }
+
+  /**
+   * Delete a Message Batch.
+   *
+   * Message Batches can only be deleted once they've finished processing. If you'd
+   * like to delete an in-progress batch, you must first cancel it.
+   *
+   * Learn more about the Message Batches API in our
+   * [user guide](/en/docs/build-with-claude/batch-processing)
+   *
+   * @example
+   * ```ts
+   * const betaDeletedMessageBatch =
+   *   await client.beta.messages.batches.delete(
+   *     'message_batch_id',
+   *   );
+   * ```
+   */
+  delete(
+    messageBatchID: string,
+    params: BatchDeleteParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<BetaDeletedMessageBatch> {
+    const { betas } = params ?? {};
+    return this._client.delete(path`/v1/messages/batches/${messageBatchID}?beta=true`, {
+      ...options,
+      headers: buildHeaders([
+        { 'anthropic-beta': [...(betas ?? []), 'message-batches-2024-09-24'].toString() },
+        options?.headers,
+      ]),
+    });
+  }
+
+  /**
+   * Batches may be canceled any time before processing ends. Once cancellation is
+   * initiated, the batch enters a `canceling` state, at which time the system may
+   * complete any in-progress, non-interruptible requests before finalizing
+   * cancellation.
+   *
+   * The number of canceled requests is specified in `request_counts`. To determine
+   * which requests were canceled, check the individual results within the batch.
+   * Note that cancellation may not result in any canceled requests if they were
+   * non-interruptible.
+   *
+   * Learn more about the Message Batches API in our
+   * [user guide](/en/docs/build-with-claude/batch-processing)
+   *
+   * @example
+   * ```ts
+   * const betaMessageBatch =
+   *   await client.beta.messages.batches.cancel(
+   *     'message_batch_id',
+   *   );
+   * ```
+   */
+  cancel(
+    messageBatchID: string,
+    params: BatchCancelParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<BetaMessageBatch> {
+    const { betas } = params ?? {};
+    return this._client.post(path`/v1/messages/batches/${messageBatchID}/cancel?beta=true`, {
+      ...options,
+      headers: buildHeaders([
+        { 'anthropic-beta': [...(betas ?? []), 'message-batches-2024-09-24'].toString() },
+        options?.headers,
+      ]),
+    });
+  }
+
+  /**
+   * Streams the results of a Message Batch as a `.jsonl` file.
+   *
+   * Each line in the file is a JSON object containing the result of a single request
+   * in the Message Batch. Results are not guaranteed to be in the same order as
+   * requests. Use the `custom_id` field to match results to requests.
+   *
+   * Learn more about the Message Batches API in our
+   * [user guide](/en/docs/build-with-claude/batch-processing)
+   *
+   * @example
+   * ```ts
+   * const betaMessageBatchIndividualResponse =
+   *   await client.beta.messages.batches.results(
+   *     'message_batch_id',
+   *   );
+   * ```
+   */
+  async results(
+    messageBatchID: string,
+    params: BatchResultsParams | undefined = {},
+    options?: RequestOptions,
+  ): Promise<JSONLDecoder<BetaMessageBatchIndividualResponse>> {
+    const batch = await this.retrieve(messageBatchID);
+    if (!batch.results_url) {
+      throw new AnthropicError(
+        `No batch \`results_url\`; Has it finished processing? ${batch.processing_status} - ${batch.id}`,
+      );
+    }
+
+    const { betas } = params ?? {};
+    return this._client
+      .get(batch.results_url, {
+        ...options,
+        headers: buildHeaders([
+          {
+            'anthropic-beta': [...(betas ?? []), 'message-batches-2024-09-24'].toString(),
+            Accept: 'application/binary',
+          },
+          options?.headers,
+        ]),
+        stream: true,
+        __binaryResponse: true,
+      })
+      ._thenUnwrap((_, props) => JSONLDecoder.fromResponse(props.response, props.controller)) as APIPromise<
+      JSONLDecoder<BetaMessageBatchIndividualResponse>
+    >;
+  }
+}
+
+export type BetaMessageBatchesPage = Page<BetaMessageBatch>;
+
+export interface BetaDeletedMessageBatch {
+  /**
+   * ID of the Message Batch.
+   */
+  id: string;
+
+  /**
+   * Deleted object type.
+   *
+   * For Message Batches, this is always `"message_batch_deleted"`.
+   */
+  type: 'message_batch_deleted';
+}
+
+export interface BetaMessageBatch {
+  /**
+   * Unique object identifier.
+   *
+   * The format and length of IDs may change over time.
+   */
+  id: string;
+
+  /**
+   * RFC 3339 datetime string representing the time at which the Message Batch was
+   * archived and its results became unavailable.
+   */
+  archived_at: string | null;
+
+  /**
+   * RFC 3339 datetime string representing the time at which cancellation was
+   * initiated for the Message Batch. Specified only if cancellation was initiated.
+   */
+  cancel_initiated_at: string | null;
+
+  /**
+   * RFC 3339 datetime string representing the time at which the Message Batch was
+   * created.
+   */
+  created_at: string;
+
+  /**
+   * RFC 3339 datetime string representing the time at which processing for the
+   * Message Batch ended. Specified only once processing ends.
+   *
+   * Processing ends when every request in a Message Batch has either succeeded,
+   * errored, canceled, or expired.
+   */
+  ended_at: string | null;
+
+  /**
+   * RFC 3339 datetime string representing the time at which the Message Batch will
+   * expire and end processing, which is 24 hours after creation.
+   */
+  expires_at: string;
+
+  /**
+   * Processing status of the Message Batch.
+   */
+  processing_status: 'in_progress' | 'canceling' | 'ended';
+
+  /**
+   * Tallies requests within the Message Batch, categorized by their status.
+   *
+   * Requests start as `processing` and move to one of the other statuses only once
+   * processing of the entire batch ends. The sum of all values always matches the
+   * total number of requests in the batch.
+   */
+  request_counts: BetaMessageBatchRequestCounts;
+
+  /**
+   * URL to a `.jsonl` file containing the results of the Message Batch requests.
+   * Specified only once processing ends.
+   *
+   * Results in the file are not guaranteed to be in the same order as requests. Use
+   * the `custom_id` field to match results to requests.
+   */
+  results_url: string | null;
+
+  /**
+   * Object type.
+   *
+   * For Message Batches, this is always `"message_batch"`.
+   */
+  type: 'message_batch';
+}
+
+export interface BetaMessageBatchCanceledResult {
+  type: 'canceled';
+}
+
+export interface BetaMessageBatchErroredResult {
+  error: BetaAPI.BetaErrorResponse;
+
+  type: 'errored';
+}
+
+export interface BetaMessageBatchExpiredResult {
+  type: 'expired';
+}
+
+/**
+ * This is a single line in the response `.jsonl` file and does not represent the
+ * response as a whole.
+ */
+export interface BetaMessageBatchIndividualResponse {
+  /**
+   * Developer-provided ID created for each request in a Message Batch. Useful for
+   * matching results to requests, as results may be given out of request order.
+   *
+   * Must be unique for each request within the Message Batch.
+   */
+  custom_id: string;
+
+  /**
+   * Processing result for this request.
+   *
+   * Contains a Message output if processing was successful, an error response if
+   * processing failed, or the reason why processing was not attempted, such as
+   * cancellation or expiration.
+   */
+  result: BetaMessageBatchResult;
+}
+
+export interface BetaMessageBatchRequestCounts {
+  /**
+   * Number of requests in the Message Batch that have been canceled.
+   *
+   * This is zero until processing of the entire Message Batch has ended.
+   */
+  canceled: number;
+
+  /**
+   * Number of requests in the Message Batch that encountered an error.
+   *
+   * This is zero until processing of the entire Message Batch has ended.
+   */
+  errored: number;
+
+  /**
+   * Number of requests in the Message Batch that have expired.
+   *
+   * This is zero until processing of the entire Message Batch has ended.
+   */
+  expired: number;
+
+  /**
+   * Number of requests in the Message Batch that are processing.
+   */
+  processing: number;
+
+  /**
+   * Number of requests in the Message Batch that have completed successfully.
+   *
+   * This is zero until processing of the entire Message Batch has ended.
+   */
+  succeeded: number;
+}
+
+/**
+ * Processing result for this request.
+ *
+ * Contains a Message output if processing was successful, an error response if
+ * processing failed, or the reason why processing was not attempted, such as
+ * cancellation or expiration.
+ */
+export type BetaMessageBatchResult =
+  | BetaMessageBatchSucceededResult
+  | BetaMessageBatchErroredResult
+  | BetaMessageBatchCanceledResult
+  | BetaMessageBatchExpiredResult;
+
+export interface BetaMessageBatchSucceededResult {
+  message: BetaMessagesAPI.BetaMessage;
+
+  type: 'succeeded';
+}
+
+export interface BatchCreateParams {
+  /**
+   * Body param: List of requests for prompt completion. Each is an individual
+   * request to create a Message.
+   */
+  requests: Array<BatchCreateParams.Request>;
+
+  /**
+   * Header param: Optional header to specify the beta version(s) you want to use.
+   */
+  betas?: Array<BetaAPI.AnthropicBeta>;
+}
+
+export namespace BatchCreateParams {
+  export interface Request {
+    /**
+     * Developer-provided ID created for each request in a Message Batch. Useful for
+     * matching results to requests, as results may be given out of request order.
+     *
+     * Must be unique for each request within the Message Batch.
+     */
+    custom_id: string;
+
+    /**
+     * Messages API creation parameters for the individual request.
+     *
+     * See the [Messages API reference](/en/api/messages) for full documentation on
+     * available parameters.
+     */
+    params: Omit<BetaMessagesAPI.MessageCreateParamsNonStreaming, 'betas'>;
+  }
+}
+
+export interface BatchRetrieveParams {
+  /**
+   * Optional header to specify the beta version(s) you want to use.
+   */
+  betas?: Array<BetaAPI.AnthropicBeta>;
+}
+
+export interface BatchListParams extends PageParams {
+  /**
+   * Header param: Optional header to specify the beta version(s) you want to use.
+   */
+  betas?: Array<BetaAPI.AnthropicBeta>;
+}
+
+export interface BatchDeleteParams {
+  /**
+   * Optional header to specify the beta version(s) you want to use.
+   */
+  betas?: Array<BetaAPI.AnthropicBeta>;
+}
+
+export interface BatchCancelParams {
+  /**
+   * Optional header to specify the beta version(s) you want to use.
+   */
+  betas?: Array<BetaAPI.AnthropicBeta>;
+}
+
+export interface BatchResultsParams {
+  /**
+   * Optional header to specify the beta version(s) you want to use.
+   */
+  betas?: Array<BetaAPI.AnthropicBeta>;
+}
+
+export declare namespace Batches {
+  export {
+    type BetaDeletedMessageBatch as BetaDeletedMessageBatch,
+    type BetaMessageBatch as BetaMessageBatch,
+    type BetaMessageBatchCanceledResult as BetaMessageBatchCanceledResult,
+    type BetaMessageBatchErroredResult as BetaMessageBatchErroredResult,
+    type BetaMessageBatchExpiredResult as BetaMessageBatchExpiredResult,
+    type BetaMessageBatchIndividualResponse as BetaMessageBatchIndividualResponse,
+    type BetaMessageBatchRequestCounts as BetaMessageBatchRequestCounts,
+    type BetaMessageBatchResult as BetaMessageBatchResult,
+    type BetaMessageBatchSucceededResult as BetaMessageBatchSucceededResult,
+    type BetaMessageBatchesPage as BetaMessageBatchesPage,
+    type BatchCreateParams as BatchCreateParams,
+    type BatchRetrieveParams as BatchRetrieveParams,
+    type BatchListParams as BatchListParams,
+    type BatchDeleteParams as BatchDeleteParams,
+    type BatchCancelParams as BatchCancelParams,
+    type BatchResultsParams as BatchResultsParams,
+  };
+}

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/@anthropic-ai/sdk/src/resources/messages.ts

@@ -0,0 +1,3 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export * from './messages/index';

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/@anthropic-ai/sdk/src/resources/messages/batches.ts

@@ -0,0 +1,396 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as Shared from '../shared';
+import * as MessagesAPI from './messages';
+import { APIPromise } from '../../core/api-promise';
+import { Page, type PageParams, PagePromise } from '../../core/pagination';
+import { buildHeaders } from '../../internal/headers';
+import { RequestOptions } from '../../internal/request-options';
+import { JSONLDecoder } from '../../internal/decoders/jsonl';
+import { AnthropicError } from '../../error';
+import { path } from '../../internal/utils/path';
+
+export class Batches extends APIResource {
+  /**
+   * Send a batch of Message creation requests.
+   *
+   * The Message Batches API can be used to process multiple Messages API requests at
+   * once. Once a Message Batch is created, it begins processing immediately. Batches
+   * can take up to 24 hours to complete.
+   *
+   * Learn more about the Message Batches API in our
+   * [user guide](/en/docs/build-with-claude/batch-processing)
+   *
+   * @example
+   * ```ts
+   * const messageBatch = await client.messages.batches.create({
+   *   requests: [
+   *     {
+   *       custom_id: 'my-custom-id-1',
+   *       params: {
+   *         max_tokens: 1024,
+   *         messages: [
+   *           { content: 'Hello, world', role: 'user' },
+   *         ],
+   *         model: 'claude-3-7-sonnet-20250219',
+   *       },
+   *     },
+   *   ],
+   * });
+   * ```
+   */
+  create(body: BatchCreateParams, options?: RequestOptions): APIPromise<MessageBatch> {
+    return this._client.post('/v1/messages/batches', { body, ...options });
+  }
+
+  /**
+   * This endpoint is idempotent and can be used to poll for Message Batch
+   * completion. To access the results of a Message Batch, make a request to the
+   * `results_url` field in the response.
+   *
+   * Learn more about the Message Batches API in our
+   * [user guide](/en/docs/build-with-claude/batch-processing)
+   *
+   * @example
+   * ```ts
+   * const messageBatch = await client.messages.batches.retrieve(
+   *   'message_batch_id',
+   * );
+   * ```
+   */
+  retrieve(messageBatchID: string, options?: RequestOptions): APIPromise<MessageBatch> {
+    return this._client.get(path`/v1/messages/batches/${messageBatchID}`, options);
+  }
+
+  /**
+   * List all Message Batches within a Workspace. Most recently created batches are
+   * returned first.
+   *
+   * Learn more about the Message Batches API in our
+   * [user guide](/en/docs/build-with-claude/batch-processing)
+   *
+   * @example
+   * ```ts
+   * // Automatically fetches more pages as needed.
+   * for await (const messageBatch of client.messages.batches.list()) {
+   *   // ...
+   * }
+   * ```
+   */
+  list(
+    query: BatchListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): PagePromise<MessageBatchesPage, MessageBatch> {
+    return this._client.getAPIList('/v1/messages/batches', Page<MessageBatch>, { query, ...options });
+  }
+
+  /**
+   * Delete a Message Batch.
+   *
+   * Message Batches can only be deleted once they've finished processing. If you'd
+   * like to delete an in-progress batch, you must first cancel it.
+   *
+   * Learn more about the Message Batches API in our
+   * [user guide](/en/docs/build-with-claude/batch-processing)
+   *
+   * @example
+   * ```ts
+   * const deletedMessageBatch =
+   *   await client.messages.batches.delete('message_batch_id');
+   * ```
+   */
+  delete(messageBatchID: string, options?: RequestOptions): APIPromise<DeletedMessageBatch> {
+    return this._client.delete(path`/v1/messages/batches/${messageBatchID}`, options);
+  }
+
+  /**
+   * Batches may be canceled any time before processing ends. Once cancellation is
+   * initiated, the batch enters a `canceling` state, at which time the system may
+   * complete any in-progress, non-interruptible requests before finalizing
+   * cancellation.
+   *
+   * The number of canceled requests is specified in `request_counts`. To determine
+   * which requests were canceled, check the individual results within the batch.
+   * Note that cancellation may not result in any canceled requests if they were
+   * non-interruptible.
+   *
+   * Learn more about the Message Batches API in our
+   * [user guide](/en/docs/build-with-claude/batch-processing)
+   *
+   * @example
+   * ```ts
+   * const messageBatch = await client.messages.batches.cancel(
+   *   'message_batch_id',
+   * );
+   * ```
+   */
+  cancel(messageBatchID: string, options?: RequestOptions): APIPromise<MessageBatch> {
+    return this._client.post(path`/v1/messages/batches/${messageBatchID}/cancel`, options);
+  }
+
+  /**
+   * Streams the results of a Message Batch as a `.jsonl` file.
+   *
+   * Each line in the file is a JSON object containing the result of a single request
+   * in the Message Batch. Results are not guaranteed to be in the same order as
+   * requests. Use the `custom_id` field to match results to requests.
+   *
+   * Learn more about the Message Batches API in our
+   * [user guide](/en/docs/build-with-claude/batch-processing)
+   *
+   * @example
+   * ```ts
+   * const messageBatchIndividualResponse =
+   *   await client.messages.batches.results('message_batch_id');
+   * ```
+   */
+  async results(
+    messageBatchID: string,
+    options?: RequestOptions,
+  ): Promise<JSONLDecoder<MessageBatchIndividualResponse>> {
+    const batch = await this.retrieve(messageBatchID);
+    if (!batch.results_url) {
+      throw new AnthropicError(
+        `No batch \`results_url\`; Has it finished processing? ${batch.processing_status} - ${batch.id}`,
+      );
+    }
+
+    return this._client
+      .get(batch.results_url, {
+        ...options,
+        headers: buildHeaders([{ Accept: 'application/binary' }, options?.headers]),
+        stream: true,
+        __binaryResponse: true,
+      })
+      ._thenUnwrap((_, props) => JSONLDecoder.fromResponse(props.response, props.controller)) as APIPromise<
+      JSONLDecoder<MessageBatchIndividualResponse>
+    >;
+  }
+}
+
+export type MessageBatchesPage = Page<MessageBatch>;
+
+export interface DeletedMessageBatch {
+  /**
+   * ID of the Message Batch.
+   */
+  id: string;
+
+  /**
+   * Deleted object type.
+   *
+   * For Message Batches, this is always `"message_batch_deleted"`.
+   */
+  type: 'message_batch_deleted';
+}
+
+export interface MessageBatch {
+  /**
+   * Unique object identifier.
+   *
+   * The format and length of IDs may change over time.
+   */
+  id: string;
+
+  /**
+   * RFC 3339 datetime string representing the time at which the Message Batch was
+   * archived and its results became unavailable.
+   */
+  archived_at: string | null;
+
+  /**
+   * RFC 3339 datetime string representing the time at which cancellation was
+   * initiated for the Message Batch. Specified only if cancellation was initiated.
+   */
+  cancel_initiated_at: string | null;
+
+  /**
+   * RFC 3339 datetime string representing the time at which the Message Batch was
+   * created.
+   */
+  created_at: string;
+
+  /**
+   * RFC 3339 datetime string representing the time at which processing for the
+   * Message Batch ended. Specified only once processing ends.
+   *
+   * Processing ends when every request in a Message Batch has either succeeded,
+   * errored, canceled, or expired.
+   */
+  ended_at: string | null;
+
+  /**
+   * RFC 3339 datetime string representing the time at which the Message Batch will
+   * expire and end processing, which is 24 hours after creation.
+   */
+  expires_at: string;
+
+  /**
+   * Processing status of the Message Batch.
+   */
+  processing_status: 'in_progress' | 'canceling' | 'ended';
+
+  /**
+   * Tallies requests within the Message Batch, categorized by their status.
+   *
+   * Requests start as `processing` and move to one of the other statuses only once
+   * processing of the entire batch ends. The sum of all values always matches the
+   * total number of requests in the batch.
+   */
+  request_counts: MessageBatchRequestCounts;
+
+  /**
+   * URL to a `.jsonl` file containing the results of the Message Batch requests.
+   * Specified only once processing ends.
+   *
+   * Results in the file are not guaranteed to be in the same order as requests. Use
+   * the `custom_id` field to match results to requests.
+   */
+  results_url: string | null;
+
+  /**
+   * Object type.
+   *
+   * For Message Batches, this is always `"message_batch"`.
+   */
+  type: 'message_batch';
+}
+
+export interface MessageBatchCanceledResult {
+  type: 'canceled';
+}
+
+export interface MessageBatchErroredResult {
+  error: Shared.ErrorResponse;
+
+  type: 'errored';
+}
+
+export interface MessageBatchExpiredResult {
+  type: 'expired';
+}
+
+/**
+ * This is a single line in the response `.jsonl` file and does not represent the
+ * response as a whole.
+ */
+export interface MessageBatchIndividualResponse {
+  /**
+   * Developer-provided ID created for each request in a Message Batch. Useful for
+   * matching results to requests, as results may be given out of request order.
+   *
+   * Must be unique for each request within the Message Batch.
+   */
+  custom_id: string;
+
+  /**
+   * Processing result for this request.
+   *
+   * Contains a Message output if processing was successful, an error response if
+   * processing failed, or the reason why processing was not attempted, such as
+   * cancellation or expiration.
+   */
+  result: MessageBatchResult;
+}
+
+export interface MessageBatchRequestCounts {
+  /**
+   * Number of requests in the Message Batch that have been canceled.
+   *
+   * This is zero until processing of the entire Message Batch has ended.
+   */
+  canceled: number;
+
+  /**
+   * Number of requests in the Message Batch that encountered an error.
+   *
+   * This is zero until processing of the entire Message Batch has ended.
+   */
+  errored: number;
+
+  /**
+   * Number of requests in the Message Batch that have expired.
+   *
+   * This is zero until processing of the entire Message Batch has ended.
+   */
+  expired: number;
+
+  /**
+   * Number of requests in the Message Batch that are processing.
+   */
+  processing: number;
+
+  /**
+   * Number of requests in the Message Batch that have completed successfully.
+   *
+   * This is zero until processing of the entire Message Batch has ended.
+   */
+  succeeded: number;
+}
+
+/**
+ * Processing result for this request.
+ *
+ * Contains a Message output if processing was successful, an error response if
+ * processing failed, or the reason why processing was not attempted, such as
+ * cancellation or expiration.
+ */
+export type MessageBatchResult =
+  | MessageBatchSucceededResult
+  | MessageBatchErroredResult
+  | MessageBatchCanceledResult
+  | MessageBatchExpiredResult;
+
+export interface MessageBatchSucceededResult {
+  message: MessagesAPI.Message;
+
+  type: 'succeeded';
+}
+
+export interface BatchCreateParams {
+  /**
+   * List of requests for prompt completion. Each is an individual request to create
+   * a Message.
+   */
+  requests: Array<BatchCreateParams.Request>;
+}
+
+export namespace BatchCreateParams {
+  export interface Request {
+    /**
+     * Developer-provided ID created for each request in a Message Batch. Useful for
+     * matching results to requests, as results may be given out of request order.
+     *
+     * Must be unique for each request within the Message Batch.
+     */
+    custom_id: string;
+
+    /**
+     * Messages API creation parameters for the individual request.
+     *
+     * See the [Messages API reference](/en/api/messages) for full documentation on
+     * available parameters.
+     */
+    params: MessagesAPI.MessageCreateParamsNonStreaming;
+  }
+}
+
+export interface BatchListParams extends PageParams {}
+
+export declare namespace Batches {
+  export {
+    type DeletedMessageBatch as DeletedMessageBatch,
+    type MessageBatch as MessageBatch,
+    type MessageBatchCanceledResult as MessageBatchCanceledResult,
+    type MessageBatchErroredResult as MessageBatchErroredResult,
+    type MessageBatchExpiredResult as MessageBatchExpiredResult,
+    type MessageBatchIndividualResponse as MessageBatchIndividualResponse,
+    type MessageBatchRequestCounts as MessageBatchRequestCounts,
+    type MessageBatchResult as MessageBatchResult,
+    type MessageBatchSucceededResult as MessageBatchSucceededResult,
+    type MessageBatchesPage as MessageBatchesPage,
+    type BatchCreateParams as BatchCreateParams,
+    type BatchListParams as BatchListParams,
+  };
+}

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/@anthropic-ai/sdk/src/resources/models.ts

@@ -0,0 +1,103 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import * as BetaAPI from './beta/beta';
+import { APIPromise } from '../core/api-promise';
+import { Page, type PageParams, PagePromise } from '../core/pagination';
+import { buildHeaders } from '../internal/headers';
+import { RequestOptions } from '../internal/request-options';
+import { path } from '../internal/utils/path';
+
+export class Models extends APIResource {
+  /**
+   * Get a specific model.
+   *
+   * The Models API response can be used to determine information about a specific
+   * model or resolve a model alias to a model ID.
+   */
+  retrieve(
+    modelID: string,
+    params: ModelRetrieveParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<ModelInfo> {
+    const { betas } = params ?? {};
+    return this._client.get(path`/v1/models/${modelID}`, {
+      ...options,
+      headers: buildHeaders([
+        { ...(betas?.toString() != null ? { 'anthropic-beta': betas?.toString() } : undefined) },
+        options?.headers,
+      ]),
+    });
+  }
+
+  /**
+   * List available models.
+   *
+   * The Models API response can be used to determine which models are available for
+   * use in the API. More recently released models are listed first.
+   */
+  list(
+    params: ModelListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): PagePromise<ModelInfosPage, ModelInfo> {
+    const { betas, ...query } = params ?? {};
+    return this._client.getAPIList('/v1/models', Page<ModelInfo>, {
+      query,
+      ...options,
+      headers: buildHeaders([
+        { ...(betas?.toString() != null ? { 'anthropic-beta': betas?.toString() } : undefined) },
+        options?.headers,
+      ]),
+    });
+  }
+}
+
+export type ModelInfosPage = Page<ModelInfo>;
+
+export interface ModelInfo {
+  /**
+   * Unique model identifier.
+   */
+  id: string;
+
+  /**
+   * RFC 3339 datetime string representing the time at which the model was released.
+   * May be set to an epoch value if the release date is unknown.
+   */
+  created_at: string;
+
+  /**
+   * A human-readable name for the model.
+   */
+  display_name: string;
+
+  /**
+   * Object type.
+   *
+   * For Models, this is always `"model"`.
+   */
+  type: 'model';
+}
+
+export interface ModelRetrieveParams {
+  /**
+   * Optional header to specify the beta version(s) you want to use.
+   */
+  betas?: Array<BetaAPI.AnthropicBeta>;
+}
+
+export interface ModelListParams extends PageParams {
+  /**
+   * Header param: Optional header to specify the beta version(s) you want to use.
+   */
+  betas?: Array<BetaAPI.AnthropicBeta>;
+}
+
+export declare namespace Models {
+  export {
+    type ModelInfo as ModelInfo,
+    type ModelInfosPage as ModelInfosPage,
+    type ModelRetrieveParams as ModelRetrieveParams,
+    type ModelListParams as ModelListParams,
+  };
+}

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/@fastify/ajv-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: "weekly"
+    open-pull-requests-limit: 10

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/@fastify/ajv-compiler/.taprc

@@ -0,0 +1,2 @@
+files:
+  - test/**/*.test.js

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/@fastify/cors/.editorconfig

@@ -0,0 +1,8 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+charset = utf-8
+trim_trailing_whitespace = false
+insert_final_newline = false

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/@fastify/cors/.gitattributes

@@ -0,0 +1,5 @@
+# Set the default behavior, in case people don't have core.autocrlf set
+* text=auto
+
+# Require Unix line endings
+* text eol=lf

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/@fastify/cors/bench.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const fastify = require('fastify')()
+
+fastify.register((instance, _opts, next) => {
+  instance.register(require('./index'))
+  instance.get('/fastify', (_req, reply) => reply.send('ok'))
+  next()
+})
+
+fastify.register((instance, _opts, next) => {
+  instance.use(require('cors')())
+  instance.get('/express', (_req, reply) => reply.send('ok'))
+  next()
+})
+
+fastify.listen({ port: 3000 })

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/@fastify/fast-json-stringify-compiler/.eslintrc

@@ -0,0 +1 @@
+{"extends": "standard"}

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/@fastify/fast-json-stringify-compiler/.gitattributes

@@ -0,0 +1,2 @@
+# Set default behavior to automatically convert line endings
+* text=auto eol=lf

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/@fastify/fast-json-stringify-compiler/index.js

@@ -0,0 +1,8 @@
+'use strict'
+
+const { SerializerSelector, StandaloneSerializer } = require('./standalone')
+
+module.exports = SerializerSelector
+module.exports.default = SerializerSelector
+module.exports.SerializerSelector = SerializerSelector
+module.exports.StandaloneSerializer = StandaloneSerializer

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/@fastify/fast-json-stringify-compiler/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@fastify/fast-json-stringify-compiler",
+  "description": "Build and manage the fast-json-stringify instances for the fastify framework",
+  "version": "5.0.3",
+  "main": "index.js",
+  "type": "commonjs",
+  "types": "types/index.d.ts",
+  "scripts": {
+    "lint": "eslint",
+    "lint:fix": "eslint --fix",
+    "unit": "c8 --100 node --test",
+    "test": "npm run unit && npm run test:typescript",
+    "test:typescript": "tsd"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fastify/fast-json-stringify-compiler.git"
+  },
+  "keywords": [],
+  "author": "Manuel Spigolon <manuel.spigolon@nearform.com> (https://github.com/Eomm)",
+  "contributors": [
+    {
+      "name": "Matteo Collina",
+      "email": "hello@matteocollina.com"
+    },
+    {
+      "name": "Aras Abbasi",
+      "email": "aras.abbasi@gmail.com"
+    },
+    {
+      "name": "James Sumners",
+      "url": "https://james.sumners.info"
+    },
+    {
+      "name": "Frazer Smith",
+      "email": "frazer.dev@icloud.com",
+      "url": "https://github.com/fdawgs"
+    }
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/fastify/fast-json-stringify-compiler/issues"
+  },
+  "homepage": "https://github.com/fastify/fast-json-stringify-compiler#readme",
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/fastify"
+    },
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/fastify"
+    }
+  ],
+  "devDependencies": {
+    "@fastify/pre-commit": "^2.1.0",
+    "c8": "^10.1.3",
+    "eslint": "^9.17.0",
+    "fastify": "^5.0.0",
+    "neostandard": "^0.12.0",
+    "sanitize-filename": "^1.6.3",
+    "tsd": "^0.31.0"
+  },
+  "pre-commit": [
+    "lint",
+    "test"
+  ],
+  "dependencies": {
+    "fast-json-stringify": "^6.0.0"
+  }
+}

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/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))
+}