diff --git a/.github/workflows/js.yaml b/.github/workflows/js.yaml index a0b6a8de..f86a1f22 100644 --- a/.github/workflows/js.yaml +++ b/.github/workflows/js.yaml @@ -8,12 +8,38 @@ on: jobs: build: runs-on: ubuntu-latest - strategy: matrix: node-version: - 20 + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-node@v4 + with: + node-version: ${{ matrix.node-version }} + registry-url: "https://registry.npmjs.org" + - uses: pnpm/action-setup@v4 + - name: Get pnpm store directory + shell: bash + run: echo "STORE_PATH=$(pnpm store path --silent)" >> $GITHUB_ENV + - uses: actions/cache@v4 + with: + path: ${{ env.STORE_PATH }} + key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }} + restore-keys: | + ${{ runner.os }}-pnpm-store- + - name: Install dependencies + run: pnpm install + - name: Build + run: pnpm run build + test: + runs-on: ubuntu-latest + needs: build + strategy: + matrix: + node-version: + - 20 steps: - uses: actions/checkout@v4 - uses: actions/setup-node@v4 @@ -21,10 +47,19 @@ jobs: node-version: ${{ matrix.node-version }} registry-url: "https://registry.npmjs.org" - uses: pnpm/action-setup@v4 - - run: | - pnpm install - pnpm run test - pnpm run build + - name: Get pnpm store directory + shell: bash + run: echo "STORE_PATH=$(pnpm store path --silent)" >> $GITHUB_ENV + - uses: actions/cache@v4 + with: + path: ${{ env.STORE_PATH }} + key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }} + restore-keys: | + ${{ runner.os }}-pnpm-store- + - name: Install dependencies + run: pnpm install + - name: Run tests + run: pnpm run test env: OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }} ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }} diff --git a/packages/proxy/package.json b/packages/proxy/package.json index 8d4e1ef0..ea11f745 100644 --- a/packages/proxy/package.json +++ b/packages/proxy/package.json @@ -100,7 +100,7 @@ "zod-to-json-schema": "^3.24.6" }, "dependencies": { - "@anthropic-ai/sdk": "^0.39.0", + "@anthropic-ai/sdk": "^0.71.2", "@aws-sdk/client-bedrock-runtime": "^3.806.0", "@breezystack/lamejs": "^1.2.7", "@openapi-contrib/json-schema-to-openapi-schema": "^4.2.0", diff --git a/packages/proxy/schema/index.ts b/packages/proxy/schema/index.ts index f7bd7069..0fb9b643 100644 --- a/packages/proxy/schema/index.ts +++ b/packages/proxy/schema/index.ts @@ -8,6 +8,7 @@ import type { import { ModelFormat, ModelEndpointType, + type ModelName, ModelSpec, getAvailableModels, } from "./models"; @@ -25,6 +26,17 @@ export { } from "./audio"; export * from "./openai-realtime"; +export { + isImageMediaType, + isTextBasedMediaType, + isMediaTypeSupported, + getSupportedMediaTypes, + ModelFormatMediaTypes, + ModelMediaTypeOverrides, + type TextBasedTextType, + type ImageMediaType, +} from "./media-types"; + export const MessageTypeToMessageType: { [messageType in MessageRole]: MessageRole | undefined; } = { diff --git a/packages/proxy/schema/media-types.test.ts b/packages/proxy/schema/media-types.test.ts new file mode 100644 index 00000000..228157a8 --- /dev/null +++ b/packages/proxy/schema/media-types.test.ts @@ -0,0 +1,238 @@ +import { describe, expect, it } from "vitest"; +import { + isMediaTypeSupported, + getSupportedMediaTypes, + isImageMediaType, + isTextBasedMediaType, + getAvailableModels, + type ModelFormat, +} from "./index"; + +describe("media-types helpers for playground file upload validation", () => { + describe("isMediaTypeSupported - validates file uploads by model format", () => { + it("should allow PDFs for all major providers except js/window", () => { + const pdfMimeType = "application/pdf"; + + expect(isMediaTypeSupported(pdfMimeType, "openai")).toBe(true); + expect(isMediaTypeSupported(pdfMimeType, "anthropic")).toBe(true); + expect(isMediaTypeSupported(pdfMimeType, "google")).toBe(true); + expect(isMediaTypeSupported(pdfMimeType, "converse")).toBe(true); + + expect(isMediaTypeSupported(pdfMimeType, "js")).toBe(false); + expect(isMediaTypeSupported(pdfMimeType, "window")).toBe(false); + }); + + it("should allow common images for google but not heic/heif for openai/anthropic", () => { + expect(isMediaTypeSupported("image/jpeg", "google")).toBe(true); + expect(isMediaTypeSupported("image/png", "google")).toBe(true); + expect(isMediaTypeSupported("image/webp", "google")).toBe(true); + expect(isMediaTypeSupported("image/heic", "google")).toBe(true); + + expect(isMediaTypeSupported("image/jpeg", "openai")).toBe(true); + expect(isMediaTypeSupported("image/heic", "openai")).toBe(false); + expect(isMediaTypeSupported("image/heif", "openai")).toBe(false); + }); + + it("should allow text-based files only for anthropic and google", () => { + const textMimeTypes = [ + "text/plain", + "text/markdown", + "text/csv", + "application/json", + ]; + + for (const mimeType of textMimeTypes) { + expect(isMediaTypeSupported(mimeType, "google")).toBe(true); + expect(isMediaTypeSupported(mimeType, "anthropic")).toBe(true); + expect(isMediaTypeSupported(mimeType, "openai")).toBe(false); + } + }); + + it("should allow audio/video only for google", () => { + expect(isMediaTypeSupported("audio/mp3", "google")).toBe(true); + expect(isMediaTypeSupported("audio/wav", "google")).toBe(true); + expect(isMediaTypeSupported("video/mp4", "google")).toBe(true); + + expect(isMediaTypeSupported("audio/mp3", "openai")).toBe(false); + expect(isMediaTypeSupported("audio/mp3", "anthropic")).toBe(false); + expect(isMediaTypeSupported("video/mp4", "openai")).toBe(false); + expect(isMediaTypeSupported("video/mp4", "anthropic")).toBe(false); + }); + }); + + describe("frontend playground file upload scenario", () => { + function getModelFormat(modelName: string): ModelFormat | undefined { + const models = getAvailableModels(); + return models[modelName]?.format; + } + + function canUploadFile( + file: { name: string; type: string }, + modelName: string, + ): { allowed: boolean; reason?: string; allowedTypes?: Set } { + const format = getModelFormat(modelName); + if (!format) { + return { allowed: false, reason: `Unknown model: ${modelName}` }; + } + + if (!file.type) { + return { allowed: false, reason: "File has no MIME type" }; + } + + const allowedTypes = getSupportedMediaTypes(format); + + if (!allowedTypes.has(file.type)) { + return { + allowed: false, + reason: `${file.type} is not supported by ${format} models`, + allowedTypes, + }; + } + + return { allowed: true, allowedTypes }; + } + + it("should allow PDF upload when using gpt-5-mini (openai format)", () => { + const pdfFile = { name: "document.pdf", type: "application/pdf" }; + const result = canUploadFile(pdfFile, "gpt-5-mini"); + expect(result.allowed).toBe(true); + expect(result.allowedTypes?.has("application/pdf")).toBe(true); + }); + + it("should reject video upload when using gpt-5-mini (openai format)", () => { + const videoFile = { name: "video.mp4", type: "video/mp4" }; + const result = canUploadFile(videoFile, "gpt-5-mini"); + expect(result.allowed).toBe(false); + expect(result.reason).toContain("not supported by openai"); + expect(result.allowedTypes?.has("video/mp4")).toBe(false); + }); + + it("should allow video upload when using gemini-2.0-flash (google format)", () => { + const videoFile = { name: "video.mp4", type: "video/mp4" }; + const result = canUploadFile(videoFile, "gemini-2.0-flash"); + expect(result.allowed).toBe(true); + expect(result.allowedTypes?.has("video/mp4")).toBe(true); + expect(result.allowedTypes?.has("audio/mp3")).toBe(true); + }); + + it("should allow text/markdown upload for claude-sonnet-4-5 (anthropic format)", () => { + const markdownFile = { name: "readme.md", type: "text/markdown" }; + const result = canUploadFile(markdownFile, "claude-sonnet-4-5"); + expect(result.allowed).toBe(true); + expect(result.allowedTypes?.has("text/markdown")).toBe(true); + }); + + it("should reject text/markdown upload for gpt-5-mini (openai format)", () => { + const markdownFile = { name: "readme.md", type: "text/markdown" }; + const result = canUploadFile(markdownFile, "gpt-5-mini"); + expect(result.allowed).toBe(false); + expect(result.reason).toContain("text/markdown is not supported"); + expect(result.allowedTypes?.has("text/markdown")).toBe(false); + }); + + it("should handle unknown models gracefully", () => { + const pdfFile = { name: "document.pdf", type: "application/pdf" }; + const result = canUploadFile(pdfFile, "nonexistent-model"); + expect(result.allowed).toBe(false); + expect(result.reason).toBe("Unknown model: nonexistent-model"); + expect(result.allowedTypes).toBeUndefined(); + }); + + it("should provide allowedTypes for building file input accept attribute", () => { + const result = canUploadFile( + { name: "any.txt", type: "text/plain" }, + "gemini-2.0-flash", + ); + expect(result.allowedTypes).toBeDefined(); + const acceptAttribute = [...result.allowedTypes!].join(","); + expect(acceptAttribute).toContain("image/jpeg"); + expect(acceptAttribute).toContain("application/pdf"); + expect(acceptAttribute).toContain("video/mp4"); + }); + }); + + describe("isImageMediaType - type guard for image files", () => { + it("should return true for standard image types", () => { + expect(isImageMediaType("image/jpeg")).toBe(true); + expect(isImageMediaType("image/png")).toBe(true); + expect(isImageMediaType("image/gif")).toBe(true); + expect(isImageMediaType("image/webp")).toBe(true); + }); + + it("should return false for non-image types", () => { + expect(isImageMediaType("application/pdf")).toBe(false); + expect(isImageMediaType("text/plain")).toBe(false); + expect(isImageMediaType("video/mp4")).toBe(false); + }); + }); + + describe("getSupportedMediaTypes - returns a Set of supported media types", () => { + it("should return a Set of supported media types for openai format", () => { + const supported = getSupportedMediaTypes("openai"); + + expect(supported).toBeInstanceOf(Set); + expect(supported.has("application/pdf")).toBe(true); + expect(supported.has("image/heic")).toBe(false); + expect(supported.has("image/jpeg")).toBe(true); + expect(supported.has("text/plain")).toBe(false); + }); + + it("should return a Set of supported media types for google format", () => { + const supported = getSupportedMediaTypes("google"); + + expect(supported.has("application/pdf")).toBe(true); + expect(supported.has("image/jpeg")).toBe(true); + expect(supported.has("image/png")).toBe(true); + expect(supported.has("text/plain")).toBe(true); + expect(supported.has("audio/mp3")).toBe(true); + expect(supported.has("video/mp4")).toBe(true); + }); + + it("should return empty Set for js/window formats", () => { + const jsSupported = getSupportedMediaTypes("js"); + const windowSupported = getSupportedMediaTypes("window"); + + expect(jsSupported.size).toBe(0); + expect(windowSupported.size).toBe(0); + }); + + it("can be used to show users what file types are allowed", () => { + const format: ModelFormat = "anthropic"; + const supported = getSupportedMediaTypes(format); + + expect(supported.has("application/pdf")).toBe(true); + expect(supported.has("text/plain")).toBe(true); + expect(supported.has("application/json")).toBe(true); + expect(supported.has("video/mp4")).toBe(false); + }); + + it("can be spread into an array for building accept attributes", () => { + const supported = getSupportedMediaTypes("google"); + const acceptAttribute = [...supported].join(","); + + expect(acceptAttribute).toContain("image/jpeg"); + expect(acceptAttribute).toContain("application/pdf"); + }); + }); + + describe("isTextBasedMediaType - type guard for text files", () => { + it("should return true for text/* mime types", () => { + expect(isTextBasedMediaType("text/plain")).toBe(true); + expect(isTextBasedMediaType("text/markdown")).toBe(true); + expect(isTextBasedMediaType("text/csv")).toBe(true); + expect(isTextBasedMediaType("text/html")).toBe(true); + }); + + it("should return true for application types that are text-based", () => { + expect(isTextBasedMediaType("application/json")).toBe(true); + expect(isTextBasedMediaType("application/xml")).toBe(true); + expect(isTextBasedMediaType("application/yaml")).toBe(true); + }); + + it("should return false for binary types", () => { + expect(isTextBasedMediaType("application/pdf")).toBe(false); + expect(isTextBasedMediaType("image/png")).toBe(false); + expect(isTextBasedMediaType("audio/mp3")).toBe(false); + }); + }); +}); diff --git a/packages/proxy/schema/media-types.ts b/packages/proxy/schema/media-types.ts new file mode 100644 index 00000000..942b0c8d --- /dev/null +++ b/packages/proxy/schema/media-types.ts @@ -0,0 +1,164 @@ +import type { ModelFormat, ModelName } from "./models"; + +const IMAGE_MEDIA_TYPES = [ + "image/jpeg", + "image/png", + "image/gif", + "image/webp", + "image/heic", + "image/heif", + "image/tiff", + "image/bmp", +] as const; + +export type ImageMediaType = (typeof IMAGE_MEDIA_TYPES)[number]; + +const TEXT_BASED_TEXT_TYPES = [ + "text/plain", + "text/markdown", + "text/html", + "text/css", + "text/csv", + "text/javascript", + "text/xml", + "text/yaml", + "application/json", + "application/xml", + "application/javascript", + "application/yaml", + "application/x-yaml", +] as const; + +export type TextBasedTextType = (typeof TEXT_BASED_TEXT_TYPES)[number]; + +const DOCUMENT_MEDIA_TYPES = ["application/pdf"] as const; + +const AUDIO_MEDIA_TYPES = [ + "audio/wav", + "audio/mp3", + "audio/mpeg", + "audio/mp4", + "audio/webm", +] as const; + +const VIDEO_MEDIA_TYPES = [ + "video/mp4", + "video/webm", + "video/mpeg", + "video/quicktime", + "video/x-msvideo", +] as const; + +const SupportedMediaTypes = [ + ...IMAGE_MEDIA_TYPES, + ...DOCUMENT_MEDIA_TYPES, + ...TEXT_BASED_TEXT_TYPES, + ...AUDIO_MEDIA_TYPES, + ...VIDEO_MEDIA_TYPES, +] as const; + +type SupportedMediaType = (typeof SupportedMediaTypes)[number]; + +export function isTextBasedMediaType( + mediaType: string, +): mediaType is TextBasedTextType { + return ( + mediaType.startsWith("text/") || + TEXT_BASED_TEXT_TYPES.includes(mediaType as TextBasedTextType) + ); +} + +export function isImageMediaType( + mediaType: string, +): mediaType is ImageMediaType { + return IMAGE_MEDIA_TYPES.includes(mediaType as ImageMediaType); +} + +type MediaTypeSupport = { + [mediaType in SupportedMediaType]?: boolean; +}; + +const toMediaTypeSupport = ( + mediaTypes: readonly SupportedMediaType[], +): MediaTypeSupport => { + return mediaTypes.reduce( + (acc, type) => { + acc[type] = true; + return acc; + }, + {} as Record, + ); +}; + +export const ModelFormatMediaTypes: { + [format in ModelFormat]: MediaTypeSupport; +} = { + openai: { + ...toMediaTypeSupport( + IMAGE_MEDIA_TYPES.filter( + (type) => !(type.endsWith("heic") || type.endsWith("heif")), + ), + ), + ...toMediaTypeSupport(DOCUMENT_MEDIA_TYPES), + }, + anthropic: { + ...toMediaTypeSupport( + IMAGE_MEDIA_TYPES.filter( + (type) => !(type.endsWith("heic") || type.endsWith("heif")), + ), + ), + ...toMediaTypeSupport(TEXT_BASED_TEXT_TYPES), + ...toMediaTypeSupport(DOCUMENT_MEDIA_TYPES), + }, + google: { + ...toMediaTypeSupport(IMAGE_MEDIA_TYPES), + ...toMediaTypeSupport(TEXT_BASED_TEXT_TYPES), + ...toMediaTypeSupport(DOCUMENT_MEDIA_TYPES), + ...toMediaTypeSupport(AUDIO_MEDIA_TYPES), + ...toMediaTypeSupport(VIDEO_MEDIA_TYPES), + }, + converse: { + ...toMediaTypeSupport( + IMAGE_MEDIA_TYPES.filter( + (type) => !(type.endsWith("heic") || type.endsWith("heif")), + ), + ), + ...toMediaTypeSupport(DOCUMENT_MEDIA_TYPES), + }, + js: {}, + window: {}, +}; + +/** + * Overrides for specific models to support additional media types. + */ +export const ModelMediaTypeOverrides: { + [model in ModelName]?: MediaTypeSupport; +} = { + // will be useful for gpt-audio +}; + +export function getSupportedMediaTypes( + format: ModelFormat, + model?: ModelName, +): Set { + const baseSupport = { ...ModelFormatMediaTypes[format] }; + + if (model && ModelMediaTypeOverrides[model]) { + Object.assign(baseSupport, ModelMediaTypeOverrides[model]); + } + + return new Set( + Object.entries(baseSupport) + .filter(([_, supported]) => supported) + .map(([type]) => type), + ); +} + +export function isMediaTypeSupported( + mediaType: string, + format: ModelFormat, + model?: ModelName, +): boolean { + return getSupportedMediaTypes(format, model).has(mediaType); +} diff --git a/packages/proxy/schema/models.ts b/packages/proxy/schema/models.ts index 1e0e8e08..5f63b8d5 100644 --- a/packages/proxy/schema/models.ts +++ b/packages/proxy/schema/models.ts @@ -89,6 +89,8 @@ export type ModelSpec = z.infer; import modelListJson from "./model_list.json"; const modelListJsonTyped = z.record(ModelSchema).parse(modelListJson); +export type ModelName = keyof typeof modelListJson; + // Because this file can be included and bundled in various ways, it's important to // really inject these variables into the global scope, rather than let the bundler // have its way with them. diff --git a/packages/proxy/src/providers/anthropic.test.ts b/packages/proxy/src/providers/anthropic.test.ts index 4df3ee4a..dfbcf154 100644 --- a/packages/proxy/src/providers/anthropic.test.ts +++ b/packages/proxy/src/providers/anthropic.test.ts @@ -1,11 +1,19 @@ -import { it, expect } from "vitest"; +import { it, expect, describe } from "vitest"; import { callProxyV1, createCapturingFetch } from "../../utils/tests"; import { OpenAIChatCompletion, OpenAIChatCompletionChunk, OpenAIChatCompletionCreateParams, } from "@types"; -import { IMAGE_DATA_URL, PDF_DATA_URL } from "./fixtures"; +import { + IMAGE_DATA_URL, + PDF_DATA_URL, + TEXT_DATA_URL, + MD_DATA_URL, + CSV_DATA_URL, + AUDIO_DATA_URL, + VIDEO_DATA_URL, +} from "../../tests/fixtures/base64"; it("should convert OpenAI streaming request to Anthropic and back", async () => { const { events } = await callProxyV1< @@ -576,6 +584,299 @@ it("should use 128000 max_tokens and add beta header for claude-3-7-sonnet when ); }); +it("should convert plain text file to Anthropic PlainTextSource document", async () => { + const { fetch, requests } = createCapturingFetch({ captureOnly: true }); + + await callProxyV1({ + body: { + model: "claude-3-7-sonnet-latest", + messages: [ + { + role: "user", + content: [ + { + type: "text", + text: "What's in this text file?", + }, + { + type: "file", + file: { + file_data: TEXT_DATA_URL, + filename: "test.txt", + }, + }, + ], + }, + ], + stream: false, + }, + fetch, + }); + + expect(requests).toHaveLength(1); + const messages = requests[0].body.messages; + expect(messages).toHaveLength(1); + expect(messages[0].content).toHaveLength(2); + expect(messages[0].content[0]).toMatchObject({ type: "text" }); + expect(messages[0].content[1]).toMatchObject({ + type: "document", + source: { + type: "text", + media_type: "text/plain", + }, + }); + expect(typeof messages[0].content[1].source.data).toBe("string"); + expect(messages[0].content[1].source.data).toContain("Hello"); +}); + +it("should convert markdown file to Anthropic PlainTextSource document", async () => { + const { fetch, requests } = createCapturingFetch({ captureOnly: true }); + + await callProxyV1({ + body: { + model: "claude-3-7-sonnet-latest", + messages: [ + { + role: "user", + content: [ + { + type: "text", + text: "What's in this markdown file?", + }, + { + type: "file", + file: { + file_data: MD_DATA_URL, + filename: "test.md", + }, + }, + ], + }, + ], + stream: false, + }, + fetch, + }); + + expect(requests).toHaveLength(1); + const messages = requests[0].body.messages; + expect(messages).toHaveLength(1); + expect(messages[0].content).toHaveLength(2); + expect(messages[0].content[0]).toMatchObject({ type: "text" }); + expect(messages[0].content[1]).toMatchObject({ + type: "document", + source: { + type: "text", + media_type: "text/plain", + }, + }); + expect(typeof messages[0].content[1].source.data).toBe("string"); +}); + +it("should convert CSV file to Anthropic PlainTextSource document", async () => { + const { fetch, requests } = createCapturingFetch({ captureOnly: true }); + + await callProxyV1({ + body: { + model: "claude-3-7-sonnet-latest", + messages: [ + { + role: "user", + content: [ + { + type: "text", + text: "List all the muppets in this CSV file", + }, + { + type: "file", + file: { + file_data: CSV_DATA_URL, + filename: "muppets.csv", + }, + }, + ], + }, + ], + stream: false, + }, + fetch, + }); + + expect(requests).toHaveLength(1); + const messages = requests[0].body.messages; + expect(messages).toHaveLength(1); + expect(messages[0].content).toHaveLength(2); + expect(messages[0].content[0]).toMatchObject({ type: "text" }); + expect(messages[0].content[1]).toMatchObject({ + type: "document", + source: { + type: "text", + media_type: "text/plain", + }, + }); + expect(typeof messages[0].content[1].source.data).toBe("string"); + expect(messages[0].content[1].source.data).toContain("Kermit"); + expect(messages[0].content[1].source.data).toContain("Miss Piggy"); +}); + +it("should handle file content parts with plain text data", async () => { + const { json } = await callProxyV1< + OpenAIChatCompletionCreateParams, + OpenAIChatCompletion + >({ + body: { + model: "claude-3-7-sonnet-latest", + messages: [ + { + role: "user", + content: [ + { + type: "text", + text: "What's in this text file?", + }, + { + type: "file", + file: { + file_data: TEXT_DATA_URL, + filename: "test.txt", + }, + }, + ], + }, + ], + stream: false, + }, + }); + + const response = json(); + expect(response).toBeTruthy(); + expect(response!.choices[0].message.role).toBe("assistant"); + expect(response!.choices[0].message.content).toBeTruthy(); + expect(typeof response!.choices[0].message.content).toBe("string"); +}); + +it("should handle file content parts with markdown data", async () => { + const { json } = await callProxyV1< + OpenAIChatCompletionCreateParams, + OpenAIChatCompletion + >({ + body: { + model: "claude-3-7-sonnet-latest", + messages: [ + { + role: "user", + content: [ + { + type: "text", + text: "What's in this markdown file?", + }, + { + type: "file", + file: { + file_data: MD_DATA_URL, + filename: "test.md", + }, + }, + ], + }, + ], + stream: false, + }, + }); + + const response = json(); + expect(response).toBeTruthy(); + expect(response!.choices[0].message.role).toBe("assistant"); + expect(response!.choices[0].message.content).toBeTruthy(); + expect(typeof response!.choices[0].message.content).toBe("string"); +}); + +describe("unsupported media types", () => { + it("should return error for audio file content", async () => { + const { statusCode, json } = await callProxyV1< + OpenAIChatCompletionCreateParams, + OpenAIChatCompletion + >({ + body: { + model: "claude-3-7-sonnet-latest", + messages: [ + { + role: "user", + content: [ + { + type: "text", + text: "What's in this audio file?", + }, + { + type: "file", + file: { + file_data: AUDIO_DATA_URL, + filename: "test.wav", + }, + }, + ], + }, + ], + stream: false, + }, + }); + + expect(statusCode).toBe(400); + const response = json(); + expect(response).toMatchObject({ + type: "error", + error: { + type: "invalid_request_error", + message: expect.stringMatching( + /media_type.*should be 'application\/pdf'/, + ), + }, + }); + }); + + it("should return error for video file content", async () => { + const { statusCode, json } = await callProxyV1< + OpenAIChatCompletionCreateParams, + OpenAIChatCompletion + >({ + body: { + model: "claude-3-7-sonnet-latest", + messages: [ + { + role: "user", + content: [ + { + type: "text", + text: "What's in this video file?", + }, + { + type: "file", + file: { + file_data: VIDEO_DATA_URL, + filename: "test.mp4", + }, + }, + ], + }, + ], + stream: false, + }, + }); + + expect(statusCode).toBe(400); + const response = json(); + expect(response).toMatchObject({ + type: "error", + error: { + type: "invalid_request_error", + message: expect.stringMatching( + /media_type.*should be 'application\/pdf'/, + ), + }, + }); + }); +}); + it("should translate json_object response format to tool-based structured output", async () => { // This test verifies BRA-3896: json_object response format should be translated // to a tool-based workaround for Anthropic, similar to how json_schema is handled. diff --git a/packages/proxy/src/providers/anthropic.ts b/packages/proxy/src/providers/anthropic.ts index 9aa32d52..4d27d1b7 100644 --- a/packages/proxy/src/providers/anthropic.ts +++ b/packages/proxy/src/providers/anthropic.ts @@ -27,7 +27,7 @@ import { ChatCompletionTool, ChatCompletionToolMessageParam, } from "openai/resources"; -import { ModelSpec } from "@schema"; +import { ModelSpec, isImageMediaType, isTextBasedMediaType } from "@schema"; import { getBudgetMultiplier } from "utils"; import { cleanOpenAIParams } from "utils/openai"; import { v4 as uuidv4 } from "uuid"; @@ -561,13 +561,7 @@ const openAIContentPartToAnthropicContentPart = async ( const { media_type, data } = await convertMediaToBase64({ media, - allowedMediaTypes: [ - "image/jpeg", - "image/png", - "image/gif", - "image/webp", - "application/pdf", - ], + allowedMediaTypes: null, maxMediaBytes: 5 * 1024 * 1024, }); @@ -580,16 +574,35 @@ const openAIContentPartToAnthropicContentPart = async ( data, }, }; - } else { + } else if (isTextBasedMediaType(media_type)) { + const textContent = Buffer.from(data, "base64").toString("utf-8"); + return { + type: "document", + source: { + type: "text", + media_type: "text/plain", + data: textContent, + }, + }; + } else if (isImageMediaType(media_type)) { return { type: "image", source: { type: "base64", - // eslint-disable-next-line @typescript-eslint/consistent-type-assertions - media_type: media_type as Base64ImageSource["media_type"], + media_type, data, }, }; + } else { + // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any + return { + type: "document", + source: { + type: "base64", + media_type, + data, + }, + } as any; } } default: diff --git a/packages/proxy/src/providers/fixtures.ts b/packages/proxy/src/providers/fixtures.ts deleted file mode 100644 index 0edf925d..00000000 --- a/packages/proxy/src/providers/fixtures.ts +++ /dev/null @@ -1,5 +0,0 @@ -export const IMAGE_DATA_URL = - "data:image/png;base64,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"; // codespell:ignore - -export const PDF_DATA_URL = - "data:application/pdf;base64,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"; // codespell:ignore diff --git a/packages/proxy/src/providers/google.test.ts b/packages/proxy/src/providers/google.test.ts index 34c0e25d..334ea05b 100644 --- a/packages/proxy/src/providers/google.test.ts +++ b/packages/proxy/src/providers/google.test.ts @@ -17,7 +17,15 @@ import { } from "./google"; import { zodToJsonSchema } from "zod-to-json-schema"; import { z } from "zod"; -import { IMAGE_DATA_URL, PDF_DATA_URL } from "./fixtures"; +import { + IMAGE_DATA_URL, + PDF_DATA_URL, + AUDIO_DATA_URL, + VIDEO_DATA_URL, + TEXT_DATA_URL, + MD_DATA_URL, + CSV_DATA_URL, +} from "../../tests/fixtures/base64"; // Integration tests that actually call the Google API for (const model of [ @@ -2318,4 +2326,209 @@ describe("file content part handling", () => { expect(response.choices[0].message.role).toBe("assistant"); expect(response.choices[0].message.content).toBeTruthy(); }); + + it("should handle file content parts with audio data", async () => { + const { json } = await callProxyV1< + OpenAIChatCompletionCreateParams, + OpenAIChatCompletionChunk + >({ + body: { + model: "gemini-2.5-flash", + messages: [ + { + role: "user", + content: [ + { + type: "text", + text: "What's in this audio file?", + }, + { + type: "file", + file: { + file_data: AUDIO_DATA_URL, + filename: "test.wav", + }, + }, + ], + }, + ], + stream: false, + }, + }); + + const response = json(); + expect(response).toBeTruthy(); + expect(response.error).not.toBeDefined(); + expect(response.choices).toBeDefined(); + expect(Array.isArray(response.choices)).toBe(true); + expect(response.choices.length).toBeGreaterThan(0); + expect(response.choices[0].message).toBeDefined(); + expect(response.choices[0].message.role).toBe("assistant"); + expect(response.choices[0].message.content).toBeTruthy(); + expect(typeof response.choices[0].message.content).toBe("string"); + }); + + it("should handle file content parts with video data", async () => { + const { json } = await callProxyV1< + OpenAIChatCompletionCreateParams, + OpenAIChatCompletionChunk + >({ + body: { + model: "gemini-2.5-flash", + messages: [ + { + role: "user", + content: [ + { + type: "text", + text: "What's in this video file?", + }, + { + type: "file", + file: { + file_data: VIDEO_DATA_URL, + filename: "test.mp4", + }, + }, + ], + }, + ], + stream: false, + }, + }); + + const response = json(); + expect(response).toBeTruthy(); + expect(response.error).not.toBeDefined(); + expect(response.choices).toBeDefined(); + expect(Array.isArray(response.choices)).toBe(true); + expect(response.choices.length).toBeGreaterThan(0); + expect(response.choices[0].message).toBeDefined(); + expect(response.choices[0].message.role).toBe("assistant"); + expect(response.choices[0].message.content).toBeTruthy(); + expect(typeof response.choices[0].message.content).toBe("string"); + }); + + it("should handle file content parts with plain text data", async () => { + const { json } = await callProxyV1< + OpenAIChatCompletionCreateParams, + OpenAIChatCompletionChunk + >({ + body: { + model: "gemini-2.5-flash", + messages: [ + { + role: "user", + content: [ + { + type: "text", + text: "What's in this text file?", + }, + { + type: "file", + file: { + file_data: TEXT_DATA_URL, + filename: "test.txt", + }, + }, + ], + }, + ], + stream: false, + }, + }); + + const response = json(); + expect(response).toBeTruthy(); + expect(response.error).not.toBeDefined(); + expect(response.choices).toBeDefined(); + expect(Array.isArray(response.choices)).toBe(true); + expect(response.choices.length).toBeGreaterThan(0); + expect(response.choices[0].message).toBeDefined(); + expect(response.choices[0].message.role).toBe("assistant"); + expect(response.choices[0].message.content).toBeTruthy(); + expect(typeof response.choices[0].message.content).toBe("string"); + }); + + it("should handle file content parts with markdown data", async () => { + const { json } = await callProxyV1< + OpenAIChatCompletionCreateParams, + OpenAIChatCompletionChunk + >({ + body: { + model: "gemini-2.5-flash", + messages: [ + { + role: "user", + content: [ + { + type: "text", + text: "What's in this markdown file?", + }, + { + type: "file", + file: { + file_data: MD_DATA_URL, + filename: "test.md", + }, + }, + ], + }, + ], + stream: false, + }, + }); + + const response = json(); + expect(response).toBeTruthy(); + expect(response.error).not.toBeDefined(); + expect(response.choices).toBeDefined(); + expect(Array.isArray(response.choices)).toBe(true); + expect(response.choices.length).toBeGreaterThan(0); + expect(response.choices[0].message).toBeDefined(); + expect(response.choices[0].message.role).toBe("assistant"); + expect(response.choices[0].message.content).toBeTruthy(); + expect(typeof response.choices[0].message.content).toBe("string"); + }); + + it("should handle file content parts with muppets CSV data", async () => { + const { json } = await callProxyV1< + OpenAIChatCompletionCreateParams, + OpenAIChatCompletionChunk + >({ + body: { + model: "gemini-2.5-flash", + messages: [ + { + role: "user", + content: [ + { + type: "text", + text: "List the first 3 muppet names from this CSV file", + }, + { + type: "file", + file: { + file_data: CSV_DATA_URL, + filename: "muppets.csv", + }, + }, + ], + }, + ], + stream: false, + }, + }); + + const response = json(); + expect(response).toBeTruthy(); + expect(response.error).not.toBeDefined(); + expect(response.choices).toBeDefined(); + expect(Array.isArray(response.choices)).toBe(true); + expect(response.choices.length).toBeGreaterThan(0); + expect(response.choices[0].message).toBeDefined(); + expect(response.choices[0].message.role).toBe("assistant"); + expect(response.choices[0].message.content).toBeTruthy(); + expect(typeof response.choices[0].message.content).toBe("string"); + }); }); diff --git a/packages/proxy/src/providers/google.ts b/packages/proxy/src/providers/google.ts index a6b9f923..11facd9b 100644 --- a/packages/proxy/src/providers/google.ts +++ b/packages/proxy/src/providers/google.ts @@ -42,24 +42,6 @@ export async function openAIContentToGoogleContent( return Promise.all(content?.map(openAIContentPartToGooglePart) ?? []); } -const GEMINI_ALLOWED_MEDIA_TYPES = [ - "image/png", - "image/jpeg", - "image/webp", - "image/heic", - "image/heif", - "video/mp4", - "video/webm", - "video/mpeg", - "video/quicktime", - "video/x-msvideo", - "audio/mpeg", - "audio/mp4", - "audio/wav", - "audio/webm", - "application/pdf", -]; - const openAIContentPartToGooglePart = async ( part: ChatCompletionContentPartType, ): Promise => { @@ -68,7 +50,6 @@ const openAIContentPartToGooglePart = async ( return { text: part.text }; case "image_url": case "file": { - // Both image_url and file parts contain media that needs to be converted let media: string; if (part.type === "image_url") { media = part.image_url.url; @@ -81,7 +62,7 @@ const openAIContentPartToGooglePart = async ( const { media_type: mimeType, data } = await convertMediaToBase64({ media, - allowedMediaTypes: GEMINI_ALLOWED_MEDIA_TYPES, + allowedMediaTypes: null, maxMediaBytes: null, }); diff --git a/packages/proxy/src/providers/openai.test.ts b/packages/proxy/src/providers/openai.test.ts index 37fbd55b..f9b8983a 100644 --- a/packages/proxy/src/providers/openai.test.ts +++ b/packages/proxy/src/providers/openai.test.ts @@ -20,6 +20,15 @@ import { callProxyV1 } from "../../utils/tests"; import * as proxyUtil from "../util"; import { normalizeOpenAIContent } from "./openai"; import * as util from "./util"; +import { + IMAGE_DATA_URL, + PDF_DATA_URL, + AUDIO_DATA_URL, + VIDEO_DATA_URL, + TEXT_DATA_URL, + MD_DATA_URL, + CSV_DATA_URL, +} from "../../tests/fixtures/base64"; it("should deny reasoning_effort for unsupported models non-streaming", async () => { const { json } = await callProxyV1< @@ -495,6 +504,259 @@ describe("request/response checking", () => { }); }); +describe("file content parts", () => { + it("should handle file content part with PDF data URL", async () => { + const { json } = await callProxyV1< + OpenAIChatCompletionCreateParams, + OpenAIChatCompletion + >({ + body: { + model: "gpt-4o", + messages: [ + { + role: "user", + content: [ + { + type: "text", + text: "What is in this document?", + }, + { + type: "file", + file: { + file_data: PDF_DATA_URL, + filename: "document.pdf", + }, + }, + ], + }, + ], + stream: false, + }, + proxyHeaders: { + "x-bt-endpoint-name": "openai", + }, + }); + + const response = json() as OpenAIChatCompletion & { error?: unknown }; + expect(response).toBeTruthy(); + expect(response.error).not.toBeDefined(); + expect(response.choices[0].message.role).toBe("assistant"); + expect(response.choices[0].message.content).toBeTruthy(); + }); + + it("should return error for plain text file content (unsupported)", async () => { + const { statusCode, json } = await callProxyV1< + OpenAIChatCompletionCreateParams, + OpenAIChatCompletion + >({ + body: { + model: "gpt-4o", + messages: [ + { + role: "user", + content: [ + { + type: "text", + text: "What is in this text file?", + }, + { + type: "file", + file: { + file_data: TEXT_DATA_URL, + filename: "document.txt", + }, + }, + ], + }, + ], + stream: false, + }, + proxyHeaders: { + "x-bt-endpoint-name": "openai", + }, + }); + + expect(statusCode).toBe(400); + const response = json() as { error?: { type?: string; message?: string } }; + console.log(response); + expect(response.error).toBeDefined(); + expect(response.error!.type).toBe("invalid_request_error"); + expect(response.error!.message).toContain( + "unsupported MIME type 'text/plain'", + ); + }); + + it("should return error for markdown file content (unsupported)", async () => { + const { statusCode, json } = await callProxyV1< + OpenAIChatCompletionCreateParams, + OpenAIChatCompletion + >({ + body: { + model: "gpt-4o", + messages: [ + { + role: "user", + content: [ + { + type: "text", + text: "What is in this markdown file?", + }, + { + type: "file", + file: { + file_data: MD_DATA_URL, + filename: "document.md", + }, + }, + ], + }, + ], + stream: false, + }, + proxyHeaders: { + "x-bt-endpoint-name": "openai", + }, + }); + + expect(statusCode).toBe(400); + const response = json() as { error?: { type?: string; message?: string } }; + expect(response.error).toBeDefined(); + expect(response.error!.type).toBe("invalid_request_error"); + expect(response.error!.message).toContain( + "unsupported MIME type 'text/markdown'", + ); + }); + + it("should return error for CSV file content (unsupported)", async () => { + const { statusCode, json } = await callProxyV1< + OpenAIChatCompletionCreateParams, + OpenAIChatCompletion + >({ + body: { + model: "gpt-4o", + messages: [ + { + role: "user", + content: [ + { + type: "text", + text: "What muppets are in this CSV file?", + }, + { + type: "file", + file: { + file_data: CSV_DATA_URL, + filename: "muppets.csv", + }, + }, + ], + }, + ], + stream: false, + }, + proxyHeaders: { + "x-bt-endpoint-name": "openai", + }, + }); + + expect(statusCode).toBe(400); + const response = json() as { error?: { type?: string; message?: string } }; + expect(response.error).toBeDefined(); + expect(response.error!.type).toBe("invalid_request_error"); + expect(response.error!.message).toContain( + "unsupported MIME type 'text/csv'", + ); + }); + + it("should handle file content part with audio/wav data URL", async () => { + try { + const { statusCode, json } = await callProxyV1< + OpenAIChatCompletionCreateParams, + OpenAIChatCompletion + >({ + body: { + model: "gpt-audio", + messages: [ + { + role: "user", + content: [ + { + type: "text", + text: "What is in this audio file?", + }, + { + type: "input_audio", + input_audio: { + data: AUDIO_DATA_URL, + format: "wav", + }, + }, + ], + }, + ], + stream: false, + }, + proxyHeaders: { + "x-bt-endpoint-name": "openai", + }, + }); + + expect(statusCode).toBe(400); + const response = json() as { + error?: { type?: string; message?: string }; + }; + expect(response.error).toBeDefined(); + expect(response.error!.type).toBe("invalid_request_error"); + expect(response.error!.message).toContain( + "unsupported MIME type 'audio/wav'", + ); + } catch (error) { + console.log("known missing model, skipping"); + } + }); + + it("should return error for video file content (unsupported)", async () => { + const { statusCode, json } = await callProxyV1< + OpenAIChatCompletionCreateParams, + OpenAIChatCompletion + >({ + body: { + model: "gpt-4o", + messages: [ + { + role: "user", + content: [ + { + type: "text", + text: "What is in this video file?", + }, + { + type: "file", + file: { + file_data: VIDEO_DATA_URL, + filename: "video.mp4", + }, + }, + ], + }, + ], + stream: false, + }, + proxyHeaders: { + "x-bt-endpoint-name": "openai", + }, + }); + + expect(statusCode).toBe(400); + const response = json() as { error?: { type?: string; message?: string } }; + expect(response.error).toBeDefined(); + expect(response.error!.type).toBe("invalid_request_error"); + expect(response.error!.message).toContain( + "unsupported MIME type 'video/mp4'", + ); + }); +}); + const mockBase64Data = "AF1231KF=="; describe("normalizeOpenAIContent", () => { diff --git a/packages/proxy/src/providers/util.ts b/packages/proxy/src/providers/util.ts index 683f621b..1571fe5f 100644 --- a/packages/proxy/src/providers/util.ts +++ b/packages/proxy/src/providers/util.ts @@ -3,7 +3,7 @@ import { arrayBufferToBase64 } from "utils"; const base64MediaPattern = /^data:([a-zA-Z0-9]+\/[a-zA-Z0-9+.-]+);base64,([A-Za-z0-9+/]+={0,2})$/; -interface MediaBlock { +export interface MediaBlock { media_type: string; data: string; } diff --git a/packages/proxy/tests/fixtures/audio.wav b/packages/proxy/tests/fixtures/audio.wav new file mode 100644 index 00000000..f932b9c2 Binary files /dev/null and b/packages/proxy/tests/fixtures/audio.wav differ diff --git a/packages/proxy/tests/fixtures/base64.ts b/packages/proxy/tests/fixtures/base64.ts new file mode 100644 index 00000000..affb5aac --- /dev/null +++ b/packages/proxy/tests/fixtures/base64.ts @@ -0,0 +1,21 @@ +import { readFileSync } from "fs"; + +const fileToBase64 = (filename: string, mimetype: string) => + `data:${mimetype};base64,${readFileSync( + `${__dirname}/${filename}`, + "base64", + )}`; + +export const IMAGE_DATA_URL = fileToBase64("image.png", "image/png"); + +export const PDF_DATA_URL = fileToBase64("file.pdf", "application/pdf"); + +export const TEXT_DATA_URL = fileToBase64("text.txt", "text/plain"); + +export const MD_DATA_URL = fileToBase64("text.md", "text/markdown"); + +export const CSV_DATA_URL = fileToBase64("muppets.csv", "text/csv"); + +export const AUDIO_DATA_URL = fileToBase64("audio.wav", "audio/wav"); + +export const VIDEO_DATA_URL = fileToBase64("video.mp4", "video/mp4"); diff --git a/packages/proxy/tests/fixtures/file.pdf b/packages/proxy/tests/fixtures/file.pdf new file mode 100644 index 00000000..7e3a60fe Binary files /dev/null and b/packages/proxy/tests/fixtures/file.pdf differ diff --git a/packages/proxy/tests/fixtures/image.png b/packages/proxy/tests/fixtures/image.png new file mode 100644 index 00000000..edfca454 Binary files /dev/null and b/packages/proxy/tests/fixtures/image.png differ diff --git a/packages/proxy/tests/fixtures/muppets.csv b/packages/proxy/tests/fixtures/muppets.csv new file mode 100644 index 00000000..c804449c --- /dev/null +++ b/packages/proxy/tests/fixtures/muppets.csv @@ -0,0 +1,13 @@ +Muppet Name,Primary Performer,Estimated Debut Date,Muppet Species,Signature Catchphrase,Is Still Active +Kermit the Frog,Jim Henson,5/9/1955,Frog,"""Hi-ho, Kermit the Frog here!""",TRUE +Miss Piggy,Frank Oz,9/17/1974,Pig,"""Moi!""",TRUE +Fozzie Bear,Frank Oz,9/17/1976,Bear,"""Wocka Wocka!""",TRUE +Gonzo the Great,Dave Goelz,9/17/1976,Whatever,"""Greetings, my fans!""",TRUE +Animal,Frank Oz,9/17/1975,Humanoid Monster,"""Drums! Drums! Drums!""",TRUE +Rowlf the Dog,Jim Henson,9/2/1962,Dog,(Usually humming),TRUE +Dr. Bunsen Honeydew,Dave Goelz,9/17/1977,Human,"""Well, I think it's time for another demonstration.""",TRUE +Beaker,Richard Hunt,9/17/1977,Humanoid,"""Mee-mee-mee-meep!""",TRUE +Scooter,Richard Hunt,9/17/1977,Human,"""Pardon me, Mr. Kermit...""",TRUE +Statler,Richard Hunt,9/5/1975,Human,"""Doh-ho-ho-ho!"" (Laughing with Waldorf)",TRUE +Waldorf,Jim Henson,9/5/1975,Human,"""That's why they call it show *business*, not show *pleasure*\!""",TRUE +Pepe the King Prawn,Bill Barretta,7/16/1996,Prawn,"""Okay, okay, I am telling you, so what is the big deal?""",TRUE diff --git a/packages/proxy/tests/fixtures/text.md b/packages/proxy/tests/fixtures/text.md new file mode 100644 index 00000000..0756648a --- /dev/null +++ b/packages/proxy/tests/fixtures/text.md @@ -0,0 +1,3 @@ +# Title + +This is a paragraph. diff --git a/packages/proxy/tests/fixtures/text.txt b/packages/proxy/tests/fixtures/text.txt new file mode 100644 index 00000000..cd087558 --- /dev/null +++ b/packages/proxy/tests/fixtures/text.txt @@ -0,0 +1 @@ +Hello world! diff --git a/packages/proxy/tests/fixtures/video.mp4 b/packages/proxy/tests/fixtures/video.mp4 new file mode 100644 index 00000000..7936dc09 Binary files /dev/null and b/packages/proxy/tests/fixtures/video.mp4 differ diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 7f0c13fa..9340d811 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -16,7 +16,7 @@ importers: version: 8.57.1 eslint-config-turbo: specifier: latest - version: 2.5.6(eslint@8.57.1)(turbo@2.5.6) + version: 2.7.4(eslint@8.57.1)(turbo@2.5.6) prettier: specifier: 3.3.2 version: 3.3.2 @@ -25,10 +25,10 @@ importers: version: 2.5.6 vite-tsconfig-paths: specifier: ^4.3.2 - version: 4.3.2(typescript@5.5.4) + version: 4.3.2(typescript@5.5.4)(vite@5.4.19(@types/node@20.10.5)) vitest: specifier: ^2.1.9 - version: 2.1.9(@types/node@20.10.5)(msw@2.8.4) + version: 2.1.9(@types/node@20.10.5)(msw@2.8.4(@types/node@20.10.5)(typescript@5.5.4)) apis/cloudflare: dependencies: @@ -49,13 +49,13 @@ importers: version: 2.1.0(@opentelemetry/api@1.9.0) braintrust: specifier: ^0.3.7 - version: 0.3.7(zod@3.25.34) + version: 0.3.7(@aws-sdk/credential-provider-web-identity@3.817.0)(zod@3.25.34) dotenv: specifier: ^16.3.1 version: 16.3.1 openai: specifier: ^6.3.0 - version: 6.3.0(zod@3.25.34) + version: 6.3.0(ws@8.18.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(zod@3.25.34) zod: specifier: 3.25.34 version: 3.25.34 @@ -68,13 +68,13 @@ importers: version: 3.0.12 tsup: specifier: ^8.4.0 - version: 8.4.0(typescript@5.3.3) + version: 8.4.0(postcss@8.5.6)(typescript@5.3.3) typescript: specifier: ^5.0.4 version: 5.3.3 wrangler: specifier: ^4.28.1 - version: 4.42.2(@cloudflare/workers-types@4.20251011.0) + version: 4.42.2(@cloudflare/workers-types@4.20251011.0)(bufferutil@4.0.8)(utf-8-validate@5.0.10) apis/node: dependencies: @@ -86,7 +86,7 @@ importers: version: 2.32.0 ai: specifier: 2.2.22 - version: 2.2.22(react@18.3.1)(solid-js@1.9.10)(svelte@4.2.20)(vue@3.5.22) + version: 2.2.22(react@19.2.3)(solid-js@1.9.10)(svelte@4.2.20)(vue@3.5.22(typescript@5.3.3)) aws-lambda: specifier: ^1.0.7 version: 1.0.7 @@ -116,7 +116,7 @@ importers: version: 4.19.2 openai: specifier: ^4.104.0 - version: 4.104.0(zod@3.25.34) + version: 4.104.0(ws@8.18.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(zod@3.25.34) redis: specifier: ^4.6.8 version: 4.6.8 @@ -159,26 +159,26 @@ importers: version: 0.4.3 '@vercel/examples-ui': specifier: ^1.0.5 - version: 1.0.5(next@14.2.34)(react-dom@18.3.1)(react@18.3.1) + version: 1.0.5(next@14.2.34(@babel/core@7.28.3)(@opentelemetry/api@1.9.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3))(react-dom@19.2.3(react@19.2.3))(react@19.2.3) '@vercel/kv': specifier: ^0.2.2 version: 0.2.2 next: specifier: 14.2.34 - version: 14.2.34(react-dom@18.3.1)(react@18.3.1) + version: 14.2.34(@babel/core@7.28.3)(@opentelemetry/api@1.9.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3) react: specifier: latest - version: 18.3.1 + version: 19.2.3 react-dom: specifier: latest - version: 18.3.1(react@18.3.1) + version: 19.2.3(react@19.2.3) devDependencies: '@types/node': specifier: ^17.0.45 version: 17.0.45 '@types/react': specifier: latest - version: 18.3.3 + version: 19.2.8 autoprefixer: specifier: ^10.4.14 version: 10.4.14(postcss@8.4.38) @@ -187,7 +187,7 @@ importers: version: 8.56.0 eslint-config-next: specifier: canary - version: 15.0.0-canary.36(eslint@8.56.0)(typescript@4.7.4) + version: 16.1.1-canary.22(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint@8.56.0)(typescript@4.7.4) postcss: specifier: ^8.4.21 version: 8.4.38 @@ -204,8 +204,8 @@ importers: packages/proxy: dependencies: '@anthropic-ai/sdk': - specifier: ^0.39.0 - version: 0.39.0 + specifier: ^0.71.2 + version: 0.71.2(zod@3.25.34) '@aws-sdk/client-bedrock-runtime': specifier: ^3.806.0 version: 3.817.0 @@ -333,8 +333,14 @@ packages: resolution: {integrity: sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==} engines: {node: '>=6.0.0'} - '@anthropic-ai/sdk@0.39.0': - resolution: {integrity: sha512-eMyDIPRZbt1CCLErRCi3exlAvNkBtRe+kW5vvJyef93PmNr/clstYgHhtvmkxN82nlKgzyGPCyGxrm0JQ1ZIdg==} + '@anthropic-ai/sdk@0.71.2': + resolution: {integrity: sha512-TGNDEUuEstk/DKu0/TflXAEt+p+p/WhTlFzEnoosvbaDU2LTjm42igSdlL0VijrKpWejtOKxX0b8A7uc+XiSAQ==} + hasBin: true + peerDependencies: + zod: 3.25.34 + peerDependenciesMeta: + zod: + optional: true '@apidevtools/json-schema-ref-parser@11.7.2': resolution: {integrity: sha512-4gY54eEGEstClvEkGnwVkTkrx0sqwemEFG5OSRRn3tD91XH0+Q8XIkYIfo7IwEWPpJZwILb9GUXeShtplRc/eA==} @@ -1262,6 +1268,12 @@ packages: peerDependencies: eslint: ^6.0.0 || ^7.0.0 || >=8.0.0 + '@eslint-community/eslint-utils@4.9.1': + resolution: {integrity: sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + peerDependencies: + eslint: ^6.0.0 || ^7.0.0 || >=8.0.0 + '@eslint-community/regexpp@4.10.0': resolution: {integrity: sha512-Cu96Sd2By9mCNTx2iyKOmq10v22jUVQv0lQnlGNy16oE9589yE+QADPbrMGCkA51cKZSg3Pu/aTJVTGfL/qjUA==} engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0} @@ -1270,6 +1282,10 @@ packages: resolution: {integrity: sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==} engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0} + '@eslint-community/regexpp@4.12.2': + resolution: {integrity: sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==} + engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0} + '@eslint/eslintrc@2.1.4': resolution: {integrity: sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} @@ -1468,9 +1484,6 @@ packages: '@jridgewell/trace-mapping@0.3.25': resolution: {integrity: sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==} - '@jridgewell/trace-mapping@0.3.30': - resolution: {integrity: sha512-GQ7Nw5G2lTu/BtHTKfXhKHok2WGetd4XYcVKGx00SjAk8GMwgJM3zr6zORiPGuOE+/vkc90KtTosSSvaCjKb2Q==} - '@jridgewell/trace-mapping@0.3.31': resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==} @@ -1499,8 +1512,8 @@ packages: '@next/env@14.2.34': resolution: {integrity: sha512-iuGW/UM+EZbn2dm+aLx+avo1rVap+ASoFr7oLpTBVW2G2DqhD5l8Fme9IsLZ6TTsp0ozVSFswidiHK1NGNO+pg==} - '@next/eslint-plugin-next@15.0.0-canary.36': - resolution: {integrity: sha512-e+nAaxXGX5OXx3OVV7zDSAni0mWsBwVu8OPH9p6ZJv8GySDLW15wFEOqlDEgJOcVRQ997ZSn7lSsNGPrbhAWfQ==} + '@next/eslint-plugin-next@16.1.1-canary.22': + resolution: {integrity: sha512-EfRnbLSMYHx8U6YbalpjnMvB3A5IAtsgGZEsyWXBPeUoK96SOndb8a+nCgwvDB99v7I6PoYXSfWF1bPPqOPdGg==} '@next/swc-darwin-arm64@14.2.33': resolution: {integrity: sha512-HqYnb6pxlsshoSTubdXKu15g3iivcbsMXg4bYpjL2iS/V6aQot+iyF4BUc2qA/J/n55YtvE4PHMKWBKGCF/+wA==} @@ -1999,8 +2012,8 @@ packages: cpu: [x64] os: [win32] - '@rushstack/eslint-patch@1.6.1': - resolution: {integrity: sha512-UY+FGM/2jjMkzQLn8pxcHGMaVLh9aEitG3zY2CiY7XHdLiz3bZOwa6oDxNqEMv7zZkV+cj5DOdz0cQ1BP5Hjgw==} + '@rtsao/scc@1.1.0': + resolution: {integrity: sha512-zt6OdqaDoOnJ1ZYsCYGt9YmWzDXl4vQdKTyJev62gFhRGKdx7mcT54V9KIjg+d2wi9EXsPvAPKe7i7WjfVWB8g==} '@sindresorhus/is@7.1.0': resolution: {integrity: sha512-7F/yz2IphV39hiS2zB4QYVkivrptHHh0K8qJJd9HhuWSdvf8AN7NpebW3CcDZDBQsUPMoDKWsY2WWgW7bqOcfA==} @@ -2310,17 +2323,14 @@ packages: '@types/phoenix@1.6.4': resolution: {integrity: sha512-B34A7uot1Cv0XtaHRYDATltAdKx0BvVKNgYNqE4WjtPUa4VQJM7kxeXcVKaH+KS+kCmZ+6w+QaUdcljiheiBJA==} - '@types/prop-types@15.7.11': - resolution: {integrity: sha512-ga8y9v9uyeiLdpKddhxYQkxNDrfvuPrlFb0N1qnZZByvcElJaXthF1UhvCh9TLWJBEHeNtdnbysW7Y6Uq8CVng==} - '@types/qs@6.9.10': resolution: {integrity: sha512-3Gnx08Ns1sEoCrWssEgTSJs/rsT2vhGP+Ja9cnnk9k4ALxinORlQneLXFeFKOTJMOeZUFD1s7w+w2AphTpvzZw==} '@types/range-parser@1.2.7': resolution: {integrity: sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==} - '@types/react@18.3.3': - resolution: {integrity: sha512-hti/R0pS0q1/xx+TsI73XIqk26eBsISZ2R0wUijXIngRK9R/e7Xw/cXVxQK7R5JjW+SV4zGcn5hXjudkN/pLIw==} + '@types/react@19.2.8': + resolution: {integrity: sha512-3MbSL37jEchWZz2p2mjntRZtPt837ij10ApxKfgmXCTuHWagYg7iA5bqPw6C8BMPfwidlvfPI/fxOc42HLhcyg==} '@types/send@0.17.4': resolution: {integrity: sha512-x2EM6TJOybec7c52BX0ZspPodMsQUd5L6PRwOunVyVUhXiBSKf3AezDL8Dgvgt5o0UfKNfuA0eMLr2wLT4AiBA==} @@ -2354,15 +2364,13 @@ packages: eslint: ^8.57.0 || ^9.0.0 typescript: '>=4.8.4 <5.8.0' - '@typescript-eslint/parser@6.14.0': - resolution: {integrity: sha512-QjToC14CKacd4Pa7JK4GeB/vHmWFJckec49FR4hmIRf97+KXole0T97xxu9IFiPxVQ1DBWrQ5wreLwAGwWAVQA==} - engines: {node: ^16.0.0 || >=18.0.0} + '@typescript-eslint/eslint-plugin@8.53.0': + resolution: {integrity: sha512-eEXsVvLPu8Z4PkFibtuFJLJOTAV/nPdgtSjkGoPpddpFk3/ym2oy97jynY6ic2m6+nc5M8SE1e9v/mHKsulcJg==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} peerDependencies: - eslint: ^7.0.0 || ^8.0.0 - typescript: '*' - peerDependenciesMeta: - typescript: - optional: true + '@typescript-eslint/parser': ^8.53.0 + eslint: ^8.57.0 || ^9.0.0 + typescript: '>=4.8.4 <6.0.0' '@typescript-eslint/parser@8.46.2': resolution: {integrity: sha512-BnOroVl1SgrPLywqxyqdJ4l3S2MsKVLDVxZvjI1Eoe8ev2r3kGDo+PcMihNmDE+6/KjkTubSJnmqGZZjQSBq/g==} @@ -2371,15 +2379,24 @@ packages: eslint: ^8.57.0 || ^9.0.0 typescript: '>=4.8.4 <6.0.0' + '@typescript-eslint/parser@8.53.0': + resolution: {integrity: sha512-npiaib8XzbjtzS2N4HlqPvlpxpmZ14FjSJrteZpPxGUaYPlvhzlzUZ4mZyABo0EFrOWnvyd0Xxroq//hKhtAWg==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + eslint: ^8.57.0 || ^9.0.0 + typescript: '>=4.8.4 <6.0.0' + '@typescript-eslint/project-service@8.46.2': resolution: {integrity: sha512-PULOLZ9iqwI7hXcmL4fVfIsBi6AN9YxRc0frbvmg8f+4hQAjQ5GYNKK0DIArNo+rOKmR/iBYwkpBmnIwin4wBg==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} peerDependencies: typescript: '>=4.8.4 <6.0.0' - '@typescript-eslint/scope-manager@6.14.0': - resolution: {integrity: sha512-VT7CFWHbZipPncAZtuALr9y3EuzY1b1t1AEkIq2bTXUPKw+pHoXflGNG5L+Gv6nKul1cz1VH8fz16IThIU0tdg==} - engines: {node: ^16.0.0 || >=18.0.0} + '@typescript-eslint/project-service@8.53.0': + resolution: {integrity: sha512-Bl6Gdr7NqkqIP5yP9z1JU///Nmes4Eose6L1HwpuVHwScgDPPuEWbUVhvlZmb8hy0vX9syLk5EGNL700WcBlbg==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + typescript: '>=4.8.4 <6.0.0' '@typescript-eslint/scope-manager@8.21.0': resolution: {integrity: sha512-G3IBKz0/0IPfdeGRMbp+4rbjfSSdnGkXsM/pFZA8zM9t9klXDnB/YnKOBQ0GoPmoROa4bCq2NeHgJa5ydsQ4mA==} @@ -2389,12 +2406,22 @@ packages: resolution: {integrity: sha512-LF4b/NmGvdWEHD2H4MsHD8ny6JpiVNDzrSZr3CsckEgCbAGZbYM4Cqxvi9L+WqDMT+51Ozy7lt2M+d0JLEuBqA==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + '@typescript-eslint/scope-manager@8.53.0': + resolution: {integrity: sha512-kWNj3l01eOGSdVBnfAF2K1BTh06WS0Yet6JUgb9Cmkqaz3Jlu0fdVUjj9UI8gPidBWSMqDIglmEXifSgDT/D0g==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + '@typescript-eslint/tsconfig-utils@8.46.2': resolution: {integrity: sha512-a7QH6fw4S57+F5y2FIxxSDyi5M4UfGF+Jl1bCGd7+L4KsaUY80GsiF/t0UoRFDHAguKlBaACWJRmdrc6Xfkkag==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} peerDependencies: typescript: '>=4.8.4 <6.0.0' + '@typescript-eslint/tsconfig-utils@8.53.0': + resolution: {integrity: sha512-K6Sc0R5GIG6dNoPdOooQ+KtvT5KCKAvTcY8h2rIuul19vxH5OTQk7ArKkd4yTzkw66WnNY0kPPzzcmWA+XRmiA==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + typescript: '>=4.8.4 <6.0.0' + '@typescript-eslint/type-utils@8.21.0': resolution: {integrity: sha512-95OsL6J2BtzoBxHicoXHxgk3z+9P3BEcQTpBKriqiYzLKnM2DeSqs+sndMKdamU8FosiadQFT3D+BSL9EKnAJQ==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} @@ -2402,9 +2429,12 @@ packages: eslint: ^8.57.0 || ^9.0.0 typescript: '>=4.8.4 <5.8.0' - '@typescript-eslint/types@6.14.0': - resolution: {integrity: sha512-uty9H2K4Xs8E47z3SnXEPRNDfsis8JO27amp2GNCnzGETEW3yTqEIVg5+AI7U276oGF/tw6ZA+UesxeQ104ceA==} - engines: {node: ^16.0.0 || >=18.0.0} + '@typescript-eslint/type-utils@8.53.0': + resolution: {integrity: sha512-BBAUhlx7g4SmcLhn8cnbxoxtmS7hcq39xKCgiutL3oNx1TaIp+cny51s8ewnKMpVUKQUGb41RAUWZ9kxYdovuw==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + eslint: ^8.57.0 || ^9.0.0 + typescript: '>=4.8.4 <6.0.0' '@typescript-eslint/types@7.13.1': resolution: {integrity: sha512-7K7HMcSQIAND6RBL4kDl24sG/xKM13cA85dc7JnmQXw2cBDngg7c19B++JzvJHRG3zG36n9j1i451GBzRuHchw==} @@ -2418,14 +2448,9 @@ packages: resolution: {integrity: sha512-lNCWCbq7rpg7qDsQrd3D6NyWYu+gkTENkG5IKYhUIcxSb59SQC/hEQ+MrG4sTgBVghTonNWq42bA/d4yYumldQ==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} - '@typescript-eslint/typescript-estree@6.14.0': - resolution: {integrity: sha512-yPkaLwK0yH2mZKFE/bXkPAkkFgOv15GJAUzgUVonAbv0Hr4PK/N2yaA/4XQbTZQdygiDkpt5DkxPELqHguNvyw==} - engines: {node: ^16.0.0 || >=18.0.0} - peerDependencies: - typescript: '*' - peerDependenciesMeta: - typescript: - optional: true + '@typescript-eslint/types@8.53.0': + resolution: {integrity: sha512-Bmh9KX31Vlxa13+PqPvt4RzKRN1XORYSLlAE+sO1i28NkisGbTtSLFVB3l7PWdHtR3E0mVMuC7JilWJ99m2HxQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} '@typescript-eslint/typescript-estree@7.13.1': resolution: {integrity: sha512-uxNr51CMV7npU1BxZzYjoVz9iyjckBduFBP0S5sLlh1tXYzHzgZ3BR9SVsNed+LmwKrmnqN3Kdl5t7eZ5TS1Yw==} @@ -2448,6 +2473,12 @@ packages: peerDependencies: typescript: '>=4.8.4 <6.0.0' + '@typescript-eslint/typescript-estree@8.53.0': + resolution: {integrity: sha512-pw0c0Gdo7Z4xOG987u3nJ8akL9093yEEKv8QTJ+Bhkghj1xyj8cgPaavlr9rq8h7+s6plUJ4QJYw2gCZodqmGw==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + typescript: '>=4.8.4 <6.0.0' + '@typescript-eslint/utils@8.21.0': resolution: {integrity: sha512-xcXBfcq0Kaxgj7dwejMbFyq7IOHgpNMtVuDveK7w3ZGwG9owKzhALVwKpTF2yrZmEwl9SWdetf3fxNzJQaVuxw==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} @@ -2455,9 +2486,12 @@ packages: eslint: ^8.57.0 || ^9.0.0 typescript: '>=4.8.4 <5.8.0' - '@typescript-eslint/visitor-keys@6.14.0': - resolution: {integrity: sha512-fB5cw6GRhJUz03MrROVuj5Zm/Q+XWlVdIsFj+Zb1Hvqouc8t+XP2H5y53QYU/MGtd2dPg6/vJJlhoX3xc2ehfw==} - engines: {node: ^16.0.0 || >=18.0.0} + '@typescript-eslint/utils@8.53.0': + resolution: {integrity: sha512-XDY4mXTez3Z1iRDI5mbRhH4DFSt46oaIFsLg+Zn97+sYrXACziXSQcSelMybnVZ5pa1P6xYkPr5cMJyunM1ZDA==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + eslint: ^8.57.0 || ^9.0.0 + typescript: '>=4.8.4 <6.0.0' '@typescript-eslint/visitor-keys@7.13.1': resolution: {integrity: sha512-k/Bfne7lrP7hcb7m9zSsgcBmo+8eicqqfNAJ7uUY+jkTFpKeH2FSkWpFRtimBxgkyvqfu9jTPRbYOvud6isdXA==} @@ -2471,6 +2505,10 @@ packages: resolution: {integrity: sha512-tUFMXI4gxzzMXt4xpGJEsBsTox0XbNQ1y94EwlD/CuZwFcQP79xfQqMhau9HsRc/J0cAPA/HZt1dZPtGn9V/7w==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + '@typescript-eslint/visitor-keys@8.53.0': + resolution: {integrity: sha512-LZ2NqIHFhvFwxG0qZeLL9DvdNAHPGCY5dIRwBhyYeU+LfLhcStE1ImjsuTG/WaVh3XysGaeLW8Rqq7cGkPCFvw==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + '@ungap/structured-clone@1.2.0': resolution: {integrity: sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==} @@ -2725,9 +2763,6 @@ packages: argparse@2.0.1: resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==} - aria-query@5.3.0: - resolution: {integrity: sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==} - aria-query@5.3.2: resolution: {integrity: sha512-COROpnaoap1E2F000S62r6A60uHZnmlvomhfyT2DlTcrY1OrBKn2UhH7qn5wTC9zMvD0AY7csdPSNwKP+7WiQw==} engines: {node: '>= 0.4'} @@ -2735,6 +2770,10 @@ packages: array-buffer-byte-length@1.0.0: resolution: {integrity: sha512-LPuwb2P+NrQw3XhxGc36+XSvuBPopovXYTR9Ew++Du9Yb/bx5AzBfrIsBoj0EZUifjQU+sHL21sseZ3jerWO/A==} + array-buffer-byte-length@1.0.2: + resolution: {integrity: sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw==} + engines: {node: '>= 0.4'} + array-differ@3.0.0: resolution: {integrity: sha512-THtfYS6KtME/yIAhKjZ2ul7XI96lQGHRputJQHO80LAWQnuGP4iCIN8vdMRboGbIEYBwU33q8Tch1os2+X0kMg==} engines: {node: '>=8'} @@ -2742,33 +2781,50 @@ packages: array-flatten@1.1.1: resolution: {integrity: sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==} - array-includes@3.1.7: - resolution: {integrity: sha512-dlcsNBIiWhPkHdOEEKnehA+RNUWDc4UqFtnIXU4uuYDPtA4LDkr7qip2p0VvFAEXNDr0yWZ9PJyIRiGjRLQzwQ==} + array-includes@3.1.9: + resolution: {integrity: sha512-FmeCCAenzH0KH381SPT5FZmiA/TmpndpcaShhfgEN9eCVjnFBqq3l1xrI42y8+PPLI6hypzou4GXw00WHmPBLQ==} engines: {node: '>= 0.4'} array-union@2.1.0: resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==} engines: {node: '>=8'} - array.prototype.findlastindex@1.2.3: - resolution: {integrity: sha512-LzLoiOMAxvy+Gd3BAq3B7VeIgPdo+Q8hthvKtXybMvRV0jrXfJM/t8mw7nNlpEcVlVUnCnM2KSX4XU5HmpodOA==} + array.prototype.findlast@1.2.5: + resolution: {integrity: sha512-CVvd6FHg1Z3POpBLxO6E6zr+rSKEQ9L6rZHAaY7lLfhKsWYUBBOuMs0e9o24oopj6H+geRCX0YJ+TJLBK2eHyQ==} + engines: {node: '>= 0.4'} + + array.prototype.findlastindex@1.2.6: + resolution: {integrity: sha512-F/TKATkzseUExPlfvmwQKGITM3DGTK+vkAsCZoDc5daVygbJBnjEUCbgkAvVFsgfXfX4YIqZ/27G3k3tdXrTxQ==} engines: {node: '>= 0.4'} array.prototype.flat@1.3.2: resolution: {integrity: sha512-djYB+Zx2vLewY8RWlNCUdHjDXs2XOgm602S9E7P/UpHgfeHL00cRiIF+IN/G/aUJ7kGPb6yO/ErDI5V2s8iycA==} engines: {node: '>= 0.4'} + array.prototype.flat@1.3.3: + resolution: {integrity: sha512-rwG/ja1neyLqCuGZ5YYrznA62D4mZXg0i1cIskIUKSiqF3Cje9/wXAls9B9s1Wa2fomMsIv8czB8jZcPmxCXFg==} + engines: {node: '>= 0.4'} + array.prototype.flatmap@1.3.2: resolution: {integrity: sha512-Ewyx0c9PmpcsByhSW4r+9zDU7sGjFc86qf/kKtuSCRdhfbk0SNLLkaT5qvcHnRGgc5NP/ly/y+qkXkqONX54CQ==} engines: {node: '>= 0.4'} - array.prototype.tosorted@1.1.2: - resolution: {integrity: sha512-HuQCHOlk1Weat5jzStICBCd83NxiIMwqDg/dHEsoefabn/hJRj5pVdWcPUSpRrwhwxZOsQassMpgN/xRYFBMIg==} + array.prototype.flatmap@1.3.3: + resolution: {integrity: sha512-Y7Wt51eKJSyi80hFrJCePGGNo5ktJCslFuboqJsbf57CCPcm5zztluPlc4/aD8sWsKvlwatezpV4U1efk8kpjg==} + engines: {node: '>= 0.4'} + + array.prototype.tosorted@1.1.4: + resolution: {integrity: sha512-p6Fx8B7b7ZhL/gmUsAy0D15WhvDccw3mnGNbZpi3pmeJdxtWsj2jEaI4Y6oo3XiHfzuSgPwKc04MYt6KgvC/wA==} + engines: {node: '>= 0.4'} arraybuffer.prototype.slice@1.0.2: resolution: {integrity: sha512-yMBKppFur/fbHu9/6USUe03bZ4knMYiwFBcyiaXB8Go0qNehwX6inYPzK9U0NeQvGxKthcmHcaR8P5MStSRBAw==} engines: {node: '>= 0.4'} + arraybuffer.prototype.slice@1.0.4: + resolution: {integrity: sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ==} + engines: {node: '>= 0.4'} + arrify@2.0.1: resolution: {integrity: sha512-3duEwti880xqi4eAMN8AyR4a0ByT90zoYdLlevfrvU43vb0YZwZVfxOgxWrLXXXpyugL0hNZc9G6BiB5B3nUug==} engines: {node: '>=8'} @@ -2780,9 +2836,6 @@ packages: ast-types-flow@0.0.8: resolution: {integrity: sha512-OH/2E5Fg20h2aPrbe+QL8JZQFko0YZaF+j4mnQ7BGhfavO7OpSLa8a0y9sBwomHdSbkhTS8TQNayBfnW5DwbvQ==} - asynciterator.prototype@1.0.0: - resolution: {integrity: sha512-wwHYEIS0Q80f5mosx3L/dfG5t5rjEa9Ft51GTaNt862EnpyGHpgz2RkZvLPp1oF5TnAiTohkEKVEu8pQPJI7Vg==} - asynckit@0.4.0: resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==} @@ -2797,6 +2850,10 @@ packages: resolution: {integrity: sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw==} engines: {node: '>= 0.4'} + available-typed-arrays@1.0.7: + resolution: {integrity: sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==} + engines: {node: '>= 0.4'} + aws-lambda@1.0.7: resolution: {integrity: sha512-9GNFMRrEMG5y3Jvv+V4azWvc+qNWdWLTjDdhf/zgMlz8haaaLWv0xeAIWxz9PuWUBawsVxy0zZotjCdR3Xq+2w==} hasBin: true @@ -2805,16 +2862,13 @@ packages: resolution: {integrity: sha512-mUXUaWmbIyqE6zyIcbUUQIUgw1evK7gV1vQP7ZZEE0qi6hO2Mw99Nc25Bh+187yvRxamMTsFXvvmBViR0Q75SA==} engines: {node: '>= 10.0.0'} - axe-core@4.7.0: - resolution: {integrity: sha512-M0JtH+hlOL5pLQwHOLNYZaXuhqmvS8oExsqB1SBYgA4Dk7u/xx+YdGHXaK5pyUfed5mYXdlYiphWq3G8cRi5JQ==} + axe-core@4.11.1: + resolution: {integrity: sha512-BASOg+YwO2C+346x3LZOeoovTIoTrRqEsqMa6fmfAV0P+U9mFr9NsyOEpiYvFjbc64NMrSswhV50WdXzdb/Z5A==} engines: {node: '>=4'} axios@1.13.1: resolution: {integrity: sha512-hU4EGxxt+j7TQijx1oYdAjw4xuIp1wRQSsbMFwSthCWeBQur1eF+qJ5iQ5sN3Tw8YRzQNKb8jszgBdMDVqwJcw==} - axobject-query@3.2.1: - resolution: {integrity: sha512-jsyHu61e6N4Vbz/v18DHwWYKK0bSWLqn47eeDSKPB7m8tqMHF9YJ+mhIk2lVteyZrY8tnSj/jHOv4YiTCuCJgg==} - axobject-query@4.1.0: resolution: {integrity: sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ==} engines: {node: '>= 0.4'} @@ -2920,6 +2974,10 @@ packages: call-bind@1.0.5: resolution: {integrity: sha512-C3nQxfFZxFRVoJoGKKI8y3MOEo129NQ+FgQ08iye+Mk4zNZZGdjfs06bVTr+DBSlA66Q2VEcMki/cUCP4SercQ==} + call-bind@1.0.8: + resolution: {integrity: sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==} + engines: {node: '>= 0.4'} + call-bound@1.0.4: resolution: {integrity: sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==} engines: {node: '>= 0.4'} @@ -3146,12 +3204,27 @@ packages: csstype@3.1.3: resolution: {integrity: sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==} + csstype@3.2.3: + resolution: {integrity: sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==} + d@1.0.1: resolution: {integrity: sha512-m62ShEObQ39CfralilEQRjH6oAMtNCV1xJyEx5LpRYUVN+EviphDgUc/F3hnYbADmkiNs67Y+3ylmlG7Lnu+FA==} damerau-levenshtein@1.0.8: resolution: {integrity: sha512-sdQSFB7+llfUcQHUQO3+B8ERRj0Oa4w9POWMI/puGtuf7gFywGmkaLCElnudfTiKZV+NvHqL0ifzdrI8Ro7ESA==} + data-view-buffer@1.0.2: + resolution: {integrity: sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ==} + engines: {node: '>= 0.4'} + + data-view-byte-length@1.0.2: + resolution: {integrity: sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ==} + engines: {node: '>= 0.4'} + + data-view-byte-offset@1.0.1: + resolution: {integrity: sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ==} + engines: {node: '>= 0.4'} + date-fns@4.1.0: resolution: {integrity: sha512-Ukq0owbQXxa/U3EGtsdVBkR1w7KOQ5gIBqdH2hkvknzZPYvBxb/aa6E8L7tmjFtkwZBu3UXBbjIgPo/Ez4xaNg==} @@ -3230,6 +3303,10 @@ packages: resolution: {integrity: sha512-E7uGkTzkk1d0ByLeSc6ZsFS79Axg+m1P/VsgYsxHgiuc3tFSj+MjMIwe90FC4lOAZzNBdY7kkO2P2wKdsQ1vgQ==} engines: {node: '>= 0.4'} + define-data-property@1.1.4: + resolution: {integrity: sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==} + engines: {node: '>= 0.4'} + define-properties@1.2.1: resolution: {integrity: sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==} engines: {node: '>= 0.4'} @@ -3376,6 +3453,10 @@ packages: resolution: {integrity: sha512-eiiY8HQeYfYH2Con2berK+To6GrK2RxbPawDkGq4UiCQQfZHb6wX9qQqkbpPqaxQFcl8d9QzZqo0tGE0VcrdwA==} engines: {node: '>= 0.4'} + es-abstract@1.24.1: + resolution: {integrity: sha512-zHXBLhP+QehSSbsS9Pt23Gg964240DPd6QCf8WpkqEXxQ7fhdZzYsocOr5u7apWonsS5EjZDmTF+/slGMyasvw==} + engines: {node: '>= 0.4'} + es-define-property@1.0.1: resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==} engines: {node: '>= 0.4'} @@ -3384,8 +3465,9 @@ packages: resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==} engines: {node: '>= 0.4'} - es-iterator-helpers@1.0.15: - resolution: {integrity: sha512-GhoY8uYqd6iwUl2kgjTm4CZAf6oo5mHK7BPqx3rKgx893YSsy0LGHV6gfqqQvZt/8xM8xeOnfXBCfqclMKkJ5g==} + es-iterator-helpers@1.2.2: + resolution: {integrity: sha512-BrUQ0cPTB/IwXj23HtwHjS9n7O4h9FX94b4xc5zlTHxeLgTAdzYUDyy6KdExAl9lbN5rtfe44xpjpmj9grxs5w==} + engines: {node: '>= 0.4'} es-module-lexer@1.7.0: resolution: {integrity: sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==} @@ -3401,10 +3483,18 @@ packages: es-shim-unscopables@1.0.2: resolution: {integrity: sha512-J3yBRXCzDu4ULnQwxyToo/OjdMx6akgVC7K6few0a7F/0wLtmKKN7I73AH5T2836UuXRqN7Qg+IIUw/+YJksRw==} + es-shim-unscopables@1.1.0: + resolution: {integrity: sha512-d9T8ucsEhh8Bi1woXCf+TIKDIROLG5WCkxg8geBCbvk22kzwC5G2OnXVMO6FUsvQlgUUXQ2itephWDLqDzbeCw==} + engines: {node: '>= 0.4'} + es-to-primitive@1.2.1: resolution: {integrity: sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==} engines: {node: '>= 0.4'} + es-to-primitive@1.3.0: + resolution: {integrity: sha512-w+5mJ3GuFL+NjVtJlvydShqE1eN3h3PbI7/5LAsYJP/2qtuMXjfL2LpHSRqo4b4eSF5K/DH1JXKUAHSB2UW50g==} + engines: {node: '>= 0.4'} + es5-ext@0.10.62: resolution: {integrity: sha512-BHLqn0klhEpnOKSrzn/Xsz2UIW8j+cGmo9JLzr8BiUapV8hPL9+FliFqjwr9ngW7jWdnxv6eO+/LqyhJVqgrjA==} engines: {node: '>=0.10'} @@ -3454,17 +3544,17 @@ packages: resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==} engines: {node: '>=10'} - eslint-config-next@15.0.0-canary.36: - resolution: {integrity: sha512-tSHB3+DEefRv6qVqysW0m7dplatzcyZdgpTSq+6pV5JBsFlIx3grdYxxQrRlTOxZl7+pH6G6hhhZDUMmQcQYEA==} + eslint-config-next@16.1.1-canary.22: + resolution: {integrity: sha512-kjB5uc5QjBg2TLFDbOoW8W0PVk+oHQEAFTDVbwIRbaqvmz8T2/ccMeeS25HqBXHj5QtuagTjs/YTzmNPgNgXZw==} peerDependencies: - eslint: ^7.23.0 || ^8.0.0 + eslint: '>=9.0.0' typescript: '>=3.3.1' peerDependenciesMeta: typescript: optional: true - eslint-config-turbo@2.5.6: - resolution: {integrity: sha512-1EV/UqdKE75st9q6y0MCxz7qp2v7RyGvbQsMLSuCz+VH8ScnSfmhd8FcAbqx3BshCy5IluujzMB6T5iCgL3/sA==} + eslint-config-turbo@2.7.4: + resolution: {integrity: sha512-HhIqaGxIxZ8IxOqH30zvOr8kMmLGiOiDaOrFJwER9R++9L1OztVVsbs695Vti60XkYG6aa5F1TIBsYA5TP3hEw==} peerDependencies: eslint: '>6.6.0' turbo: '>2.0.0' @@ -3479,6 +3569,27 @@ packages: eslint: '*' eslint-plugin-import: '*' + eslint-module-utils@2.12.1: + resolution: {integrity: sha512-L8jSWTze7K2mTg0vos/RuLRS5soomksDPoJLXIslC7c8Wmut3bx7CPpJijDcBZtxQ5lrbUdM+s0OlNbz0DCDNw==} + engines: {node: '>=4'} + peerDependencies: + '@typescript-eslint/parser': '*' + eslint: '*' + eslint-import-resolver-node: '*' + eslint-import-resolver-typescript: '*' + eslint-import-resolver-webpack: '*' + peerDependenciesMeta: + '@typescript-eslint/parser': + optional: true + eslint: + optional: true + eslint-import-resolver-node: + optional: true + eslint-import-resolver-typescript: + optional: true + eslint-import-resolver-webpack: + optional: true + eslint-module-utils@2.8.0: resolution: {integrity: sha512-aWajIYfsqCKRDgUfjEXNN/JlrzauMuSEy5sbd7WXbtW3EH6A6MpwEh42c7qD+MqQo9QMJ6fWLAeIJynx0g6OAw==} engines: {node: '>=4'} @@ -3500,36 +3611,36 @@ packages: eslint-import-resolver-webpack: optional: true - eslint-plugin-import@2.29.1: - resolution: {integrity: sha512-BbPC0cuExzhiMo4Ff1BTVwHpjjv28C5R+btTOGaCRC7UEz801up0JadwkeSk5Ued6TG34uaczuVuH6qyy5YUxw==} + eslint-plugin-import@2.32.0: + resolution: {integrity: sha512-whOE1HFo/qJDyX4SnXzP4N6zOWn79WhnCUY/iDR0mPfQZO8wcYE4JClzI2oZrhBnnMUCBCHZhO6VQyoBU95mZA==} engines: {node: '>=4'} peerDependencies: '@typescript-eslint/parser': '*' - eslint: ^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8 + eslint: ^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8 || ^9 peerDependenciesMeta: '@typescript-eslint/parser': optional: true - eslint-plugin-jsx-a11y@6.8.0: - resolution: {integrity: sha512-Hdh937BS3KdwwbBaKd5+PLCOmYY6U4f2h9Z2ktwtNKvIdIEu137rjYbcb9ApSbVJfWxANNuiKTD/9tOKjK9qOA==} + eslint-plugin-jsx-a11y@6.10.2: + resolution: {integrity: sha512-scB3nz4WmG75pV8+3eRUQOHZlNSUhFNq37xnpgRkCCELU3XMvXAxLk1eqWWyE22Ki4Q01Fnsw9BA3cJHDPgn2Q==} engines: {node: '>=4.0'} peerDependencies: - eslint: ^3 || ^4 || ^5 || ^6 || ^7 || ^8 + eslint: ^3 || ^4 || ^5 || ^6 || ^7 || ^8 || ^9 - eslint-plugin-react-hooks@4.6.0: - resolution: {integrity: sha512-oFc7Itz9Qxh2x4gNHStv3BqJq54ExXmfC+a1NjAta66IAN87Wu0R/QArgIS9qKzX3dXKPI9H5crl9QchNMY9+g==} - engines: {node: '>=10'} + eslint-plugin-react-hooks@7.0.1: + resolution: {integrity: sha512-O0d0m04evaNzEPoSW+59Mezf8Qt0InfgGIBJnpC0h3NH/WjUAR7BIKUfysC6todmtiZ/A0oUVS8Gce0WhBrHsA==} + engines: {node: '>=18'} peerDependencies: - eslint: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 + eslint: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0 - eslint-plugin-react@7.33.2: - resolution: {integrity: sha512-73QQMKALArI8/7xGLNI/3LylrEYrlKZSb5C9+q3OtOewTnMQi5cT+aE9E41sLCmli3I9PGGmD1yiZydyo4FEPw==} + eslint-plugin-react@7.37.5: + resolution: {integrity: sha512-Qteup0SqU15kdocexFNAJMvCJEfa2xUKNV4CC1xsVMrIIqEy3SQ/rqyxCWNzfrd3/ldy6HMlD2e0JDVpDg2qIA==} engines: {node: '>=4'} peerDependencies: - eslint: ^3 || ^4 || ^5 || ^6 || ^7 || ^8 + eslint: ^3 || ^4 || ^5 || ^6 || ^7 || ^8 || ^9.7 - eslint-plugin-turbo@2.5.6: - resolution: {integrity: sha512-KUDE23aP2JV8zbfZ4TeM1HpAXzMM/AYG/bJam7P4AalUxas8Pd/lS/6R3p4uX91qJcH1LwL4h0ED48nDe8KorQ==} + eslint-plugin-turbo@2.7.4: + resolution: {integrity: sha512-kye4pyGpZMJLgykeRDYTK2kpzHFw7kWlaio66Y4dL/9IMa7cIXirvvHVryV8D7ni3eOsHZYYQ9k0nADKNnecjQ==} peerDependencies: eslint: '>6.6.0' turbo: '>2.0.0' @@ -3553,6 +3664,7 @@ packages: eslint@8.56.0: resolution: {integrity: sha512-Go19xM6T9puCOWntie1/P997aXxFsOi37JIHRWI514Hc6ZnaHGKY9xFhrU65RT6CcBEzZoGG1e6Nq+DT04ZtZQ==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + deprecated: This version is no longer supported. Please see https://eslint.org/version-support for other options. hasBin: true eslint@8.57.1: @@ -3648,6 +3760,10 @@ packages: fast-deep-equal@3.1.3: resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==} + fast-glob@3.3.1: + resolution: {integrity: sha512-kNFPyjhh5cKjrUltxs+wFx+ZkbRaxxmZ+X0ZU31SOsxCEtP9VPgtq2teZw1DebupL5GmDaNQ6yKMMVcM41iqDg==} + engines: {node: '>=8.6.0'} + fast-glob@3.3.2: resolution: {integrity: sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow==} engines: {node: '>=8.6.0'} @@ -3680,6 +3796,15 @@ packages: picomatch: optional: true + fdir@6.5.0: + resolution: {integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==} + engines: {node: '>=12.0.0'} + peerDependencies: + picomatch: ^3 || ^4 + peerDependenciesMeta: + picomatch: + optional: true + file-entry-cache@6.0.1: resolution: {integrity: sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==} engines: {node: ^10.12.0 || >=12.0.0} @@ -3730,6 +3855,10 @@ packages: for-each@0.3.3: resolution: {integrity: sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==} + for-each@0.3.5: + resolution: {integrity: sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==} + engines: {node: '>= 0.4'} + foreground-child@3.2.1: resolution: {integrity: sha512-PXUUyLqrR2XCWICfv6ukppP96sdFwWbNEnfEMt7jNsISjMsvaLNinAHNDYyvkyU+SZG2BTSbT5NjG+vZslfGTA==} engines: {node: '>=14'} @@ -3781,6 +3910,10 @@ packages: resolution: {integrity: sha512-Z5kx79swU5P27WEayXM1tBi5Ze/lbIyiNgU3qyXUOf9b2rgXYyF9Dy9Cx+IQv/Lc8WCG6L82zwUPpSS9hGehIg==} engines: {node: '>= 0.4'} + function.prototype.name@1.1.8: + resolution: {integrity: sha512-e5iwyodOHhbMr/yNrc7fDYG4qlbIvI5gajyzPnb5TCwyhjApznQh1BMFou9b30SevY43gCJKXycoCBjMbsuW0Q==} + engines: {node: '>= 0.4'} + functions-have-names@1.2.3: resolution: {integrity: sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==} @@ -3815,6 +3948,10 @@ packages: resolution: {integrity: sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==} engines: {node: '>= 0.4'} + get-symbol-description@1.1.0: + resolution: {integrity: sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==} + engines: {node: '>= 0.4'} + get-tsconfig@4.7.2: resolution: {integrity: sha512-wuMsz4leaj5hbGgg4IvDU0bqJagpftG5l5cXIAvo8uZrqn0NJqwtfupTN00VnkQJPcIRrxYrm1Ue24btpCha2A==} @@ -3854,10 +3991,18 @@ packages: resolution: {integrity: sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==} engines: {node: '>=8'} + globals@16.4.0: + resolution: {integrity: sha512-ob/2LcVVaVGCYN+r14cnwnoDPUufjiYgSqRhiFD0Q1iI4Odora5RE8Iv1D24hAz5oMophRGkGz+yuvQmmUMnMw==} + engines: {node: '>=18'} + globalthis@1.0.3: resolution: {integrity: sha512-sFdI5LyBiNTHjRd7cGPWapiHWMOXKyuBNX/cWJ3NfzrZQVa8GI/8cofCl74AOVqq9W5kNmguTIzJ/1s2gyI9wA==} engines: {node: '>= 0.4'} + globalthis@1.0.4: + resolution: {integrity: sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==} + engines: {node: '>= 0.4'} + globby@11.1.0: resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==} engines: {node: '>=10'} @@ -3901,10 +4046,17 @@ packages: has-property-descriptors@1.0.1: resolution: {integrity: sha512-VsX8eaIewvas0xnvinAe9bw4WfIeODpGYikiWYLH+dma0Jw6KHYqWiWfhQlgOVK8D6PvjubK5Uc4P0iIhIcNVg==} + has-property-descriptors@1.0.2: + resolution: {integrity: sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==} + has-proto@1.0.1: resolution: {integrity: sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==} engines: {node: '>= 0.4'} + has-proto@1.2.0: + resolution: {integrity: sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ==} + engines: {node: '>= 0.4'} + has-symbols@1.0.3: resolution: {integrity: sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==} engines: {node: '>= 0.4'} @@ -3917,10 +4069,6 @@ packages: resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==} engines: {node: '>= 0.4'} - hasown@2.0.0: - resolution: {integrity: sha512-vUptKVTpIJhcczKBbgnS+RtcuYMB8+oNzPK2/Hp3hanz8JmpATdmmgLgSaadVREkDm+e2giHwY3ZRkyjSIDDFA==} - engines: {node: '>= 0.4'} - hasown@2.0.2: resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==} engines: {node: '>= 0.4'} @@ -3928,6 +4076,12 @@ packages: headers-polyfill@4.0.3: resolution: {integrity: sha512-IScLbePpkvO846sIwOtOTDjutRMWdXdJmXdMvk6gCBHxFO8d+QKOQedyZSxFTTFYRSmlgSTDtXqqq4pcenBXLQ==} + hermes-estree@0.25.1: + resolution: {integrity: sha512-0wUoCcLp+5Ev5pDW2OriHC2MJCbwLwuRx+gAqMTOkGKJJiBCLjtrvy4PWUGn6MIVefecRpzoOZ/UV6iGdOr+Cw==} + + hermes-parser@0.25.1: + resolution: {integrity: sha512-6pEjquH3rqaI6cYAXYPcz9MS4rY6R4ngRgrgfDshRptUZIc3lw0MCIJIGDj9++mfySOuPTHB4nrSW99BCvOPIA==} + homedir-polyfill@1.0.3: resolution: {integrity: sha512-eSmmWE5bZTK2Nou4g0AI3zZ9rswp7GRKoKXS1BLUkvPviOqs4YTN1djQIqrXy9k5gEtdLPy86JjRwsNM9tnDcA==} engines: {node: '>=0.10.0'} @@ -3967,6 +4121,10 @@ packages: resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==} engines: {node: '>= 4'} + ignore@7.0.5: + resolution: {integrity: sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==} + engines: {node: '>= 4'} + import-fresh@3.3.1: resolution: {integrity: sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==} engines: {node: '>=6'} @@ -3989,6 +4147,10 @@ packages: resolution: {integrity: sha512-Xj6dv+PsbtwyPpEflsejS+oIZxmMlV44zAhG479uYu89MsjcYOhCFnNyKrkJrihbsiasQyY0afoCl/9BLR65bg==} engines: {node: '>= 0.4'} + internal-slot@1.1.0: + resolution: {integrity: sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==} + engines: {node: '>= 0.4'} + io-ts@2.2.22: resolution: {integrity: sha512-FHCCztTkHoV9mdBsHpocLpdTAfh956ZQcIkWQxxS0U5HT53vtrcuYdQneEJKH6xILaLNzXVl2Cvwtoy8XNN0AA==} peerDependencies: @@ -4005,6 +4167,10 @@ packages: is-array-buffer@3.0.2: resolution: {integrity: sha512-y+FyyR/w8vfIRq4eQcM1EYgSTnmHXPqaF+IgzgraytCFq5Xh8lllDVmAZolPJiZttZLeFSINPYMaEJ7/vWUa1w==} + is-array-buffer@3.0.5: + resolution: {integrity: sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==} + engines: {node: '>= 0.4'} + is-arrayish@0.2.1: resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==} @@ -4018,6 +4184,10 @@ packages: is-bigint@1.0.4: resolution: {integrity: sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==} + is-bigint@1.1.0: + resolution: {integrity: sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ==} + engines: {node: '>= 0.4'} + is-binary-path@2.1.0: resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==} engines: {node: '>=8'} @@ -4026,6 +4196,10 @@ packages: resolution: {integrity: sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==} engines: {node: '>= 0.4'} + is-boolean-object@1.2.2: + resolution: {integrity: sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A==} + engines: {node: '>= 0.4'} + is-callable@1.2.7: resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==} engines: {node: '>= 0.4'} @@ -4033,10 +4207,22 @@ packages: is-core-module@2.13.1: resolution: {integrity: sha512-hHrIjvZsftOsvKSn2TRYl63zvxsgE0K+0mYMoH6gD4omR5IWB2KynivBQczo3+wF1cCkjzvptnI9Q0sPU66ilw==} + is-core-module@2.16.1: + resolution: {integrity: sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==} + engines: {node: '>= 0.4'} + + is-data-view@1.0.2: + resolution: {integrity: sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw==} + engines: {node: '>= 0.4'} + is-date-object@1.0.5: resolution: {integrity: sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==} engines: {node: '>= 0.4'} + is-date-object@1.1.0: + resolution: {integrity: sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==} + engines: {node: '>= 0.4'} + is-docker@3.0.0: resolution: {integrity: sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ==} engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} @@ -4046,8 +4232,9 @@ packages: resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==} engines: {node: '>=0.10.0'} - is-finalizationregistry@1.0.2: - resolution: {integrity: sha512-0by5vtUJs8iFQb5TYUHHPudOR+qXYIMKtiUzvLIZITZUjknFmziyBJuLhVRc+Ds0dREFlskDNJKYIdIzu/9pfw==} + is-finalizationregistry@1.1.1: + resolution: {integrity: sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg==} + engines: {node: '>= 0.4'} is-fullwidth-code-point@3.0.0: resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==} @@ -4070,13 +4257,18 @@ packages: resolution: {integrity: sha512-qP1vozQRI+BMOPcjFzrjXuQvdak2pHNUMZoeG2eRbiSqyvbEf/wQtEOTOX1guk6E3t36RkaqiSt8A/6YElNxLQ==} engines: {node: '>=12'} - is-map@2.0.2: - resolution: {integrity: sha512-cOZFQQozTha1f4MxLFzlgKYPTyj26picdZTx82hbc/Xf4K/tZOOXSCkMvU4pKioRXGDLJRn0GM7Upe7kR721yg==} + is-map@2.0.3: + resolution: {integrity: sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw==} + engines: {node: '>= 0.4'} is-negative-zero@2.0.2: resolution: {integrity: sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA==} engines: {node: '>= 0.4'} + is-negative-zero@2.0.3: + resolution: {integrity: sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==} + engines: {node: '>= 0.4'} + is-node-process@1.2.0: resolution: {integrity: sha512-Vg4o6/fqPxIjtxgUH5QLJhwZ7gW5diGCVlXpuUfELC62CuxM1iHcRe51f2W1FDy04Ai4KJkagKjx3XaqyfRKXw==} @@ -4084,6 +4276,10 @@ packages: resolution: {integrity: sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==} engines: {node: '>= 0.4'} + is-number-object@1.1.1: + resolution: {integrity: sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw==} + engines: {node: '>= 0.4'} + is-number@7.0.0: resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==} engines: {node: '>=0.12.0'} @@ -4099,24 +4295,45 @@ packages: resolution: {integrity: sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==} engines: {node: '>= 0.4'} - is-set@2.0.2: - resolution: {integrity: sha512-+2cnTEZeY5z/iXGbLhPrOAaK/Mau5k5eXq9j14CpRTftq0pAJu2MwVRSZhyZWBzx3o6X795Lz6Bpb6R0GKf37g==} + is-regex@1.2.1: + resolution: {integrity: sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==} + engines: {node: '>= 0.4'} + + is-set@2.0.3: + resolution: {integrity: sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==} + engines: {node: '>= 0.4'} is-shared-array-buffer@1.0.2: resolution: {integrity: sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==} + is-shared-array-buffer@1.0.4: + resolution: {integrity: sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A==} + engines: {node: '>= 0.4'} + is-string@1.0.7: resolution: {integrity: sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==} engines: {node: '>= 0.4'} + is-string@1.1.1: + resolution: {integrity: sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA==} + engines: {node: '>= 0.4'} + is-symbol@1.0.4: resolution: {integrity: sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==} engines: {node: '>= 0.4'} + is-symbol@1.1.1: + resolution: {integrity: sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w==} + engines: {node: '>= 0.4'} + is-typed-array@1.1.12: resolution: {integrity: sha512-Z14TF2JNG8Lss5/HMqt0//T9JeHXttXy5pH/DBU4vi98ozO2btxzq9MwYDZYnKwU8nRsz/+GVFVRDq3DkVuSPg==} engines: {node: '>= 0.4'} + is-typed-array@1.1.15: + resolution: {integrity: sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==} + engines: {node: '>= 0.4'} + is-typedarray@1.0.0: resolution: {integrity: sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==} @@ -4124,14 +4341,20 @@ packages: resolution: {integrity: sha512-43r2mRvz+8JRIKnWJ+3j8JtjRKZ6GmjzfaE/qiBJnikNnYv/6bagRJ1kUhNk8R5EX/GkobD+r+sfxCPJsiKBLQ==} engines: {node: '>=12'} - is-weakmap@2.0.1: - resolution: {integrity: sha512-NSBR4kH5oVj1Uwvv970ruUkCV7O1mzgVFO4/rev2cLRda9Tm9HrL70ZPut4rOHgY0FNrUu9BCbXA2sdQ+x0chA==} + is-weakmap@2.0.2: + resolution: {integrity: sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==} + engines: {node: '>= 0.4'} is-weakref@1.0.2: resolution: {integrity: sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==} - is-weakset@2.0.2: - resolution: {integrity: sha512-t2yVvttHkQktwnNNmBQ98AhENLdPUTDTE21uPqAQ0ARwQfGeQKRVS0NNurH7bTf7RrvcVn1OOge45CnBeHCSmg==} + is-weakref@1.1.1: + resolution: {integrity: sha512-6i9mGWSlqzNMEqpCp93KwRS1uUOodk2OJ6b+sq7ZPDSy2WuI5NFIxp/254TytR8ftefexkWn5xNiHUNpPOfSew==} + engines: {node: '>= 0.4'} + + is-weakset@2.0.4: + resolution: {integrity: sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ==} + engines: {node: '>= 0.4'} is-windows@1.0.2: resolution: {integrity: sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==} @@ -4153,8 +4376,9 @@ packages: isomorphic-fetch@3.0.0: resolution: {integrity: sha512-qvUtwJ3j6qwsF3jLxkZ72qCgjMysPzDfeV240JHiGZsANBYd+EEuu35v7dfrJ9Up0Ak07D7GGSkGhCHTqg/5wA==} - iterator.prototype@1.1.2: - resolution: {integrity: sha512-DR33HMMr8EzwuRL8Y9D3u2BMj8+RqSE850jfGu59kS7tbmPLzGkZmVSfyCFSDxuZiEY6Rzt3T2NA/qU+NwVj1w==} + iterator.prototype@1.1.5: + resolution: {integrity: sha512-H0dkQoCa3b2VEeKQBOxFph+JAbcrQdE7KC0UkqwpLmv2EC4P41QXP+rqo9wYodACiG5/WM5s9oDApTU8utwj9g==} + engines: {node: '>= 0.4'} itty-router@3.0.12: resolution: {integrity: sha512-s98XTPhle6GGbaFf0kYrOD3Q8gyhnqvOqkwYijC3AmkceNKqWUp13YHg6dWmqmVv4pP7l7c94XI92I0EXVGO0w==} @@ -4199,6 +4423,10 @@ packages: json-parse-even-better-errors@2.3.1: resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==} + json-schema-to-ts@3.1.1: + resolution: {integrity: sha512-+DWg8jCJG2TEnpy7kOm/7/AxaYoaRbjVB4LFZLySZlWn8exGs3A4OLJR966cVvU26N7X9TWxl+Jsw7dzAqKT6g==} + engines: {node: '>=16'} + json-schema-traverse@0.4.1: resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==} @@ -4529,6 +4757,7 @@ packages: next@14.2.34: resolution: {integrity: sha512-s7mRraWlkEVRLjHHdu5khn0bSnmUh+U+YtigBc+t2Ge7jJHFIVBZna+W9Jcx7b04HhM7eJWrNJ2A+sQs9gJ3eg==} engines: {node: '>=18.17.0'} + deprecated: This version has a security vulnerability. Please upgrade to a patched version. See https://nextjs.org/blog/security-update-2025-12-11 for more details. hasBin: true peerDependencies: '@opentelemetry/api': ^1.1.0 @@ -4622,24 +4851,30 @@ packages: resolution: {integrity: sha512-byy+U7gp+FVwmyzKPYhW2h5l3crpmGsxl7X2s8y43IgxvG4g3QZ6CffDtsNQy1WsmZpQbO+ybo0AlW7TY6DcBQ==} engines: {node: '>= 0.4'} - object.entries@1.1.7: - resolution: {integrity: sha512-jCBs/0plmPsOnrKAfFQXRG2NFjlhZgjjcBLSmTnEhU8U6vVTsVe8ANeQJCHTl3gSsI4J+0emOoCgoKlmQPMgmA==} + object.assign@4.1.7: + resolution: {integrity: sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==} engines: {node: '>= 0.4'} - object.fromentries@2.0.7: - resolution: {integrity: sha512-UPbPHML6sL8PI/mOqPwsH4G6iyXcCGzLin8KvEPenOZN5lpCNBZZQ+V62vdjB1mQHrmqGQt5/OJzemUA+KJmEA==} + object.entries@1.1.9: + resolution: {integrity: sha512-8u/hfXFRBD1O0hPUjioLhoWFHRmt6tKA4/vZPyckBr18l1KE9uHrFaFaUi8MDRTpi4uak2goyPTSNJLXX2k2Hw==} engines: {node: '>= 0.4'} - object.groupby@1.0.1: - resolution: {integrity: sha512-HqaQtqLnp/8Bn4GL16cj+CUYbnpe1bh0TtEaWvybszDG4tgxCJuRpV8VGuvNaI1fAnI4lUJzDG55MXcOH4JZcQ==} + object.fromentries@2.0.8: + resolution: {integrity: sha512-k6E21FzySsSK5a21KRADBd/NGneRegFO5pLHfdQLpRDETUNJueLXs3WCzyQ3tFRDYgbq3KHGXfTbi2bs8WQ6rQ==} + engines: {node: '>= 0.4'} - object.hasown@1.1.3: - resolution: {integrity: sha512-fFI4VcYpRHvSLXxP7yiZOMAd331cPfd2p7PFDVbgUsYOfCT3tICVqXWngbjr4m49OvsBwUBQ6O2uQoJvy3RexA==} + object.groupby@1.0.3: + resolution: {integrity: sha512-+Lhy3TQTuzXI5hevh8sBGqbmurHbbIjAi0Z4S63nthVLmLxfbj4T54a4CfZrXIrt9iP4mVAPYMo/v99taj3wjQ==} + engines: {node: '>= 0.4'} object.values@1.1.7: resolution: {integrity: sha512-aU6xnDFYT3x17e/f0IiiwlGPTy2jzMySGfUB4fq6z7CV8l85CWHDk5ErhyhpfDHhrOMwGFhSQkhMGHaIotA6Ng==} engines: {node: '>= 0.4'} + object.values@1.2.1: + resolution: {integrity: sha512-gXah6aZrcUxjWg2zR2MwouP2eHlCBzdV4pygudehaKXSGW4v2AsRQUK+lwwXhii6KFZcunEnmSUoYp5CXibxtA==} + engines: {node: '>= 0.4'} + ohash@2.0.11: resolution: {integrity: sha512-RdR9FQrFwNBNXAr4GixM8YaRZRJ5PUWbKYbE5eOsrwAjJW0q2REGcf79oYPsLyskQCZG1PLN+S/K1V00joZAoQ==} @@ -4711,6 +4946,10 @@ packages: outvariant@1.4.3: resolution: {integrity: sha512-+Sl2UErvtsoajRDKCE5/dBz4DIvHXQQnAxtQTF04OJxY0+DyZXSo5P5Bb7XYWOh81syohlYL24hbDwxedPUJCA==} + own-keys@1.0.1: + resolution: {integrity: sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==} + engines: {node: '>= 0.4'} + p-limit@3.1.0: resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==} engines: {node: '>=10'} @@ -4826,6 +5065,10 @@ packages: resolution: {integrity: sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==} engines: {node: '>=12'} + picomatch@4.0.3: + resolution: {integrity: sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==} + engines: {node: '>=12'} + pidtree@0.3.1: resolution: {integrity: sha512-qQbW94hLHEqCg7nhby4yRC7G2+jYHY4Rguc2bjw7Uug4GIJuu1tvf2uHaZv5Q8zdt+WKJ6qK1FOI6amaWUo5FA==} engines: {node: '>=0.10'} @@ -4856,6 +5099,10 @@ packages: polka@0.5.2: resolution: {integrity: sha512-FVg3vDmCqP80tOrs+OeNlgXYmFppTXdjD5E7I4ET1NjvtNmQrb1/mJibybKkb/d4NA7YWAr1ojxuhpL3FHqdlw==} + possible-typed-array-names@1.1.0: + resolution: {integrity: sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==} + engines: {node: '>= 0.4'} + postcss-import@14.1.0: resolution: {integrity: sha512-flwI+Vgm4SElObFVPpTIT7SU7R3qk2L7PyduMcokiaVKuWv9d/U+Gm/QAd8NDLuykTWTkcrjOeD2Pp1rMeBTGw==} engines: {node: '>=10.0.0'} @@ -5003,10 +5250,10 @@ packages: resolution: {integrity: sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==} engines: {node: '>= 0.8'} - react-dom@18.3.1: - resolution: {integrity: sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==} + react-dom@19.2.3: + resolution: {integrity: sha512-yELu4WmLPw5Mr/lmeEpox5rw3RETacE++JgHqQzd2dg+YbJuat3jH4ingc+WPZhxaoFzdv9y33G+F7Nl5O0GBg==} peerDependencies: - react: ^18.3.1 + react: ^19.2.3 react-is@16.13.1: resolution: {integrity: sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==} @@ -5015,6 +5262,10 @@ packages: resolution: {integrity: sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==} engines: {node: '>=0.10.0'} + react@19.2.3: + resolution: {integrity: sha512-Ku/hhYbVjOQnXDZFv2+RibmLFGwFdeeKHFcOTlrt7xplBnya5OGn/hIRDsqDiSUcfORsDC7MPxwork8jBwsIWA==} + engines: {node: '>=0.10.0'} + read-cache@1.0.0: resolution: {integrity: sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==} @@ -5037,8 +5288,8 @@ packages: redis@4.6.8: resolution: {integrity: sha512-S7qNkPUYrsofQ0ztWlTHSaK0Qqfl1y+WMIxrzeAGNG+9iUZB4HGeBgkHxE6uJJ6iXrkvLd1RVJ2nvu6H1sAzfQ==} - reflect.getprototypeof@1.0.4: - resolution: {integrity: sha512-ECkTw8TmJwW60lOTR+ZkODISW6RQ8+2CL3COqtiJKLd6MmB45hN51HprHFziKLGkAuTGQhBb91V8cy+KHlaCjw==} + reflect.getprototypeof@1.0.10: + resolution: {integrity: sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw==} engines: {node: '>= 0.4'} regenerator-runtime@0.14.1: @@ -5048,6 +5299,10 @@ packages: resolution: {integrity: sha512-sy6TXMN+hnP/wMy+ISxg3krXx7BAtWVO4UouuCN/ziM9UEne0euamVNafDfvC83bRNr95y0V5iijeDQFUNpvrg==} engines: {node: '>= 0.4'} + regexp.prototype.flags@1.5.4: + resolution: {integrity: sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA==} + engines: {node: '>= 0.4'} + require-directory@2.1.1: resolution: {integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==} engines: {node: '>=0.10.0'} @@ -5115,20 +5370,32 @@ packages: resolution: {integrity: sha512-6XbUAseYE2KtOuGueyeobCySj9L4+66Tn6KQMOPQJrAJEowYKW/YR/MGJZl7FdydUdaFu4LYyDZjxf4/Nmo23Q==} engines: {node: '>=0.4'} + safe-array-concat@1.1.3: + resolution: {integrity: sha512-AURm5f0jYEOydBj7VQlVvDrjeFgthDdEF5H1dP+6mNpoXOMo1quQqJ4wvJDyRZ9+pO3kGWoOdmV08cSv2aJV6Q==} + engines: {node: '>=0.4'} + safe-buffer@5.2.1: resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==} + safe-push-apply@1.0.0: + resolution: {integrity: sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA==} + engines: {node: '>= 0.4'} + safe-regex-test@1.0.0: resolution: {integrity: sha512-JBUUzyOgEwXQY1NuPtvcj/qcBDbDmEvWufhlnXZIm75DEHp+afM1r1ujJpJsV/gSM4t59tpDyPi1sd6ZaPFfsA==} + safe-regex-test@1.1.0: + resolution: {integrity: sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==} + engines: {node: '>= 0.4'} + safer-buffer@2.1.2: resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==} sax@1.2.1: resolution: {integrity: sha512-8I2a3LovHTOpm7NV5yOyO8IHqgVsfK4+UuySrXU8YXkSRX7k6hCV9b3HrkKCr3nMpgj+0bmocaJJWpvp1oc7ZA==} - scheduler@0.23.2: - resolution: {integrity: sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==} + scheduler@0.27.0: + resolution: {integrity: sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==} semver-compare@1.0.0: resolution: {integrity: sha512-YM3/ITh2MJ5MtzaM429anh+x2jiLVjqILF4m4oyQB18W7Ggea7BfqdH/wGMK7dDiMghv/6WG7znWMwUDzJiXow==} @@ -5196,10 +5463,22 @@ packages: resolution: {integrity: sha512-VoaqjbBJKiWtg4yRcKBQ7g7wnGnLV3M8oLvVWwOk2PdYY6PEFegR1vezXR0tw6fZGF9csVakIRjrJiy2veSBFQ==} engines: {node: '>= 0.4'} + set-function-length@1.2.2: + resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==} + engines: {node: '>= 0.4'} + set-function-name@2.0.1: resolution: {integrity: sha512-tMNCiqYVkXIZgc2Hnoy2IvC/f8ezc5koaRFkCjrpWzGpCd3qbZXPzVy9MAZzK1ch/X0jvSkojys3oqJN0qCmdA==} engines: {node: '>= 0.4'} + set-function-name@2.0.2: + resolution: {integrity: sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==} + engines: {node: '>= 0.4'} + + set-proto@1.0.0: + resolution: {integrity: sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw==} + engines: {node: '>= 0.4'} + setprototypeof@1.2.0: resolution: {integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==} @@ -5317,6 +5596,7 @@ packages: source-map@0.8.0-beta.0: resolution: {integrity: sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==} engines: {node: '>= 8'} + deprecated: The work that was done in this beta branch won't be included in future versions spdx-correct@3.2.0: resolution: {integrity: sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==} @@ -5352,6 +5632,10 @@ packages: resolution: {integrity: sha512-xhV7w8S+bUwlPTb4bAOUQhv8/cSS5offJuX8GQGq32ONF0ZtDWKfkdomM3HMRA+LhX6um/FZ0COqlwsjD53LeQ==} engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + stop-iteration-iterator@1.1.0: + resolution: {integrity: sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ==} + engines: {node: '>= 0.4'} + stoppable@1.1.0: resolution: {integrity: sha512-KXDYZ9dszj6bzvnEMRYvxgeTHU74QBFL54XKtP3nyMuJ81CFYtABZ3bAzL2EdFUaEwJOBOgENyFj3R7oTzDyyw==} engines: {node: '>=4', npm: '>=6'} @@ -5375,13 +5659,25 @@ packages: resolution: {integrity: sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==} engines: {node: '>=18'} - string.prototype.matchall@4.0.10: - resolution: {integrity: sha512-rGXbGmOEosIQi6Qva94HUjgPs9vKW+dkG7Y8Q5O2OYkWL6wFaTRZO8zM4mhP94uX55wgyrXzfS2aGtGzUL7EJQ==} + string.prototype.includes@2.0.1: + resolution: {integrity: sha512-o7+c9bW6zpAdJHTtujeePODAhkuicdAryFsfVKwA+wGw89wJ4GTY484WTucM9hLtDEOpOvI+aHnzqnC5lHp4Rg==} + engines: {node: '>= 0.4'} + + string.prototype.matchall@4.0.12: + resolution: {integrity: sha512-6CC9uyBL+/48dYizRf7H7VAYCMCNTBeM78x/VTUe9bFEaxBepPJDa1Ow99LqI/1yF7kuy7Q3cQsYMrcjGUcskA==} + engines: {node: '>= 0.4'} string.prototype.padend@3.1.5: resolution: {integrity: sha512-DOB27b/2UTTD+4myKUFh+/fXWcu/UDyASIXfg+7VzoCNNGOfWvoyU/x5pvVHr++ztyt/oSYI1BcWBBG/hmlNjA==} engines: {node: '>= 0.4'} + string.prototype.repeat@1.0.0: + resolution: {integrity: sha512-0u/TldDbKD8bFCQ/4f5+mNRrXwZ8hg2w7ZR8wa16e8z9XpePWl3eGEcUD0OXpEH/VJH/2G3gjUtR3ZOiBe2S/w==} + + string.prototype.trim@1.2.10: + resolution: {integrity: sha512-Rs66F0P/1kedk5lyYyH9uBzuiI/kNRmwJAR9quK6VOtIpZ2G+hMZd+HQbbv25MgCA6gEffoMZYxlTod4WcdrKA==} + engines: {node: '>= 0.4'} + string.prototype.trim@1.2.8: resolution: {integrity: sha512-lfjY4HcixfQXOfaqCvcBuOIapyaroTXhbkfJN3gcB1OtyupngWK4sEET9Knd0cXd28kTUqu/kHoV4HKSJdnjiQ==} engines: {node: '>= 0.4'} @@ -5389,9 +5685,17 @@ packages: string.prototype.trimend@1.0.7: resolution: {integrity: sha512-Ni79DqeB72ZFq1uH/L6zJ+DKZTkOtPIHovb3YZHQViE+HDouuU4mBrLOLDn5Dde3RF8qw5qVETEjhu9locMLvA==} + string.prototype.trimend@1.0.9: + resolution: {integrity: sha512-G7Ok5C6E/j4SGfyLCloXTrngQIQU3PWtXGst3yM7Bea9FRURf1S42ZHlZZtsNque2FN2PoUhfZXYLNWwEr4dLQ==} + engines: {node: '>= 0.4'} + string.prototype.trimstart@1.0.7: resolution: {integrity: sha512-NGhtDFu3jCEm7B4Fy0DpLewdJQOZcQ0rGbwQ/+stjnrp2i+rlKeCvos9hOIeCmqwratM47OBxY7uFZzjxHXmrg==} + string.prototype.trimstart@1.0.8: + resolution: {integrity: sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==} + engines: {node: '>= 0.4'} + string_decoder@1.3.0: resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==} @@ -5506,6 +5810,10 @@ packages: resolution: {integrity: sha512-qkf4trmKSIiMTs/E63cxH+ojC2unam7rJ0WrauAzpT3ECNTxGRMlaXxVbfxMUC/w0LaYk6jQ4y/nGR9uBO3tww==} engines: {node: '>=12.0.0'} + tinyglobby@0.2.15: + resolution: {integrity: sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==} + engines: {node: '>=12.0.0'} + tinypool@1.1.1: resolution: {integrity: sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==} engines: {node: ^18.0.0 || >=20.0.0} @@ -5552,11 +5860,8 @@ packages: resolution: {integrity: sha512-kr8SKKw94OI+xTGOkfsvwZQ8mWoikZDd2n8XZHjJVZUARZT+4/VV6cacRS6CLsH9bNm+HFIPU1Zx4CnNnb4qlQ==} engines: {node: '>=6'} - ts-api-utils@1.0.3: - resolution: {integrity: sha512-wNMeqtMz5NtwpT/UZGY5alT+VoKdSsOOP/kqHFcUW1P/VRhH2wJ48+DN2WwUliNbQ976ETwDL0Ifd2VVvgonvg==} - engines: {node: '>=16.13.0'} - peerDependencies: - typescript: '>=4.2.0' + ts-algebra@2.0.0: + resolution: {integrity: sha512-FPAhNPFMrkwz76P7cdjdmiShwMynZYN6SgOujD1urY4oNm80Ou9oMdmbR45LotcKOXoy7wSmHkRFE6Mxbrhefw==} ts-api-utils@1.4.3: resolution: {integrity: sha512-i3eMG77UTMD0hZhgRS562pv83RC6ukSAC2GMNWc+9dieh/+jDM5u5YG+NHX6VNDRHQcHwmsTHctP9LhbC3WxVw==} @@ -5576,6 +5881,12 @@ packages: peerDependencies: typescript: '>=4.8.4' + ts-api-utils@2.4.0: + resolution: {integrity: sha512-3TaVTaAv2gTiMB35i3FiGJaRfwb3Pyn/j3m/bfAvGe8FB7CF6u+LMYqYlDh7reQf7UNvoTvdfAqHGmPGOSsPmA==} + engines: {node: '>=18.12'} + peerDependencies: + typescript: '>=4.8.4' + ts-interface-checker@0.1.13: resolution: {integrity: sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==} @@ -5744,20 +6055,43 @@ packages: resolution: {integrity: sha512-Y8KTSIglk9OZEr8zywiIHG/kmQ7KWyjseXs1CbSo8vC42w7hg2HgYTxSWwP0+is7bWDc1H+Fo026CpHFwm8tkw==} engines: {node: '>= 0.4'} + typed-array-buffer@1.0.3: + resolution: {integrity: sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==} + engines: {node: '>= 0.4'} + typed-array-byte-length@1.0.0: resolution: {integrity: sha512-Or/+kvLxNpeQ9DtSydonMxCx+9ZXOswtwJn17SNLvhptaXYDJvkFFP5zbfU/uLmvnBJlI4yrnXRxpdWH/M5tNA==} engines: {node: '>= 0.4'} + typed-array-byte-length@1.0.3: + resolution: {integrity: sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg==} + engines: {node: '>= 0.4'} + typed-array-byte-offset@1.0.0: resolution: {integrity: sha512-RD97prjEt9EL8YgAgpOkf3O4IF9lhJFr9g0htQkm0rchFp/Vx7LW5Q8fSXXub7BXAODyUQohRMyOc3faCPd0hg==} engines: {node: '>= 0.4'} + typed-array-byte-offset@1.0.4: + resolution: {integrity: sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ==} + engines: {node: '>= 0.4'} + typed-array-length@1.0.4: resolution: {integrity: sha512-KjZypGq+I/H7HI5HlOoGHkWUUGq+Q0TPhQurLbyrVrvnKTBgzLhIJ7j6J/XTQOi0d1RjyZ0wdas8bKs2p0x3Ng==} + typed-array-length@1.0.7: + resolution: {integrity: sha512-3KS2b+kL7fsuk/eJZ7EQdnEmQoaho/r6KUef7hxvltNA5DR8NAUM+8wJMbJyZ4G9/7i3v5zPBIMN5aybAh2/Jg==} + engines: {node: '>= 0.4'} + typedarray-to-buffer@3.1.5: resolution: {integrity: sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==} + typescript-eslint@8.53.0: + resolution: {integrity: sha512-xHURCQNxZ1dsWn0sdOaOfCSQG0HKeqSj9OexIxrz6ypU6wHYOdX2I3D2b8s8wFSsSOYJb+6q283cLiLlkEsBYw==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + eslint: ^8.57.0 || ^9.0.0 + typescript: '>=4.8.4 <6.0.0' + typescript@4.7.4: resolution: {integrity: sha512-C0WQT0gezHuw6AdY1M2jxUO83Rjf0HP7Sk1DtXj6j1EwkQNZrHAg2XPWlq62oqEhYvONq5pkC2Y9oPljWToLmQ==} engines: {node: '>=4.2.0'} @@ -5789,6 +6123,10 @@ packages: unbox-primitive@1.0.2: resolution: {integrity: sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==} + unbox-primitive@1.1.0: + resolution: {integrity: sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw==} + engines: {node: '>= 0.4'} + undefsafe@2.0.5: resolution: {integrity: sha512-WxONCrssBM8TSPRqN5EmsjVrsv4A8X12J4ArBiiayv3DyyG3ZlIg6yysuuSYdZsVz3TKcTg2fd//Ujd4CHV1iA==} @@ -5983,17 +6321,26 @@ packages: which-boxed-primitive@1.0.2: resolution: {integrity: sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==} - which-builtin-type@1.1.3: - resolution: {integrity: sha512-YmjsSMDBYsM1CaFiayOVT06+KJeXf0o5M/CAd4o1lTadFAtacTUM49zoYxr/oroopFDfhvN6iEcBxUyc3gvKmw==} + which-boxed-primitive@1.1.1: + resolution: {integrity: sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA==} + engines: {node: '>= 0.4'} + + which-builtin-type@1.2.1: + resolution: {integrity: sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q==} engines: {node: '>= 0.4'} - which-collection@1.0.1: - resolution: {integrity: sha512-W8xeTUwaln8i3K/cY1nGXzdnVZlidBcagyNFtBdD5kxnb4TvGKR7FfSIS3mYpwWS1QUCutfKz8IY8RjftB0+1A==} + which-collection@1.0.2: + resolution: {integrity: sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==} + engines: {node: '>= 0.4'} which-typed-array@1.1.13: resolution: {integrity: sha512-P5Nra0qjSncduVPEAr7xhoF5guty49ArDTwzJ/yNuPIbZppyRxFQsRCWrocxIY+CnMVG+qfbU2FmDKyvSGClow==} engines: {node: '>= 0.4'} + which-typed-array@1.1.19: + resolution: {integrity: sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==} + engines: {node: '>= 0.4'} + which@1.3.1: resolution: {integrity: sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==} hasBin: true @@ -6080,6 +6427,7 @@ packages: yaeti@0.0.6: resolution: {integrity: sha512-MvQa//+KcZCUkBTIC9blM+CU9J2GzuTytsOUwf2lidtvkx/6gnEp1QvJv34t9vdjhFmha/mUiNDbN0D0mJWdug==} engines: {node: '>=0.10.32'} + deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. yallist@3.1.1: resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==} @@ -6144,6 +6492,12 @@ packages: peerDependencies: zod: 3.25.34 + zod-validation-error@4.0.2: + resolution: {integrity: sha512-Q6/nZLe6jxuU80qb/4uJ4t5v2VEZ44lzQjPDhYJNztRQ4wyWc6VF3D3Kb/fAuPetZQnhS3hnajCf9CsWesghLQ==} + engines: {node: '>=18.0.0'} + peerDependencies: + zod: 3.25.34 + zod@3.25.34: resolution: {integrity: sha512-lZHvSc2PpWdcfpHlyB33HA9nqP16GpC9IpiG4lYq9jZCJVLZNnWd6Y1cj79bcLSBKTkxepfpjckPv5Y5VOPlwA==} @@ -6158,19 +6512,13 @@ snapshots: '@ampproject/remapping@2.3.0': dependencies: '@jridgewell/gen-mapping': 0.3.13 - '@jridgewell/trace-mapping': 0.3.30 + '@jridgewell/trace-mapping': 0.3.31 - '@anthropic-ai/sdk@0.39.0': + '@anthropic-ai/sdk@0.71.2(zod@3.25.34)': dependencies: - '@types/node': 18.19.123 - '@types/node-fetch': 2.6.13 - abort-controller: 3.0.0 - agentkeepalive: 4.6.0 - form-data-encoder: 1.7.2 - formdata-node: 4.4.1 - node-fetch: 2.7.0 - transitivePeerDependencies: - - encoding + json-schema-to-ts: 3.1.1 + optionalDependencies: + zod: 3.25.34 '@apidevtools/json-schema-ref-parser@11.7.2': dependencies: @@ -6214,23 +6562,23 @@ snapshots: '@aws-sdk/types': 3.804.0 '@aws-sdk/util-locate-window': 3.535.0 '@smithy/util-utf8': 2.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-crypto/sha256-js@5.2.0': dependencies: '@aws-crypto/util': 5.2.0 '@aws-sdk/types': 3.804.0 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-crypto/supports-web-crypto@5.2.0': dependencies: - tslib: 2.6.2 + tslib: 2.8.1 '@aws-crypto/util@5.2.0': dependencies: '@aws-sdk/types': 3.804.0 '@smithy/util-utf8': 2.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/client-bedrock-runtime@3.817.0': dependencies: @@ -6339,7 +6687,7 @@ snapshots: '@smithy/types': 4.3.0 '@smithy/util-middleware': 4.0.3 fast-xml-parser: 4.4.1 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/credential-provider-env@3.816.0': dependencies: @@ -6426,7 +6774,7 @@ snapshots: '@aws-sdk/types': 3.804.0 '@smithy/property-provider': 4.0.3 '@smithy/types': 4.3.0 - tslib: 2.6.2 + tslib: 2.8.1 transitivePeerDependencies: - aws-crt @@ -6449,20 +6797,20 @@ snapshots: '@aws-sdk/types': 3.804.0 '@smithy/protocol-http': 5.1.1 '@smithy/types': 4.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/middleware-logger@3.804.0': dependencies: '@aws-sdk/types': 3.804.0 '@smithy/types': 4.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/middleware-recursion-detection@3.804.0': dependencies: '@aws-sdk/types': 3.804.0 '@smithy/protocol-http': 5.1.1 '@smithy/types': 4.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/middleware-user-agent@3.816.0': dependencies: @@ -6472,7 +6820,7 @@ snapshots: '@smithy/core': 3.4.0 '@smithy/protocol-http': 5.1.1 '@smithy/types': 4.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/nested-clients@3.817.0': dependencies: @@ -6513,7 +6861,7 @@ snapshots: '@smithy/util-middleware': 4.0.3 '@smithy/util-retry': 4.0.4 '@smithy/util-utf8': 4.0.0 - tslib: 2.6.2 + tslib: 2.8.1 transitivePeerDependencies: - aws-crt @@ -6524,7 +6872,7 @@ snapshots: '@smithy/types': 4.3.0 '@smithy/util-config-provider': 4.0.0 '@smithy/util-middleware': 4.0.3 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/token-providers@3.817.0': dependencies: @@ -6541,25 +6889,25 @@ snapshots: '@aws-sdk/types@3.804.0': dependencies: '@smithy/types': 4.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/util-endpoints@3.808.0': dependencies: '@aws-sdk/types': 3.804.0 '@smithy/types': 4.3.0 '@smithy/util-endpoints': 3.0.5 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/util-locate-window@3.535.0': dependencies: - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/util-user-agent-browser@3.804.0': dependencies: '@aws-sdk/types': 3.804.0 '@smithy/types': 4.3.0 bowser: 2.11.0 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/util-user-agent-node@3.816.0': dependencies: @@ -6567,11 +6915,11 @@ snapshots: '@aws-sdk/types': 3.804.0 '@smithy/node-config-provider': 4.1.2 '@smithy/types': 4.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@babel/code-frame@7.27.1': dependencies: - '@babel/helper-validator-identifier': 7.27.1 + '@babel/helper-validator-identifier': 7.28.5 js-tokens: 4.0.0 picocolors: 1.1.1 @@ -6585,12 +6933,12 @@ snapshots: '@babel/helper-compilation-targets': 7.27.2 '@babel/helper-module-transforms': 7.28.3(@babel/core@7.28.3) '@babel/helpers': 7.28.3 - '@babel/parser': 7.28.3 + '@babel/parser': 7.28.5 '@babel/template': 7.27.2 '@babel/traverse': 7.28.3 - '@babel/types': 7.28.2 + '@babel/types': 7.28.5 convert-source-map: 2.0.0 - debug: 4.4.1 + debug: 4.4.3 gensync: 1.0.0-beta.2 json5: 2.2.3 semver: 6.3.1 @@ -6607,10 +6955,10 @@ snapshots: '@babel/generator@7.28.3': dependencies: - '@babel/parser': 7.28.3 - '@babel/types': 7.28.2 + '@babel/parser': 7.28.5 + '@babel/types': 7.28.5 '@jridgewell/gen-mapping': 0.3.13 - '@jridgewell/trace-mapping': 0.3.30 + '@jridgewell/trace-mapping': 0.3.31 jsesc: 3.1.0 '@babel/helper-compilation-targets@7.27.2': @@ -6626,7 +6974,7 @@ snapshots: '@babel/helper-module-imports@7.27.1': dependencies: '@babel/traverse': 7.28.3 - '@babel/types': 7.28.2 + '@babel/types': 7.28.5 transitivePeerDependencies: - supports-color @@ -6634,7 +6982,7 @@ snapshots: dependencies: '@babel/core': 7.28.3 '@babel/helper-module-imports': 7.27.1 - '@babel/helper-validator-identifier': 7.27.1 + '@babel/helper-validator-identifier': 7.28.5 '@babel/traverse': 7.28.3 transitivePeerDependencies: - supports-color @@ -6650,7 +6998,7 @@ snapshots: '@babel/helpers@7.28.3': dependencies: '@babel/template': 7.27.2 - '@babel/types': 7.28.2 + '@babel/types': 7.28.5 '@babel/parser@7.27.1': dependencies: @@ -6675,8 +7023,8 @@ snapshots: '@babel/template@7.27.2': dependencies: '@babel/code-frame': 7.27.1 - '@babel/parser': 7.28.3 - '@babel/types': 7.28.2 + '@babel/parser': 7.28.5 + '@babel/types': 7.28.5 '@babel/traverse@7.27.1': dependencies: @@ -6695,10 +7043,10 @@ snapshots: '@babel/code-frame': 7.27.1 '@babel/generator': 7.28.3 '@babel/helper-globals': 7.28.0 - '@babel/parser': 7.28.3 + '@babel/parser': 7.28.5 '@babel/template': 7.27.2 - '@babel/types': 7.28.2 - debug: 4.4.1 + '@babel/types': 7.28.5 + debug: 4.4.3 transitivePeerDependencies: - supports-color @@ -6739,6 +7087,7 @@ snapshots: '@cloudflare/unenv-preset@2.7.7(unenv@2.0.0-rc.21)(workerd@1.20251008.0)': dependencies: unenv: 2.0.0-rc.21 + optionalDependencies: workerd: 1.20251008.0 '@cloudflare/workerd-darwin-64@1.20251008.0': @@ -7082,10 +7431,17 @@ snapshots: eslint: 8.57.1 eslint-visitor-keys: 3.4.3 + '@eslint-community/eslint-utils@4.9.1(eslint@8.56.0)': + dependencies: + eslint: 8.56.0 + eslint-visitor-keys: 3.4.3 + '@eslint-community/regexpp@4.10.0': {} '@eslint-community/regexpp@4.12.1': {} + '@eslint-community/regexpp@4.12.2': {} + '@eslint/eslintrc@2.1.4': dependencies: ajv: 6.12.6 @@ -7205,24 +7561,26 @@ snapshots: dependencies: '@inquirer/core': 10.1.13(@types/node@20.10.5) '@inquirer/type': 3.0.7(@types/node@20.10.5) + optionalDependencies: '@types/node': 20.10.5 '@inquirer/core@10.1.13(@types/node@20.10.5)': dependencies: '@inquirer/figures': 1.0.12 '@inquirer/type': 3.0.7(@types/node@20.10.5) - '@types/node': 20.10.5 ansi-escapes: 4.3.2 cli-width: 4.1.0 mute-stream: 2.0.0 signal-exit: 4.1.0 wrap-ansi: 6.2.0 yoctocolors-cjs: 2.1.2 + optionalDependencies: + '@types/node': 20.10.5 '@inquirer/figures@1.0.12': {} '@inquirer/type@3.0.7(@types/node@20.10.5)': - dependencies: + optionalDependencies: '@types/node': 20.10.5 '@isaacs/cliui@8.0.2': @@ -7237,7 +7595,7 @@ snapshots: '@jridgewell/gen-mapping@0.3.13': dependencies: '@jridgewell/sourcemap-codec': 1.5.5 - '@jridgewell/trace-mapping': 0.3.30 + '@jridgewell/trace-mapping': 0.3.31 '@jridgewell/gen-mapping@0.3.8': dependencies: @@ -7258,11 +7616,6 @@ snapshots: '@jridgewell/resolve-uri': 3.1.2 '@jridgewell/sourcemap-codec': 1.5.0 - '@jridgewell/trace-mapping@0.3.30': - dependencies: - '@jridgewell/resolve-uri': 3.1.2 - '@jridgewell/sourcemap-codec': 1.5.5 - '@jridgewell/trace-mapping@0.3.31': dependencies: '@jridgewell/resolve-uri': 3.1.2 @@ -7301,9 +7654,9 @@ snapshots: '@next/env@14.2.34': {} - '@next/eslint-plugin-next@15.0.0-canary.36': + '@next/eslint-plugin-next@16.1.1-canary.22': dependencies: - glob: 10.3.10 + fast-glob: 3.3.1 '@next/swc-darwin-arm64@14.2.33': optional: true @@ -7672,14 +8025,14 @@ snapshots: '@rollup/rollup-win32-x64-msvc@4.46.4': optional: true - '@rushstack/eslint-patch@1.6.1': {} + '@rtsao/scc@1.1.0': {} '@sindresorhus/is@7.1.0': {} '@smithy/abort-controller@4.0.3': dependencies: '@smithy/types': 4.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/config-resolver@4.1.3': dependencies: @@ -7687,7 +8040,7 @@ snapshots: '@smithy/types': 4.3.0 '@smithy/util-config-provider': 4.0.0 '@smithy/util-middleware': 4.0.3 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/core@3.4.0': dependencies: @@ -7698,7 +8051,7 @@ snapshots: '@smithy/util-middleware': 4.0.3 '@smithy/util-stream': 4.2.1 '@smithy/util-utf8': 4.0.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/credential-provider-imds@4.0.5': dependencies: @@ -7706,7 +8059,7 @@ snapshots: '@smithy/property-provider': 4.0.3 '@smithy/types': 4.3.0 '@smithy/url-parser': 4.0.3 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/eventstream-codec@4.0.3': dependencies: @@ -7744,33 +8097,33 @@ snapshots: '@smithy/querystring-builder': 4.0.3 '@smithy/types': 4.3.0 '@smithy/util-base64': 4.0.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/hash-node@4.0.3': dependencies: '@smithy/types': 4.3.0 '@smithy/util-buffer-from': 4.0.0 '@smithy/util-utf8': 4.0.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/invalid-dependency@4.0.3': dependencies: '@smithy/types': 4.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/is-array-buffer@2.2.0': dependencies: - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/is-array-buffer@4.0.0': dependencies: - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/middleware-content-length@4.0.3': dependencies: '@smithy/protocol-http': 5.1.1 '@smithy/types': 4.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/middleware-endpoint@4.1.7': dependencies: @@ -7781,7 +8134,7 @@ snapshots: '@smithy/types': 4.3.0 '@smithy/url-parser': 4.0.3 '@smithy/util-middleware': 4.0.3 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/middleware-retry@4.1.8': dependencies: @@ -7792,26 +8145,26 @@ snapshots: '@smithy/types': 4.3.0 '@smithy/util-middleware': 4.0.3 '@smithy/util-retry': 4.0.4 - tslib: 2.6.2 + tslib: 2.8.1 uuid: 9.0.1 '@smithy/middleware-serde@4.0.6': dependencies: '@smithy/protocol-http': 5.1.1 '@smithy/types': 4.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/middleware-stack@4.0.3': dependencies: '@smithy/types': 4.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/node-config-provider@4.1.2': dependencies: '@smithy/property-provider': 4.0.3 '@smithy/shared-ini-file-loader': 4.0.3 '@smithy/types': 4.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/node-http-handler@4.0.5': dependencies: @@ -7819,7 +8172,7 @@ snapshots: '@smithy/protocol-http': 5.1.1 '@smithy/querystring-builder': 4.0.3 '@smithy/types': 4.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/property-provider@4.0.3': dependencies: @@ -7829,18 +8182,18 @@ snapshots: '@smithy/protocol-http@5.1.1': dependencies: '@smithy/types': 4.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/querystring-builder@4.0.3': dependencies: '@smithy/types': 4.3.0 '@smithy/util-uri-escape': 4.0.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/querystring-parser@4.0.3': dependencies: '@smithy/types': 4.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/service-error-classification@4.0.4': dependencies: @@ -7849,7 +8202,7 @@ snapshots: '@smithy/shared-ini-file-loader@4.0.3': dependencies: '@smithy/types': 4.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/signature-v4@5.1.1': dependencies: @@ -7870,45 +8223,45 @@ snapshots: '@smithy/protocol-http': 5.1.1 '@smithy/types': 4.3.0 '@smithy/util-stream': 4.2.1 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/types@4.3.0': dependencies: - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/url-parser@4.0.3': dependencies: '@smithy/querystring-parser': 4.0.3 '@smithy/types': 4.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-base64@4.0.0': dependencies: '@smithy/util-buffer-from': 4.0.0 '@smithy/util-utf8': 4.0.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-body-length-browser@4.0.0': dependencies: - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-body-length-node@4.0.0': dependencies: - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-buffer-from@2.2.0': dependencies: '@smithy/is-array-buffer': 2.2.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-buffer-from@4.0.0': dependencies: '@smithy/is-array-buffer': 4.0.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-config-provider@4.0.0': dependencies: - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-defaults-mode-browser@4.0.15': dependencies: @@ -7916,7 +8269,7 @@ snapshots: '@smithy/smithy-client': 4.3.0 '@smithy/types': 4.3.0 bowser: 2.11.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-defaults-mode-node@4.0.15': dependencies: @@ -7926,28 +8279,28 @@ snapshots: '@smithy/property-provider': 4.0.3 '@smithy/smithy-client': 4.3.0 '@smithy/types': 4.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-endpoints@3.0.5': dependencies: '@smithy/node-config-provider': 4.1.2 '@smithy/types': 4.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-hex-encoding@4.0.0': dependencies: - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-middleware@4.0.3': dependencies: '@smithy/types': 4.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-retry@4.0.4': dependencies: '@smithy/service-error-classification': 4.0.4 '@smithy/types': 4.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-stream@4.2.1': dependencies: @@ -7958,21 +8311,21 @@ snapshots: '@smithy/util-buffer-from': 4.0.0 '@smithy/util-hex-encoding': 4.0.0 '@smithy/util-utf8': 4.0.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-uri-escape@4.0.0': dependencies: - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-utf8@2.3.0': dependencies: '@smithy/util-buffer-from': 2.2.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-utf8@4.0.0': dependencies: '@smithy/util-buffer-from': 4.0.0 - tslib: 2.6.2 + tslib: 2.8.1 '@speed-highlight/core@1.2.7': {} @@ -8114,16 +8467,13 @@ snapshots: '@types/phoenix@1.6.4': {} - '@types/prop-types@15.7.11': {} - '@types/qs@6.9.10': {} '@types/range-parser@1.2.7': {} - '@types/react@18.3.3': + '@types/react@19.2.8': dependencies: - '@types/prop-types': 15.7.11 - csstype: 3.1.3 + csstype: 3.2.3 '@types/send@0.17.4': dependencies: @@ -8169,14 +8519,18 @@ snapshots: transitivePeerDependencies: - supports-color - '@typescript-eslint/parser@6.14.0(eslint@8.56.0)(typescript@4.7.4)': + '@typescript-eslint/eslint-plugin@8.53.0(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint@8.56.0)(typescript@4.7.4)': dependencies: - '@typescript-eslint/scope-manager': 6.14.0 - '@typescript-eslint/types': 6.14.0 - '@typescript-eslint/typescript-estree': 6.14.0(typescript@4.7.4) - '@typescript-eslint/visitor-keys': 6.14.0 - debug: 4.4.0 + '@eslint-community/regexpp': 4.12.2 + '@typescript-eslint/parser': 8.53.0(eslint@8.56.0)(typescript@4.7.4) + '@typescript-eslint/scope-manager': 8.53.0 + '@typescript-eslint/type-utils': 8.53.0(eslint@8.56.0)(typescript@4.7.4) + '@typescript-eslint/utils': 8.53.0(eslint@8.56.0)(typescript@4.7.4) + '@typescript-eslint/visitor-keys': 8.53.0 eslint: 8.56.0 + ignore: 7.0.5 + natural-compare: 1.4.0 + ts-api-utils: 2.4.0(typescript@4.7.4) typescript: 4.7.4 transitivePeerDependencies: - supports-color @@ -8193,6 +8547,18 @@ snapshots: transitivePeerDependencies: - supports-color + '@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4)': + dependencies: + '@typescript-eslint/scope-manager': 8.53.0 + '@typescript-eslint/types': 8.53.0 + '@typescript-eslint/typescript-estree': 8.53.0(typescript@4.7.4) + '@typescript-eslint/visitor-keys': 8.53.0 + debug: 4.4.3 + eslint: 8.56.0 + typescript: 4.7.4 + transitivePeerDependencies: + - supports-color + '@typescript-eslint/project-service@8.46.2(typescript@5.5.4)': dependencies: '@typescript-eslint/tsconfig-utils': 8.46.2(typescript@5.5.4) @@ -8202,10 +8568,14 @@ snapshots: transitivePeerDependencies: - supports-color - '@typescript-eslint/scope-manager@6.14.0': + '@typescript-eslint/project-service@8.53.0(typescript@4.7.4)': dependencies: - '@typescript-eslint/types': 6.14.0 - '@typescript-eslint/visitor-keys': 6.14.0 + '@typescript-eslint/tsconfig-utils': 8.53.0(typescript@4.7.4) + '@typescript-eslint/types': 8.53.0 + debug: 4.4.3 + typescript: 4.7.4 + transitivePeerDependencies: + - supports-color '@typescript-eslint/scope-manager@8.21.0': dependencies: @@ -8217,10 +8587,19 @@ snapshots: '@typescript-eslint/types': 8.46.2 '@typescript-eslint/visitor-keys': 8.46.2 + '@typescript-eslint/scope-manager@8.53.0': + dependencies: + '@typescript-eslint/types': 8.53.0 + '@typescript-eslint/visitor-keys': 8.53.0 + '@typescript-eslint/tsconfig-utils@8.46.2(typescript@5.5.4)': dependencies: typescript: 5.5.4 + '@typescript-eslint/tsconfig-utils@8.53.0(typescript@4.7.4)': + dependencies: + typescript: 4.7.4 + '@typescript-eslint/type-utils@8.21.0(eslint@8.57.1)(typescript@5.5.4)': dependencies: '@typescript-eslint/typescript-estree': 8.21.0(typescript@5.5.4) @@ -8232,7 +8611,17 @@ snapshots: transitivePeerDependencies: - supports-color - '@typescript-eslint/types@6.14.0': {} + '@typescript-eslint/type-utils@8.53.0(eslint@8.56.0)(typescript@4.7.4)': + dependencies: + '@typescript-eslint/types': 8.53.0 + '@typescript-eslint/typescript-estree': 8.53.0(typescript@4.7.4) + '@typescript-eslint/utils': 8.53.0(eslint@8.56.0)(typescript@4.7.4) + debug: 4.4.3 + eslint: 8.56.0 + ts-api-utils: 2.4.0(typescript@4.7.4) + typescript: 4.7.4 + transitivePeerDependencies: + - supports-color '@typescript-eslint/types@7.13.1': {} @@ -8240,18 +8629,7 @@ snapshots: '@typescript-eslint/types@8.46.2': {} - '@typescript-eslint/typescript-estree@6.14.0(typescript@4.7.4)': - dependencies: - '@typescript-eslint/types': 6.14.0 - '@typescript-eslint/visitor-keys': 6.14.0 - debug: 4.4.1 - globby: 11.1.0 - is-glob: 4.0.3 - semver: 7.7.1 - ts-api-utils: 1.0.3(typescript@4.7.4) - typescript: 4.7.4 - transitivePeerDependencies: - - supports-color + '@typescript-eslint/types@8.53.0': {} '@typescript-eslint/typescript-estree@7.13.1(typescript@5.4.5)': dependencies: @@ -8297,6 +8675,21 @@ snapshots: transitivePeerDependencies: - supports-color + '@typescript-eslint/typescript-estree@8.53.0(typescript@4.7.4)': + dependencies: + '@typescript-eslint/project-service': 8.53.0(typescript@4.7.4) + '@typescript-eslint/tsconfig-utils': 8.53.0(typescript@4.7.4) + '@typescript-eslint/types': 8.53.0 + '@typescript-eslint/visitor-keys': 8.53.0 + debug: 4.4.3 + minimatch: 9.0.5 + semver: 7.7.3 + tinyglobby: 0.2.15 + ts-api-utils: 2.4.0(typescript@4.7.4) + typescript: 4.7.4 + transitivePeerDependencies: + - supports-color + '@typescript-eslint/utils@8.21.0(eslint@8.57.1)(typescript@5.5.4)': dependencies: '@eslint-community/eslint-utils': 4.4.0(eslint@8.57.1) @@ -8308,10 +8701,16 @@ snapshots: transitivePeerDependencies: - supports-color - '@typescript-eslint/visitor-keys@6.14.0': + '@typescript-eslint/utils@8.53.0(eslint@8.56.0)(typescript@4.7.4)': dependencies: - '@typescript-eslint/types': 6.14.0 - eslint-visitor-keys: 3.4.3 + '@eslint-community/eslint-utils': 4.9.1(eslint@8.56.0) + '@typescript-eslint/scope-manager': 8.53.0 + '@typescript-eslint/types': 8.53.0 + '@typescript-eslint/typescript-estree': 8.53.0(typescript@4.7.4) + eslint: 8.56.0 + typescript: 4.7.4 + transitivePeerDependencies: + - supports-color '@typescript-eslint/visitor-keys@7.13.1': dependencies: @@ -8328,6 +8727,11 @@ snapshots: '@typescript-eslint/types': 8.46.2 eslint-visitor-keys: 4.2.1 + '@typescript-eslint/visitor-keys@8.53.0': + dependencies: + '@typescript-eslint/types': 8.53.0 + eslint-visitor-keys: 4.2.1 + '@ungap/structured-clone@1.2.0': {} '@ungap/structured-clone@1.3.0': {} @@ -8350,16 +8754,18 @@ snapshots: dependencies: crypto-js: 4.2.0 - '@vercel/examples-ui@1.0.5(next@14.2.34)(react-dom@18.3.1)(react@18.3.1)': + '@vercel/examples-ui@1.0.5(next@14.2.34(@babel/core@7.28.3)(@opentelemetry/api@1.9.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3))(react-dom@19.2.3(react@19.2.3))(react@19.2.3)': dependencies: '@swc/helpers': 0.4.14 clsx: 1.2.1 - next: 14.2.34(react-dom@18.3.1)(react@18.3.1) - react: 18.3.1 - react-dom: 18.3.1(react@18.3.1) + next: 14.2.34(@babel/core@7.28.3)(@opentelemetry/api@1.9.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3) + react: 19.2.3 + react-dom: 19.2.3(react@19.2.3) sugar-high: 0.4.7 - '@vercel/functions@1.5.0': {} + '@vercel/functions@1.5.0(@aws-sdk/credential-provider-web-identity@3.817.0)': + optionalDependencies: + '@aws-sdk/credential-provider-web-identity': 3.817.0 '@vercel/kv@0.2.2': dependencies: @@ -8374,6 +8780,15 @@ snapshots: chai: 5.1.2 tinyrainbow: 1.2.0 + '@vitest/mocker@2.1.9(msw@2.8.4(@types/node@20.10.5)(typescript@5.5.4))(vite@5.4.19(@types/node@20.10.5))': + dependencies: + '@vitest/spy': 2.1.9 + estree-walker: 3.0.3 + magic-string: 0.30.17 + optionalDependencies: + msw: 2.8.4(@types/node@20.10.5)(typescript@5.5.4) + vite: 5.4.19(@types/node@20.10.5) + '@vitest/mocker@2.1.9(msw@2.8.4)(vite@5.4.19)': dependencies: '@vitest/spy': 2.1.9 @@ -8483,6 +8898,12 @@ snapshots: '@vue/shared': 3.5.22 csstype: 3.1.3 + '@vue/server-renderer@3.5.22(vue@3.5.22(typescript@5.3.3))': + dependencies: + '@vue/compiler-ssr': 3.5.22 + '@vue/shared': 3.5.22 + vue: 3.5.22(typescript@5.3.3) + '@vue/server-renderer@3.5.22(vue@3.5.22)': dependencies: '@vue/compiler-ssr': 3.5.22 @@ -8533,18 +8954,19 @@ snapshots: dependencies: humanize-ms: 1.2.1 - ai@2.2.22(react@18.3.1)(solid-js@1.9.10)(svelte@4.2.20)(vue@3.5.22): + ai@2.2.22(react@19.2.3)(solid-js@1.9.10)(svelte@4.2.20)(vue@3.5.22(typescript@5.3.3)): dependencies: eventsource-parser: 1.0.0 nanoid: 3.3.6 - react: 18.3.1 - solid-js: 1.9.10 solid-swr-store: 0.10.7(solid-js@1.9.10)(swr-store@0.10.6) sswr: 2.0.0(svelte@4.2.20) - svelte: 4.2.20 - swr: 2.2.0(react@18.3.1) + swr: 2.2.0(react@19.2.3) swr-store: 0.10.6 - swrv: 1.0.4(vue@3.5.22) + swrv: 1.0.4(vue@3.5.22(typescript@5.3.3)) + optionalDependencies: + react: 19.2.3 + solid-js: 1.9.10 + svelte: 4.2.20 vue: 3.5.22(typescript@5.3.3) ai@2.2.37(react@18.3.1)(solid-js@1.9.10)(svelte@4.2.20)(vue@3.5.22): @@ -8612,10 +9034,6 @@ snapshots: argparse@2.0.1: {} - aria-query@5.3.0: - dependencies: - dequal: 2.0.3 - aria-query@5.3.2: {} array-buffer-byte-length@1.0.0: @@ -8623,27 +9041,46 @@ snapshots: call-bind: 1.0.5 is-array-buffer: 3.0.2 + array-buffer-byte-length@1.0.2: + dependencies: + call-bound: 1.0.4 + is-array-buffer: 3.0.5 + array-differ@3.0.0: {} array-flatten@1.1.1: {} - array-includes@3.1.7: + array-includes@3.1.9: dependencies: - call-bind: 1.0.5 + call-bind: 1.0.8 + call-bound: 1.0.4 define-properties: 1.2.1 - es-abstract: 1.22.3 - get-intrinsic: 1.2.2 - is-string: 1.0.7 + es-abstract: 1.24.1 + es-object-atoms: 1.1.1 + get-intrinsic: 1.3.0 + is-string: 1.1.1 + math-intrinsics: 1.1.0 array-union@2.1.0: {} - array.prototype.findlastindex@1.2.3: + array.prototype.findlast@1.2.5: dependencies: - call-bind: 1.0.5 + call-bind: 1.0.8 define-properties: 1.2.1 - es-abstract: 1.22.3 - es-shim-unscopables: 1.0.2 - get-intrinsic: 1.2.2 + es-abstract: 1.24.1 + es-errors: 1.3.0 + es-object-atoms: 1.1.1 + es-shim-unscopables: 1.0.2 + + array.prototype.findlastindex@1.2.6: + dependencies: + call-bind: 1.0.8 + call-bound: 1.0.4 + define-properties: 1.2.1 + es-abstract: 1.24.1 + es-errors: 1.3.0 + es-object-atoms: 1.1.1 + es-shim-unscopables: 1.1.0 array.prototype.flat@1.3.2: dependencies: @@ -8652,6 +9089,13 @@ snapshots: es-abstract: 1.22.3 es-shim-unscopables: 1.0.2 + array.prototype.flat@1.3.3: + dependencies: + call-bind: 1.0.8 + define-properties: 1.2.1 + es-abstract: 1.24.1 + es-shim-unscopables: 1.0.2 + array.prototype.flatmap@1.3.2: dependencies: call-bind: 1.0.5 @@ -8659,13 +9103,20 @@ snapshots: es-abstract: 1.22.3 es-shim-unscopables: 1.0.2 - array.prototype.tosorted@1.1.2: + array.prototype.flatmap@1.3.3: dependencies: - call-bind: 1.0.5 + call-bind: 1.0.8 define-properties: 1.2.1 - es-abstract: 1.22.3 + es-abstract: 1.24.1 + es-shim-unscopables: 1.0.2 + + array.prototype.tosorted@1.1.4: + dependencies: + call-bind: 1.0.8 + define-properties: 1.2.1 + es-abstract: 1.24.1 + es-errors: 1.3.0 es-shim-unscopables: 1.0.2 - get-intrinsic: 1.2.2 arraybuffer.prototype.slice@1.0.2: dependencies: @@ -8677,16 +9128,22 @@ snapshots: is-array-buffer: 3.0.2 is-shared-array-buffer: 1.0.2 + arraybuffer.prototype.slice@1.0.4: + dependencies: + array-buffer-byte-length: 1.0.2 + call-bind: 1.0.8 + define-properties: 1.2.1 + es-abstract: 1.24.1 + es-errors: 1.3.0 + get-intrinsic: 1.3.0 + is-array-buffer: 3.0.5 + arrify@2.0.1: {} assertion-error@2.0.1: {} ast-types-flow@0.0.8: {} - asynciterator.prototype@1.0.0: - dependencies: - has-symbols: 1.0.3 - asynckit@0.4.0: {} autoprefixer@10.4.14(postcss@8.4.38): @@ -8701,6 +9158,10 @@ snapshots: available-typed-arrays@1.0.5: {} + available-typed-arrays@1.0.7: + dependencies: + possible-typed-array-names: 1.1.0 + aws-lambda@1.0.7: dependencies: aws-sdk: 2.1502.0 @@ -8721,7 +9182,7 @@ snapshots: uuid: 8.0.0 xml2js: 0.5.0 - axe-core@4.7.0: {} + axe-core@4.11.1: {} axios@1.13.1: dependencies: @@ -8731,10 +9192,6 @@ snapshots: transitivePeerDependencies: - debug - axobject-query@3.2.1: - dependencies: - dequal: 2.0.3 - axobject-query@4.1.0: {} balanced-match@1.0.2: {} @@ -8806,11 +9263,11 @@ snapshots: dependencies: fill-range: 7.1.1 - braintrust@0.3.7(zod@3.25.34): + braintrust@0.3.7(@aws-sdk/credential-provider-web-identity@3.817.0)(zod@3.25.34): dependencies: '@ai-sdk/provider': 1.1.3 '@next/env': 14.2.3 - '@vercel/functions': 1.5.0 + '@vercel/functions': 1.5.0(@aws-sdk/credential-provider-web-identity@3.817.0) argparse: 2.0.1 chalk: 4.1.2 cli-progress: 3.12.0 @@ -8896,6 +9353,13 @@ snapshots: get-intrinsic: 1.2.2 set-function-length: 1.1.1 + call-bind@1.0.8: + dependencies: + call-bind-apply-helpers: 1.0.2 + es-define-property: 1.0.1 + get-intrinsic: 1.3.0 + set-function-length: 1.2.2 + call-bound@1.0.4: dependencies: call-bind-apply-helpers: 1.0.2 @@ -9130,6 +9594,8 @@ snapshots: csstype@3.1.3: {} + csstype@3.2.3: {} + d@1.0.1: dependencies: es5-ext: 0.10.62 @@ -9137,6 +9603,24 @@ snapshots: damerau-levenshtein@1.0.8: {} + data-view-buffer@1.0.2: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + is-data-view: 1.0.2 + + data-view-byte-length@1.0.2: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + is-data-view: 1.0.2 + + data-view-byte-offset@1.0.1: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + is-data-view: 1.0.2 + date-fns@4.1.0: {} debug@2.6.9: @@ -9146,6 +9630,7 @@ snapshots: debug@3.2.7(supports-color@5.5.0): dependencies: ms: 2.1.3 + optionalDependencies: supports-color: 5.5.0 debug@4.3.4: @@ -9182,6 +9667,12 @@ snapshots: gopd: 1.0.1 has-property-descriptors: 1.0.1 + define-data-property@1.1.4: + dependencies: + es-define-property: 1.0.1 + es-errors: 1.3.0 + gopd: 1.2.0 + define-properties@1.2.1: dependencies: define-data-property: 1.1.1 @@ -9356,26 +9847,85 @@ snapshots: unbox-primitive: 1.0.2 which-typed-array: 1.1.13 + es-abstract@1.24.1: + dependencies: + array-buffer-byte-length: 1.0.2 + arraybuffer.prototype.slice: 1.0.4 + available-typed-arrays: 1.0.7 + call-bind: 1.0.8 + call-bound: 1.0.4 + data-view-buffer: 1.0.2 + data-view-byte-length: 1.0.2 + data-view-byte-offset: 1.0.1 + es-define-property: 1.0.1 + es-errors: 1.3.0 + es-object-atoms: 1.1.1 + es-set-tostringtag: 2.1.0 + es-to-primitive: 1.3.0 + function.prototype.name: 1.1.8 + get-intrinsic: 1.3.0 + get-proto: 1.0.1 + get-symbol-description: 1.1.0 + globalthis: 1.0.4 + gopd: 1.2.0 + has-property-descriptors: 1.0.2 + has-proto: 1.2.0 + has-symbols: 1.1.0 + hasown: 2.0.2 + internal-slot: 1.1.0 + is-array-buffer: 3.0.5 + is-callable: 1.2.7 + is-data-view: 1.0.2 + is-negative-zero: 2.0.3 + is-regex: 1.2.1 + is-set: 2.0.3 + is-shared-array-buffer: 1.0.4 + is-string: 1.1.1 + is-typed-array: 1.1.15 + is-weakref: 1.1.1 + math-intrinsics: 1.1.0 + object-inspect: 1.13.4 + object-keys: 1.1.1 + object.assign: 4.1.7 + own-keys: 1.0.1 + regexp.prototype.flags: 1.5.4 + safe-array-concat: 1.1.3 + safe-push-apply: 1.0.0 + safe-regex-test: 1.1.0 + set-proto: 1.0.0 + stop-iteration-iterator: 1.1.0 + string.prototype.trim: 1.2.10 + string.prototype.trimend: 1.0.9 + string.prototype.trimstart: 1.0.8 + typed-array-buffer: 1.0.3 + typed-array-byte-length: 1.0.3 + typed-array-byte-offset: 1.0.4 + typed-array-length: 1.0.7 + unbox-primitive: 1.1.0 + which-typed-array: 1.1.19 + es-define-property@1.0.1: {} es-errors@1.3.0: {} - es-iterator-helpers@1.0.15: + es-iterator-helpers@1.2.2: dependencies: - asynciterator.prototype: 1.0.0 - call-bind: 1.0.5 + call-bind: 1.0.8 + call-bound: 1.0.4 define-properties: 1.2.1 - es-abstract: 1.22.3 + es-abstract: 1.24.1 + es-errors: 1.3.0 es-set-tostringtag: 2.1.0 function-bind: 1.1.2 - get-intrinsic: 1.2.2 - globalthis: 1.0.3 - has-property-descriptors: 1.0.1 - has-proto: 1.0.1 - has-symbols: 1.0.3 - internal-slot: 1.0.6 - iterator.prototype: 1.1.2 - safe-array-concat: 1.0.1 + get-intrinsic: 1.3.0 + globalthis: 1.0.4 + gopd: 1.2.0 + has-property-descriptors: 1.0.2 + has-proto: 1.2.0 + has-symbols: 1.1.0 + internal-slot: 1.1.0 + iterator.prototype: 1.1.5 + safe-array-concat: 1.1.3 es-module-lexer@1.7.0: {} @@ -9392,7 +9942,11 @@ snapshots: es-shim-unscopables@1.0.2: dependencies: - hasown: 2.0.0 + hasown: 2.0.2 + + es-shim-unscopables@1.1.0: + dependencies: + hasown: 2.0.2 es-to-primitive@1.2.1: dependencies: @@ -9400,6 +9954,12 @@ snapshots: is-date-object: 1.0.5 is-symbol: 1.0.4 + es-to-primitive@1.3.0: + dependencies: + is-callable: 1.2.7 + is-date-object: 1.0.5 + is-symbol: 1.0.4 + es5-ext@0.10.62: dependencies: es6-iterator: 2.0.3 @@ -9539,27 +10099,29 @@ snapshots: escape-string-regexp@4.0.0: {} - eslint-config-next@15.0.0-canary.36(eslint@8.56.0)(typescript@4.7.4): + eslint-config-next@16.1.1-canary.22(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint@8.56.0)(typescript@4.7.4): dependencies: - '@next/eslint-plugin-next': 15.0.0-canary.36 - '@rushstack/eslint-patch': 1.6.1 - '@typescript-eslint/parser': 6.14.0(eslint@8.56.0)(typescript@4.7.4) + '@next/eslint-plugin-next': 16.1.1-canary.22 eslint: 8.56.0 eslint-import-resolver-node: 0.3.9 - eslint-import-resolver-typescript: 3.6.1(@typescript-eslint/parser@6.14.0)(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.29.1)(eslint@8.56.0) - eslint-plugin-import: 2.29.1(@typescript-eslint/parser@6.14.0)(eslint-import-resolver-typescript@3.6.1)(eslint@8.56.0) - eslint-plugin-jsx-a11y: 6.8.0(eslint@8.56.0) - eslint-plugin-react: 7.33.2(eslint@8.56.0) - eslint-plugin-react-hooks: 4.6.0(eslint@8.56.0) + eslint-import-resolver-typescript: 3.6.1(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint@8.56.0))(eslint@8.56.0) + eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint@8.56.0))(eslint@8.56.0))(eslint@8.56.0) + eslint-plugin-jsx-a11y: 6.10.2(eslint@8.56.0) + eslint-plugin-react: 7.37.5(eslint@8.56.0) + eslint-plugin-react-hooks: 7.0.1(eslint@8.56.0) + globals: 16.4.0 + typescript-eslint: 8.53.0(eslint@8.56.0)(typescript@4.7.4) + optionalDependencies: typescript: 4.7.4 transitivePeerDependencies: + - '@typescript-eslint/parser' - eslint-import-resolver-webpack - supports-color - eslint-config-turbo@2.5.6(eslint@8.57.1)(turbo@2.5.6): + eslint-config-turbo@2.7.4(eslint@8.57.1)(turbo@2.5.6): dependencies: eslint: 8.57.1 - eslint-plugin-turbo: 2.5.6(eslint@8.57.1)(turbo@2.5.6) + eslint-plugin-turbo: 2.7.4(eslint@8.57.1)(turbo@2.5.6) turbo: 2.5.6 eslint-import-resolver-node@0.3.9: @@ -9570,13 +10132,13 @@ snapshots: transitivePeerDependencies: - supports-color - eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@6.14.0)(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.29.1)(eslint@8.56.0): + eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint@8.56.0))(eslint@8.56.0): dependencies: debug: 4.4.0 enhanced-resolve: 5.15.0 eslint: 8.56.0 - eslint-module-utils: 2.8.0(@typescript-eslint/parser@6.14.0)(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1)(eslint@8.56.0) - eslint-plugin-import: 2.29.1(@typescript-eslint/parser@6.14.0)(eslint-import-resolver-typescript@3.6.1)(eslint@8.56.0) + eslint-module-utils: 2.8.0(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint@8.56.0))(eslint@8.56.0))(eslint@8.56.0) + eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint@8.56.0))(eslint@8.56.0))(eslint@8.56.0) fast-glob: 3.3.2 get-tsconfig: 4.7.2 is-core-module: 2.13.1 @@ -9587,87 +10149,110 @@ snapshots: - eslint-import-resolver-webpack - supports-color - eslint-module-utils@2.8.0(@typescript-eslint/parser@6.14.0)(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1)(eslint@8.56.0): + eslint-module-utils@2.12.1(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint@8.56.0))(eslint@8.56.0))(eslint@8.56.0): dependencies: - '@typescript-eslint/parser': 6.14.0(eslint@8.56.0)(typescript@4.7.4) debug: 3.2.7(supports-color@5.5.0) + optionalDependencies: + '@typescript-eslint/parser': 8.53.0(eslint@8.56.0)(typescript@4.7.4) eslint: 8.56.0 eslint-import-resolver-node: 0.3.9 - eslint-import-resolver-typescript: 3.6.1(@typescript-eslint/parser@6.14.0)(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.29.1)(eslint@8.56.0) + eslint-import-resolver-typescript: 3.6.1(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint@8.56.0))(eslint@8.56.0) transitivePeerDependencies: - supports-color - eslint-plugin-import@2.29.1(@typescript-eslint/parser@6.14.0)(eslint-import-resolver-typescript@3.6.1)(eslint@8.56.0): + eslint-module-utils@2.8.0(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint@8.56.0))(eslint@8.56.0))(eslint@8.56.0): dependencies: - '@typescript-eslint/parser': 6.14.0(eslint@8.56.0)(typescript@4.7.4) - array-includes: 3.1.7 - array.prototype.findlastindex: 1.2.3 - array.prototype.flat: 1.3.2 - array.prototype.flatmap: 1.3.2 + debug: 3.2.7(supports-color@5.5.0) + optionalDependencies: + '@typescript-eslint/parser': 8.53.0(eslint@8.56.0)(typescript@4.7.4) + eslint: 8.56.0 + eslint-import-resolver-node: 0.3.9 + eslint-import-resolver-typescript: 3.6.1(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint@8.56.0))(eslint@8.56.0) + transitivePeerDependencies: + - supports-color + + eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint@8.56.0))(eslint@8.56.0))(eslint@8.56.0): + dependencies: + '@rtsao/scc': 1.1.0 + array-includes: 3.1.9 + array.prototype.findlastindex: 1.2.6 + array.prototype.flat: 1.3.3 + array.prototype.flatmap: 1.3.3 debug: 3.2.7(supports-color@5.5.0) doctrine: 2.1.0 eslint: 8.56.0 eslint-import-resolver-node: 0.3.9 - eslint-module-utils: 2.8.0(@typescript-eslint/parser@6.14.0)(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1)(eslint@8.56.0) - hasown: 2.0.0 - is-core-module: 2.13.1 + eslint-module-utils: 2.12.1(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint@8.56.0))(eslint@8.56.0))(eslint@8.56.0) + hasown: 2.0.2 + is-core-module: 2.16.1 is-glob: 4.0.3 minimatch: 3.1.2 - object.fromentries: 2.0.7 - object.groupby: 1.0.1 - object.values: 1.1.7 + object.fromentries: 2.0.8 + object.groupby: 1.0.3 + object.values: 1.2.1 semver: 6.3.1 + string.prototype.trimend: 1.0.9 tsconfig-paths: 3.15.0 + optionalDependencies: + '@typescript-eslint/parser': 8.53.0(eslint@8.56.0)(typescript@4.7.4) transitivePeerDependencies: - eslint-import-resolver-typescript - eslint-import-resolver-webpack - supports-color - eslint-plugin-jsx-a11y@6.8.0(eslint@8.56.0): + eslint-plugin-jsx-a11y@6.10.2(eslint@8.56.0): dependencies: - '@babel/runtime': 7.23.6 - aria-query: 5.3.0 - array-includes: 3.1.7 + aria-query: 5.3.2 + array-includes: 3.1.9 array.prototype.flatmap: 1.3.2 ast-types-flow: 0.0.8 - axe-core: 4.7.0 - axobject-query: 3.2.1 + axe-core: 4.11.1 + axobject-query: 4.1.0 damerau-levenshtein: 1.0.8 emoji-regex: 9.2.2 - es-iterator-helpers: 1.0.15 eslint: 8.56.0 - hasown: 2.0.0 + hasown: 2.0.2 jsx-ast-utils: 3.3.5 language-tags: 1.0.9 minimatch: 3.1.2 - object.entries: 1.1.7 - object.fromentries: 2.0.7 + object.fromentries: 2.0.8 + safe-regex-test: 1.1.0 + string.prototype.includes: 2.0.1 - eslint-plugin-react-hooks@4.6.0(eslint@8.56.0): + eslint-plugin-react-hooks@7.0.1(eslint@8.56.0): dependencies: + '@babel/core': 7.28.3 + '@babel/parser': 7.28.5 eslint: 8.56.0 + hermes-parser: 0.25.1 + zod: 3.25.34 + zod-validation-error: 4.0.2(zod@3.25.34) + transitivePeerDependencies: + - supports-color - eslint-plugin-react@7.33.2(eslint@8.56.0): + eslint-plugin-react@7.37.5(eslint@8.56.0): dependencies: - array-includes: 3.1.7 - array.prototype.flatmap: 1.3.2 - array.prototype.tosorted: 1.1.2 + array-includes: 3.1.9 + array.prototype.findlast: 1.2.5 + array.prototype.flatmap: 1.3.3 + array.prototype.tosorted: 1.1.4 doctrine: 2.1.0 - es-iterator-helpers: 1.0.15 + es-iterator-helpers: 1.2.2 eslint: 8.56.0 estraverse: 5.3.0 + hasown: 2.0.2 jsx-ast-utils: 3.3.5 minimatch: 3.1.2 - object.entries: 1.1.7 - object.fromentries: 2.0.7 - object.hasown: 1.1.3 - object.values: 1.1.7 + object.entries: 1.1.9 + object.fromentries: 2.0.8 + object.values: 1.2.1 prop-types: 15.8.1 resolve: 2.0.0-next.5 semver: 6.3.1 - string.prototype.matchall: 4.0.10 + string.prototype.matchall: 4.0.12 + string.prototype.repeat: 1.0.0 - eslint-plugin-turbo@2.5.6(eslint@8.57.1)(turbo@2.5.6): + eslint-plugin-turbo@2.7.4(eslint@8.57.1)(turbo@2.5.6): dependencies: dotenv: 16.0.3 eslint: 8.57.1 @@ -9900,6 +10485,14 @@ snapshots: fast-deep-equal@3.1.3: {} + fast-glob@3.3.1: + dependencies: + '@nodelib/fs.stat': 2.0.5 + '@nodelib/fs.walk': 1.2.8 + glob-parent: 5.1.2 + merge2: 1.4.1 + micromatch: 4.0.8 + fast-glob@3.3.2: dependencies: '@nodelib/fs.stat': 2.0.5 @@ -9931,9 +10524,13 @@ snapshots: reusify: 1.1.0 fdir@6.4.3(picomatch@4.0.2): - dependencies: + optionalDependencies: picomatch: 4.0.2 + fdir@6.5.0(picomatch@4.0.3): + optionalDependencies: + picomatch: 4.0.3 + file-entry-cache@6.0.1: dependencies: flat-cache: 3.2.0 @@ -10002,6 +10599,10 @@ snapshots: dependencies: is-callable: 1.2.7 + for-each@0.3.5: + dependencies: + is-callable: 1.2.7 + foreground-child@3.2.1: dependencies: cross-spawn: 7.0.6 @@ -10054,6 +10655,15 @@ snapshots: es-abstract: 1.22.3 functions-have-names: 1.2.3 + function.prototype.name@1.1.8: + dependencies: + call-bind: 1.0.8 + call-bound: 1.0.4 + define-properties: 1.2.1 + functions-have-names: 1.2.3 + hasown: 2.0.2 + is-callable: 1.2.7 + functions-have-names@1.2.3: {} generic-pool@3.9.0: {} @@ -10094,6 +10704,12 @@ snapshots: call-bind: 1.0.5 get-intrinsic: 1.2.2 + get-symbol-description@1.1.0: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + get-intrinsic: 1.3.0 + get-tsconfig@4.7.2: dependencies: resolve-pkg-maps: 1.0.0 @@ -10145,10 +10761,17 @@ snapshots: dependencies: type-fest: 0.20.2 + globals@16.4.0: {} + globalthis@1.0.3: dependencies: define-properties: 1.2.1 + globalthis@1.0.4: + dependencies: + define-properties: 1.2.1 + gopd: 1.2.0 + globby@11.1.0: dependencies: array-union: 2.1.0 @@ -10191,8 +10814,16 @@ snapshots: dependencies: get-intrinsic: 1.3.0 + has-property-descriptors@1.0.2: + dependencies: + es-define-property: 1.0.1 + has-proto@1.0.1: {} + has-proto@1.2.0: + dependencies: + dunder-proto: 1.0.1 + has-symbols@1.0.3: {} has-symbols@1.1.0: {} @@ -10201,16 +10832,18 @@ snapshots: dependencies: has-symbols: 1.1.0 - hasown@2.0.0: - dependencies: - function-bind: 1.1.2 - hasown@2.0.2: dependencies: function-bind: 1.1.2 headers-polyfill@4.0.3: {} + hermes-estree@0.25.1: {} + + hermes-parser@0.25.1: + dependencies: + hermes-estree: 0.25.1 + homedir-polyfill@1.0.3: dependencies: parse-passwd: 1.0.0 @@ -10247,6 +10880,8 @@ snapshots: ignore@5.3.2: {} + ignore@7.0.5: {} + import-fresh@3.3.1: dependencies: parent-module: 1.0.1 @@ -10269,6 +10904,12 @@ snapshots: hasown: 2.0.2 side-channel: 1.0.4 + internal-slot@1.1.0: + dependencies: + es-errors: 1.3.0 + hasown: 2.0.2 + side-channel: 1.1.0 + io-ts@2.2.22(fp-ts@2.5.0): dependencies: fp-ts: 2.5.0 @@ -10286,6 +10927,12 @@ snapshots: get-intrinsic: 1.2.2 is-typed-array: 1.1.12 + is-array-buffer@3.0.5: + dependencies: + call-bind: 1.0.8 + call-bound: 1.0.4 + get-intrinsic: 1.3.0 + is-arrayish@0.2.1: {} is-arrayish@0.3.4: {} @@ -10298,6 +10945,10 @@ snapshots: dependencies: has-bigints: 1.0.2 + is-bigint@1.1.0: + dependencies: + has-bigints: 1.0.2 + is-binary-path@2.1.0: dependencies: binary-extensions: 2.2.0 @@ -10307,23 +10958,43 @@ snapshots: call-bind: 1.0.5 has-tostringtag: 1.0.2 + is-boolean-object@1.2.2: + dependencies: + call-bound: 1.0.4 + has-tostringtag: 1.0.2 + is-callable@1.2.7: {} is-core-module@2.13.1: dependencies: hasown: 2.0.2 + is-core-module@2.16.1: + dependencies: + hasown: 2.0.2 + + is-data-view@1.0.2: + dependencies: + call-bound: 1.0.4 + get-intrinsic: 1.3.0 + is-typed-array: 1.1.15 + is-date-object@1.0.5: dependencies: has-tostringtag: 1.0.2 + is-date-object@1.1.0: + dependencies: + call-bound: 1.0.4 + has-tostringtag: 1.0.2 + is-docker@3.0.0: {} is-extglob@2.1.1: {} - is-finalizationregistry@1.0.2: + is-finalizationregistry@1.1.1: dependencies: - call-bind: 1.0.5 + call-bound: 1.0.4 is-fullwidth-code-point@3.0.0: {} @@ -10341,16 +11012,23 @@ snapshots: is-interactive@2.0.0: {} - is-map@2.0.2: {} + is-map@2.0.3: {} is-negative-zero@2.0.2: {} + is-negative-zero@2.0.3: {} + is-node-process@1.2.0: {} is-number-object@1.0.7: dependencies: has-tostringtag: 1.0.2 + is-number-object@1.1.1: + dependencies: + call-bound: 1.0.4 + has-tostringtag: 1.0.2 + is-number@7.0.0: {} is-path-inside@3.0.3: {} @@ -10364,37 +11042,67 @@ snapshots: call-bind: 1.0.5 has-tostringtag: 1.0.2 - is-set@2.0.2: {} + is-regex@1.2.1: + dependencies: + call-bound: 1.0.4 + gopd: 1.2.0 + has-tostringtag: 1.0.2 + hasown: 2.0.2 + + is-set@2.0.3: {} is-shared-array-buffer@1.0.2: dependencies: call-bind: 1.0.5 + is-shared-array-buffer@1.0.4: + dependencies: + call-bound: 1.0.4 + is-string@1.0.7: dependencies: has-tostringtag: 1.0.2 + is-string@1.1.1: + dependencies: + call-bound: 1.0.4 + has-tostringtag: 1.0.2 + is-symbol@1.0.4: dependencies: has-symbols: 1.0.3 + is-symbol@1.1.1: + dependencies: + call-bound: 1.0.4 + has-symbols: 1.1.0 + safe-regex-test: 1.1.0 + is-typed-array@1.1.12: dependencies: which-typed-array: 1.1.13 + is-typed-array@1.1.15: + dependencies: + which-typed-array: 1.1.19 + is-typedarray@1.0.0: {} is-unicode-supported@1.3.0: {} - is-weakmap@2.0.1: {} + is-weakmap@2.0.2: {} is-weakref@1.0.2: dependencies: call-bind: 1.0.5 - is-weakset@2.0.2: + is-weakref@1.1.1: dependencies: - call-bind: 1.0.5 + call-bound: 1.0.4 + + is-weakset@2.0.4: + dependencies: + call-bound: 1.0.4 get-intrinsic: 1.3.0 is-windows@1.0.2: {} @@ -10416,13 +11124,14 @@ snapshots: transitivePeerDependencies: - encoding - iterator.prototype@1.1.2: + iterator.prototype@1.1.5: dependencies: - define-properties: 1.2.1 + define-data-property: 1.1.4 + es-object-atoms: 1.1.1 get-intrinsic: 1.3.0 - has-symbols: 1.0.3 - reflect.getprototypeof: 1.0.4 - set-function-name: 2.0.1 + get-proto: 1.0.1 + has-symbols: 1.1.0 + set-function-name: 2.0.2 itty-router@3.0.12: {} @@ -10457,6 +11166,11 @@ snapshots: json-parse-even-better-errors@2.3.1: {} + json-schema-to-ts@3.1.1: + dependencies: + '@babel/runtime': 7.23.6 + ts-algebra: 2.0.0 + json-schema-traverse@0.4.1: {} json-schema-traverse@1.0.0: {} @@ -10498,7 +11212,7 @@ snapshots: jsx-ast-utils@3.3.5: dependencies: - array-includes: 3.1.7 + array-includes: 3.1.9 array.prototype.flat: 1.3.2 object.assign: 4.1.5 object.values: 1.1.7 @@ -10657,7 +11371,7 @@ snapshots: mimic-fn@2.1.0: {} - miniflare@4.20251008.0: + miniflare@4.20251008.0(bufferutil@4.0.8)(utf-8-validate@5.0.10): dependencies: '@cspotcode/source-map-support': 0.8.1 acorn: 8.14.0 @@ -10668,7 +11382,7 @@ snapshots: stoppable: 1.1.0 undici: 7.14.0 workerd: 1.20251008.0 - ws: 8.18.0 + ws: 8.18.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) youch: 4.1.0-beta.10 zod: 3.25.34 transitivePeerDependencies: @@ -10725,8 +11439,9 @@ snapshots: picocolors: 1.1.1 strict-event-emitter: 0.5.1 type-fest: 4.41.0 - typescript: 5.5.4 yargs: 17.7.2 + optionalDependencies: + typescript: 5.5.4 transitivePeerDependencies: - '@types/node' @@ -10764,7 +11479,7 @@ snapshots: next-tick@1.1.0: {} - next@14.2.34(react-dom@18.3.1)(react@18.3.1): + next@14.2.34(@babel/core@7.28.3)(@opentelemetry/api@1.9.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3): dependencies: '@next/env': 14.2.34 '@swc/helpers': 0.5.5 @@ -10772,9 +11487,9 @@ snapshots: caniuse-lite: 1.0.30001735 graceful-fs: 4.2.11 postcss: 8.4.31 - react: 18.3.1 - react-dom: 18.3.1(react@18.3.1) - styled-jsx: 5.1.1(react@18.3.1) + react: 19.2.3 + react-dom: 19.2.3(react@19.2.3) + styled-jsx: 5.1.1(@babel/core@7.28.3)(react@19.2.3) optionalDependencies: '@next/swc-darwin-arm64': 14.2.33 '@next/swc-darwin-x64': 14.2.33 @@ -10785,6 +11500,7 @@ snapshots: '@next/swc-win32-arm64-msvc': 14.2.33 '@next/swc-win32-ia32-msvc': 14.2.33 '@next/swc-win32-x64-msvc': 14.2.33 + '@opentelemetry/api': 1.9.0 transitivePeerDependencies: - '@babel/core' - babel-plugin-macros @@ -10862,29 +11578,34 @@ snapshots: has-symbols: 1.0.3 object-keys: 1.1.1 - object.entries@1.1.7: + object.assign@4.1.7: dependencies: - call-bind: 1.0.5 + call-bind: 1.0.8 + call-bound: 1.0.4 define-properties: 1.2.1 - es-abstract: 1.22.3 + es-object-atoms: 1.1.1 + has-symbols: 1.1.0 + object-keys: 1.1.1 - object.fromentries@2.0.7: + object.entries@1.1.9: dependencies: - call-bind: 1.0.5 + call-bind: 1.0.8 + call-bound: 1.0.4 define-properties: 1.2.1 - es-abstract: 1.22.3 + es-object-atoms: 1.1.1 - object.groupby@1.0.1: + object.fromentries@2.0.8: dependencies: - call-bind: 1.0.5 + call-bind: 1.0.8 define-properties: 1.2.1 - es-abstract: 1.22.3 - get-intrinsic: 1.2.2 + es-abstract: 1.24.1 + es-object-atoms: 1.1.1 - object.hasown@1.1.3: + object.groupby@1.0.3: dependencies: + call-bind: 1.0.8 define-properties: 1.2.1 - es-abstract: 1.22.3 + es-abstract: 1.24.1 object.values@1.1.7: dependencies: @@ -10892,6 +11613,13 @@ snapshots: define-properties: 1.2.1 es-abstract: 1.22.3 + object.values@1.2.1: + dependencies: + call-bind: 1.0.8 + call-bound: 1.0.4 + define-properties: 1.2.1 + es-object-atoms: 1.1.1 + ohash@2.0.11: {} on-finished@2.4.1: @@ -10908,7 +11636,7 @@ snapshots: dependencies: mimic-fn: 2.1.0 - openai@4.104.0(zod@3.25.34): + openai@4.104.0(ws@8.18.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(zod@3.25.34): dependencies: '@types/node': 18.19.123 '@types/node-fetch': 2.6.13 @@ -10917,12 +11645,28 @@ snapshots: form-data-encoder: 1.7.2 formdata-node: 4.4.1 node-fetch: 2.7.0 + optionalDependencies: + ws: 8.18.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) zod: 3.25.34 transitivePeerDependencies: - encoding - openai@6.3.0(zod@3.25.34): + openai@4.104.0(zod@3.25.34): dependencies: + '@types/node': 18.19.123 + '@types/node-fetch': 2.6.13 + abort-controller: 3.0.0 + agentkeepalive: 4.6.0 + form-data-encoder: 1.7.2 + formdata-node: 4.4.1 + node-fetch: 2.7.0 + zod: 3.25.34 + transitivePeerDependencies: + - encoding + + openai@6.3.0(ws@8.18.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(zod@3.25.34): + optionalDependencies: + ws: 8.18.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) zod: 3.25.34 openapi-json-schema@2.0.0: {} @@ -10987,6 +11731,12 @@ snapshots: outvariant@1.4.3: {} + own-keys@1.0.1: + dependencies: + get-intrinsic: 1.3.0 + object-keys: 1.1.1 + safe-push-apply: 1.0.0 + p-limit@3.1.0: dependencies: yocto-queue: 0.1.0 @@ -11075,6 +11825,8 @@ snapshots: picomatch@4.0.2: {} + picomatch@4.0.3: {} + pidtree@0.3.1: {} pify@2.3.0: {} @@ -11100,6 +11852,8 @@ snapshots: '@polka/url': 0.5.0 trouter: 2.0.1 + possible-typed-array-names@1.1.0: {} + postcss-import@14.1.0(postcss@8.4.38): dependencies: postcss: 8.4.38 @@ -11115,13 +11869,20 @@ snapshots: postcss-load-config@3.1.4(postcss@8.4.38): dependencies: lilconfig: 2.1.0 - postcss: 8.4.38 yaml: 1.10.2 + optionalDependencies: + postcss: 8.4.38 postcss-load-config@6.0.1: dependencies: lilconfig: 3.1.3 + postcss-load-config@6.0.1(postcss@8.5.6): + dependencies: + lilconfig: 3.1.3 + optionalDependencies: + postcss: 8.5.6 + postcss-nested@6.0.0(postcss@8.4.38): dependencies: postcss: 8.4.38 @@ -11229,11 +11990,10 @@ snapshots: iconv-lite: 0.4.24 unpipe: 1.0.0 - react-dom@18.3.1(react@18.3.1): + react-dom@19.2.3(react@19.2.3): dependencies: - loose-envify: 1.4.0 - react: 18.3.1 - scheduler: 0.23.2 + react: 19.2.3 + scheduler: 0.27.0 react-is@16.13.1: {} @@ -11241,6 +12001,8 @@ snapshots: dependencies: loose-envify: 1.4.0 + react@19.2.3: {} + read-cache@1.0.0: dependencies: pify: 2.3.0 @@ -11272,14 +12034,16 @@ snapshots: '@redis/search': 1.1.3(@redis/client@1.5.9) '@redis/time-series': 1.0.5(@redis/client@1.5.9) - reflect.getprototypeof@1.0.4: + reflect.getprototypeof@1.0.10: dependencies: - call-bind: 1.0.5 + call-bind: 1.0.8 define-properties: 1.2.1 - es-abstract: 1.22.3 + es-abstract: 1.24.1 + es-errors: 1.3.0 + es-object-atoms: 1.1.1 get-intrinsic: 1.3.0 - globalthis: 1.0.3 - which-builtin-type: 1.1.3 + get-proto: 1.0.1 + which-builtin-type: 1.2.1 regenerator-runtime@0.14.1: {} @@ -11289,6 +12053,15 @@ snapshots: define-properties: 1.2.1 set-function-name: 2.0.1 + regexp.prototype.flags@1.5.4: + dependencies: + call-bind: 1.0.8 + define-properties: 1.2.1 + es-errors: 1.3.0 + get-proto: 1.0.1 + gopd: 1.2.0 + set-function-name: 2.0.2 + require-directory@2.1.1: {} require-from-string@2.0.2: {} @@ -11393,21 +12166,38 @@ snapshots: has-symbols: 1.0.3 isarray: 2.0.5 + safe-array-concat@1.1.3: + dependencies: + call-bind: 1.0.8 + call-bound: 1.0.4 + get-intrinsic: 1.3.0 + has-symbols: 1.1.0 + isarray: 2.0.5 + safe-buffer@5.2.1: {} + safe-push-apply@1.0.0: + dependencies: + es-errors: 1.3.0 + isarray: 2.0.5 + safe-regex-test@1.0.0: dependencies: call-bind: 1.0.5 get-intrinsic: 1.2.2 is-regex: 1.1.4 + safe-regex-test@1.1.0: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + is-regex: 1.2.1 + safer-buffer@2.1.2: {} sax@1.2.1: {} - scheduler@0.23.2: - dependencies: - loose-envify: 1.4.0 + scheduler@0.27.0: {} semver-compare@1.0.0: {} @@ -11494,12 +12284,34 @@ snapshots: gopd: 1.0.1 has-property-descriptors: 1.0.1 + set-function-length@1.2.2: + dependencies: + define-data-property: 1.1.4 + es-errors: 1.3.0 + function-bind: 1.1.2 + get-intrinsic: 1.3.0 + gopd: 1.2.0 + has-property-descriptors: 1.0.2 + set-function-name@2.0.1: dependencies: define-data-property: 1.1.1 functions-have-names: 1.2.3 has-property-descriptors: 1.0.1 + set-function-name@2.0.2: + dependencies: + define-data-property: 1.1.4 + es-errors: 1.3.0 + functions-have-names: 1.2.3 + has-property-descriptors: 1.0.2 + + set-proto@1.0.0: + dependencies: + dunder-proto: 1.0.1 + es-errors: 1.3.0 + es-object-atoms: 1.1.1 + setprototypeof@1.2.0: {} sharp@0.33.5: @@ -11697,6 +12509,11 @@ snapshots: dependencies: bl: 5.1.0 + stop-iteration-iterator@1.1.0: + dependencies: + es-errors: 1.3.0 + internal-slot: 1.1.0 + stoppable@1.1.0: {} streamsearch@1.1.0: {} @@ -11721,17 +12538,27 @@ snapshots: get-east-asian-width: 1.4.0 strip-ansi: 7.1.0 - string.prototype.matchall@4.0.10: + string.prototype.includes@2.0.1: dependencies: - call-bind: 1.0.5 + call-bind: 1.0.8 define-properties: 1.2.1 - es-abstract: 1.22.3 - get-intrinsic: 1.2.2 - has-symbols: 1.0.3 - internal-slot: 1.0.6 - regexp.prototype.flags: 1.5.1 - set-function-name: 2.0.1 - side-channel: 1.0.4 + es-abstract: 1.24.1 + + string.prototype.matchall@4.0.12: + dependencies: + call-bind: 1.0.8 + call-bound: 1.0.4 + define-properties: 1.2.1 + es-abstract: 1.24.1 + es-errors: 1.3.0 + es-object-atoms: 1.1.1 + get-intrinsic: 1.3.0 + gopd: 1.2.0 + has-symbols: 1.1.0 + internal-slot: 1.1.0 + regexp.prototype.flags: 1.5.4 + set-function-name: 2.0.2 + side-channel: 1.1.0 string.prototype.padend@3.1.5: dependencies: @@ -11739,6 +12566,21 @@ snapshots: define-properties: 1.2.1 es-abstract: 1.22.3 + string.prototype.repeat@1.0.0: + dependencies: + define-properties: 1.2.1 + es-abstract: 1.22.3 + + string.prototype.trim@1.2.10: + dependencies: + call-bind: 1.0.8 + call-bound: 1.0.4 + define-data-property: 1.1.4 + define-properties: 1.2.1 + es-abstract: 1.24.1 + es-object-atoms: 1.1.1 + has-property-descriptors: 1.0.2 + string.prototype.trim@1.2.8: dependencies: call-bind: 1.0.5 @@ -11751,12 +12593,25 @@ snapshots: define-properties: 1.2.1 es-abstract: 1.22.3 + string.prototype.trimend@1.0.9: + dependencies: + call-bind: 1.0.8 + call-bound: 1.0.4 + define-properties: 1.2.1 + es-object-atoms: 1.1.1 + string.prototype.trimstart@1.0.7: dependencies: call-bind: 1.0.5 define-properties: 1.2.1 es-abstract: 1.22.3 + string.prototype.trimstart@1.0.8: + dependencies: + call-bind: 1.0.8 + define-properties: 1.2.1 + es-object-atoms: 1.1.1 + string_decoder@1.3.0: dependencies: safe-buffer: 5.2.1 @@ -11775,10 +12630,12 @@ snapshots: strnum@1.0.5: {} - styled-jsx@5.1.1(react@18.3.1): + styled-jsx@5.1.1(@babel/core@7.28.3)(react@19.2.3): dependencies: client-only: 0.0.1 - react: 18.3.1 + react: 19.2.3 + optionalDependencies: + '@babel/core': 7.28.3 sucrase@3.35.0: dependencies: @@ -11830,8 +12687,17 @@ snapshots: react: 18.3.1 use-sync-external-store: 1.2.0(react@18.3.1) + swr@2.2.0(react@19.2.3): + dependencies: + react: 19.2.3 + use-sync-external-store: 1.2.0(react@19.2.3) + swrev@4.0.0: {} + swrv@1.0.4(vue@3.5.22(typescript@5.3.3)): + dependencies: + vue: 3.5.22(typescript@5.3.3) + swrv@1.0.4(vue@3.5.22): dependencies: vue: 3.5.22(typescript@5.5.4) @@ -11890,6 +12756,11 @@ snapshots: fdir: 6.4.3(picomatch@4.0.2) picomatch: 4.0.2 + tinyglobby@0.2.15: + dependencies: + fdir: 6.5.0(picomatch@4.0.3) + picomatch: 4.0.3 + tinypool@1.1.1: {} tinyrainbow@1.2.0: {} @@ -11911,7 +12782,7 @@ snapshots: tough-cookie@4.1.4: dependencies: psl: 1.15.0 - punycode: 2.1.1 + punycode: 2.3.1 universalify: 0.2.0 url-parse: 1.5.10 @@ -11927,9 +12798,7 @@ snapshots: dependencies: matchit: 1.1.0 - ts-api-utils@1.0.3(typescript@4.7.4): - dependencies: - typescript: 4.7.4 + ts-algebra@2.0.0: {} ts-api-utils@1.4.3(typescript@5.4.5): dependencies: @@ -11943,6 +12812,10 @@ snapshots: dependencies: typescript: 5.5.4 + ts-api-utils@2.4.0(typescript@4.7.4): + dependencies: + typescript: 4.7.4 + ts-interface-checker@0.1.13: {} ts-pattern@5.8.0: {} @@ -11950,7 +12823,7 @@ snapshots: ts-toolbelt@9.6.0: {} tsconfck@3.1.4(typescript@5.5.4): - dependencies: + optionalDependencies: typescript: 5.5.4 tsconfig-paths@3.15.0: @@ -11964,7 +12837,7 @@ snapshots: tslib@2.8.1: {} - tsup@8.4.0(typescript@5.3.3): + tsup@8.4.0(postcss@8.5.6)(typescript@5.3.3): dependencies: bundle-require: 5.1.0(esbuild@0.25.9) cac: 6.7.14 @@ -11974,7 +12847,7 @@ snapshots: esbuild: 0.25.9 joycon: 3.1.1 picocolors: 1.1.1 - postcss-load-config: 6.0.1 + postcss-load-config: 6.0.1(postcss@8.5.6) resolve-from: 5.0.0 rollup: 4.35.0 source-map: 0.8.0-beta.0 @@ -11982,6 +12855,8 @@ snapshots: tinyexec: 0.3.2 tinyglobby: 0.2.12 tree-kill: 1.2.2 + optionalDependencies: + postcss: 8.5.6 typescript: 5.3.3 transitivePeerDependencies: - jiti @@ -12096,6 +12971,12 @@ snapshots: get-intrinsic: 1.2.2 is-typed-array: 1.1.12 + typed-array-buffer@1.0.3: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + is-typed-array: 1.1.15 + typed-array-byte-length@1.0.0: dependencies: call-bind: 1.0.5 @@ -12103,6 +12984,14 @@ snapshots: has-proto: 1.0.1 is-typed-array: 1.1.12 + typed-array-byte-length@1.0.3: + dependencies: + call-bind: 1.0.8 + for-each: 0.3.3 + gopd: 1.2.0 + has-proto: 1.2.0 + is-typed-array: 1.1.15 + typed-array-byte-offset@1.0.0: dependencies: available-typed-arrays: 1.0.5 @@ -12111,16 +13000,46 @@ snapshots: has-proto: 1.0.1 is-typed-array: 1.1.12 + typed-array-byte-offset@1.0.4: + dependencies: + available-typed-arrays: 1.0.7 + call-bind: 1.0.8 + for-each: 0.3.3 + gopd: 1.2.0 + has-proto: 1.2.0 + is-typed-array: 1.1.15 + reflect.getprototypeof: 1.0.10 + typed-array-length@1.0.4: dependencies: call-bind: 1.0.5 for-each: 0.3.3 is-typed-array: 1.1.12 + typed-array-length@1.0.7: + dependencies: + call-bind: 1.0.8 + for-each: 0.3.3 + gopd: 1.2.0 + is-typed-array: 1.1.15 + possible-typed-array-names: 1.1.0 + reflect.getprototypeof: 1.0.10 + typedarray-to-buffer@3.1.5: dependencies: is-typedarray: 1.0.0 + typescript-eslint@8.53.0(eslint@8.56.0)(typescript@4.7.4): + dependencies: + '@typescript-eslint/eslint-plugin': 8.53.0(@typescript-eslint/parser@8.53.0(eslint@8.56.0)(typescript@4.7.4))(eslint@8.56.0)(typescript@4.7.4) + '@typescript-eslint/parser': 8.53.0(eslint@8.56.0)(typescript@4.7.4) + '@typescript-eslint/typescript-estree': 8.53.0(typescript@4.7.4) + '@typescript-eslint/utils': 8.53.0(eslint@8.56.0)(typescript@4.7.4) + eslint: 8.56.0 + typescript: 4.7.4 + transitivePeerDependencies: + - supports-color + typescript@4.7.4: {} typescript@5.3.3: {} @@ -12141,6 +13060,13 @@ snapshots: has-symbols: 1.0.3 which-boxed-primitive: 1.0.2 + unbox-primitive@1.1.0: + dependencies: + call-bound: 1.0.4 + has-bigints: 1.0.2 + has-symbols: 1.1.0 + which-boxed-primitive: 1.1.1 + undefsafe@2.0.5: {} undici-types@5.26.5: {} @@ -12191,6 +13117,10 @@ snapshots: dependencies: react: 18.3.1 + use-sync-external-store@1.2.0(react@19.2.3): + dependencies: + react: 19.2.3 + utf-8-validate@5.0.10: dependencies: node-gyp-build: 4.7.0 @@ -12245,15 +13175,61 @@ snapshots: - supports-color - typescript + vite-tsconfig-paths@4.3.2(typescript@5.5.4)(vite@5.4.19(@types/node@20.10.5)): + dependencies: + debug: 4.3.7 + globrex: 0.1.2 + tsconfck: 3.1.4(typescript@5.5.4) + optionalDependencies: + vite: 5.4.19(@types/node@20.10.5) + transitivePeerDependencies: + - supports-color + - typescript + vite@5.4.19(@types/node@20.10.5): dependencies: - '@types/node': 20.10.5 esbuild: 0.21.5 postcss: 8.5.6 rollup: 4.46.4 optionalDependencies: + '@types/node': 20.10.5 fsevents: 2.3.3 + vitest@2.1.9(@types/node@20.10.5)(msw@2.8.4(@types/node@20.10.5)(typescript@5.5.4)): + dependencies: + '@vitest/expect': 2.1.9 + '@vitest/mocker': 2.1.9(msw@2.8.4(@types/node@20.10.5)(typescript@5.5.4))(vite@5.4.19(@types/node@20.10.5)) + '@vitest/pretty-format': 2.1.9 + '@vitest/runner': 2.1.9 + '@vitest/snapshot': 2.1.9 + '@vitest/spy': 2.1.9 + '@vitest/utils': 2.1.9 + chai: 5.3.1 + debug: 4.4.1 + expect-type: 1.2.2 + magic-string: 0.30.17 + pathe: 1.1.2 + std-env: 3.9.0 + tinybench: 2.9.0 + tinyexec: 0.3.2 + tinypool: 1.1.1 + tinyrainbow: 1.2.0 + vite: 5.4.19(@types/node@20.10.5) + vite-node: 2.1.9(@types/node@20.10.5) + why-is-node-running: 2.3.0 + optionalDependencies: + '@types/node': 20.10.5 + transitivePeerDependencies: + - less + - lightningcss + - msw + - sass + - sass-embedded + - stylus + - sugarss + - supports-color + - terser + vitest@2.1.9(@types/node@20.10.5)(msw@2.8.4): dependencies: '@types/node': 20.10.5 @@ -12293,8 +13269,9 @@ snapshots: '@vue/compiler-dom': 3.5.22 '@vue/compiler-sfc': 3.5.22 '@vue/runtime-dom': 3.5.22 - '@vue/server-renderer': 3.5.22(vue@3.5.22) + '@vue/server-renderer': 3.5.22(vue@3.5.22(typescript@5.3.3)) '@vue/shared': 3.5.22 + optionalDependencies: typescript: 5.3.3 vue@3.5.22(typescript@5.5.4): @@ -12358,27 +13335,36 @@ snapshots: is-string: 1.0.7 is-symbol: 1.0.4 - which-builtin-type@1.1.3: + which-boxed-primitive@1.1.1: dependencies: - function.prototype.name: 1.1.6 + is-bigint: 1.1.0 + is-boolean-object: 1.2.2 + is-number-object: 1.1.1 + is-string: 1.1.1 + is-symbol: 1.1.1 + + which-builtin-type@1.2.1: + dependencies: + call-bound: 1.0.4 + function.prototype.name: 1.1.8 has-tostringtag: 1.0.2 is-async-function: 2.0.0 - is-date-object: 1.0.5 - is-finalizationregistry: 1.0.2 + is-date-object: 1.1.0 + is-finalizationregistry: 1.1.1 is-generator-function: 1.0.10 - is-regex: 1.1.4 - is-weakref: 1.0.2 + is-regex: 1.2.1 + is-weakref: 1.1.1 isarray: 2.0.5 - which-boxed-primitive: 1.0.2 - which-collection: 1.0.1 - which-typed-array: 1.1.13 + which-boxed-primitive: 1.1.1 + which-collection: 1.0.2 + which-typed-array: 1.1.19 - which-collection@1.0.1: + which-collection@1.0.2: dependencies: - is-map: 2.0.2 - is-set: 2.0.2 - is-weakmap: 2.0.1 - is-weakset: 2.0.2 + is-map: 2.0.3 + is-set: 2.0.3 + is-weakmap: 2.0.2 + is-weakset: 2.0.4 which-typed-array@1.1.13: dependencies: @@ -12388,6 +13374,16 @@ snapshots: gopd: 1.0.1 has-tostringtag: 1.0.2 + which-typed-array@1.1.19: + dependencies: + available-typed-arrays: 1.0.7 + call-bind: 1.0.8 + call-bound: 1.0.4 + for-each: 0.3.5 + get-proto: 1.0.1 + gopd: 1.2.0 + has-tostringtag: 1.0.2 + which@1.3.1: dependencies: isexe: 2.0.0 @@ -12413,18 +13409,18 @@ snapshots: '@cloudflare/workerd-linux-arm64': 1.20251008.0 '@cloudflare/workerd-windows-64': 1.20251008.0 - wrangler@4.42.2(@cloudflare/workers-types@4.20251011.0): + wrangler@4.42.2(@cloudflare/workers-types@4.20251011.0)(bufferutil@4.0.8)(utf-8-validate@5.0.10): dependencies: '@cloudflare/kv-asset-handler': 0.4.0 '@cloudflare/unenv-preset': 2.7.7(unenv@2.0.0-rc.21)(workerd@1.20251008.0) - '@cloudflare/workers-types': 4.20251011.0 blake3-wasm: 2.1.5 esbuild: 0.25.4 - miniflare: 4.20251008.0 + miniflare: 4.20251008.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) path-to-regexp: 6.3.0 unenv: 2.0.0-rc.21 workerd: 1.20251008.0 optionalDependencies: + '@cloudflare/workers-types': 4.20251011.0 fsevents: 2.3.3 transitivePeerDependencies: - bufferutil @@ -12456,7 +13452,10 @@ snapshots: wrappy@1.0.2: {} - ws@8.18.0: {} + ws@8.18.0(bufferutil@4.0.8)(utf-8-validate@5.0.10): + optionalDependencies: + bufferutil: 4.0.8 + utf-8-validate: 5.0.10 xml2js@0.5.0: dependencies: @@ -12539,4 +13538,8 @@ snapshots: dependencies: zod: 3.25.34 + zod-validation-error@4.0.2(zod@3.25.34): + dependencies: + zod: 3.25.34 + zod@3.25.34: {}