Upload folder using huggingface_hub (part 10)

VAE/Harvest_VAE.py

@@ -0,0 +1,88 @@
+import os
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torchvision.utils import save_image
+from tqdm import tqdm
+
+# 1. Rebuild the exact VAE Architecture to load the weights
+class VAE(nn.Module):
+    def __init__(self, latent_dim=128):
+        super(VAE, self).__init__()
+        self.enc1 = nn.Conv2d(1, 32, 4, 2, 1)    
+        self.enc2 = nn.Conv2d(32, 64, 4, 2, 1)   
+        self.enc3 = nn.Conv2d(64, 128, 4, 2, 1)  
+        self.enc4 = nn.Conv2d(128, 256, 4, 2, 1) 
+        self.enc5 = nn.Conv2d(256, 512, 4, 2, 1) 
+        self.fc_mu = nn.Linear(512 * 7 * 7, latent_dim)
+        self.fc_logvar = nn.Linear(512 * 7 * 7, latent_dim)
+
+        self.dec_fc = nn.Linear(latent_dim, 512 * 7 * 7)
+        self.dec1 = nn.ConvTranspose2d(512, 256, 4, 2, 1)
+        self.dec2 = nn.ConvTranspose2d(256, 128, 4, 2, 1)
+        self.dec3 = nn.ConvTranspose2d(128, 64, 4, 2, 1)
+        self.dec4 = nn.ConvTranspose2d(64, 32, 4, 2, 1)
+        self.dec5 = nn.ConvTranspose2d(32, 1, 4, 2, 1)
+
+    def decode(self, z):
+        x = F.relu(self.dec_fc(z))
+        x = x.view(x.size(0), 512, 7, 7)
+        x = F.relu(self.dec1(x))
+        x = F.relu(self.dec2(x))
+        x = F.relu(self.dec3(x))
+        x = F.relu(self.dec4(x))
+        x = torch.sigmoid(self.dec5(x)) 
+        return x
+
+def main():
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Targeting device for VAE harvesting: {device}")
+
+    # Set up NVMe paths
+    dataset_root = r"C:\Users\USER\Downloads\MedMNIST_Data"
+    output_dir = os.path.join(dataset_root, "VAE_Synthetic", "Normal_0")
+    os.makedirs(output_dir, exist_ok=True)
+
+    # 2. Load the trained brain
+    print("Loading VAE weights...")
+    model = VAE(latent_dim=128).to(device)
+    weight_path = os.path.join(dataset_root, "vae_baseline.pth")
+    
+    if not os.path.exists(weight_path):
+        print(f"Error: Weights not found at {weight_path}")
+        return
+
+    model.load_state_dict(torch.load(weight_path, map_location=device, weights_only=True))
+    model.eval()
+
+    # 3. Harvest Parameters
+    total_images_needed = 2600
+    batch_size = 64
+    latent_dim = 128
+    generated_count = 0
+
+    print(f"Sampling {total_images_needed} images from the VAE latent space...")
+
+    with torch.no_grad():
+        with tqdm(total=total_images_needed, desc="Decoding Images") as pbar:
+            while generated_count < total_images_needed:
+                current_batch_size = min(batch_size, total_images_needed - generated_count)
+                
+                # Sample random coordinates from the standard normal distribution
+                z = torch.randn(current_batch_size, latent_dim).to(device)
+                
+                # Push through the Decoder (no need to un-normalize, Sigmoid handled it)
+                fake_images = model.decode(z)
+                
+                # Save out
+                for i in range(current_batch_size):
+                    img_path = os.path.join(output_dir, f"vae_normal_{generated_count}.png")
+                    save_image(fake_images[i], img_path)
+                    generated_count += 1
+                    
+                pbar.update(current_batch_size)
+
+    print(f"\nVAE Harvest complete. Images stored in: {output_dir}")
+
+if __name__ == "__main__":
+    main()

VAE/Train_VAE.py

@@ -0,0 +1,151 @@
+import os
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from torchvision import transforms
+from torchvision.utils import save_image
+from torch.utils.data import DataLoader, Subset
+import medmnist
+from medmnist import INFO
+from tqdm import tqdm
+
+# ==========================================
+# 1. The VAE Architecture
+# ==========================================
+class VAE(nn.Module):
+    def __init__(self, latent_dim=128):
+        super(VAE, self).__init__()
+        
+        # ENCODER: Compress 224x224 down to 7x7
+        self.enc1 = nn.Conv2d(1, 32, 4, 2, 1)    # Output: 112x112
+        self.enc2 = nn.Conv2d(32, 64, 4, 2, 1)   # Output: 56x56
+        self.enc3 = nn.Conv2d(64, 128, 4, 2, 1)  # Output: 28x28
+        self.enc4 = nn.Conv2d(128, 256, 4, 2, 1) # Output: 14x14
+        self.enc5 = nn.Conv2d(256, 512, 4, 2, 1) # Output: 7x7
+
+        # The Probabilistic Split (Mean and Log-Variance)
+        self.fc_mu = nn.Linear(512 * 7 * 7, latent_dim)
+        self.fc_logvar = nn.Linear(512 * 7 * 7, latent_dim)
+
+        # DECODER: Expand from latent_dim back to 224x224
+        self.dec_fc = nn.Linear(latent_dim, 512 * 7 * 7)
+        self.dec1 = nn.ConvTranspose2d(512, 256, 4, 2, 1)
+        self.dec2 = nn.ConvTranspose2d(256, 128, 4, 2, 1)
+        self.dec3 = nn.ConvTranspose2d(128, 64, 4, 2, 1)
+        self.dec4 = nn.ConvTranspose2d(64, 32, 4, 2, 1)
+        self.dec5 = nn.ConvTranspose2d(32, 1, 4, 2, 1)
+
+    def encode(self, x):
+        x = F.relu(self.enc1(x))
+        x = F.relu(self.enc2(x))
+        x = F.relu(self.enc3(x))
+        x = F.relu(self.enc4(x))
+        x = F.relu(self.enc5(x))
+        x = x.view(x.size(0), -1) # Flatten
+        return self.fc_mu(x), self.fc_logvar(x)
+
+    def reparameterize(self, mu, logvar):
+        # The Reparameterization Trick: z = mu + std * epsilon
+        std = torch.exp(0.5 * logvar)
+        eps = torch.randn_like(std)
+        return mu + eps * std
+
+    def decode(self, z):
+        x = F.relu(self.dec_fc(z))
+        x = x.view(x.size(0), 512, 7, 7) # Unflatten
+        x = F.relu(self.dec1(x))
+        x = F.relu(self.dec2(x))
+        x = F.relu(self.dec3(x))
+        x = F.relu(self.dec4(x))
+        # Sigmoid pushes pixels to exact [0, 1] range
+        x = torch.sigmoid(self.dec5(x)) 
+        return x
+
+    def forward(self, x):
+        mu, logvar = self.encode(x)
+        z = self.reparameterize(mu, logvar)
+        recon_x = self.decode(z)
+        return recon_x, mu, logvar
+
+# ==========================================
+# 2. The Custom VAE Loss Function
+# ==========================================
+def vae_loss_function(recon_x, x, mu, logvar):
+    # Loss 1: Reconstruction Loss (How well did it recreate the image?)
+    BCE = F.binary_cross_entropy(recon_x, x, reduction='sum')
+    
+    # Loss 2: KL Divergence (Forces latent space to be a standard normal distribution)
+    KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
+    
+    return BCE + KLD
+
+# ==========================================
+# 3. The Training Engine
+# ==========================================
+def main():
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Igniting VAE Engine on: {device}")
+
+    dataset_root = r"C:\Users\USER\Downloads\MedMNIST_Data"
+    out_dir = os.path.join(dataset_root, "VAE_Outputs")
+    os.makedirs(out_dir, exist_ok=True)
+
+    # Hyperparameters
+    num_epochs = 100
+    batch_size = 64
+    learning_rate = 1e-4
+
+    # Strict Normalization to [0, 1] for BCE Loss
+    transform = transforms.Compose([
+        transforms.ToTensor(),
+    ])
+
+    print("Isolating pure 'Normal (0)' lungs...")
+    info = INFO['pneumoniamnist']
+    DataClass = getattr(medmnist, info['python_class'])
+    full_dataset = DataClass(split='train', transform=transform, download=False, size=224, root=dataset_root)
+    
+    normal_indices = [i for i in range(len(full_dataset)) if full_dataset[i][1][0] == 0]
+    normal_dataset = Subset(full_dataset, normal_indices)
+    dataloader = DataLoader(normal_dataset, batch_size=batch_size, shuffle=True, num_workers=0)
+
+    model = VAE(latent_dim=128).to(device)
+    optimizer = optim.Adam(model.parameters(), lr=learning_rate)
+
+    print(f"Commencing VAE Training over {num_epochs} Epochs...")
+    for epoch in range(num_epochs):
+        model.train()
+        train_loss = 0
+        loop = tqdm(dataloader, leave=True)
+        
+        for batch_idx, (data, _) in enumerate(loop):
+            data = data.to(device)
+            optimizer.zero_grad()
+            
+            recon_batch, mu, logvar = model(data)
+            loss = vae_loss_function(recon_batch, data, mu, logvar)
+            
+            loss.backward()
+            train_loss += loss.item()
+            optimizer.step()
+            
+            loop.set_description(f"Epoch [{epoch+1}/{num_epochs}]")
+            loop.set_postfix(Loss=loss.item() / len(data))
+
+        # Generate a test image every 10 epochs
+        if (epoch + 1) % 10 == 0:
+            model.eval()
+            with torch.no_grad():
+                # Sample pure random noise from the normal distribution
+                sample = torch.randn(16, 128).to(device)
+                sample = model.decode(sample).cpu()
+                save_image(sample.view(16, 1, 224, 224), os.path.join(out_dir, f'sample_epoch_{epoch+1}.png'), nrow=4)
+
+    # Save the final brain
+    save_path = os.path.join(dataset_root, 'vae_baseline.pth')
+    torch.save(model.state_dict(), save_path)
+    print(f"\nVAE Training Complete! Weights saved to: {save_path}")
+
+if __name__ == "__main__":
+    main()

gui/frontend/README.md

@@ -0,0 +1,16 @@
+# React + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Oxc](https://oxc.rs)
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/)
+
+## React Compiler
+
+The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation).
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend using TypeScript with type-aware lint rules enabled. Check out the [TS template](https://github.com/vitejs/vite/tree/main/packages/create-vite/template-react-ts) for information on how to integrate TypeScript and [`typescript-eslint`](https://typescript-eslint.io) in your project.

gui/frontend/node_modules/zod-validation-error/LICENSE

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

gui/frontend/node_modules/zod-validation-error/README.md

@@ -0,0 +1,504 @@
+# zod-validation-error
+
+Wrap zod validation errors in user-friendly readable messages.
+
+[![Build Status](https://github.com/causaly/zod-validation-error/actions/workflows/ci.yml/badge.svg)](https://github.com/causaly/zod-validation-error/actions/workflows/ci.yml) [![npm version](https://img.shields.io/npm/v/zod-validation-error.svg?color=0c0)](https://www.npmjs.com/package/zod-validation-error)
+
+#### Features
+
+- User-friendly readable error messages with extensive configuration options;
+- Preserves original error details accessible via `error.details`;
+- Provides a custom error map for better user-friendly messages;
+- Supports both Zod v3 and v4.
+
+**_Note:_** This version of `zod-validation-error` works with zod v4. If you are looking for zod v3 support, please refer to the [v3 documentation](./README.v3.md)
+
+## Installation
+
+```bash
+npm install zod-validation-error
+```
+
+#### Requirements
+
+- Node.js v.18+
+- TypeScript v.4.5+
+
+## Quick start
+
+```typescript
+import { z as zod } from 'zod';
+import { fromError, createErrorMap } from 'zod-validation-error';
+
+// configure zod to use zod-validation-error's error map
+// this is optional, you may also use your own custom error map or zod's native error map
+// we recommend using zod-validation-error's error map for better user-friendly messages
+// see https://zod.dev/error-customization for further details
+zod.config({
+  customError: createErrorMap(),
+});
+
+// create zod schema
+const zodSchema = zod.object({
+  id: zod.int().positive(),
+  email: zod.email(),
+});
+
+// parse some invalid value
+try {
+  zodSchema.parse({
+    id: 1,
+    email: 'coyote@acme', // note: invalid email
+  });
+} catch (err) {
+  const validationError = fromError(err);
+  // the error is now readable by the user
+  // you may print it to console
+  console.log(validationError.toString());
+  // or return it as an actual error
+  return validationError;
+}
+```
+
+## Motivation
+
+Zod errors are difficult to consume for the end-user. This library wraps Zod validation errors in user-friendly readable messages that can be exposed to the outer world, while maintaining the original errors in an array for _dev_ use.
+
+### Example
+
+#### Input (from Zod)
+
+```json
+[
+  {
+    "origin": "number",
+    "code": "too_small",
+    "minimum": 0,
+    "inclusive": false,
+    "path": ["id"],
+    "message": "Number must be greater than 0 at \"id\""
+  },
+  {
+    "origin": "string",
+    "code": "invalid_format",
+    "format": "email",
+    "pattern": "/^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$/",
+    "path": ["email"],
+    "message": "Invalid email at \"email\""
+  }
+]
+```
+
+#### Output
+
+```
+Validation error: Number must be greater than 0 at "id"; Invalid email at "email"
+```
+
+## API
+
+- [ValidationError(message[, options])](#validationerror)
+- [createErrorMap(options)](#createErrorMap)
+- [createMessageBuilder(options)](#createMessageBuilder)
+- [isValidationError(error)](#isvalidationerror)
+- [isValidationErrorLike(error)](#isvalidationerrorlike)
+- [isZodErrorLike(error)](#iszoderrorlike)
+- [fromError(error[, options])](#fromerror)
+- [fromZodIssue(zodIssue[, options])](#fromzodissue)
+- [fromZodError(zodError[, options])](#fromzoderror)
+- [toValidationError([options]) => (error) => ValidationError](#tovalidationerror)
+
+### ValidationError
+
+Main `ValidationError` class, extending JavaScript's native `Error`.
+
+#### Arguments
+
+- `message` - _string_; error message (required)
+- `options` - _ErrorOptions_; error options as per [JavaScript definition](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/Error#options) (optional)
+  - `options.cause` - _any_; can be used to hold the original zod error (optional)
+
+#### Example 1: construct new ValidationError with `message`
+
+```typescript
+import { ValidationError } from 'zod-validation-error';
+
+const error = new ValidationError('foobar');
+console.log(error instanceof Error); // prints true
+```
+
+#### Example 2: construct new ValidationError with `message` and `options.cause`
+
+```typescript
+import { z as zod } from 'zod';
+import { ValidationError } from 'zod-validation-error';
+
+const error = new ValidationError('foobar', {
+  cause: new zod.ZodError([
+    {
+      origin: 'number',
+      code: 'too_small',
+      minimum: 0,
+      inclusive: false,
+      path: ['id'],
+      message: 'Number must be greater than 0 at "id"',
+      input: -1,
+    },
+  ]),
+});
+
+console.log(error.details); // prints issues from zod error
+```
+
+### createErrorMap
+
+Creates zod-validation-error's `errorMap`, which is used to format issues into user-friendly error messages.
+
+We think that zod's native error map is not user-friendly enough, so we provide our own implementation that formats issues into human-readable messages.
+
+Note: zod-validation-error's `errorMap` is an errorMap like all others and thus can also be used directly with `zod` (see https://zod.dev/error-customization for further details), e.g.
+
+#### Arguments
+
+- `options` - _Object_; formatting options (optional)
+
+##### createErrorMap Options
+
+| Name                            |               Type                | Description                                                                                                                                                                                                            |
+| ------------------------------- | :-------------------------------: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `displayInvalidFormatDetails`   |             `boolean`             | Indicates whether to display invalid format details (e.g. regexp pattern) in the error message (optional, defaults to `false`)                                                                                         |
+| `maxAllowedValuesToDisplay`     |             `number`              | Max number of allowed values to display (optional, defaults to `10`). Allowed values beyond this limit will be hidden.                                                                                                 |
+| `allowedValuesSeparator`        |             `string`              | Used to concatenate allowed values in the message (optional, defaults to `", "`)                                                                                                                                       |
+| `allowedValuesLastSeparator`    |       `string \| undefined`       | Used to concatenate last allowed value in the message (optional, defaults to `" or "`). Set to `undefined` to disable.                                                                                                 |
+| `wrapAllowedValuesInQuote`      |             `boolean`             | Indicates whether to wrap allowed values in quotes (optional, defaults to `true`). Note that this only applies to string values.                                                                                       |
+| `maxUnrecognizedKeysToDisplay`  |             `number`              | Max number of unrecognized keys to display in the error message (optional, defaults to `5`)                                                                                                                            |
+| `unrecognizedKeysSeparator`     |             `string`              | Used to concatenate unrecognized keys in the message (optional, defaults to `", "`)                                                                                                                                    |
+| `unrecognizedKeysLastSeparator` |       `string \| undefined`       | Used to concatenate the last unrecognized key in message (optional, defaults to `" and "`). Set to `undefined` to disable.                                                                                             |
+| `wrapUnrecognizedKeysInQuote`   |             `boolean`             | Indicates whether to wrap unrecognized keys in quotes (optional, defaults to `true`). Note that this only applies to string keys.                                                                                      |
+| `dateLocalization`              | `boolean \| Intl.LocalesArgument` | Indicates whether to localize date values (optional, defaults to `true`). If set to `true`, it will use the default locale of the environment. You can also pass `Intl.LocalesArgument` to specify a custom locale.    |
+| `numberLocalization`            | `boolean \| Intl.LocalesArgument` | Indicates whether to localize numeric values (optional, defaults to `true`). If set to `true`, it will use the default locale of the environment. You can also pass `Intl.LocalesArgument` to specify a custom locale. |
+
+#### Example
+
+```typescript
+import { z as zod } from 'zod';
+import { createErrorMap } from 'zod-validation-error';
+
+zod.config({
+  customError: createErrorMap({
+    // default values are used when not specified
+    displayInvalidFormatDetails: true,
+  }),
+});
+```
+
+### createMessageBuilder
+
+Creates zod-validation-error's default `MessageBuilder`, which is used to produce user-friendly error messages.
+
+Meant to be passed as an option to [fromError](#fromerror), [fromZodIssue](#fromzodissue), [fromZodError](#fromzoderror) or [toValidationError](#tovalidationerror).
+
+#### Arguments
+
+- `options` - _Object_; formatting options (optional)
+
+##### createMessageBuilder Options
+
+| Name                 |         Type          | Description                                                                                                                              |
+| -------------------- | :-------------------: | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `maxIssuesInMessage` |       `number`        | Max issues to include in user-friendly message (optional, defaults to `99`)                                                              |
+| `issueSeparator`     |       `string`        | Used to concatenate issues in user-friendly message (optional, defaults to `";"`)                                                        |
+| `unionSeparator`     |       `string`        | Used to concatenate union-issues in user-friendly message (optional, defaults to `" or "`)                                               |
+| `prefix`             | `string \| undefined` | Prefix to use in user-friendly message (optional, defaults to `"Validation error"`). Pass `undefined` to disable prefix completely.      |
+| `prefixSeparator`    |       `string`        | Used to concatenate prefix with rest of the user-friendly message (optional, defaults to `": "`). Not used when `prefix` is `undefined`. |
+| `includePath`        |       `boolean`       | Indicates whether to include the erroneous property key in the error message (optional, defaults to `true`)                              |
+| `forceTitleCase`     |       `boolean`       | Indicates whether to convert individual issue messages to title case (optional, defaults to `true`).                                     |
+
+#### Example
+
+```typescript
+import { createMessageBuilder } from 'zod-validation-error';
+
+const messageBuilder = createMessageBuilder({
+  maxIssuesInMessage: 3,
+  includePath: false,
+});
+```
+
+### isValidationError
+
+A [type guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) utility function, based on `instanceof` comparison.
+
+#### Arguments
+
+- `error` - error instance (required)
+
+#### Example
+
+```typescript
+import { z as zod } from 'zod';
+import { ValidationError, isValidationError } from 'zod-validation-error';
+
+const err = new ValidationError('foobar');
+isValidationError(err); // returns true
+
+const invalidErr = new Error('foobar');
+isValidationError(err); // returns false
+```
+
+### isValidationErrorLike
+
+A [type guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) utility function, based on _heuristics_ comparison.
+
+_Why do we need heuristics since we can use a simple `instanceof` comparison?_ Because of multi-version inconsistencies. For instance, it's possible that a dependency is using an older `zod-validation-error` version internally. In such case, the `instanceof` comparison will yield invalid results because module deduplication does not apply at npm/yarn level and the prototype is different.
+
+tl;dr if you are uncertain then it is preferable to use `isValidationErrorLike` instead of `isValidationError`.
+
+#### Arguments
+
+- `error` - error instance (required)
+
+#### Example
+
+```typescript
+import { ValidationError, isValidationErrorLike } from 'zod-validation-error';
+
+const err = new ValidationError('foobar');
+isValidationErrorLike(err); // returns true
+
+const invalidErr = new Error('foobar');
+isValidationErrorLike(err); // returns false
+```
+
+### isZodErrorLike
+
+A [type guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) utility function, based on _heuristics_ comparison.
+
+_Why do we need heuristics since we can use a simple `instanceof` comparison?_ Because of multi-version inconsistencies. For instance, it's possible that a dependency is using an older `zod` version internally. In such case, the `instanceof` comparison will yield invalid results because module deduplication does not apply at npm/yarn level and the prototype is different.
+
+#### Arguments
+
+- `error` - error instance (required)
+
+#### Example
+
+```typescript
+import { z as zod } from 'zod';
+import { ValidationError, isZodErrorLike } from 'zod-validation-error';
+
+const zodValidationErr = new ValidationError('foobar');
+isZodErrorLike(zodValidationErr); // returns false
+
+const genericErr = new Error('foobar');
+isZodErrorLike(genericErr); // returns false
+
+const zodErr = new zod.ZodError([
+  {
+    origin: 'number',
+    code: 'too_small',
+    minimum: 0,
+    inclusive: false,
+    path: ['id'],
+    message: 'Number must be greater than 0 at "id"',
+    input: -1,
+  },
+]);
+isZodErrorLike(zodErr); // returns true
+```
+
+### fromError
+
+Converts an error to `ValidationError`.
+
+_What is the difference between `fromError` and `fromZodError`?_ The `fromError` function is a less strict version of `fromZodError`. It can accept an unknown error and attempt to convert it to a `ValidationError`.
+
+#### Arguments
+
+- `error` - _unknown_; an error (required)
+- `options` - _Object_; formatting options (optional)
+  - `messageBuilder` - _MessageBuilder_; a function that accepts an array of `zod.ZodIssue` objects and returns a user-friendly error message in the form of a `string` (optional).
+
+#### Notes
+
+Alternatively, you may pass [createMessageBuilder options](#createmessagebuilder-options) directly as `options`. These will be used as arguments to create the `MessageBuilder` instance internally.
+
+### fromZodIssue
+
+Converts a single zod issue to `ValidationError`.
+
+#### Arguments
+
+- `zodIssue` - _zod.ZodIssue_; a ZodIssue instance (required)
+- `options` - _Object_; formatting options (optional)
+  - `messageBuilder` - _MessageBuilder_; a function that accepts an array of `zod.ZodIssue` objects and returns a user-friendly error message in the form of a `string` (optional).
+
+#### Notes
+
+Alternatively, you may pass [createMessageBuilder options](#createmessagebuilder-options) directly as `options`. These will be used as arguments to create the `MessageBuilder` instance internally.
+
+### fromZodError
+
+Converts zod error to `ValidationError`.
+
+_Why is the difference between `ZodError` and `ZodIssue`?_ A `ZodError` is a collection of 1 or more `ZodIssue` instances. It's what you get when you call `zodSchema.parse()`.
+
+#### Arguments
+
+- `zodError` - _zod.ZodError_; a ZodError instance (required)
+- `options` - _Object_; formatting options (optional)
+  - `messageBuilder` - _MessageBuilder_; a function that accepts an array of `zod.ZodIssue` objects and returns a user-friendly error message in the form of a `string` (optional).
+
+#### Notes
+
+Alternatively, you may pass [createMessageBuilder options](#createmessagebuilder-optionscreateMessageBuilder) directly as `options`. These will be used as arguments to create the `MessageBuilder` instance internally.
+
+### toValidationError
+
+A curried version of `fromZodError` meant to be used for FP (Functional Programming). Note it first takes the options object if needed and returns a function that converts the `zodError` to a `ValidationError` object
+
+```js
+toValidationError(options) => (zodError) => ValidationError
+```
+
+#### Example using fp-ts
+
+```typescript
+import * as Either from 'fp-ts/Either';
+import { z as zod } from 'zod';
+import { toValidationError, ValidationError } from 'zod-validation-error';
+
+// create zod schema
+const zodSchema = zod
+  .object({
+    id: zod.int().positive(),
+    email: zod.email(),
+  })
+  .brand<'User'>();
+
+export type User = zod.infer<typeof zodSchema>;
+
+export function parse(
+  value: zod.input<typeof zodSchema>
+): Either.Either<ValidationError, User> {
+  return Either.tryCatch(() => schema.parse(value), toValidationError());
+}
+```
+
+## FAQ
+
+### What is the difference between zod-validation-error and zod's own [prettifyError](https://zod.dev/error-formatting#zprettifyerror)?
+
+While both libraries aim to provide a human-readable string representation of a zod error, they differ in several ways...
+
+1. **End-user focus**: zod-validation-error provides opinionated, user-friendly error messages designed to be displayed directly to end-users in forms or API responses.
+1. **Customization options**: zod-validation-error offers extensive configuration for message formatting, such as controlling path inclusion, allowed values display, localization, and more.
+1. **Error handling**: zod-validation-error maintains the original error details while providing a clean, consistent interface through the ValidationError class.
+1. **Integration flexibility**: Beyond just formatting, zod-validation-error provides utility functions for error detection and conversion that work well in various architectural patterns, e.g. functional programming.
+
+Disclaimer: as per this [comment](https://github.com/causaly/zod-validation-error/issues/455#issuecomment-2811895152), we have no intention to antagonize zod. In fact, we are happy to decommission this module assuming it's in the best interest of the community. As of now, it seems that there's room for both `zod-validation-error` and `prettifyError`, also based on Colin McDonnell's [response](https://github.com/causaly/zod-validation-error/issues/455#issuecomment-2814466019).
+
+### Do I need to use `zod-validation-error`'s error map?
+
+No, you can use zod's native error map if you prefer. However, we recommend using `zod-validation-error`'s error map for better user-friendly messages.
+
+You may also use your own custom error map if you have specific requirements, e.g. internationalization.
+
+### Where can I see how `zod-validation-error`'s error map formatting works?
+
+The easiest way to understand how `zod-validation-error`'s error map works is to look at the [tests](./lib/v4/errorMap/errorMap.test.ts). They cover various scenarios and demonstrate how the error map formats issues into user-friendly messages.
+
+### How to distinguish between errors
+
+Use the `isValidationErrorLike` type guard.
+
+#### Example
+
+Scenario: Distinguish between `ValidationError` VS generic `Error` in order to respond with 400 VS 500 HTTP status code respectively.
+
+```typescript
+import { isValidationErrorLike } from 'zod-validation-error';
+
+try {
+  func(); // throws Error - or - ValidationError
+} catch (err) {
+  if (isValidationErrorLike(err)) {
+    return 400; // Bad Data (this is a client error)
+  }
+
+  return 500; // Server Error
+}
+```
+
+### How to use `ValidationError` outside `zod`
+
+It's possible to implement custom validation logic outside `zod` and throw a `ValidationError`.
+
+#### Example 1: passing custom message
+
+```typescript
+import { ValidationError } from 'zod-validation-error';
+import { Buffer } from 'node:buffer';
+
+function parseBuffer(buf: unknown): Buffer {
+  if (!Buffer.isBuffer(buf)) {
+    throw new ValidationError('Invalid argument; expected buffer');
+  }
+
+  return buf;
+}
+```
+
+#### Example 2: passing custom message and original error as cause
+
+```typescript
+import { ValidationError } from 'zod-validation-error';
+
+try {
+  // do something that throws an error
+} catch (err) {
+  throw new ValidationError('Something went deeply wrong', { cause: err });
+}
+```
+
+### How to use `ValidationError` with custom "error map"
+
+Zod supports customizing error messages by providing a custom "error map". You may combine this with `zod-validation-error` to produce user-friendly messages.
+
+#### Example: produce user-friendly error messages using the `customError` property
+
+If all you need is to produce user-friendly error messages you may use the `customError` property.
+
+```typescript
+import { z as zod } from 'zod';
+import { createErrorMap } from 'zod-validation-error';
+
+zod.config({
+  customError: createErrorMap({
+    includePath: true,
+  }),
+});
+```
+
+`zod-validation-error` will respect the `customError` property when it is set, no further configuration is needed.
+
+### Does `zod-validation-error` support CommonJS
+
+Yes, `zod-validation-error` supports CommonJS out-of-the-box. All you need to do is import it using `require`.
+
+#### Example
+
+```typescript
+const { ValidationError } = require('zod-validation-error');
+```
+
+## Contribute
+
+Source code contributions are most welcome. Please open a PR, ensure the linter is satisfied and all tests pass.
+
+#### We are hiring
+
+Causaly is building the world's largest biomedical knowledge platform, using technologies such as TypeScript, React and Node.js. Find out more about our openings at https://jobs.ashbyhq.com/causaly.
+
+## License
+
+MIT

gui/frontend/node_modules/zod-validation-error/README.v3.md

@@ -0,0 +1,558 @@
+# zod-validation-error
+
+Wrap zod validation errors in user-friendly readable messages.
+
+[![Build Status](https://github.com/causaly/zod-validation-error/actions/workflows/ci.yml/badge.svg)](https://github.com/causaly/zod-validation-error/actions/workflows/ci.yml) [![npm version](https://img.shields.io/npm/v/zod-validation-error.svg?color=0c0)](https://www.npmjs.com/package/zod-validation-error)
+
+#### Features
+
+- User-friendly readable messages, configurable via options;
+- Maintain original issues under `error.details`;
+- Supports both `zod` v3 and v4.
+
+**_Note:_** This is the v3 version of `zod-validation-error`. If you are looking for zod v4 support, please click [here](/README.md).
+
+## Installation
+
+```bash
+npm install zod-validation-error
+```
+
+#### Requirements
+
+- Node.js v.18+
+- TypeScript v.4.5+
+
+## Quick start
+
+```typescript
+import { z as zod } from 'zod/v3';
+import { fromError } from 'zod-validation-error/v3';
+
+// create zod schema
+const zodSchema = zod.object({
+  id: zod.number().int().positive(),
+  email: zod.string().email(),
+});
+
+// parse some invalid value
+try {
+  zodSchema.parse({
+    id: 1,
+    email: 'foobar', // note: invalid email
+  });
+} catch (err) {
+  const validationError = fromError(err);
+  // the error is now readable by the user
+  // you may print it to console
+  console.log(validationError.toString());
+  // or return it as an actual error
+  return validationError;
+}
+```
+
+## Motivation
+
+Zod errors are difficult to consume for the end-user. This library wraps Zod validation errors in user-friendly readable messages that can be exposed to the outer world, while maintaining the original errors in an array for _dev_ use.
+
+### Example
+
+#### Input (from Zod)
+
+```json
+[
+  {
+    "code": "too_small",
+    "inclusive": false,
+    "message": "Number must be greater than 0",
+    "minimum": 0,
+    "path": ["id"],
+    "type": "number"
+  },
+  {
+    "code": "invalid_string",
+    "message": "Invalid email",
+    "path": ["email"],
+    "validation": "email"
+  }
+]
+```
+
+#### Output
+
+```
+Validation error: Number must be greater than 0 at "id"; Invalid email at "email"
+```
+
+## API
+
+- [ValidationError(message[, options])](#validationerror)
+- [createMessageBuilder(props)](#createMessageBuilder)
+- [errorMap](#errormap)
+- [isValidationError(error)](#isvalidationerror)
+- [isValidationErrorLike(error)](#isvalidationerrorlike)
+- [isZodErrorLike(error)](#iszoderrorlike)
+- [fromError(error[, options])](#fromerror)
+- [fromZodIssue(zodIssue[, options])](#fromzodissue)
+- [fromZodError(zodError[, options])](#fromzoderror)
+- [toValidationError([options]) => (error) => ValidationError](#tovalidationerror)
+
+### ValidationError
+
+Main `ValidationError` class, extending native JavaScript `Error`.
+
+#### Arguments
+
+- `message` - _string_; error message (required)
+- `options` - _ErrorOptions_; error options as per [JavaScript definition](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/Error#options) (optional)
+  - `options.cause` - _any_; can be used to hold the original zod error (optional)
+
+#### Example 1: construct new ValidationError with `message`
+
+```typescript
+const { ValidationError } = require('zod-validation-error');
+
+const error = new ValidationError('foobar');
+console.log(error instanceof Error); // prints true
+```
+
+#### Example 2: construct new ValidationError with `message` and `options.cause`
+
+```typescript
+import { z as zod } from 'zod/v3';
+const { ValidationError } = require('zod-validation-error');
+
+const error = new ValidationError('foobar', {
+  cause: new zod.ZodError([
+    {
+      code: 'invalid_string',
+      message: 'Invalid email',
+      path: ['email'],
+      validation: 'email',
+    },
+  ]),
+});
+
+console.log(error.details); // prints issues from zod error
+```
+
+### createMessageBuilder
+
+Creates zod-validation-error's default `MessageBuilder`, which is used to produce user-friendly error messages.
+
+Meant to be passed as an option to [fromError](#fromerror), [fromZodIssue](#fromzodissue), [fromZodError](#fromzoderror) or [toValidationError](#tovalidationerror).
+
+You may read more on the concept of the `MessageBuilder` further [below](#MessageBuilder).
+
+#### Arguments
+
+- `props` - _Object_; formatting options (optional)
+  - `maxIssuesInMessage` - _number_; max issues to include in user-friendly message (optional, defaults to 99)
+  - `issueSeparator` - _string_; used to concatenate issues in user-friendly message (optional, defaults to ";")
+  - `unionSeparator` - _string_; used to concatenate union-issues in user-friendly message (optional, defaults to ", or")
+  - `prefix` - _string_ or _null_; prefix to use in user-friendly message (optional, defaults to "Validation error"). Pass `null` to disable prefix completely.
+  - `prefixSeparator` - _string_; used to concatenate prefix with rest of the user-friendly message (optional, defaults to ": "). Not used when `prefix` is `null`.
+  - `includePath` - _boolean_; used to provide control on whether to include the erroneous property name suffix or not (optional, defaults to `true`).
+
+#### Example
+
+```typescript
+import { createMessageBuilder } from 'zod-validation-error/v3';
+
+const messageBuilder = createMessageBuilder({
+  includePath: false,
+  maxIssuesInMessage: 3,
+});
+```
+
+### errorMap
+
+A custom error map to use with zod's `setErrorMap` method and get user-friendly messages automatically.
+
+#### Example
+
+```typescript
+import { z as zod } from 'zod/v3';
+import { errorMap } from 'zod-validation-error/v3';
+
+zod.setErrorMap(errorMap);
+```
+
+### isValidationError
+
+A [type guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) utility function, based on `instanceof` comparison.
+
+#### Arguments
+
+- `error` - error instance (required)
+
+#### Example
+
+```typescript
+import { z as zod } from 'zod/v3';
+import { ValidationError, isValidationError } from 'zod-validation-error/v3';
+
+const err = new ValidationError('foobar');
+isValidationError(err); // returns true
+
+const invalidErr = new Error('foobar');
+isValidationError(err); // returns false
+```
+
+### isValidationErrorLike
+
+A [type guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) utility function, based on _heuristics_ comparison.
+
+_Why do we need heuristics since we can use a simple `instanceof` comparison?_ Because of multi-version inconsistencies. For instance, it's possible that a dependency is using an older `zod-validation-error` version internally. In such case, the `instanceof` comparison will yield invalid results because module deduplication does not apply at npm/yarn level and the prototype is different.
+
+tl;dr if you are uncertain then it is preferable to use `isValidationErrorLike` instead of `isValidationError`.
+
+#### Arguments
+
+- `error` - error instance (required)
+
+#### Example
+
+```typescript
+import {
+  ValidationError,
+  isValidationErrorLike,
+} from 'zod-validation-error/v3';
+
+const err = new ValidationError('foobar');
+isValidationErrorLike(err); // returns true
+
+const invalidErr = new Error('foobar');
+isValidationErrorLike(err); // returns false
+```
+
+### isZodErrorLike
+
+A [type guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) utility function, based on _heuristics_ comparison.
+
+_Why do we need heuristics since we can use a simple `instanceof` comparison?_ Because of multi-version inconsistencies. For instance, it's possible that a dependency is using an older `zod` version internally. In such case, the `instanceof` comparison will yield invalid results because module deduplication does not apply at npm/yarn level and the prototype is different.
+
+#### Arguments
+
+- `error` - error instance (required)
+
+#### Example
+
+```typescript
+import { z as zod } from 'zod/v3';
+import { ValidationError, isZodErrorLike } from 'zod-validation-error/v3';
+
+const zodValidationErr = new ValidationError('foobar');
+isZodErrorLike(zodValidationErr); // returns false
+
+const genericErr = new Error('foobar');
+isZodErrorLike(genericErr); // returns false
+
+const zodErr = new zod.ZodError([
+  {
+    code: zod.ZodIssueCode.custom,
+    path: [],
+    message: 'foobar',
+    fatal: true,
+  },
+]);
+isZodErrorLike(zodErr); // returns true
+```
+
+### fromError
+
+Converts an error to `ValidationError`.
+
+_What is the difference between `fromError` and `fromZodError`?_ The `fromError` function is a less strict version of `fromZodError`. It can accept an unknown error and attempt to convert it to a `ValidationError`.
+
+#### Arguments
+
+- `error` - _unknown_; an error (required)
+- `options` - _Object_; formatting options (optional)
+  - `messageBuilder` - _MessageBuilder_; a function that accepts an array of `zod.ZodIssue` objects and returns a user-friendly error message in the form of a `string` (optional).
+
+#### Notes
+
+Alternatively, you may pass the following `options` instead of a `messageBuilder`.
+
+- `options` - _Object_; formatting options (optional)
+  - `maxIssuesInMessage` - _number_; max issues to include in user-friendly message (optional, defaults to 99)
+  - `issueSeparator` - _string_; used to concatenate issues in user-friendly message (optional, defaults to ";")
+  - `unionSeparator` - _string_; used to concatenate union-issues in user-friendly message (optional, defaults to ", or")
+  - `prefix` - _string_ or _null_; prefix to use in user-friendly message (optional, defaults to "Validation error"). Pass `null` to disable prefix completely.
+  - `prefixSeparator` - _string_; used to concatenate prefix with rest of the user-friendly message (optional, defaults to ": "). Not used when `prefix` is `null`.
+  - `includePath` - _boolean_; used to provide control on whether to include the erroneous property name suffix or not (optional, defaults to `true`).
+
+They will be passed as arguments to the [createMessageBuilder](#createMessageBuilder) function. The only reason they exist is to provide backwards-compatibility with older versions of `zod-validation-error`. They should however be considered deprecated and may be removed in the future.
+
+### fromZodIssue
+
+Converts a single zod issue to `ValidationError`.
+
+#### Arguments
+
+- `zodIssue` - _zod.ZodIssue_; a ZodIssue instance (required)
+- `options` - _Object_; formatting options (optional)
+  - `messageBuilder` - _MessageBuilder_; a function that accepts an array of `zod.ZodIssue` objects and returns a user-friendly error message in the form of a `string` (optional).
+
+#### Notes
+
+Alternatively, you may pass the following `options` instead of a `messageBuilder`.
+
+- `options` - _Object_; formatting options (optional)
+  - `issueSeparator` - _string_; used to concatenate issues in user-friendly message (optional, defaults to ";")
+  - `unionSeparator` - _string_; used to concatenate union-issues in user-friendly message (optional, defaults to ", or")
+  - `prefix` - _string_ or _null_; prefix to use in user-friendly message (optional, defaults to "Validation error"). Pass `null` to disable prefix completely.
+  - `prefixSeparator` - _string_; used to concatenate prefix with rest of the user-friendly message (optional, defaults to ": "). Not used when `prefix` is `null`.
+  - `includePath` - _boolean_; used to provide control on whether to include the erroneous property name suffix or not (optional, defaults to `true`).
+
+They will be passed as arguments to the [createMessageBuilder](#createMessageBuilder) function. The only reason they exist is to provide backwards-compatibility with older versions of `zod-validation-error`. They should however be considered deprecated and may be removed in the future.
+
+### fromZodError
+
+Converts zod error to `ValidationError`.
+
+_Why is the difference between `ZodError` and `ZodIssue`?_ A `ZodError` is a collection of 1 or more `ZodIssue` instances. It's what you get when you call `zodSchema.parse()`.
+
+#### Arguments
+
+- `zodError` - _zod.ZodError_; a ZodError instance (required)
+- `options` - _Object_; formatting options (optional)
+  - `messageBuilder` - _MessageBuilder_; a function that accepts an array of `zod.ZodIssue` objects and returns a user-friendly error message in the form of a `string` (optional).
+
+#### Notes
+
+Alternatively, you may pass the following `options` instead of a `messageBuilder`.
+
+- `options` - _Object_; formatting options (optional)
+  - `maxIssuesInMessage` - _number_; max issues to include in user-friendly message (optional, defaults to 99)
+  - `issueSeparator` - _string_; used to concatenate issues in user-friendly message (optional, defaults to ";")
+  - `unionSeparator` - _string_; used to concatenate union-issues in user-friendly message (optional, defaults to ", or")
+  - `prefix` - _string_ or _null_; prefix to use in user-friendly message (optional, defaults to "Validation error"). Pass `null` to disable prefix completely.
+  - `prefixSeparator` - _string_; used to concatenate prefix with rest of the user-friendly message (optional, defaults to ": "). Not used when `prefix` is `null`.
+  - `includePath` - _boolean_; used to provide control on whether to include the erroneous property name suffix or not (optional, defaults to `true`).
+
+They will be passed as arguments to the [createMessageBuilder](#createMessageBuilder) function. The only reason they exist is to provide backwards-compatibility with older versions of `zod-validation-error`. They should however be considered deprecated and may be removed in the future.
+
+### toValidationError
+
+A curried version of `fromZodError` meant to be used for FP (Functional Programming). Note it first takes the options object if needed and returns a function that converts the `zodError` to a `ValidationError` object
+
+```js
+toValidationError(options) => (zodError) => ValidationError
+```
+
+#### Example using fp-ts
+
+```typescript
+import * as Either from 'fp-ts/Either';
+import { z as zod } from 'zod/v3';
+import { toValidationError, ValidationError } from 'zod-validation-error/v3';
+
+// create zod schema
+const zodSchema = zod
+  .object({
+    id: zod.number().int().positive(),
+    email: zod.string().email(),
+  })
+  .brand<'User'>();
+
+export type User = zod.infer<typeof zodSchema>;
+
+export function parse(
+  value: zod.input<typeof zodSchema>
+): Either.Either<ValidationError, User> {
+  return Either.tryCatch(() => schema.parse(value), toValidationError());
+}
+```
+
+## MessageBuilder
+
+`zod-validation-error` can be configured with a custom `MessageBuilder` function in order to produce case-specific error messages.
+
+#### Example
+
+For instance, one may want to print `invalid_string` errors to the console in red color.
+
+```typescript
+import { z as zod } from 'zod/v3';
+import { type MessageBuilder, fromError } from 'zod-validation-error/v3';
+import chalk from 'chalk';
+
+// create custom MessageBuilder
+const myMessageBuilder: MessageBuilder = (issues) => {
+  return (
+    issues
+      // format error message
+      .map((issue) => {
+        if (issue.code === zod.ZodIssueCode.invalid_string) {
+          return chalk.red(issue.message);
+        }
+
+        return issue.message;
+      })
+      // join as string with new-line character
+      .join('\n')
+  );
+};
+
+// create zod schema
+const zodSchema = zod.object({
+  id: zod.number().int().positive(),
+  email: zod.string().email(),
+});
+
+// parse some invalid value
+try {
+  zodSchema.parse({
+    id: 1,
+    email: 'foobar', // note: invalid email value
+  });
+} catch (err) {
+  const validationError = fromError(err, {
+    messageBuilder: myMessageBuilder,
+  });
+  // the error is now displayed with red letters
+  console.log(validationError.toString());
+}
+```
+
+## FAQ
+
+### How to distinguish between errors
+
+Use the `isValidationErrorLike` type guard.
+
+#### Example
+
+Scenario: Distinguish between `ValidationError` VS generic `Error` in order to respond with 400 VS 500 HTTP status code respectively.
+
+```typescript
+import * as Either from 'fp-ts/Either';
+import { z as zod } from 'zod/v3';
+import { isValidationErrorLike } from 'zod-validation-error/v3';
+
+try {
+  func(); // throws Error - or - ValidationError
+} catch (err) {
+  if (isValidationErrorLike(err)) {
+    return 400; // Bad Data (this is a client error)
+  }
+
+  return 500; // Server Error
+}
+```
+
+### How to use `ValidationError` outside `zod`
+
+It's possible to implement custom validation logic outside `zod` and throw a `ValidationError`.
+
+#### Example 1: passing custom message
+
+```typescript
+import { ValidationError } from 'zod-validation-error/v3';
+import { Buffer } from 'node:buffer';
+
+function parseBuffer(buf: unknown): Buffer {
+  if (!Buffer.isBuffer(buf)) {
+    throw new ValidationError('Invalid argument; expected buffer');
+  }
+
+  return buf;
+}
+```
+
+#### Example 2: passing custom message and original error as cause
+
+```typescript
+import { ValidationError } from 'zod-validation-error/v3';
+
+try {
+  // do something that throws an error
+} catch (err) {
+  throw new ValidationError('Something went deeply wrong', { cause: err });
+}
+```
+
+### How to use `ValidationError` with custom "error map"
+
+Zod supports customizing error messages by providing a custom "error map". You may combine this with `zod-validation-error` to produce user-friendly messages.
+
+#### Example 1: produce user-friendly error messages using the `errorMap` property
+
+If all you need is to produce user-friendly error messages you may use the `errorMap` property.
+
+```typescript
+import { z as zod } from 'zod/v3';
+import { errorMap } from 'zod-validation-error/v3';
+
+zod.setErrorMap(errorMap);
+```
+
+#### Example 2: extra customization using `fromZodIssue`
+
+If you need to customize some error code, you may use the `fromZodIssue` function.
+
+```typescript
+import { z as zod } from 'zod/v3';
+import { fromZodIssue } from 'zod-validation-error/v3';
+
+const customErrorMap: zod.ZodErrorMap = (issue, ctx) => {
+  switch (issue.code) {
+    case ZodIssueCode.invalid_type: {
+      return {
+        message:
+          'Custom error message of your preference for invalid_type errors',
+      };
+    }
+    default: {
+      const validationError = fromZodIssue({
+        ...issue,
+        // fallback to the default error message
+        // when issue does not have a message
+        message: issue.message ?? ctx.defaultError,
+      });
+
+      return {
+        message: validationError.message,
+      };
+    }
+  }
+};
+
+zod.setErrorMap(customErrorMap);
+```
+
+### How to use `zod-validation-error` with `react-hook-form`?
+
+```typescript
+import { useForm } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { errorMap } from 'zod-validation-error/v3';
+
+useForm({
+  resolver: zodResolver(schema, { errorMap }),
+});
+```
+
+### Does `zod-validation-error` support CommonJS
+
+Yes, `zod-validation-error` supports CommonJS out-of-the-box. All you need to do is import it using `require`.
+
+#### Example
+
+```typescript
+const { ValidationError } = require('zod-validation-error');
+```
+
+## Contribute
+
+Source code contributions are most welcome. Please open a PR, ensure the linter is satisfied and all tests pass.
+
+#### We are hiring
+
+Causaly is building the world's largest biomedical knowledge platform, using technologies such as TypeScript, React and Node.js. Find out more about our openings at https://jobs.ashbyhq.com/causaly.
+
+## License
+
+MIT

gui/frontend/node_modules/zod-validation-error/package.json

@@ -0,0 +1,108 @@
+{
+  "name": "zod-validation-error",
+  "version": "4.0.2",
+  "description": "Wrap zod validation errors in user-friendly readable messages",
+  "keywords": [
+    "zod",
+    "error",
+    "validation"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/causaly/zod-validation-error.git"
+  },
+  "author": {
+    "name": "Dimitrios C. Michalakos",
+    "email": "dimitris@jmike.gr",
+    "url": "https://github.com/jmike"
+  },
+  "contributors": [
+    {
+      "name": "Thanos Karagiannis",
+      "email": "hey@maestros.io",
+      "url": "https://github.com/thanoskrg"
+    },
+    {
+      "name": "Nikos Tsompanides",
+      "email": "nikostsompanides@gmail.com",
+      "url": "https://github.com/NikosTsompanides"
+    },
+    {
+      "name": "Nikos Kalogridis",
+      "url": "https://github.com/nikoskalogridis"
+    }
+  ],
+  "main": "./v4/index.js",
+  "module": "./v4/index.mjs",
+  "types": "./v4/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./v4/index.d.ts",
+      "require": "./v4/index.js",
+      "import": "./v4/index.mjs"
+    },
+    "./v3": {
+      "types": "./v3/index.d.ts",
+      "require": "./v3/index.js",
+      "import": "./v3/index.mjs"
+    },
+    "./v4": {
+      "types": "./v4/index.d.ts",
+      "require": "./v4/index.js",
+      "import": "./v4/index.mjs"
+    }
+  },
+  "files": [
+    "v3",
+    "v4"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "tsup --config ./tsup.config.ts",
+    "lint": "eslint lib --ext .ts",
+    "format": "prettier --config ./.prettierrc --ignore-path .gitignore -w .",
+    "test": "vitest run",
+    "changeset": "changeset",
+    "prerelease": "npm run build && npm run test",
+    "release": "changeset publish",
+    "prepare": "husky"
+  },
+  "lint-staged": {
+    "*.{js,jsx,ts,tsx}": [
+      "eslint --fix",
+      "prettier --config ./.prettierrc.json --write"
+    ]
+  },
+  "devDependencies": {
+    "@changesets/changelog-github": "^0.5.0",
+    "@changesets/cli": "^2.27.7",
+    "@commitlint/cli": "^18.0.0",
+    "@commitlint/config-conventional": "^18.0.0",
+    "@types/node": "^20.5.0",
+    "@typescript-eslint/eslint-plugin": "^6.4.1",
+    "@typescript-eslint/parser": "^6.4.1",
+    "concurrently": "^8.2.0",
+    "eslint": "^8.4.1",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-prettier": "^4.2.1",
+    "husky": "^9.1.7",
+    "lint-staged": "^15.0.1",
+    "prettier": "^2.8.8",
+    "tsup": "^8.0.2",
+    "typescript": "^5.1.6",
+    "vitest": "^3.1.2",
+    "zod": "^4.0.2"
+  },
+  "peerDependencies": {
+    "zod": "^3.25.0 || ^4.0.0"
+  }
+}

gui/frontend/node_modules/zod-validation-error/v3/index.d.mts

@@ -0,0 +1,50 @@
+import * as zod from 'zod/v3';
+
+interface ErrorOptions {
+    cause?: unknown;
+}
+declare class ValidationError extends Error {
+    name: 'ZodValidationError';
+    details: Array<zod.ZodIssue>;
+    constructor(message?: string, options?: ErrorOptions);
+    toString(): string;
+}
+
+declare function isValidationError(err: unknown): err is ValidationError;
+
+declare function isValidationErrorLike(err: unknown): err is ValidationError;
+
+declare function isZodErrorLike(err: unknown): err is zod.ZodError;
+
+declare const errorMap: zod.ZodErrorMap;
+
+type NonEmptyArray<T> = [T, ...T[]];
+
+type ZodIssue = zod.ZodIssue;
+type MessageBuilder = (issues: NonEmptyArray<ZodIssue>) => string;
+type CreateMessageBuilderProps = {
+    issueSeparator?: string;
+    unionSeparator?: string;
+    prefix?: string | null;
+    prefixSeparator?: string;
+    includePath?: boolean;
+    maxIssuesInMessage?: number;
+};
+declare function createMessageBuilder(props?: CreateMessageBuilderProps): MessageBuilder;
+
+type ZodError = zod.ZodError;
+type FromZodErrorOptions = {
+    messageBuilder: MessageBuilder;
+} | CreateMessageBuilderProps;
+declare function fromZodError(zodError: ZodError, options?: FromZodErrorOptions): ValidationError;
+
+declare function fromError(err: unknown, options?: FromZodErrorOptions): ValidationError;
+
+type FromZodIssueOptions = {
+    messageBuilder: MessageBuilder;
+} | Omit<CreateMessageBuilderProps, 'maxIssuesInMessage'>;
+declare function fromZodIssue(issue: ZodIssue, options?: FromZodIssueOptions): ValidationError;
+
+declare const toValidationError: (options?: FromZodErrorOptions) => (err: unknown) => ValidationError;
+
+export { type ErrorOptions, type FromZodErrorOptions, type FromZodIssueOptions, type MessageBuilder, type NonEmptyArray, ValidationError, type ZodError, type ZodIssue, createMessageBuilder, errorMap, fromError, fromZodError, fromZodIssue, isValidationError, isValidationErrorLike, isZodErrorLike, toValidationError };

gui/frontend/node_modules/zod-validation-error/v3/index.d.ts

@@ -0,0 +1,50 @@
+import * as zod from 'zod/v3';
+
+interface ErrorOptions {
+    cause?: unknown;
+}
+declare class ValidationError extends Error {
+    name: 'ZodValidationError';
+    details: Array<zod.ZodIssue>;
+    constructor(message?: string, options?: ErrorOptions);
+    toString(): string;
+}
+
+declare function isValidationError(err: unknown): err is ValidationError;
+
+declare function isValidationErrorLike(err: unknown): err is ValidationError;
+
+declare function isZodErrorLike(err: unknown): err is zod.ZodError;
+
+declare const errorMap: zod.ZodErrorMap;
+
+type NonEmptyArray<T> = [T, ...T[]];
+
+type ZodIssue = zod.ZodIssue;
+type MessageBuilder = (issues: NonEmptyArray<ZodIssue>) => string;
+type CreateMessageBuilderProps = {
+    issueSeparator?: string;
+    unionSeparator?: string;
+    prefix?: string | null;
+    prefixSeparator?: string;
+    includePath?: boolean;
+    maxIssuesInMessage?: number;
+};
+declare function createMessageBuilder(props?: CreateMessageBuilderProps): MessageBuilder;
+
+type ZodError = zod.ZodError;
+type FromZodErrorOptions = {
+    messageBuilder: MessageBuilder;
+} | CreateMessageBuilderProps;
+declare function fromZodError(zodError: ZodError, options?: FromZodErrorOptions): ValidationError;
+
+declare function fromError(err: unknown, options?: FromZodErrorOptions): ValidationError;
+
+type FromZodIssueOptions = {
+    messageBuilder: MessageBuilder;
+} | Omit<CreateMessageBuilderProps, 'maxIssuesInMessage'>;
+declare function fromZodIssue(issue: ZodIssue, options?: FromZodIssueOptions): ValidationError;
+
+declare const toValidationError: (options?: FromZodErrorOptions) => (err: unknown) => ValidationError;
+
+export { type ErrorOptions, type FromZodErrorOptions, type FromZodIssueOptions, type MessageBuilder, type NonEmptyArray, ValidationError, type ZodError, type ZodIssue, createMessageBuilder, errorMap, fromError, fromZodError, fromZodIssue, isValidationError, isValidationErrorLike, isZodErrorLike, toValidationError };

gui/frontend/node_modules/zod-validation-error/v3/index.js

@@ -0,0 +1,309 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// lib/v3/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ValidationError: () => ValidationError,
+  createMessageBuilder: () => createMessageBuilder,
+  errorMap: () => errorMap,
+  fromError: () => fromError,
+  fromZodError: () => fromZodError,
+  fromZodIssue: () => fromZodIssue,
+  isValidationError: () => isValidationError,
+  isValidationErrorLike: () => isValidationErrorLike,
+  isZodErrorLike: () => isZodErrorLike,
+  toValidationError: () => toValidationError
+});
+module.exports = __toCommonJS(index_exports);
+
+// lib/v3/isZodErrorLike.ts
+function isZodErrorLike(err) {
+  return err instanceof Error && err.name === "ZodError" && "issues" in err && Array.isArray(err.issues);
+}
+
+// lib/v3/ValidationError.ts
+var ValidationError = class extends Error {
+  name;
+  details;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ZodValidationError";
+    this.details = getIssuesFromErrorOptions(options);
+  }
+  toString() {
+    return this.message;
+  }
+};
+function getIssuesFromErrorOptions(options) {
+  if (options) {
+    const cause = options.cause;
+    if (isZodErrorLike(cause)) {
+      return cause.issues;
+    }
+  }
+  return [];
+}
+
+// lib/v3/isValidationError.ts
+function isValidationError(err) {
+  return err instanceof ValidationError;
+}
+
+// lib/v3/isValidationErrorLike.ts
+function isValidationErrorLike(err) {
+  return err instanceof Error && err.name === "ZodValidationError";
+}
+
+// lib/v3/fromZodIssue.ts
+var zod2 = __toESM(require("zod/v3"));
+
+// lib/v3/MessageBuilder.ts
+var zod = __toESM(require("zod/v3"));
+
+// lib/utils/NonEmptyArray.ts
+function isNonEmptyArray(value) {
+  return value.length !== 0;
+}
+
+// lib/utils/stringify.ts
+function stringifySymbol(symbol) {
+  return symbol.description ?? "";
+}
+
+// lib/utils/joinPath.ts
+var identifierRegex = /[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*/u;
+function joinPath(path) {
+  if (path.length === 1) {
+    let propertyKey = path[0];
+    if (typeof propertyKey === "symbol") {
+      propertyKey = stringifySymbol(propertyKey);
+    }
+    return propertyKey.toString() || '""';
+  }
+  return path.reduce((acc, propertyKey) => {
+    if (typeof propertyKey === "number") {
+      return acc + "[" + propertyKey.toString() + "]";
+    }
+    if (typeof propertyKey === "symbol") {
+      propertyKey = stringifySymbol(propertyKey);
+    }
+    if (propertyKey.includes('"')) {
+      return acc + '["' + escapeQuotes(propertyKey) + '"]';
+    }
+    if (!identifierRegex.test(propertyKey)) {
+      return acc + '["' + propertyKey + '"]';
+    }
+    const separator = acc.length === 0 ? "" : ".";
+    return acc + separator + propertyKey;
+  }, "");
+}
+function escapeQuotes(str) {
+  return str.replace(/"/g, '\\"');
+}
+
+// lib/v3/config.ts
+var ISSUE_SEPARATOR = "; ";
+var MAX_ISSUES_IN_MESSAGE = 99;
+var PREFIX = "Validation error";
+var PREFIX_SEPARATOR = ": ";
+var UNION_SEPARATOR = ", or ";
+
+// lib/v3/MessageBuilder.ts
+function createMessageBuilder(props = {}) {
+  const {
+    issueSeparator = ISSUE_SEPARATOR,
+    unionSeparator = UNION_SEPARATOR,
+    prefixSeparator = PREFIX_SEPARATOR,
+    prefix = PREFIX,
+    includePath = true,
+    maxIssuesInMessage = MAX_ISSUES_IN_MESSAGE
+  } = props;
+  return (issues) => {
+    const message = issues.slice(0, maxIssuesInMessage).map(
+      (issue) => getMessageFromZodIssue({
+        issue,
+        issueSeparator,
+        unionSeparator,
+        includePath
+      })
+    ).join(issueSeparator);
+    return prefixMessage(message, prefix, prefixSeparator);
+  };
+}
+function getMessageFromZodIssue(props) {
+  const { issue, issueSeparator, unionSeparator, includePath } = props;
+  if (issue.code === zod.ZodIssueCode.invalid_union) {
+    return issue.unionErrors.reduce((acc, zodError) => {
+      const newIssues = zodError.issues.map(
+        (issue2) => getMessageFromZodIssue({
+          issue: issue2,
+          issueSeparator,
+          unionSeparator,
+          includePath
+        })
+      ).join(issueSeparator);
+      if (!acc.includes(newIssues)) {
+        acc.push(newIssues);
+      }
+      return acc;
+    }, []).join(unionSeparator);
+  }
+  if (issue.code === zod.ZodIssueCode.invalid_arguments) {
+    return [
+      issue.message,
+      ...issue.argumentsError.issues.map(
+        (issue2) => getMessageFromZodIssue({
+          issue: issue2,
+          issueSeparator,
+          unionSeparator,
+          includePath
+        })
+      )
+    ].join(issueSeparator);
+  }
+  if (issue.code === zod.ZodIssueCode.invalid_return_type) {
+    return [
+      issue.message,
+      ...issue.returnTypeError.issues.map(
+        (issue2) => getMessageFromZodIssue({
+          issue: issue2,
+          issueSeparator,
+          unionSeparator,
+          includePath
+        })
+      )
+    ].join(issueSeparator);
+  }
+  if (includePath && isNonEmptyArray(issue.path)) {
+    if (issue.path.length === 1) {
+      const identifier = issue.path[0];
+      if (typeof identifier === "number") {
+        return `${issue.message} at index ${identifier}`;
+      }
+    }
+    return `${issue.message} at "${joinPath(issue.path)}"`;
+  }
+  return issue.message;
+}
+function prefixMessage(message, prefix, prefixSeparator) {
+  if (prefix !== null) {
+    if (message.length > 0) {
+      return [prefix, message].join(prefixSeparator);
+    }
+    return prefix;
+  }
+  if (message.length > 0) {
+    return message;
+  }
+  return PREFIX;
+}
+
+// lib/v3/fromZodIssue.ts
+function fromZodIssue(issue, options = {}) {
+  const messageBuilder = createMessageBuilderFromOptions(options);
+  const message = messageBuilder([issue]);
+  return new ValidationError(message, { cause: new zod2.ZodError([issue]) });
+}
+function createMessageBuilderFromOptions(options) {
+  if ("messageBuilder" in options) {
+    return options.messageBuilder;
+  }
+  return createMessageBuilder(options);
+}
+
+// lib/v3/errorMap.ts
+var errorMap = (issue, ctx) => {
+  const error = fromZodIssue({
+    ...issue,
+    // fallback to the default error message
+    // when issue does not have a message
+    message: issue.message ?? ctx.defaultError
+  });
+  return {
+    message: error.message
+  };
+};
+
+// lib/v3/fromZodError.ts
+function fromZodError(zodError, options = {}) {
+  if (!isZodErrorLike(zodError)) {
+    throw new TypeError(
+      `Invalid zodError param; expected instance of ZodError. Did you mean to use the "${fromError.name}" method instead?`
+    );
+  }
+  return fromZodErrorWithoutRuntimeCheck(zodError, options);
+}
+function fromZodErrorWithoutRuntimeCheck(zodError, options = {}) {
+  const zodIssues = zodError.errors;
+  let message;
+  if (isNonEmptyArray(zodIssues)) {
+    const messageBuilder = createMessageBuilderFromOptions2(options);
+    message = messageBuilder(zodIssues);
+  } else {
+    message = zodError.message;
+  }
+  return new ValidationError(message, { cause: zodError });
+}
+function createMessageBuilderFromOptions2(options) {
+  if ("messageBuilder" in options) {
+    return options.messageBuilder;
+  }
+  return createMessageBuilder(options);
+}
+
+// lib/v3/toValidationError.ts
+var toValidationError = (options = {}) => (err) => {
+  if (isZodErrorLike(err)) {
+    return fromZodErrorWithoutRuntimeCheck(err, options);
+  }
+  if (err instanceof Error) {
+    return new ValidationError(err.message, { cause: err });
+  }
+  return new ValidationError("Unknown error");
+};
+
+// lib/v3/fromError.ts
+function fromError(err, options = {}) {
+  return toValidationError(options)(err);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ValidationError,
+  createMessageBuilder,
+  errorMap,
+  fromError,
+  fromZodError,
+  fromZodIssue,
+  isValidationError,
+  isValidationErrorLike,
+  isZodErrorLike,
+  toValidationError
+});
+//# sourceMappingURL=index.js.map

gui/frontend/node_modules/zod-validation-error/v3/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../lib/v3/index.ts","../lib/v3/isZodErrorLike.ts","../lib/v3/ValidationError.ts","../lib/v3/isValidationError.ts","../lib/v3/isValidationErrorLike.ts","../lib/v3/fromZodIssue.ts","../lib/v3/MessageBuilder.ts","../lib/utils/NonEmptyArray.ts","../lib/utils/stringify.ts","../lib/utils/joinPath.ts","../lib/v3/config.ts","../lib/v3/errorMap.ts","../lib/v3/fromZodError.ts","../lib/v3/toValidationError.ts","../lib/v3/fromError.ts"],"sourcesContent":["export { ValidationError, type ErrorOptions } from './ValidationError.ts';\nexport { isValidationError } from './isValidationError.ts';\nexport { isValidationErrorLike } from './isValidationErrorLike.ts';\nexport { isZodErrorLike } from './isZodErrorLike.ts';\nexport { errorMap } from './errorMap.ts';\nexport { fromError } from './fromError.ts';\nexport { fromZodIssue, type FromZodIssueOptions } from './fromZodIssue.ts';\nexport {\n  fromZodError,\n  type FromZodErrorOptions,\n  type ZodError,\n} from './fromZodError.ts';\nexport { toValidationError } from './toValidationError.ts';\nexport {\n  type MessageBuilder,\n  type ZodIssue,\n  createMessageBuilder,\n} from './MessageBuilder.ts';\nexport { type NonEmptyArray } from '../utils/NonEmptyArray.ts';\n","import type * as zod from 'zod/v3';\n\nexport function isZodErrorLike(err: unknown): err is zod.ZodError {\n  return (\n    err instanceof Error &&\n    err.name === 'ZodError' &&\n    'issues' in err &&\n    Array.isArray(err.issues)\n  );\n}\n","import { isZodErrorLike } from './isZodErrorLike.ts';\nimport type * as zod from 'zod/v3';\n\n// make zod-validation-error compatible with\n// earlier to es2022 typescript configurations\n// @see https://github.com/causaly/zod-validation-error/issues/226\nexport interface ErrorOptions {\n  cause?: unknown;\n}\n\nexport class ValidationError extends Error {\n  name: 'ZodValidationError';\n  details: Array<zod.ZodIssue>;\n\n  constructor(message?: string, options?: ErrorOptions) {\n    super(message, options);\n    this.name = 'ZodValidationError';\n    this.details = getIssuesFromErrorOptions(options);\n  }\n\n  toString(): string {\n    return this.message;\n  }\n}\n\nfunction getIssuesFromErrorOptions(\n  options?: ErrorOptions\n): Array<zod.ZodIssue> {\n  if (options) {\n    const cause = options.cause;\n\n    if (isZodErrorLike(cause)) {\n      return cause.issues;\n    }\n  }\n\n  return [];\n}\n","import { ValidationError } from './ValidationError.ts';\n\nexport function isValidationError(err: unknown): err is ValidationError {\n  return err instanceof ValidationError;\n}\n","import type { ValidationError } from './ValidationError.ts';\n\nexport function isValidationErrorLike(err: unknown): err is ValidationError {\n  return err instanceof Error && err.name === 'ZodValidationError';\n}\n","import * as zod from 'zod/v3';\n\nimport {\n  type MessageBuilder,\n  type CreateMessageBuilderProps,\n  type ZodIssue,\n  createMessageBuilder,\n} from './MessageBuilder.ts';\nimport { ValidationError } from './ValidationError.ts';\n\nexport type FromZodIssueOptions =\n  | {\n      messageBuilder: MessageBuilder;\n    }\n  // maintain backwards compatibility\n  | Omit<CreateMessageBuilderProps, 'maxIssuesInMessage'>;\n\nexport function fromZodIssue(\n  issue: ZodIssue,\n  options: FromZodIssueOptions = {}\n): ValidationError {\n  const messageBuilder = createMessageBuilderFromOptions(options);\n  const message = messageBuilder([issue]);\n\n  return new ValidationError(message, { cause: new zod.ZodError([issue]) });\n}\n\nfunction createMessageBuilderFromOptions(\n  options: FromZodIssueOptions\n): MessageBuilder {\n  if ('messageBuilder' in options) {\n    return options.messageBuilder;\n  }\n\n  return createMessageBuilder(options);\n}\n","import * as zod from 'zod/v3';\nimport { type NonEmptyArray, isNonEmptyArray } from '../utils/NonEmptyArray.ts';\nimport { joinPath } from '../utils/joinPath.ts';\nimport {\n  ISSUE_SEPARATOR,\n  MAX_ISSUES_IN_MESSAGE,\n  PREFIX,\n  PREFIX_SEPARATOR,\n  UNION_SEPARATOR,\n} from './config.ts';\n\nexport type ZodIssue = zod.ZodIssue;\n\nexport type MessageBuilder = (issues: NonEmptyArray<ZodIssue>) => string;\n\nexport type CreateMessageBuilderProps = {\n  issueSeparator?: string;\n  unionSeparator?: string;\n  prefix?: string | null;\n  prefixSeparator?: string;\n  includePath?: boolean;\n  maxIssuesInMessage?: number;\n};\n\nexport function createMessageBuilder(\n  props: CreateMessageBuilderProps = {}\n): MessageBuilder {\n  const {\n    issueSeparator = ISSUE_SEPARATOR,\n    unionSeparator = UNION_SEPARATOR,\n    prefixSeparator = PREFIX_SEPARATOR,\n    prefix = PREFIX,\n    includePath = true,\n    maxIssuesInMessage = MAX_ISSUES_IN_MESSAGE,\n  } = props;\n  return (issues) => {\n    const message = issues\n      // limit max number of issues printed in the reason section\n      .slice(0, maxIssuesInMessage)\n      // format error message\n      .map((issue) =>\n        getMessageFromZodIssue({\n          issue,\n          issueSeparator,\n          unionSeparator,\n          includePath,\n        })\n      )\n      // concat as string\n      .join(issueSeparator);\n\n    return prefixMessage(message, prefix, prefixSeparator);\n  };\n}\n\nfunction getMessageFromZodIssue(props: {\n  issue: ZodIssue;\n  issueSeparator: string;\n  unionSeparator: string;\n  includePath: boolean;\n}): string {\n  const { issue, issueSeparator, unionSeparator, includePath } = props;\n\n  if (issue.code === zod.ZodIssueCode.invalid_union) {\n    return issue.unionErrors\n      .reduce<string[]>((acc, zodError) => {\n        const newIssues = zodError.issues\n          .map((issue) =>\n            getMessageFromZodIssue({\n              issue,\n              issueSeparator,\n              unionSeparator,\n              includePath,\n            })\n          )\n          .join(issueSeparator);\n\n        if (!acc.includes(newIssues)) {\n          acc.push(newIssues);\n        }\n\n        return acc;\n      }, [])\n      .join(unionSeparator);\n  }\n\n  if (issue.code === zod.ZodIssueCode.invalid_arguments) {\n    return [\n      issue.message,\n      ...issue.argumentsError.issues.map((issue) =>\n        getMessageFromZodIssue({\n          issue,\n          issueSeparator,\n          unionSeparator,\n          includePath,\n        })\n      ),\n    ].join(issueSeparator);\n  }\n\n  if (issue.code === zod.ZodIssueCode.invalid_return_type) {\n    return [\n      issue.message,\n      ...issue.returnTypeError.issues.map((issue) =>\n        getMessageFromZodIssue({\n          issue,\n          issueSeparator,\n          unionSeparator,\n          includePath,\n        })\n      ),\n    ].join(issueSeparator);\n  }\n\n  if (includePath && isNonEmptyArray(issue.path)) {\n    // handle array indices\n    if (issue.path.length === 1) {\n      const identifier = issue.path[0];\n\n      if (typeof identifier === 'number') {\n        return `${issue.message} at index ${identifier}`;\n      }\n    }\n\n    return `${issue.message} at \"${joinPath(issue.path)}\"`;\n  }\n\n  return issue.message;\n}\n\nfunction prefixMessage(\n  message: string,\n  prefix: string | null,\n  prefixSeparator: string\n): string {\n  if (prefix !== null) {\n    if (message.length > 0) {\n      return [prefix, message].join(prefixSeparator);\n    }\n\n    return prefix;\n  }\n\n  if (message.length > 0) {\n    return message;\n  }\n\n  // if both reason and prefix are empty, return default prefix\n  // to avoid having an empty error message\n  return PREFIX;\n}\n","export type NonEmptyArray<T> = [T, ...T[]];\n\nexport function isNonEmptyArray<T>(value: T[]): value is NonEmptyArray<T> {\n  return value.length !== 0;\n}\n","import type { util } from 'zod/v4/core';\n\nexport function stringifySymbol(symbol: symbol): string {\n  return symbol.description ?? '';\n}\n\nexport type StringifyValueOptions = {\n  wrapStringValueInQuote?: boolean;\n  localization?: boolean | Intl.LocalesArgument;\n};\n\nexport function stringify(\n  value: util.Primitive | Date,\n  options: StringifyValueOptions = {}\n): string {\n  switch (typeof value) {\n    case 'symbol':\n      return stringifySymbol(value);\n    case 'bigint':\n    case 'number': {\n      switch (options.localization) {\n        case true:\n          return value.toLocaleString();\n        case false:\n          return value.toString();\n        default:\n          return value.toLocaleString(options.localization);\n      }\n    }\n    case 'string': {\n      if (options.wrapStringValueInQuote) {\n        return `\"${value}\"`;\n      }\n      return value;\n    }\n    default: {\n      if (value instanceof Date) {\n        switch (options.localization) {\n          case true:\n            return value.toLocaleString();\n          case false:\n            return value.toISOString();\n          default:\n            return value.toLocaleString(options.localization);\n        }\n      }\n      return String(value);\n    }\n  }\n}\n","import { stringifySymbol } from './stringify.ts';\nimport type { NonEmptyArray } from './NonEmptyArray.ts';\n\n/**\n * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#identifiers\n */\nconst identifierRegex = /[$_\\p{ID_Start}][$\\u200c\\u200d\\p{ID_Continue}]*/u;\n\nexport function joinPath(path: NonEmptyArray<PropertyKey>): string {\n  if (path.length === 1) {\n    let propertyKey = path[0];\n\n    if (typeof propertyKey === 'symbol') {\n      propertyKey = stringifySymbol(propertyKey);\n    }\n\n    return propertyKey.toString() || '\"\"';\n  }\n\n  return path.reduce<string>((acc, propertyKey) => {\n    // handle numeric indices\n    if (typeof propertyKey === 'number') {\n      return acc + '[' + propertyKey.toString() + ']';\n    }\n\n    // handle symbols\n    if (typeof propertyKey === 'symbol') {\n      propertyKey = stringifySymbol(propertyKey);\n    }\n\n    // handle quoted values\n    if (propertyKey.includes('\"')) {\n      return acc + '[\"' + escapeQuotes(propertyKey) + '\"]';\n    }\n\n    // handle special characters\n    if (!identifierRegex.test(propertyKey)) {\n      return acc + '[\"' + propertyKey + '\"]';\n    }\n\n    // handle normal values\n    const separator = acc.length === 0 ? '' : '.';\n    return acc + separator + propertyKey;\n  }, '');\n}\n\nfunction escapeQuotes(str: string): string {\n  return str.replace(/\"/g, '\\\\\"');\n}\n","export const ISSUE_SEPARATOR = '; ';\nexport const MAX_ISSUES_IN_MESSAGE = 99; // I've got 99 problems but the b$tch ain't one\nexport const PREFIX = 'Validation error';\nexport const PREFIX_SEPARATOR = ': ';\nexport const UNION_SEPARATOR = ', or ';\n","import { fromZodIssue } from './fromZodIssue.ts';\nimport type * as zod from 'zod/v3';\n\nexport const errorMap: zod.ZodErrorMap = (issue, ctx) => {\n  const error = fromZodIssue({\n    ...issue,\n    // fallback to the default error message\n    // when issue does not have a message\n    message: issue.message ?? ctx.defaultError,\n  });\n\n  return {\n    message: error.message,\n  };\n};\n","import { isNonEmptyArray } from '../utils/NonEmptyArray.ts';\nimport { fromError } from './fromError.ts';\nimport { isZodErrorLike } from './isZodErrorLike.ts';\nimport {\n  createMessageBuilder,\n  type CreateMessageBuilderProps,\n  type MessageBuilder,\n} from './MessageBuilder.ts';\nimport { ValidationError } from './ValidationError.ts';\nimport type * as zod from 'zod/v3';\n\nexport type ZodError = zod.ZodError;\n\nexport type FromZodErrorOptions =\n  | {\n      messageBuilder: MessageBuilder;\n    }\n  // maintain backwards compatibility\n  | CreateMessageBuilderProps;\n\nexport function fromZodError(\n  zodError: ZodError,\n  options: FromZodErrorOptions = {}\n): ValidationError {\n  // perform runtime check to ensure the input is a ZodError\n  // why? because people have been historically using this function incorrectly\n  if (!isZodErrorLike(zodError)) {\n    throw new TypeError(\n      `Invalid zodError param; expected instance of ZodError. Did you mean to use the \"${fromError.name}\" method instead?`\n    );\n  }\n\n  return fromZodErrorWithoutRuntimeCheck(zodError, options);\n}\n\nexport function fromZodErrorWithoutRuntimeCheck(\n  zodError: ZodError,\n  options: FromZodErrorOptions = {}\n): ValidationError {\n  const zodIssues = zodError.errors;\n\n  let message: string;\n  if (isNonEmptyArray(zodIssues)) {\n    const messageBuilder = createMessageBuilderFromOptions(options);\n    message = messageBuilder(zodIssues);\n  } else {\n    message = zodError.message;\n  }\n\n  return new ValidationError(message, { cause: zodError });\n}\n\nfunction createMessageBuilderFromOptions(\n  options: FromZodErrorOptions\n): MessageBuilder {\n  if ('messageBuilder' in options) {\n    return options.messageBuilder;\n  }\n\n  return createMessageBuilder(options);\n}\n","import { ValidationError } from './ValidationError.ts';\nimport { isZodErrorLike } from './isZodErrorLike.ts';\nimport {\n  fromZodErrorWithoutRuntimeCheck,\n  type FromZodErrorOptions,\n} from './fromZodError.ts';\n\nexport const toValidationError =\n  (options: FromZodErrorOptions = {}) =>\n  (err: unknown): ValidationError => {\n    if (isZodErrorLike(err)) {\n      return fromZodErrorWithoutRuntimeCheck(err, options);\n    }\n\n    if (err instanceof Error) {\n      return new ValidationError(err.message, { cause: err });\n    }\n\n    return new ValidationError('Unknown error');\n  };\n","import { toValidationError } from './toValidationError.ts';\nimport type { FromZodErrorOptions } from './fromZodError.ts';\nimport type { ValidationError } from './ValidationError.ts';\n\n/**\n * This function is a non-curried version of `toValidationError`\n */\nexport function fromError(\n  err: unknown,\n  options: FromZodErrorOptions = {}\n): ValidationError {\n  return toValidationError(options)(err);\n}\n"],"mappings":"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","names":["zod","issue","createMessageBuilderFromOptions"]}

gui/frontend/node_modules/zod-validation-error/v3/index.mjs

@@ -0,0 +1,263 @@
+// lib/v3/isZodErrorLike.ts
+function isZodErrorLike(err) {
+  return err instanceof Error && err.name === "ZodError" && "issues" in err && Array.isArray(err.issues);
+}
+
+// lib/v3/ValidationError.ts
+var ValidationError = class extends Error {
+  name;
+  details;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ZodValidationError";
+    this.details = getIssuesFromErrorOptions(options);
+  }
+  toString() {
+    return this.message;
+  }
+};
+function getIssuesFromErrorOptions(options) {
+  if (options) {
+    const cause = options.cause;
+    if (isZodErrorLike(cause)) {
+      return cause.issues;
+    }
+  }
+  return [];
+}
+
+// lib/v3/isValidationError.ts
+function isValidationError(err) {
+  return err instanceof ValidationError;
+}
+
+// lib/v3/isValidationErrorLike.ts
+function isValidationErrorLike(err) {
+  return err instanceof Error && err.name === "ZodValidationError";
+}
+
+// lib/v3/fromZodIssue.ts
+import * as zod2 from "zod/v3";
+
+// lib/v3/MessageBuilder.ts
+import * as zod from "zod/v3";
+
+// lib/utils/NonEmptyArray.ts
+function isNonEmptyArray(value) {
+  return value.length !== 0;
+}
+
+// lib/utils/stringify.ts
+function stringifySymbol(symbol) {
+  return symbol.description ?? "";
+}
+
+// lib/utils/joinPath.ts
+var identifierRegex = /[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*/u;
+function joinPath(path) {
+  if (path.length === 1) {
+    let propertyKey = path[0];
+    if (typeof propertyKey === "symbol") {
+      propertyKey = stringifySymbol(propertyKey);
+    }
+    return propertyKey.toString() || '""';
+  }
+  return path.reduce((acc, propertyKey) => {
+    if (typeof propertyKey === "number") {
+      return acc + "[" + propertyKey.toString() + "]";
+    }
+    if (typeof propertyKey === "symbol") {
+      propertyKey = stringifySymbol(propertyKey);
+    }
+    if (propertyKey.includes('"')) {
+      return acc + '["' + escapeQuotes(propertyKey) + '"]';
+    }
+    if (!identifierRegex.test(propertyKey)) {
+      return acc + '["' + propertyKey + '"]';
+    }
+    const separator = acc.length === 0 ? "" : ".";
+    return acc + separator + propertyKey;
+  }, "");
+}
+function escapeQuotes(str) {
+  return str.replace(/"/g, '\\"');
+}
+
+// lib/v3/config.ts
+var ISSUE_SEPARATOR = "; ";
+var MAX_ISSUES_IN_MESSAGE = 99;
+var PREFIX = "Validation error";
+var PREFIX_SEPARATOR = ": ";
+var UNION_SEPARATOR = ", or ";
+
+// lib/v3/MessageBuilder.ts
+function createMessageBuilder(props = {}) {
+  const {
+    issueSeparator = ISSUE_SEPARATOR,
+    unionSeparator = UNION_SEPARATOR,
+    prefixSeparator = PREFIX_SEPARATOR,
+    prefix = PREFIX,
+    includePath = true,
+    maxIssuesInMessage = MAX_ISSUES_IN_MESSAGE
+  } = props;
+  return (issues) => {
+    const message = issues.slice(0, maxIssuesInMessage).map(
+      (issue) => getMessageFromZodIssue({
+        issue,
+        issueSeparator,
+        unionSeparator,
+        includePath
+      })
+    ).join(issueSeparator);
+    return prefixMessage(message, prefix, prefixSeparator);
+  };
+}
+function getMessageFromZodIssue(props) {
+  const { issue, issueSeparator, unionSeparator, includePath } = props;
+  if (issue.code === zod.ZodIssueCode.invalid_union) {
+    return issue.unionErrors.reduce((acc, zodError) => {
+      const newIssues = zodError.issues.map(
+        (issue2) => getMessageFromZodIssue({
+          issue: issue2,
+          issueSeparator,
+          unionSeparator,
+          includePath
+        })
+      ).join(issueSeparator);
+      if (!acc.includes(newIssues)) {
+        acc.push(newIssues);
+      }
+      return acc;
+    }, []).join(unionSeparator);
+  }
+  if (issue.code === zod.ZodIssueCode.invalid_arguments) {
+    return [
+      issue.message,
+      ...issue.argumentsError.issues.map(
+        (issue2) => getMessageFromZodIssue({
+          issue: issue2,
+          issueSeparator,
+          unionSeparator,
+          includePath
+        })
+      )
+    ].join(issueSeparator);
+  }
+  if (issue.code === zod.ZodIssueCode.invalid_return_type) {
+    return [
+      issue.message,
+      ...issue.returnTypeError.issues.map(
+        (issue2) => getMessageFromZodIssue({
+          issue: issue2,
+          issueSeparator,
+          unionSeparator,
+          includePath
+        })
+      )
+    ].join(issueSeparator);
+  }
+  if (includePath && isNonEmptyArray(issue.path)) {
+    if (issue.path.length === 1) {
+      const identifier = issue.path[0];
+      if (typeof identifier === "number") {
+        return `${issue.message} at index ${identifier}`;
+      }
+    }
+    return `${issue.message} at "${joinPath(issue.path)}"`;
+  }
+  return issue.message;
+}
+function prefixMessage(message, prefix, prefixSeparator) {
+  if (prefix !== null) {
+    if (message.length > 0) {
+      return [prefix, message].join(prefixSeparator);
+    }
+    return prefix;
+  }
+  if (message.length > 0) {
+    return message;
+  }
+  return PREFIX;
+}
+
+// lib/v3/fromZodIssue.ts
+function fromZodIssue(issue, options = {}) {
+  const messageBuilder = createMessageBuilderFromOptions(options);
+  const message = messageBuilder([issue]);
+  return new ValidationError(message, { cause: new zod2.ZodError([issue]) });
+}
+function createMessageBuilderFromOptions(options) {
+  if ("messageBuilder" in options) {
+    return options.messageBuilder;
+  }
+  return createMessageBuilder(options);
+}
+
+// lib/v3/errorMap.ts
+var errorMap = (issue, ctx) => {
+  const error = fromZodIssue({
+    ...issue,
+    // fallback to the default error message
+    // when issue does not have a message
+    message: issue.message ?? ctx.defaultError
+  });
+  return {
+    message: error.message
+  };
+};
+
+// lib/v3/fromZodError.ts
+function fromZodError(zodError, options = {}) {
+  if (!isZodErrorLike(zodError)) {
+    throw new TypeError(
+      `Invalid zodError param; expected instance of ZodError. Did you mean to use the "${fromError.name}" method instead?`
+    );
+  }
+  return fromZodErrorWithoutRuntimeCheck(zodError, options);
+}
+function fromZodErrorWithoutRuntimeCheck(zodError, options = {}) {
+  const zodIssues = zodError.errors;
+  let message;
+  if (isNonEmptyArray(zodIssues)) {
+    const messageBuilder = createMessageBuilderFromOptions2(options);
+    message = messageBuilder(zodIssues);
+  } else {
+    message = zodError.message;
+  }
+  return new ValidationError(message, { cause: zodError });
+}
+function createMessageBuilderFromOptions2(options) {
+  if ("messageBuilder" in options) {
+    return options.messageBuilder;
+  }
+  return createMessageBuilder(options);
+}
+
+// lib/v3/toValidationError.ts
+var toValidationError = (options = {}) => (err) => {
+  if (isZodErrorLike(err)) {
+    return fromZodErrorWithoutRuntimeCheck(err, options);
+  }
+  if (err instanceof Error) {
+    return new ValidationError(err.message, { cause: err });
+  }
+  return new ValidationError("Unknown error");
+};
+
+// lib/v3/fromError.ts
+function fromError(err, options = {}) {
+  return toValidationError(options)(err);
+}
+export {
+  ValidationError,
+  createMessageBuilder,
+  errorMap,
+  fromError,
+  fromZodError,
+  fromZodIssue,
+  isValidationError,
+  isValidationErrorLike,
+  isZodErrorLike,
+  toValidationError
+};
+//# sourceMappingURL=index.mjs.map

gui/frontend/node_modules/zod-validation-error/v3/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../lib/v3/isZodErrorLike.ts","../lib/v3/ValidationError.ts","../lib/v3/isValidationError.ts","../lib/v3/isValidationErrorLike.ts","../lib/v3/fromZodIssue.ts","../lib/v3/MessageBuilder.ts","../lib/utils/NonEmptyArray.ts","../lib/utils/stringify.ts","../lib/utils/joinPath.ts","../lib/v3/config.ts","../lib/v3/errorMap.ts","../lib/v3/fromZodError.ts","../lib/v3/toValidationError.ts","../lib/v3/fromError.ts"],"sourcesContent":["import type * as zod from 'zod/v3';\n\nexport function isZodErrorLike(err: unknown): err is zod.ZodError {\n  return (\n    err instanceof Error &&\n    err.name === 'ZodError' &&\n    'issues' in err &&\n    Array.isArray(err.issues)\n  );\n}\n","import { isZodErrorLike } from './isZodErrorLike.ts';\nimport type * as zod from 'zod/v3';\n\n// make zod-validation-error compatible with\n// earlier to es2022 typescript configurations\n// @see https://github.com/causaly/zod-validation-error/issues/226\nexport interface ErrorOptions {\n  cause?: unknown;\n}\n\nexport class ValidationError extends Error {\n  name: 'ZodValidationError';\n  details: Array<zod.ZodIssue>;\n\n  constructor(message?: string, options?: ErrorOptions) {\n    super(message, options);\n    this.name = 'ZodValidationError';\n    this.details = getIssuesFromErrorOptions(options);\n  }\n\n  toString(): string {\n    return this.message;\n  }\n}\n\nfunction getIssuesFromErrorOptions(\n  options?: ErrorOptions\n): Array<zod.ZodIssue> {\n  if (options) {\n    const cause = options.cause;\n\n    if (isZodErrorLike(cause)) {\n      return cause.issues;\n    }\n  }\n\n  return [];\n}\n","import { ValidationError } from './ValidationError.ts';\n\nexport function isValidationError(err: unknown): err is ValidationError {\n  return err instanceof ValidationError;\n}\n","import type { ValidationError } from './ValidationError.ts';\n\nexport function isValidationErrorLike(err: unknown): err is ValidationError {\n  return err instanceof Error && err.name === 'ZodValidationError';\n}\n","import * as zod from 'zod/v3';\n\nimport {\n  type MessageBuilder,\n  type CreateMessageBuilderProps,\n  type ZodIssue,\n  createMessageBuilder,\n} from './MessageBuilder.ts';\nimport { ValidationError } from './ValidationError.ts';\n\nexport type FromZodIssueOptions =\n  | {\n      messageBuilder: MessageBuilder;\n    }\n  // maintain backwards compatibility\n  | Omit<CreateMessageBuilderProps, 'maxIssuesInMessage'>;\n\nexport function fromZodIssue(\n  issue: ZodIssue,\n  options: FromZodIssueOptions = {}\n): ValidationError {\n  const messageBuilder = createMessageBuilderFromOptions(options);\n  const message = messageBuilder([issue]);\n\n  return new ValidationError(message, { cause: new zod.ZodError([issue]) });\n}\n\nfunction createMessageBuilderFromOptions(\n  options: FromZodIssueOptions\n): MessageBuilder {\n  if ('messageBuilder' in options) {\n    return options.messageBuilder;\n  }\n\n  return createMessageBuilder(options);\n}\n","import * as zod from 'zod/v3';\nimport { type NonEmptyArray, isNonEmptyArray } from '../utils/NonEmptyArray.ts';\nimport { joinPath } from '../utils/joinPath.ts';\nimport {\n  ISSUE_SEPARATOR,\n  MAX_ISSUES_IN_MESSAGE,\n  PREFIX,\n  PREFIX_SEPARATOR,\n  UNION_SEPARATOR,\n} from './config.ts';\n\nexport type ZodIssue = zod.ZodIssue;\n\nexport type MessageBuilder = (issues: NonEmptyArray<ZodIssue>) => string;\n\nexport type CreateMessageBuilderProps = {\n  issueSeparator?: string;\n  unionSeparator?: string;\n  prefix?: string | null;\n  prefixSeparator?: string;\n  includePath?: boolean;\n  maxIssuesInMessage?: number;\n};\n\nexport function createMessageBuilder(\n  props: CreateMessageBuilderProps = {}\n): MessageBuilder {\n  const {\n    issueSeparator = ISSUE_SEPARATOR,\n    unionSeparator = UNION_SEPARATOR,\n    prefixSeparator = PREFIX_SEPARATOR,\n    prefix = PREFIX,\n    includePath = true,\n    maxIssuesInMessage = MAX_ISSUES_IN_MESSAGE,\n  } = props;\n  return (issues) => {\n    const message = issues\n      // limit max number of issues printed in the reason section\n      .slice(0, maxIssuesInMessage)\n      // format error message\n      .map((issue) =>\n        getMessageFromZodIssue({\n          issue,\n          issueSeparator,\n          unionSeparator,\n          includePath,\n        })\n      )\n      // concat as string\n      .join(issueSeparator);\n\n    return prefixMessage(message, prefix, prefixSeparator);\n  };\n}\n\nfunction getMessageFromZodIssue(props: {\n  issue: ZodIssue;\n  issueSeparator: string;\n  unionSeparator: string;\n  includePath: boolean;\n}): string {\n  const { issue, issueSeparator, unionSeparator, includePath } = props;\n\n  if (issue.code === zod.ZodIssueCode.invalid_union) {\n    return issue.unionErrors\n      .reduce<string[]>((acc, zodError) => {\n        const newIssues = zodError.issues\n          .map((issue) =>\n            getMessageFromZodIssue({\n              issue,\n              issueSeparator,\n              unionSeparator,\n              includePath,\n            })\n          )\n          .join(issueSeparator);\n\n        if (!acc.includes(newIssues)) {\n          acc.push(newIssues);\n        }\n\n        return acc;\n      }, [])\n      .join(unionSeparator);\n  }\n\n  if (issue.code === zod.ZodIssueCode.invalid_arguments) {\n    return [\n      issue.message,\n      ...issue.argumentsError.issues.map((issue) =>\n        getMessageFromZodIssue({\n          issue,\n          issueSeparator,\n          unionSeparator,\n          includePath,\n        })\n      ),\n    ].join(issueSeparator);\n  }\n\n  if (issue.code === zod.ZodIssueCode.invalid_return_type) {\n    return [\n      issue.message,\n      ...issue.returnTypeError.issues.map((issue) =>\n        getMessageFromZodIssue({\n          issue,\n          issueSeparator,\n          unionSeparator,\n          includePath,\n        })\n      ),\n    ].join(issueSeparator);\n  }\n\n  if (includePath && isNonEmptyArray(issue.path)) {\n    // handle array indices\n    if (issue.path.length === 1) {\n      const identifier = issue.path[0];\n\n      if (typeof identifier === 'number') {\n        return `${issue.message} at index ${identifier}`;\n      }\n    }\n\n    return `${issue.message} at \"${joinPath(issue.path)}\"`;\n  }\n\n  return issue.message;\n}\n\nfunction prefixMessage(\n  message: string,\n  prefix: string | null,\n  prefixSeparator: string\n): string {\n  if (prefix !== null) {\n    if (message.length > 0) {\n      return [prefix, message].join(prefixSeparator);\n    }\n\n    return prefix;\n  }\n\n  if (message.length > 0) {\n    return message;\n  }\n\n  // if both reason and prefix are empty, return default prefix\n  // to avoid having an empty error message\n  return PREFIX;\n}\n","export type NonEmptyArray<T> = [T, ...T[]];\n\nexport function isNonEmptyArray<T>(value: T[]): value is NonEmptyArray<T> {\n  return value.length !== 0;\n}\n","import type { util } from 'zod/v4/core';\n\nexport function stringifySymbol(symbol: symbol): string {\n  return symbol.description ?? '';\n}\n\nexport type StringifyValueOptions = {\n  wrapStringValueInQuote?: boolean;\n  localization?: boolean | Intl.LocalesArgument;\n};\n\nexport function stringify(\n  value: util.Primitive | Date,\n  options: StringifyValueOptions = {}\n): string {\n  switch (typeof value) {\n    case 'symbol':\n      return stringifySymbol(value);\n    case 'bigint':\n    case 'number': {\n      switch (options.localization) {\n        case true:\n          return value.toLocaleString();\n        case false:\n          return value.toString();\n        default:\n          return value.toLocaleString(options.localization);\n      }\n    }\n    case 'string': {\n      if (options.wrapStringValueInQuote) {\n        return `\"${value}\"`;\n      }\n      return value;\n    }\n    default: {\n      if (value instanceof Date) {\n        switch (options.localization) {\n          case true:\n            return value.toLocaleString();\n          case false:\n            return value.toISOString();\n          default:\n            return value.toLocaleString(options.localization);\n        }\n      }\n      return String(value);\n    }\n  }\n}\n","import { stringifySymbol } from './stringify.ts';\nimport type { NonEmptyArray } from './NonEmptyArray.ts';\n\n/**\n * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#identifiers\n */\nconst identifierRegex = /[$_\\p{ID_Start}][$\\u200c\\u200d\\p{ID_Continue}]*/u;\n\nexport function joinPath(path: NonEmptyArray<PropertyKey>): string {\n  if (path.length === 1) {\n    let propertyKey = path[0];\n\n    if (typeof propertyKey === 'symbol') {\n      propertyKey = stringifySymbol(propertyKey);\n    }\n\n    return propertyKey.toString() || '\"\"';\n  }\n\n  return path.reduce<string>((acc, propertyKey) => {\n    // handle numeric indices\n    if (typeof propertyKey === 'number') {\n      return acc + '[' + propertyKey.toString() + ']';\n    }\n\n    // handle symbols\n    if (typeof propertyKey === 'symbol') {\n      propertyKey = stringifySymbol(propertyKey);\n    }\n\n    // handle quoted values\n    if (propertyKey.includes('\"')) {\n      return acc + '[\"' + escapeQuotes(propertyKey) + '\"]';\n    }\n\n    // handle special characters\n    if (!identifierRegex.test(propertyKey)) {\n      return acc + '[\"' + propertyKey + '\"]';\n    }\n\n    // handle normal values\n    const separator = acc.length === 0 ? '' : '.';\n    return acc + separator + propertyKey;\n  }, '');\n}\n\nfunction escapeQuotes(str: string): string {\n  return str.replace(/\"/g, '\\\\\"');\n}\n","export const ISSUE_SEPARATOR = '; ';\nexport const MAX_ISSUES_IN_MESSAGE = 99; // I've got 99 problems but the b$tch ain't one\nexport const PREFIX = 'Validation error';\nexport const PREFIX_SEPARATOR = ': ';\nexport const UNION_SEPARATOR = ', or ';\n","import { fromZodIssue } from './fromZodIssue.ts';\nimport type * as zod from 'zod/v3';\n\nexport const errorMap: zod.ZodErrorMap = (issue, ctx) => {\n  const error = fromZodIssue({\n    ...issue,\n    // fallback to the default error message\n    // when issue does not have a message\n    message: issue.message ?? ctx.defaultError,\n  });\n\n  return {\n    message: error.message,\n  };\n};\n","import { isNonEmptyArray } from '../utils/NonEmptyArray.ts';\nimport { fromError } from './fromError.ts';\nimport { isZodErrorLike } from './isZodErrorLike.ts';\nimport {\n  createMessageBuilder,\n  type CreateMessageBuilderProps,\n  type MessageBuilder,\n} from './MessageBuilder.ts';\nimport { ValidationError } from './ValidationError.ts';\nimport type * as zod from 'zod/v3';\n\nexport type ZodError = zod.ZodError;\n\nexport type FromZodErrorOptions =\n  | {\n      messageBuilder: MessageBuilder;\n    }\n  // maintain backwards compatibility\n  | CreateMessageBuilderProps;\n\nexport function fromZodError(\n  zodError: ZodError,\n  options: FromZodErrorOptions = {}\n): ValidationError {\n  // perform runtime check to ensure the input is a ZodError\n  // why? because people have been historically using this function incorrectly\n  if (!isZodErrorLike(zodError)) {\n    throw new TypeError(\n      `Invalid zodError param; expected instance of ZodError. Did you mean to use the \"${fromError.name}\" method instead?`\n    );\n  }\n\n  return fromZodErrorWithoutRuntimeCheck(zodError, options);\n}\n\nexport function fromZodErrorWithoutRuntimeCheck(\n  zodError: ZodError,\n  options: FromZodErrorOptions = {}\n): ValidationError {\n  const zodIssues = zodError.errors;\n\n  let message: string;\n  if (isNonEmptyArray(zodIssues)) {\n    const messageBuilder = createMessageBuilderFromOptions(options);\n    message = messageBuilder(zodIssues);\n  } else {\n    message = zodError.message;\n  }\n\n  return new ValidationError(message, { cause: zodError });\n}\n\nfunction createMessageBuilderFromOptions(\n  options: FromZodErrorOptions\n): MessageBuilder {\n  if ('messageBuilder' in options) {\n    return options.messageBuilder;\n  }\n\n  return createMessageBuilder(options);\n}\n","import { ValidationError } from './ValidationError.ts';\nimport { isZodErrorLike } from './isZodErrorLike.ts';\nimport {\n  fromZodErrorWithoutRuntimeCheck,\n  type FromZodErrorOptions,\n} from './fromZodError.ts';\n\nexport const toValidationError =\n  (options: FromZodErrorOptions = {}) =>\n  (err: unknown): ValidationError => {\n    if (isZodErrorLike(err)) {\n      return fromZodErrorWithoutRuntimeCheck(err, options);\n    }\n\n    if (err instanceof Error) {\n      return new ValidationError(err.message, { cause: err });\n    }\n\n    return new ValidationError('Unknown error');\n  };\n","import { toValidationError } from './toValidationError.ts';\nimport type { FromZodErrorOptions } from './fromZodError.ts';\nimport type { ValidationError } from './ValidationError.ts';\n\n/**\n * This function is a non-curried version of `toValidationError`\n */\nexport function fromError(\n  err: unknown,\n  options: FromZodErrorOptions = {}\n): ValidationError {\n  return toValidationError(options)(err);\n}\n"],"mappings":"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","names":["zod","issue","createMessageBuilderFromOptions"]}

gui/frontend/node_modules/zod-validation-error/v4/index.d.mts

@@ -0,0 +1,66 @@
+import * as zod from 'zod/v4/core';
+
+declare const ZOD_VALIDATION_ERROR_NAME = "ZodValidationError";
+interface ErrorOptions {
+    cause?: unknown;
+}
+declare class ValidationError extends Error {
+    name: typeof ZOD_VALIDATION_ERROR_NAME;
+    details: Array<zod.$ZodIssue>;
+    constructor(message?: string, options?: ErrorOptions);
+    toString(): string;
+}
+
+declare function isValidationError(err: unknown): err is ValidationError;
+
+declare function isValidationErrorLike(err: unknown): err is ValidationError;
+
+declare function isZodErrorLike(err: unknown): err is zod.$ZodError;
+
+type ErrorMapOptions = {
+    dateLocalization: boolean | Intl.LocalesArgument;
+    numberLocalization: boolean | Intl.LocalesArgument;
+    displayInvalidFormatDetails: boolean;
+    allowedValuesSeparator: string;
+    allowedValuesLastSeparator: string | undefined;
+    wrapAllowedValuesInQuote: boolean;
+    maxAllowedValuesToDisplay: number;
+    unrecognizedKeysSeparator: string;
+    unrecognizedKeysLastSeparator: string | undefined;
+    wrapUnrecognizedKeysInQuote: boolean;
+    maxUnrecognizedKeysToDisplay: number;
+};
+
+declare function createErrorMap(partialOptions?: Partial<ErrorMapOptions>): zod.$ZodErrorMap<zod.$ZodIssue>;
+
+type NonEmptyArray<T> = [T, ...T[]];
+
+type ZodIssue = zod.$ZodIssue;
+type MessageBuilder = (issues: NonEmptyArray<ZodIssue>) => string;
+type MessageBuilderOptions = {
+    prefix: string | null | undefined;
+    prefixSeparator: string;
+    maxIssuesInMessage: number;
+    issueSeparator: string;
+    unionSeparator: string;
+    includePath: boolean;
+    forceTitleCase: boolean;
+};
+declare function createMessageBuilder(partialOptions?: Partial<MessageBuilderOptions>): MessageBuilder;
+
+type ZodError = zod.$ZodError;
+type FromZodErrorOptions = {
+    messageBuilder: MessageBuilder;
+} | Partial<MessageBuilderOptions>;
+declare function fromZodError(zodError: ZodError, options?: FromZodErrorOptions): ValidationError;
+
+declare function fromError(err: unknown, options?: FromZodErrorOptions): ValidationError;
+
+type FromZodIssueOptions = {
+    messageBuilder: MessageBuilder;
+} | Partial<Omit<MessageBuilderOptions, 'maxIssuesInMessage'>>;
+declare function fromZodIssue(issue: ZodIssue, options?: FromZodIssueOptions): ValidationError;
+
+declare const toValidationError: (options?: FromZodErrorOptions) => (err: unknown) => ValidationError;
+
+export { type ErrorMapOptions, type ErrorOptions, type FromZodErrorOptions, type FromZodIssueOptions, type MessageBuilder, type MessageBuilderOptions, type NonEmptyArray, ValidationError, type ZodError, type ZodIssue, createErrorMap, createMessageBuilder, fromError, fromZodError, fromZodIssue, isValidationError, isValidationErrorLike, isZodErrorLike, toValidationError };

gui/frontend/node_modules/zod-validation-error/v4/index.d.ts

@@ -0,0 +1,66 @@
+import * as zod from 'zod/v4/core';
+
+declare const ZOD_VALIDATION_ERROR_NAME = "ZodValidationError";
+interface ErrorOptions {
+    cause?: unknown;
+}
+declare class ValidationError extends Error {
+    name: typeof ZOD_VALIDATION_ERROR_NAME;
+    details: Array<zod.$ZodIssue>;
+    constructor(message?: string, options?: ErrorOptions);
+    toString(): string;
+}
+
+declare function isValidationError(err: unknown): err is ValidationError;
+
+declare function isValidationErrorLike(err: unknown): err is ValidationError;
+
+declare function isZodErrorLike(err: unknown): err is zod.$ZodError;
+
+type ErrorMapOptions = {
+    dateLocalization: boolean | Intl.LocalesArgument;
+    numberLocalization: boolean | Intl.LocalesArgument;
+    displayInvalidFormatDetails: boolean;
+    allowedValuesSeparator: string;
+    allowedValuesLastSeparator: string | undefined;
+    wrapAllowedValuesInQuote: boolean;
+    maxAllowedValuesToDisplay: number;
+    unrecognizedKeysSeparator: string;
+    unrecognizedKeysLastSeparator: string | undefined;
+    wrapUnrecognizedKeysInQuote: boolean;
+    maxUnrecognizedKeysToDisplay: number;
+};
+
+declare function createErrorMap(partialOptions?: Partial<ErrorMapOptions>): zod.$ZodErrorMap<zod.$ZodIssue>;
+
+type NonEmptyArray<T> = [T, ...T[]];
+
+type ZodIssue = zod.$ZodIssue;
+type MessageBuilder = (issues: NonEmptyArray<ZodIssue>) => string;
+type MessageBuilderOptions = {
+    prefix: string | null | undefined;
+    prefixSeparator: string;
+    maxIssuesInMessage: number;
+    issueSeparator: string;
+    unionSeparator: string;
+    includePath: boolean;
+    forceTitleCase: boolean;
+};
+declare function createMessageBuilder(partialOptions?: Partial<MessageBuilderOptions>): MessageBuilder;
+
+type ZodError = zod.$ZodError;
+type FromZodErrorOptions = {
+    messageBuilder: MessageBuilder;
+} | Partial<MessageBuilderOptions>;
+declare function fromZodError(zodError: ZodError, options?: FromZodErrorOptions): ValidationError;
+
+declare function fromError(err: unknown, options?: FromZodErrorOptions): ValidationError;
+
+type FromZodIssueOptions = {
+    messageBuilder: MessageBuilder;
+} | Partial<Omit<MessageBuilderOptions, 'maxIssuesInMessage'>>;
+declare function fromZodIssue(issue: ZodIssue, options?: FromZodIssueOptions): ValidationError;
+
+declare const toValidationError: (options?: FromZodErrorOptions) => (err: unknown) => ValidationError;
+
+export { type ErrorMapOptions, type ErrorOptions, type FromZodErrorOptions, type FromZodIssueOptions, type MessageBuilder, type MessageBuilderOptions, type NonEmptyArray, ValidationError, type ZodError, type ZodIssue, createErrorMap, createMessageBuilder, fromError, fromZodError, fromZodIssue, isValidationError, isValidationErrorLike, isZodErrorLike, toValidationError };

gui/frontend/node_modules/zod-validation-error/v4/index.js

@@ -0,0 +1,725 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// lib/v4/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ValidationError: () => ValidationError,
+  createErrorMap: () => createErrorMap,
+  createMessageBuilder: () => createMessageBuilder,
+  fromError: () => fromError,
+  fromZodError: () => fromZodError,
+  fromZodIssue: () => fromZodIssue,
+  isValidationError: () => isValidationError,
+  isValidationErrorLike: () => isValidationErrorLike,
+  isZodErrorLike: () => isZodErrorLike,
+  toValidationError: () => toValidationError
+});
+module.exports = __toCommonJS(index_exports);
+
+// lib/v4/isZodErrorLike.ts
+function isZodErrorLike(err) {
+  return err instanceof Object && "name" in err && (err.name === "ZodError" || err.name === "$ZodError") && "issues" in err && Array.isArray(err.issues);
+}
+
+// lib/v4/ValidationError.ts
+var ZOD_VALIDATION_ERROR_NAME = "ZodValidationError";
+var ValidationError = class extends Error {
+  name;
+  details;
+  constructor(message, options) {
+    super(message, options);
+    this.name = ZOD_VALIDATION_ERROR_NAME;
+    this.details = getIssuesFromErrorOptions(options);
+  }
+  toString() {
+    return this.message;
+  }
+};
+function getIssuesFromErrorOptions(options) {
+  if (options) {
+    const cause = options.cause;
+    if (isZodErrorLike(cause)) {
+      return cause.issues;
+    }
+  }
+  return [];
+}
+
+// lib/v4/isValidationError.ts
+function isValidationError(err) {
+  return err instanceof ValidationError;
+}
+
+// lib/v4/isValidationErrorLike.ts
+function isValidationErrorLike(err) {
+  return err instanceof Error && err.name === ZOD_VALIDATION_ERROR_NAME;
+}
+
+// lib/v4/errorMap/custom.ts
+function parseCustomIssue(issue) {
+  return {
+    type: issue.code,
+    path: issue.path,
+    message: issue.message ?? "Invalid input"
+  };
+}
+
+// lib/v4/errorMap/invalidElement.ts
+function parseInvalidElementIssue(issue) {
+  return {
+    type: issue.code,
+    path: issue.path,
+    message: `unexpected element in ${issue.origin}`
+  };
+}
+
+// lib/v4/errorMap/invalidKey.ts
+function parseInvalidKeyIssue(issue) {
+  return {
+    type: issue.code,
+    path: issue.path,
+    message: `unexpected key in ${issue.origin}`
+  };
+}
+
+// lib/v4/errorMap/invalidStringFormat.ts
+function parseInvalidStringFormatIssue(issue, options = {
+  displayInvalidFormatDetails: false
+}) {
+  switch (issue.format) {
+    case "lowercase":
+    case "uppercase":
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `value must be in ${issue.format} format`
+      };
+    default: {
+      if (isZodIssueStringStartsWith(issue)) {
+        return parseStringStartsWith(issue);
+      }
+      if (isZodIssueStringEndsWith(issue)) {
+        return parseStringEndsWith(issue);
+      }
+      if (isZodIssueStringIncludes(issue)) {
+        return parseStringIncludes(issue);
+      }
+      if (isZodIssueStringInvalidRegex(issue)) {
+        return parseStringInvalidRegex(issue, options);
+      }
+      if (isZodIssueStringInvalidJWT(issue)) {
+        return parseStringInvalidJWT(issue, options);
+      }
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `invalid ${issue.format}`
+      };
+    }
+  }
+}
+function isZodIssueStringStartsWith(issue) {
+  return issue.format === "starts_with";
+}
+function parseStringStartsWith(issue) {
+  return {
+    type: issue.code,
+    path: issue.path,
+    message: `value must start with "${issue.prefix}"`
+  };
+}
+function isZodIssueStringEndsWith(issue) {
+  return issue.format === "ends_with";
+}
+function parseStringEndsWith(issue) {
+  return {
+    type: issue.code,
+    path: issue.path,
+    message: `value must end with "${issue.suffix}"`
+  };
+}
+function isZodIssueStringIncludes(issue) {
+  return issue.format === "includes";
+}
+function parseStringIncludes(issue) {
+  return {
+    type: issue.code,
+    path: issue.path,
+    message: `value must include "${issue.includes}"`
+  };
+}
+function isZodIssueStringInvalidRegex(issue) {
+  return issue.format === "regex";
+}
+function parseStringInvalidRegex(issue, options = {
+  displayInvalidFormatDetails: false
+}) {
+  let message = "value must match pattern";
+  if (options.displayInvalidFormatDetails) {
+    message += ` "${issue.pattern}"`;
+  }
+  return {
+    type: issue.code,
+    path: issue.path,
+    message
+  };
+}
+function isZodIssueStringInvalidJWT(issue) {
+  return issue.format === "jwt";
+}
+function parseStringInvalidJWT(issue, options = {
+  displayInvalidFormatDetails: false
+}) {
+  return {
+    type: issue.code,
+    path: issue.path,
+    message: options.displayInvalidFormatDetails && issue.algorithm ? `invalid jwt/${issue.algorithm}` : `invalid jwt`
+  };
+}
+
+// lib/v4/errorMap/invalidType.ts
+function parseInvalidTypeIssue(issue) {
+  let message = `expected ${issue.expected}`;
+  if ("input" in issue) {
+    message += `, received ${getTypeName(issue.input)}`;
+  }
+  return {
+    type: issue.code,
+    path: issue.path,
+    message
+  };
+}
+function getTypeName(value) {
+  if (typeof value === "object") {
+    if (value === null) {
+      return "null";
+    }
+    if (value === void 0) {
+      return "undefined";
+    }
+    if (Array.isArray(value)) {
+      return "array";
+    }
+    if (value instanceof Date) {
+      return "date";
+    }
+    if (value instanceof RegExp) {
+      return "regexp";
+    }
+    if (value instanceof Map) {
+      return "map";
+    }
+    if (value instanceof Set) {
+      return "set";
+    }
+    if (value instanceof Error) {
+      return "error";
+    }
+    if (value instanceof Function) {
+      return "function";
+    }
+    return "object";
+  }
+  return typeof value;
+}
+
+// lib/v4/errorMap/invalidUnion.ts
+function parseInvalidUnionIssue(issue) {
+  return {
+    type: issue.code,
+    path: issue.path,
+    message: issue.message ?? "Invalid input"
+  };
+}
+
+// lib/utils/stringify.ts
+function stringifySymbol(symbol) {
+  return symbol.description ?? "";
+}
+function stringify(value, options = {}) {
+  switch (typeof value) {
+    case "symbol":
+      return stringifySymbol(value);
+    case "bigint":
+    case "number": {
+      switch (options.localization) {
+        case true:
+          return value.toLocaleString();
+        case false:
+          return value.toString();
+        default:
+          return value.toLocaleString(options.localization);
+      }
+    }
+    case "string": {
+      if (options.wrapStringValueInQuote) {
+        return `"${value}"`;
+      }
+      return value;
+    }
+    default: {
+      if (value instanceof Date) {
+        switch (options.localization) {
+          case true:
+            return value.toLocaleString();
+          case false:
+            return value.toISOString();
+          default:
+            return value.toLocaleString(options.localization);
+        }
+      }
+      return String(value);
+    }
+  }
+}
+
+// lib/utils/joinValues.ts
+function joinValues(values, options) {
+  const valuesToDisplay = (options.maxValuesToDisplay ? values.slice(0, options.maxValuesToDisplay) : values).map((value) => {
+    return stringify(value, {
+      wrapStringValueInQuote: options.wrapStringValuesInQuote
+    });
+  });
+  if (valuesToDisplay.length < values.length) {
+    valuesToDisplay.push(
+      `${values.length - valuesToDisplay.length} more value(s)`
+    );
+  }
+  return valuesToDisplay.reduce((acc, value, index) => {
+    if (index > 0) {
+      if (index === valuesToDisplay.length - 1 && options.lastSeparator) {
+        acc += options.lastSeparator;
+      } else {
+        acc += options.separator;
+      }
+    }
+    acc += value;
+    return acc;
+  }, "");
+}
+
+// lib/v4/errorMap/invalidValue.ts
+function parseInvalidValueIssue(issue, options) {
+  let message;
+  if (issue.values.length === 0) {
+    message = "invalid value";
+  } else if (issue.values.length === 1) {
+    const valueStr = stringify(issue.values[0], {
+      wrapStringValueInQuote: true
+    });
+    message = `expected value to be ${valueStr}`;
+  } else {
+    const valuesStr = joinValues(issue.values, {
+      separator: options.allowedValuesSeparator,
+      lastSeparator: options.allowedValuesLastSeparator,
+      wrapStringValuesInQuote: options.wrapAllowedValuesInQuote,
+      maxValuesToDisplay: options.maxAllowedValuesToDisplay
+    });
+    message = `expected value to be one of ${valuesStr}`;
+  }
+  return {
+    type: issue.code,
+    path: issue.path,
+    message
+  };
+}
+
+// lib/v4/errorMap/notMultipleOf.ts
+function parseNotMultipleOfIssue(issue) {
+  return {
+    type: issue.code,
+    path: issue.path,
+    message: `expected multiple of ${issue.divisor}`
+  };
+}
+
+// lib/v4/errorMap/tooBig.ts
+function parseTooBigIssue(issue, options) {
+  const maxValueStr = issue.origin === "date" ? stringify(new Date(issue.maximum), {
+    localization: options.dateLocalization
+  }) : stringify(issue.maximum, {
+    localization: options.numberLocalization
+  });
+  switch (issue.origin) {
+    case "number":
+    case "int":
+    case "bigint": {
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `number must be less than${issue.inclusive ? " or equal to" : ""} ${maxValueStr}`
+      };
+    }
+    case "string": {
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `string must contain at most ${maxValueStr} character(s)`
+      };
+    }
+    case "date": {
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `date must be ${issue.inclusive ? "prior or equal to" : "prior to"} "${maxValueStr}"`
+      };
+    }
+    case "array": {
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `array must contain at most ${maxValueStr} item(s)`
+      };
+    }
+    case "set": {
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `set must contain at most ${maxValueStr} item(s)`
+      };
+    }
+    case "file": {
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `file must not exceed ${maxValueStr} byte(s) in size`
+      };
+    }
+    default:
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `value must be less than${issue.inclusive ? " or equal to" : ""} ${maxValueStr}`
+      };
+  }
+}
+
+// lib/v4/errorMap/tooSmall.ts
+function parseTooSmallIssue(issue, options) {
+  const minValueStr = issue.origin === "date" ? stringify(new Date(issue.minimum), {
+    localization: options.dateLocalization
+  }) : stringify(issue.minimum, {
+    localization: options.numberLocalization
+  });
+  switch (issue.origin) {
+    case "number":
+    case "int":
+    case "bigint": {
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `number must be greater than${issue.inclusive ? " or equal to" : ""} ${minValueStr}`
+      };
+    }
+    case "date": {
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `date must be ${issue.inclusive ? "later or equal to" : "later to"} "${minValueStr}"`
+      };
+    }
+    case "string": {
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `string must contain at least ${minValueStr} character(s)`
+      };
+    }
+    case "array": {
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `array must contain at least ${minValueStr} item(s)`
+      };
+    }
+    case "set": {
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `set must contain at least ${minValueStr} item(s)`
+      };
+    }
+    case "file": {
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `file must be at least ${minValueStr} byte(s) in size`
+      };
+    }
+    default:
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `value must be greater than${issue.inclusive ? " or equal to" : ""} ${minValueStr}`
+      };
+  }
+}
+
+// lib/v4/errorMap/unrecognizedKeys.ts
+function parseUnrecognizedKeysIssue(issue, options) {
+  const keysStr = joinValues(issue.keys, {
+    separator: options.unrecognizedKeysSeparator,
+    lastSeparator: options.unrecognizedKeysLastSeparator,
+    wrapStringValuesInQuote: options.wrapUnrecognizedKeysInQuote,
+    maxValuesToDisplay: options.maxUnrecognizedKeysToDisplay
+  });
+  return {
+    type: issue.code,
+    path: issue.path,
+    message: `unrecognized key(s) ${keysStr} in object`
+  };
+}
+
+// lib/v4/errorMap/errorMap.ts
+var issueParsers = {
+  invalid_type: parseInvalidTypeIssue,
+  too_big: parseTooBigIssue,
+  too_small: parseTooSmallIssue,
+  invalid_format: parseInvalidStringFormatIssue,
+  invalid_value: parseInvalidValueIssue,
+  invalid_element: parseInvalidElementIssue,
+  not_multiple_of: parseNotMultipleOfIssue,
+  unrecognized_keys: parseUnrecognizedKeysIssue,
+  invalid_key: parseInvalidKeyIssue,
+  custom: parseCustomIssue,
+  invalid_union: parseInvalidUnionIssue
+};
+var defaultErrorMapOptions = {
+  displayInvalidFormatDetails: false,
+  allowedValuesSeparator: ", ",
+  allowedValuesLastSeparator: " or ",
+  wrapAllowedValuesInQuote: true,
+  maxAllowedValuesToDisplay: 10,
+  unrecognizedKeysSeparator: ", ",
+  unrecognizedKeysLastSeparator: " and ",
+  wrapUnrecognizedKeysInQuote: true,
+  maxUnrecognizedKeysToDisplay: 5,
+  dateLocalization: true,
+  numberLocalization: true
+};
+function createErrorMap(partialOptions = {}) {
+  const options = {
+    ...defaultErrorMapOptions,
+    ...partialOptions
+  };
+  const errorMap = (issue) => {
+    if (issue.code === void 0) {
+      return "Not supported issue type";
+    }
+    const parseFunc = issueParsers[issue.code];
+    const ast = parseFunc(issue, options);
+    return ast.message;
+  };
+  return errorMap;
+}
+
+// lib/utils/NonEmptyArray.ts
+function isNonEmptyArray(value) {
+  return value.length !== 0;
+}
+
+// lib/utils/joinPath.ts
+var identifierRegex = /[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*/u;
+function joinPath(path) {
+  if (path.length === 1) {
+    let propertyKey = path[0];
+    if (typeof propertyKey === "symbol") {
+      propertyKey = stringifySymbol(propertyKey);
+    }
+    return propertyKey.toString() || '""';
+  }
+  return path.reduce((acc, propertyKey) => {
+    if (typeof propertyKey === "number") {
+      return acc + "[" + propertyKey.toString() + "]";
+    }
+    if (typeof propertyKey === "symbol") {
+      propertyKey = stringifySymbol(propertyKey);
+    }
+    if (propertyKey.includes('"')) {
+      return acc + '["' + escapeQuotes(propertyKey) + '"]';
+    }
+    if (!identifierRegex.test(propertyKey)) {
+      return acc + '["' + propertyKey + '"]';
+    }
+    const separator = acc.length === 0 ? "" : ".";
+    return acc + separator + propertyKey;
+  }, "");
+}
+function escapeQuotes(str) {
+  return str.replace(/"/g, '\\"');
+}
+
+// lib/utils/titleCase.ts
+function titleCase(value) {
+  if (value.length === 0) {
+    return value;
+  }
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+// lib/v4/MessageBuilder.ts
+var defaultMessageBuilderOptions = {
+  prefix: "Validation error",
+  prefixSeparator: ": ",
+  maxIssuesInMessage: 99,
+  // I've got 99 problems but the b$tch ain't one
+  unionSeparator: " or ",
+  issueSeparator: "; ",
+  includePath: true,
+  forceTitleCase: true
+};
+function createMessageBuilder(partialOptions = {}) {
+  const options = {
+    ...defaultMessageBuilderOptions,
+    ...partialOptions
+  };
+  return function messageBuilder(issues) {
+    const message = issues.slice(0, options.maxIssuesInMessage).map((issue) => mapIssue(issue, options)).join(options.issueSeparator);
+    return conditionallyPrefixMessage(message, options);
+  };
+}
+function mapIssue(issue, options) {
+  if (issue.code === "invalid_union" && isNonEmptyArray(issue.errors)) {
+    const individualMessages = issue.errors.map(
+      (issues) => issues.map(
+        (subIssue) => mapIssue(
+          {
+            ...subIssue,
+            path: issue.path.concat(subIssue.path)
+          },
+          options
+        )
+      ).join(options.issueSeparator)
+    );
+    return Array.from(new Set(individualMessages)).join(options.unionSeparator);
+  }
+  const buf = [];
+  if (options.forceTitleCase) {
+    buf.push(titleCase(issue.message));
+  } else {
+    buf.push(issue.message);
+  }
+  pathCondition: if (options.includePath && issue.path !== void 0 && isNonEmptyArray(issue.path)) {
+    if (issue.path.length === 1) {
+      const identifier = issue.path[0];
+      if (typeof identifier === "number") {
+        buf.push(` at index ${identifier}`);
+        break pathCondition;
+      }
+    }
+    buf.push(` at "${joinPath(issue.path)}"`);
+  }
+  return buf.join("");
+}
+function conditionallyPrefixMessage(message, options) {
+  if (options.prefix != null) {
+    if (message.length > 0) {
+      return [options.prefix, message].join(options.prefixSeparator);
+    }
+    return options.prefix;
+  }
+  if (message.length > 0) {
+    return message;
+  }
+  return defaultMessageBuilderOptions.prefix;
+}
+
+// lib/v4/fromZodError.ts
+function fromZodError(zodError, options = {}) {
+  if (!isZodErrorLike(zodError)) {
+    throw new TypeError(
+      `Invalid zodError param; expected instance of ZodError. Did you mean to use the "${fromError.name}" method instead?`
+    );
+  }
+  return fromZodErrorWithoutRuntimeCheck(zodError, options);
+}
+function fromZodErrorWithoutRuntimeCheck(zodError, options = {}) {
+  const zodIssues = zodError.issues;
+  let message;
+  if (isNonEmptyArray(zodIssues)) {
+    const messageBuilder = createMessageBuilderFromOptions(options);
+    message = messageBuilder(zodIssues);
+  } else {
+    message = zodError.message;
+  }
+  return new ValidationError(message, { cause: zodError });
+}
+function createMessageBuilderFromOptions(options) {
+  if ("messageBuilder" in options) {
+    return options.messageBuilder;
+  }
+  return createMessageBuilder(options);
+}
+
+// lib/v4/toValidationError.ts
+var toValidationError = (options = {}) => (err) => {
+  if (isZodErrorLike(err)) {
+    return fromZodErrorWithoutRuntimeCheck(err, options);
+  }
+  if (err instanceof Error) {
+    return new ValidationError(err.message, { cause: err });
+  }
+  return new ValidationError("Unknown error");
+};
+
+// lib/v4/fromError.ts
+function fromError(err, options = {}) {
+  return toValidationError(options)(err);
+}
+
+// lib/v4/fromZodIssue.ts
+var zod = __toESM(require("zod/v4/core"));
+function fromZodIssue(issue, options = {}) {
+  const messageBuilder = createMessageBuilderFromOptions2(options);
+  const message = messageBuilder([issue]);
+  return new ValidationError(message, {
+    cause: new zod.$ZodRealError([issue])
+  });
+}
+function createMessageBuilderFromOptions2(options) {
+  if ("messageBuilder" in options) {
+    return options.messageBuilder;
+  }
+  return createMessageBuilder(options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ValidationError,
+  createErrorMap,
+  createMessageBuilder,
+  fromError,
+  fromZodError,
+  fromZodIssue,
+  isValidationError,
+  isValidationErrorLike,
+  isZodErrorLike,
+  toValidationError
+});
+//# sourceMappingURL=index.js.map

gui/frontend/node_modules/zod-validation-error/v4/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../lib/v4/index.ts","../lib/v4/isZodErrorLike.ts","../lib/v4/ValidationError.ts","../lib/v4/isValidationError.ts","../lib/v4/isValidationErrorLike.ts","../lib/v4/errorMap/custom.ts","../lib/v4/errorMap/invalidElement.ts","../lib/v4/errorMap/invalidKey.ts","../lib/v4/errorMap/invalidStringFormat.ts","../lib/v4/errorMap/invalidType.ts","../lib/v4/errorMap/invalidUnion.ts","../lib/utils/stringify.ts","../lib/utils/joinValues.ts","../lib/v4/errorMap/invalidValue.ts","../lib/v4/errorMap/notMultipleOf.ts","../lib/v4/errorMap/tooBig.ts","../lib/v4/errorMap/tooSmall.ts","../lib/v4/errorMap/unrecognizedKeys.ts","../lib/v4/errorMap/errorMap.ts","../lib/utils/NonEmptyArray.ts","../lib/utils/joinPath.ts","../lib/utils/titleCase.ts","../lib/v4/MessageBuilder.ts","../lib/v4/fromZodError.ts","../lib/v4/toValidationError.ts","../lib/v4/fromError.ts","../lib/v4/fromZodIssue.ts"],"sourcesContent":["export { ValidationError, type ErrorOptions } from './ValidationError.ts';\nexport { isValidationError } from './isValidationError.ts';\nexport { isValidationErrorLike } from './isValidationErrorLike.ts';\nexport { isZodErrorLike } from './isZodErrorLike.ts';\nexport { createErrorMap, type ErrorMapOptions } from './errorMap/index.ts';\nexport { fromError } from './fromError.ts';\nexport { fromZodIssue, type FromZodIssueOptions } from './fromZodIssue.ts';\nexport {\n  fromZodError,\n  type FromZodErrorOptions,\n  type ZodError,\n} from './fromZodError.ts';\nexport { toValidationError } from './toValidationError.ts';\nexport {\n  type MessageBuilder,\n  type ZodIssue,\n  createMessageBuilder,\n  type MessageBuilderOptions,\n} from './MessageBuilder.ts';\nexport { type NonEmptyArray } from '../utils/NonEmptyArray.ts';\n","import type * as zod from 'zod/v4/core';\n\nexport function isZodErrorLike(err: unknown): err is zod.$ZodError {\n  return (\n    err instanceof Object &&\n    'name' in err &&\n    (err.name === 'ZodError' || err.name === '$ZodError') &&\n    'issues' in err &&\n    Array.isArray(err.issues)\n  );\n}\n","import { isZodErrorLike } from './isZodErrorLike.ts';\nimport type * as zod from 'zod/v4/core';\n\nexport const ZOD_VALIDATION_ERROR_NAME = 'ZodValidationError';\n\n// make zod-validation-error compatible with\n// earlier to es2022 typescript configurations\n// @see https://github.com/causaly/zod-validation-error/issues/226\nexport interface ErrorOptions {\n  cause?: unknown;\n}\n\nexport class ValidationError extends Error {\n  name: typeof ZOD_VALIDATION_ERROR_NAME;\n  details: Array<zod.$ZodIssue>;\n\n  constructor(message?: string, options?: ErrorOptions) {\n    super(message, options);\n    this.name = ZOD_VALIDATION_ERROR_NAME;\n    this.details = getIssuesFromErrorOptions(options);\n  }\n\n  toString(): string {\n    return this.message;\n  }\n}\n\nfunction getIssuesFromErrorOptions(\n  options?: ErrorOptions\n): Array<zod.$ZodIssue> {\n  if (options) {\n    const cause = options.cause;\n    if (isZodErrorLike(cause)) {\n      return cause.issues;\n    }\n  }\n\n  return [];\n}\n","import { ValidationError } from './ValidationError.ts';\n\nexport function isValidationError(err: unknown): err is ValidationError {\n  return err instanceof ValidationError;\n}\n","import {\n  ZOD_VALIDATION_ERROR_NAME,\n  type ValidationError,\n} from './ValidationError.ts';\n\nexport function isValidationErrorLike(err: unknown): err is ValidationError {\n  return err instanceof Error && err.name === ZOD_VALIDATION_ERROR_NAME;\n}\n","import type * as zod from 'zod/v4/core';\nimport type { AbstractSyntaxTree } from './types.ts';\n\nexport function parseCustomIssue(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueCustom>\n): AbstractSyntaxTree {\n  return {\n    type: issue.code,\n    path: issue.path,\n    message: issue.message ?? 'Invalid input',\n  };\n}\n","import type * as zod from 'zod/v4/core';\nimport type { AbstractSyntaxTree } from './types.ts';\n\nexport function parseInvalidElementIssue(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueInvalidElement>\n): AbstractSyntaxTree {\n  return {\n    type: issue.code,\n    path: issue.path,\n    message: `unexpected element in ${issue.origin}`,\n  };\n}\n","import type * as zod from 'zod/v4/core';\nimport type { AbstractSyntaxTree } from './types.ts';\n\nexport function parseInvalidKeyIssue(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueInvalidKey>\n): AbstractSyntaxTree {\n  return {\n    type: issue.code,\n    path: issue.path,\n    message: `unexpected key in ${issue.origin}`,\n  };\n}\n","import type { AbstractSyntaxTree, ErrorMapOptions } from './types.ts';\nimport type * as zod from 'zod/v4/core';\n\nexport function parseInvalidStringFormatIssue(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueInvalidStringFormat>,\n  options: Pick<ErrorMapOptions, 'displayInvalidFormatDetails'> = {\n    displayInvalidFormatDetails: false,\n  }\n): AbstractSyntaxTree {\n  switch (issue.format) {\n    case 'lowercase':\n    case 'uppercase':\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `value must be in ${issue.format} format`,\n      };\n    default: {\n      if (isZodIssueStringStartsWith(issue)) {\n        return parseStringStartsWith(issue);\n      }\n      if (isZodIssueStringEndsWith(issue)) {\n        return parseStringEndsWith(issue);\n      }\n      if (isZodIssueStringIncludes(issue)) {\n        return parseStringIncludes(issue);\n      }\n      if (isZodIssueStringInvalidRegex(issue)) {\n        return parseStringInvalidRegex(issue, options);\n      }\n      if (isZodIssueStringInvalidJWT(issue)) {\n        return parseStringInvalidJWT(issue, options);\n      }\n\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `invalid ${issue.format}`,\n      };\n    }\n  }\n}\nfunction isZodIssueStringStartsWith(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueInvalidStringFormat>\n): issue is zod.$ZodRawIssue<zod.$ZodIssueStringStartsWith> {\n  return issue.format === 'starts_with';\n}\n\nfunction parseStringStartsWith(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueStringStartsWith>\n): AbstractSyntaxTree {\n  return {\n    type: issue.code,\n    path: issue.path,\n    message: `value must start with \"${issue.prefix}\"`,\n  };\n}\n\nfunction isZodIssueStringEndsWith(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueInvalidStringFormat>\n): issue is zod.$ZodRawIssue<zod.$ZodIssueStringEndsWith> {\n  return issue.format === 'ends_with';\n}\nfunction parseStringEndsWith(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueStringEndsWith>\n): AbstractSyntaxTree {\n  return {\n    type: issue.code,\n    path: issue.path,\n    message: `value must end with \"${issue.suffix}\"`,\n  };\n}\n\nfunction isZodIssueStringIncludes(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueInvalidStringFormat>\n): issue is zod.$ZodRawIssue<zod.$ZodIssueStringIncludes> {\n  return issue.format === 'includes';\n}\nfunction parseStringIncludes(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueStringIncludes>\n): AbstractSyntaxTree {\n  return {\n    type: issue.code,\n    path: issue.path,\n    message: `value must include \"${issue.includes}\"`,\n  };\n}\n\nfunction isZodIssueStringInvalidRegex(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueInvalidStringFormat>\n): issue is zod.$ZodRawIssue<zod.$ZodIssueStringInvalidRegex> {\n  return issue.format === 'regex';\n}\nfunction parseStringInvalidRegex(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueStringInvalidRegex>,\n  options: Pick<ErrorMapOptions, 'displayInvalidFormatDetails'> = {\n    displayInvalidFormatDetails: false,\n  }\n): AbstractSyntaxTree {\n  let message = 'value must match pattern';\n  if (options.displayInvalidFormatDetails) {\n    message += ` \"${issue.pattern}\"`;\n  }\n\n  return {\n    type: issue.code,\n    path: issue.path,\n    message,\n  };\n}\n\nfunction isZodIssueStringInvalidJWT(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueInvalidStringFormat>\n): issue is zod.$ZodRawIssue<zod.$ZodIssueStringInvalidJWT> {\n  return issue.format === 'jwt';\n}\nfunction parseStringInvalidJWT(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueStringInvalidJWT>,\n  options: Pick<ErrorMapOptions, 'displayInvalidFormatDetails'> = {\n    displayInvalidFormatDetails: false,\n  }\n): AbstractSyntaxTree {\n  return {\n    type: issue.code,\n    path: issue.path,\n    message:\n      options.displayInvalidFormatDetails && issue.algorithm\n        ? `invalid jwt/${issue.algorithm}`\n        : `invalid jwt`,\n  };\n}\n","import type { AbstractSyntaxTree } from './types.ts';\nimport type * as zod from 'zod/v4/core';\n\nexport function parseInvalidTypeIssue(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueInvalidType>\n): AbstractSyntaxTree {\n  let message = `expected ${issue.expected}`;\n\n  // note: it's possible that issue.input is not defined\n  if ('input' in issue) {\n    message += `, received ${getTypeName(issue.input)}`;\n  }\n\n  return {\n    type: issue.code,\n    path: issue.path,\n    message,\n  };\n}\n\nexport function getTypeName(value: unknown): string {\n  if (typeof value === 'object') {\n    if (value === null) {\n      return 'null';\n    }\n    if (value === undefined) {\n      return 'undefined';\n    }\n    if (Array.isArray(value)) {\n      return 'array';\n    }\n    if (value instanceof Date) {\n      return 'date';\n    }\n    if (value instanceof RegExp) {\n      return 'regexp';\n    }\n    if (value instanceof Map) {\n      return 'map';\n    }\n    if (value instanceof Set) {\n      return 'set';\n    }\n    if (value instanceof Error) {\n      return 'error';\n    }\n    if (value instanceof Function) {\n      return 'function';\n    }\n    return 'object';\n  }\n\n  return typeof value;\n}\n","import type * as zod from 'zod/v4/core';\nimport type { AbstractSyntaxTree } from './types.ts';\n\nexport function parseInvalidUnionIssue(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueInvalidUnion>\n): AbstractSyntaxTree {\n  return {\n    type: issue.code,\n    path: issue.path,\n    message: issue.message ?? 'Invalid input',\n  };\n}\n","import type { util } from 'zod/v4/core';\n\nexport function stringifySymbol(symbol: symbol): string {\n  return symbol.description ?? '';\n}\n\nexport type StringifyValueOptions = {\n  wrapStringValueInQuote?: boolean;\n  localization?: boolean | Intl.LocalesArgument;\n};\n\nexport function stringify(\n  value: util.Primitive | Date,\n  options: StringifyValueOptions = {}\n): string {\n  switch (typeof value) {\n    case 'symbol':\n      return stringifySymbol(value);\n    case 'bigint':\n    case 'number': {\n      switch (options.localization) {\n        case true:\n          return value.toLocaleString();\n        case false:\n          return value.toString();\n        default:\n          return value.toLocaleString(options.localization);\n      }\n    }\n    case 'string': {\n      if (options.wrapStringValueInQuote) {\n        return `\"${value}\"`;\n      }\n      return value;\n    }\n    default: {\n      if (value instanceof Date) {\n        switch (options.localization) {\n          case true:\n            return value.toLocaleString();\n          case false:\n            return value.toISOString();\n          default:\n            return value.toLocaleString(options.localization);\n        }\n      }\n      return String(value);\n    }\n  }\n}\n","import { stringify } from './stringify.ts';\nimport type { util } from 'zod/v4/core';\n\nexport type JoinValuesOptions = {\n  separator: string;\n  lastSeparator?: string;\n  wrapStringValuesInQuote?: boolean;\n  maxValuesToDisplay?: number;\n};\n\nexport function joinValues(\n  values: Array<util.Primitive>,\n  options: JoinValuesOptions\n): string {\n  const valuesToDisplay = (\n    options.maxValuesToDisplay\n      ? values.slice(0, options.maxValuesToDisplay)\n      : values\n  ).map((value) => {\n    return stringify(value, {\n      wrapStringValueInQuote: options.wrapStringValuesInQuote,\n    });\n  });\n\n  // add remaining values count (if any)\n  // this is to avoid displaying too many values in the error message\n  // and to keep the message concise\n  // e.g. `\"foo\", \"bar\", \"baz\" or 3 more value(s)`\n  if (valuesToDisplay.length < values.length) {\n    valuesToDisplay.push(\n      `${values.length - valuesToDisplay.length} more value(s)`\n    );\n  }\n\n  return valuesToDisplay.reduce<string>((acc, value, index) => {\n    if (index > 0) {\n      if (index === valuesToDisplay.length - 1 && options.lastSeparator) {\n        acc += options.lastSeparator;\n      } else {\n        acc += options.separator;\n      }\n    }\n\n    acc += value;\n\n    return acc;\n  }, '');\n}\n","import { joinValues } from '../../utils/joinValues.ts';\nimport { stringify } from '../../utils/stringify.ts';\nimport type { AbstractSyntaxTree, ErrorMapOptions } from './types.ts';\nimport type * as zod from 'zod/v4/core';\n\nexport function parseInvalidValueIssue(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueInvalidValue>,\n  options: Pick<\n    ErrorMapOptions,\n    | 'allowedValuesSeparator'\n    | 'maxAllowedValuesToDisplay'\n    | 'wrapAllowedValuesInQuote'\n    | 'allowedValuesLastSeparator'\n  >\n): AbstractSyntaxTree {\n  let message: string;\n\n  if (issue.values.length === 0) {\n    message = 'invalid value';\n  } else if (issue.values.length === 1) {\n    const valueStr = stringify(issue.values[0], {\n      wrapStringValueInQuote: true,\n    });\n    message = `expected value to be ${valueStr}`;\n  } else {\n    const valuesStr = joinValues(issue.values, {\n      separator: options.allowedValuesSeparator,\n      lastSeparator: options.allowedValuesLastSeparator,\n      wrapStringValuesInQuote: options.wrapAllowedValuesInQuote,\n      maxValuesToDisplay: options.maxAllowedValuesToDisplay,\n    });\n    message = `expected value to be one of ${valuesStr}`;\n  }\n\n  return {\n    type: issue.code,\n    path: issue.path,\n    message,\n  };\n}\n","import type * as zod from 'zod/v4/core';\nimport type { AbstractSyntaxTree } from './types.ts';\n\nexport function parseNotMultipleOfIssue(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueNotMultipleOf>\n): AbstractSyntaxTree {\n  return {\n    type: issue.code,\n    path: issue.path,\n    message: `expected multiple of ${issue.divisor}`,\n  };\n}\n","import { stringify } from '../../utils/stringify.ts';\nimport type { AbstractSyntaxTree, ErrorMapOptions } from './types.ts';\nimport type * as zod from 'zod/v4/core';\n\nexport function parseTooBigIssue(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueTooBig>,\n  options: Pick<ErrorMapOptions, 'dateLocalization' | 'numberLocalization'>\n): AbstractSyntaxTree {\n  const maxValueStr =\n    issue.origin === 'date'\n      ? stringify(new Date(issue.maximum as number), {\n          localization: options.dateLocalization,\n        })\n      : stringify(issue.maximum, {\n          localization: options.numberLocalization,\n        });\n\n  switch (issue.origin) {\n    case 'number':\n    case 'int':\n    case 'bigint': {\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `number must be less than${\n          issue.inclusive ? ' or equal to' : ''\n        } ${maxValueStr}`,\n      };\n    }\n    case 'string': {\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `string must contain at most ${maxValueStr} character(s)`,\n      };\n    }\n    case 'date': {\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `date must be ${\n          issue.inclusive ? 'prior or equal to' : 'prior to'\n        } \"${maxValueStr}\"`,\n      };\n    }\n    case 'array': {\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `array must contain at most ${maxValueStr} item(s)`,\n      };\n    }\n    case 'set': {\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `set must contain at most ${maxValueStr} item(s)`,\n      };\n    }\n    case 'file': {\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `file must not exceed ${maxValueStr} byte(s) in size`,\n      };\n    }\n    default:\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `value must be less than${\n          issue.inclusive ? ' or equal to' : ''\n        } ${maxValueStr}`,\n      };\n  }\n}\n","import { stringify } from '../../utils/stringify.ts';\nimport type * as zod from 'zod/v4/core';\nimport type { AbstractSyntaxTree, ErrorMapOptions } from './types.ts';\n\nexport function parseTooSmallIssue(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueTooSmall>,\n  options: Pick<ErrorMapOptions, 'dateLocalization' | 'numberLocalization'>\n): AbstractSyntaxTree {\n  const minValueStr =\n    issue.origin === 'date'\n      ? stringify(new Date(issue.minimum as number), {\n          localization: options.dateLocalization,\n        })\n      : stringify(issue.minimum, {\n          localization: options.numberLocalization,\n        });\n\n  switch (issue.origin) {\n    case 'number':\n    case 'int':\n    case 'bigint': {\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `number must be greater than${\n          issue.inclusive ? ' or equal to' : ''\n        } ${minValueStr}`,\n      };\n    }\n    case 'date': {\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `date must be ${\n          issue.inclusive ? 'later or equal to' : 'later to'\n        } \"${minValueStr}\"`,\n      };\n    }\n    case 'string': {\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `string must contain at least ${minValueStr} character(s)`,\n      };\n    }\n    case 'array': {\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `array must contain at least ${minValueStr} item(s)`,\n      };\n    }\n    case 'set': {\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `set must contain at least ${minValueStr} item(s)`,\n      };\n    }\n    case 'file': {\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `file must be at least ${minValueStr} byte(s) in size`,\n      };\n    }\n    default:\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `value must be greater than${\n          issue.inclusive ? ' or equal to' : ''\n        } ${minValueStr}`,\n      };\n  }\n}\n","import { joinValues } from '../../utils/joinValues.ts';\nimport type * as zod from 'zod/v4/core';\nimport type { AbstractSyntaxTree, ErrorMapOptions } from './types.ts';\n\nexport function parseUnrecognizedKeysIssue(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueUnrecognizedKeys>,\n  options: Pick<\n    ErrorMapOptions,\n    | 'unrecognizedKeysSeparator'\n    | 'unrecognizedKeysLastSeparator'\n    | 'wrapUnrecognizedKeysInQuote'\n    | 'maxUnrecognizedKeysToDisplay'\n  >\n): AbstractSyntaxTree {\n  const keysStr = joinValues(issue.keys, {\n    separator: options.unrecognizedKeysSeparator,\n    lastSeparator: options.unrecognizedKeysLastSeparator,\n    wrapStringValuesInQuote: options.wrapUnrecognizedKeysInQuote,\n    maxValuesToDisplay: options.maxUnrecognizedKeysToDisplay,\n  });\n\n  return {\n    type: issue.code,\n    path: issue.path,\n    message: `unrecognized key(s) ${keysStr} in object`,\n  };\n}\n","import { parseCustomIssue } from './custom.ts';\nimport { parseInvalidElementIssue } from './invalidElement.ts';\nimport { parseInvalidKeyIssue } from './invalidKey.ts';\nimport { parseInvalidStringFormatIssue } from './invalidStringFormat.ts';\nimport { parseInvalidTypeIssue } from './invalidType.ts';\nimport { parseInvalidUnionIssue } from './invalidUnion.ts';\nimport { parseInvalidValueIssue } from './invalidValue.ts';\nimport { parseNotMultipleOfIssue } from './notMultipleOf.ts';\nimport { parseTooBigIssue } from './tooBig.ts';\nimport { parseTooSmallIssue } from './tooSmall.ts';\nimport { parseUnrecognizedKeysIssue } from './unrecognizedKeys.ts';\nimport type {\n  AbstractSyntaxTree,\n  ErrorMapOptions,\n  IssueType,\n} from './types.ts';\nimport type * as zod from 'zod/v4/core';\n\ntype IssueParsers = {\n  [IssueCode in IssueType]: (\n    issue: zod.$ZodRawIssue<Extract<zod.$ZodIssue, { code: IssueCode }>>,\n    options: ErrorMapOptions\n  ) => AbstractSyntaxTree;\n};\n\nconst issueParsers: IssueParsers = {\n  invalid_type: parseInvalidTypeIssue,\n  too_big: parseTooBigIssue,\n  too_small: parseTooSmallIssue,\n  invalid_format: parseInvalidStringFormatIssue,\n  invalid_value: parseInvalidValueIssue,\n  invalid_element: parseInvalidElementIssue,\n  not_multiple_of: parseNotMultipleOfIssue,\n  unrecognized_keys: parseUnrecognizedKeysIssue,\n  invalid_key: parseInvalidKeyIssue,\n  custom: parseCustomIssue,\n  invalid_union: parseInvalidUnionIssue,\n};\n\nexport const defaultErrorMapOptions = {\n  displayInvalidFormatDetails: false,\n  allowedValuesSeparator: ', ',\n  allowedValuesLastSeparator: ' or ',\n  wrapAllowedValuesInQuote: true,\n  maxAllowedValuesToDisplay: 10,\n  unrecognizedKeysSeparator: ', ',\n  unrecognizedKeysLastSeparator: ' and ',\n  wrapUnrecognizedKeysInQuote: true,\n  maxUnrecognizedKeysToDisplay: 5,\n  dateLocalization: true,\n  numberLocalization: true,\n} as const satisfies ErrorMapOptions;\n\nexport function createErrorMap(\n  partialOptions: Partial<ErrorMapOptions> = {}\n): zod.$ZodErrorMap<zod.$ZodIssue> {\n  // fill-in default options\n  const options = {\n    ...defaultErrorMapOptions,\n    ...partialOptions,\n  };\n\n  const errorMap: zod.$ZodErrorMap<zod.$ZodIssue> = (issue) => {\n    if (issue.code === undefined) {\n      // TODO: handle this case\n      return 'Not supported issue type';\n    }\n\n    const parseFunc = issueParsers[issue.code] as (\n      iss: typeof issue,\n      opts: ErrorMapOptions\n    ) => AbstractSyntaxTree;\n    const ast = parseFunc(issue, options);\n    return ast.message;\n  };\n\n  return errorMap;\n}\n","export type NonEmptyArray<T> = [T, ...T[]];\n\nexport function isNonEmptyArray<T>(value: T[]): value is NonEmptyArray<T> {\n  return value.length !== 0;\n}\n","import { stringifySymbol } from './stringify.ts';\nimport type { NonEmptyArray } from './NonEmptyArray.ts';\n\n/**\n * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#identifiers\n */\nconst identifierRegex = /[$_\\p{ID_Start}][$\\u200c\\u200d\\p{ID_Continue}]*/u;\n\nexport function joinPath(path: NonEmptyArray<PropertyKey>): string {\n  if (path.length === 1) {\n    let propertyKey = path[0];\n\n    if (typeof propertyKey === 'symbol') {\n      propertyKey = stringifySymbol(propertyKey);\n    }\n\n    return propertyKey.toString() || '\"\"';\n  }\n\n  return path.reduce<string>((acc, propertyKey) => {\n    // handle numeric indices\n    if (typeof propertyKey === 'number') {\n      return acc + '[' + propertyKey.toString() + ']';\n    }\n\n    // handle symbols\n    if (typeof propertyKey === 'symbol') {\n      propertyKey = stringifySymbol(propertyKey);\n    }\n\n    // handle quoted values\n    if (propertyKey.includes('\"')) {\n      return acc + '[\"' + escapeQuotes(propertyKey) + '\"]';\n    }\n\n    // handle special characters\n    if (!identifierRegex.test(propertyKey)) {\n      return acc + '[\"' + propertyKey + '\"]';\n    }\n\n    // handle normal values\n    const separator = acc.length === 0 ? '' : '.';\n    return acc + separator + propertyKey;\n  }, '');\n}\n\nfunction escapeQuotes(str: string): string {\n  return str.replace(/\"/g, '\\\\\"');\n}\n","export function titleCase(value: string): string {\n  if (value.length === 0) {\n    return value;\n  }\n  return value.charAt(0).toUpperCase() + value.slice(1);\n}\n","import { joinPath } from '../utils/joinPath.ts';\nimport { isNonEmptyArray, type NonEmptyArray } from '../utils/NonEmptyArray.ts';\nimport { titleCase } from '../utils/titleCase.ts';\nimport type * as zod from 'zod/v4/core';\n\nexport type ZodIssue = zod.$ZodIssue;\n\nexport type MessageBuilder = (issues: NonEmptyArray<ZodIssue>) => string;\n\nexport type MessageBuilderOptions = {\n  prefix: string | null | undefined;\n  prefixSeparator: string;\n  maxIssuesInMessage: number;\n  issueSeparator: string;\n  unionSeparator: string;\n  includePath: boolean;\n  forceTitleCase: boolean;\n};\n\nexport const defaultMessageBuilderOptions: MessageBuilderOptions & {\n  prefix: string;\n} = {\n  prefix: 'Validation error',\n  prefixSeparator: ': ',\n  maxIssuesInMessage: 99, // I've got 99 problems but the b$tch ain't one\n  unionSeparator: ' or ',\n  issueSeparator: '; ',\n  includePath: true,\n  forceTitleCase: true,\n};\n\nexport function createMessageBuilder(\n  partialOptions: Partial<MessageBuilderOptions> = {}\n): MessageBuilder {\n  const options = {\n    ...defaultMessageBuilderOptions,\n    ...partialOptions,\n  };\n\n  return function messageBuilder(issues) {\n    const message = issues\n      // limit max number of issues printed in the reason section\n      .slice(0, options.maxIssuesInMessage)\n      // format error message\n      .map((issue) => mapIssue(issue, options))\n      // concat as string\n      .join(options.issueSeparator);\n\n    return conditionallyPrefixMessage(message, options);\n  };\n}\n\nfunction mapIssue(\n  issue: zod.$ZodIssue,\n  options: MessageBuilderOptions\n): string {\n  if (issue.code === 'invalid_union' && isNonEmptyArray(issue.errors)) {\n    const individualMessages = issue.errors.map((issues) =>\n      issues\n        .map((subIssue) =>\n          mapIssue(\n            {\n              ...subIssue,\n              path: issue.path.concat(subIssue.path),\n            },\n            options\n          )\n        )\n        .join(options.issueSeparator)\n    );\n\n    // deduplicate messages\n    // and join them with the union separator\n    // to create a single message for the invalid union issue\n    return Array.from(new Set(individualMessages)).join(options.unionSeparator);\n  }\n\n  const buf = [];\n\n  if (options.forceTitleCase) {\n    buf.push(titleCase(issue.message));\n  } else {\n    buf.push(issue.message);\n  }\n\n  pathCondition: if (\n    options.includePath &&\n    issue.path !== undefined &&\n    isNonEmptyArray(issue.path)\n  ) {\n    // handle array indices\n    if (issue.path.length === 1) {\n      const identifier = issue.path[0];\n\n      if (typeof identifier === 'number') {\n        buf.push(` at index ${identifier}`);\n        break pathCondition;\n      }\n    }\n\n    buf.push(` at \"${joinPath(issue.path)}\"`);\n  }\n\n  return buf.join('');\n}\n\nfunction conditionallyPrefixMessage(\n  message: string,\n  options: Pick<MessageBuilderOptions, 'prefix' | 'prefixSeparator'>\n): string {\n  if (options.prefix != null) {\n    if (message.length > 0) {\n      return [options.prefix, message].join(options.prefixSeparator);\n    }\n\n    return options.prefix;\n  }\n\n  if (message.length > 0) {\n    return message;\n  }\n\n  // if both reason and prefix are empty, return default prefix\n  // to avoid having an empty error message\n  return defaultMessageBuilderOptions.prefix;\n}\n","import { isNonEmptyArray } from '../utils/NonEmptyArray.ts';\nimport { fromError } from './fromError.ts';\nimport { isZodErrorLike } from './isZodErrorLike.ts';\nimport {\n  createMessageBuilder,\n  type MessageBuilderOptions,\n  type MessageBuilder,\n} from './MessageBuilder.ts';\nimport { ValidationError } from './ValidationError.ts';\nimport type * as zod from 'zod/v4/core';\n\nexport type ZodError = zod.$ZodError;\n\nexport type FromZodErrorOptions =\n  | {\n      messageBuilder: MessageBuilder;\n    }\n  // maintain backwards compatibility\n  | Partial<MessageBuilderOptions>;\n\nexport function fromZodError(\n  zodError: ZodError,\n  options: FromZodErrorOptions = {}\n): ValidationError {\n  // perform runtime check to ensure the input is a ZodError\n  // why? because people have been historically using this function incorrectly\n  if (!isZodErrorLike(zodError)) {\n    throw new TypeError(\n      `Invalid zodError param; expected instance of ZodError. Did you mean to use the \"${fromError.name}\" method instead?`\n    );\n  }\n\n  return fromZodErrorWithoutRuntimeCheck(zodError, options);\n}\n\nexport function fromZodErrorWithoutRuntimeCheck(\n  zodError: ZodError,\n  options: FromZodErrorOptions = {}\n): ValidationError {\n  const zodIssues = zodError.issues;\n\n  let message: string;\n  if (isNonEmptyArray(zodIssues)) {\n    const messageBuilder = createMessageBuilderFromOptions(options);\n    message = messageBuilder(zodIssues);\n  } else {\n    message = zodError.message;\n  }\n\n  return new ValidationError(message, { cause: zodError });\n}\n\nfunction createMessageBuilderFromOptions(\n  options: FromZodErrorOptions\n): MessageBuilder {\n  if ('messageBuilder' in options) {\n    return options.messageBuilder;\n  }\n\n  return createMessageBuilder(options);\n}\n","import { ValidationError } from './ValidationError.ts';\nimport { isZodErrorLike } from './isZodErrorLike.ts';\nimport {\n  fromZodErrorWithoutRuntimeCheck,\n  type FromZodErrorOptions,\n} from './fromZodError.ts';\n\nexport const toValidationError =\n  (options: FromZodErrorOptions = {}) =>\n  (err: unknown): ValidationError => {\n    if (isZodErrorLike(err)) {\n      return fromZodErrorWithoutRuntimeCheck(err, options);\n    }\n\n    if (err instanceof Error) {\n      return new ValidationError(err.message, { cause: err });\n    }\n\n    return new ValidationError('Unknown error');\n  };\n","import { toValidationError } from './toValidationError.ts';\nimport type { FromZodErrorOptions } from './fromZodError.ts';\nimport type { ValidationError } from './ValidationError.ts';\n\n/**\n * This function is a non-curried version of `toValidationError`\n */\nexport function fromError(\n  err: unknown,\n  options: FromZodErrorOptions = {}\n): ValidationError {\n  return toValidationError(options)(err);\n}\n","import * as zod from 'zod/v4/core';\n\nimport {\n  type MessageBuilder,\n  type MessageBuilderOptions,\n  type ZodIssue,\n  createMessageBuilder,\n} from './MessageBuilder.ts';\nimport { ValidationError } from './ValidationError.ts';\n\nexport type FromZodIssueOptions =\n  | {\n      messageBuilder: MessageBuilder;\n    }\n  // maintain backwards compatibility\n  | Partial<Omit<MessageBuilderOptions, 'maxIssuesInMessage'>>;\n\nexport function fromZodIssue(\n  issue: ZodIssue,\n  options: FromZodIssueOptions = {}\n): ValidationError {\n  const messageBuilder = createMessageBuilderFromOptions(options);\n  const message = messageBuilder([issue]);\n\n  return new ValidationError(message, {\n    cause: new zod.$ZodRealError([issue]),\n  });\n}\n\nfunction createMessageBuilderFromOptions(\n  options: FromZodIssueOptions\n): MessageBuilder {\n  if ('messageBuilder' in options) {\n    return options.messageBuilder;\n  }\n\n  return createMessageBuilder(options);\n}\n"],"mappings":"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","names":["createMessageBuilderFromOptions"]}

gui/frontend/node_modules/zod-validation-error/v4/index.mjs

@@ -0,0 +1,679 @@
+// lib/v4/isZodErrorLike.ts
+function isZodErrorLike(err) {
+  return err instanceof Object && "name" in err && (err.name === "ZodError" || err.name === "$ZodError") && "issues" in err && Array.isArray(err.issues);
+}
+
+// lib/v4/ValidationError.ts
+var ZOD_VALIDATION_ERROR_NAME = "ZodValidationError";
+var ValidationError = class extends Error {
+  name;
+  details;
+  constructor(message, options) {
+    super(message, options);
+    this.name = ZOD_VALIDATION_ERROR_NAME;
+    this.details = getIssuesFromErrorOptions(options);
+  }
+  toString() {
+    return this.message;
+  }
+};
+function getIssuesFromErrorOptions(options) {
+  if (options) {
+    const cause = options.cause;
+    if (isZodErrorLike(cause)) {
+      return cause.issues;
+    }
+  }
+  return [];
+}
+
+// lib/v4/isValidationError.ts
+function isValidationError(err) {
+  return err instanceof ValidationError;
+}
+
+// lib/v4/isValidationErrorLike.ts
+function isValidationErrorLike(err) {
+  return err instanceof Error && err.name === ZOD_VALIDATION_ERROR_NAME;
+}
+
+// lib/v4/errorMap/custom.ts
+function parseCustomIssue(issue) {
+  return {
+    type: issue.code,
+    path: issue.path,
+    message: issue.message ?? "Invalid input"
+  };
+}
+
+// lib/v4/errorMap/invalidElement.ts
+function parseInvalidElementIssue(issue) {
+  return {
+    type: issue.code,
+    path: issue.path,
+    message: `unexpected element in ${issue.origin}`
+  };
+}
+
+// lib/v4/errorMap/invalidKey.ts
+function parseInvalidKeyIssue(issue) {
+  return {
+    type: issue.code,
+    path: issue.path,
+    message: `unexpected key in ${issue.origin}`
+  };
+}
+
+// lib/v4/errorMap/invalidStringFormat.ts
+function parseInvalidStringFormatIssue(issue, options = {
+  displayInvalidFormatDetails: false
+}) {
+  switch (issue.format) {
+    case "lowercase":
+    case "uppercase":
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `value must be in ${issue.format} format`
+      };
+    default: {
+      if (isZodIssueStringStartsWith(issue)) {
+        return parseStringStartsWith(issue);
+      }
+      if (isZodIssueStringEndsWith(issue)) {
+        return parseStringEndsWith(issue);
+      }
+      if (isZodIssueStringIncludes(issue)) {
+        return parseStringIncludes(issue);
+      }
+      if (isZodIssueStringInvalidRegex(issue)) {
+        return parseStringInvalidRegex(issue, options);
+      }
+      if (isZodIssueStringInvalidJWT(issue)) {
+        return parseStringInvalidJWT(issue, options);
+      }
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `invalid ${issue.format}`
+      };
+    }
+  }
+}
+function isZodIssueStringStartsWith(issue) {
+  return issue.format === "starts_with";
+}
+function parseStringStartsWith(issue) {
+  return {
+    type: issue.code,
+    path: issue.path,
+    message: `value must start with "${issue.prefix}"`
+  };
+}
+function isZodIssueStringEndsWith(issue) {
+  return issue.format === "ends_with";
+}
+function parseStringEndsWith(issue) {
+  return {
+    type: issue.code,
+    path: issue.path,
+    message: `value must end with "${issue.suffix}"`
+  };
+}
+function isZodIssueStringIncludes(issue) {
+  return issue.format === "includes";
+}
+function parseStringIncludes(issue) {
+  return {
+    type: issue.code,
+    path: issue.path,
+    message: `value must include "${issue.includes}"`
+  };
+}
+function isZodIssueStringInvalidRegex(issue) {
+  return issue.format === "regex";
+}
+function parseStringInvalidRegex(issue, options = {
+  displayInvalidFormatDetails: false
+}) {
+  let message = "value must match pattern";
+  if (options.displayInvalidFormatDetails) {
+    message += ` "${issue.pattern}"`;
+  }
+  return {
+    type: issue.code,
+    path: issue.path,
+    message
+  };
+}
+function isZodIssueStringInvalidJWT(issue) {
+  return issue.format === "jwt";
+}
+function parseStringInvalidJWT(issue, options = {
+  displayInvalidFormatDetails: false
+}) {
+  return {
+    type: issue.code,
+    path: issue.path,
+    message: options.displayInvalidFormatDetails && issue.algorithm ? `invalid jwt/${issue.algorithm}` : `invalid jwt`
+  };
+}
+
+// lib/v4/errorMap/invalidType.ts
+function parseInvalidTypeIssue(issue) {
+  let message = `expected ${issue.expected}`;
+  if ("input" in issue) {
+    message += `, received ${getTypeName(issue.input)}`;
+  }
+  return {
+    type: issue.code,
+    path: issue.path,
+    message
+  };
+}
+function getTypeName(value) {
+  if (typeof value === "object") {
+    if (value === null) {
+      return "null";
+    }
+    if (value === void 0) {
+      return "undefined";
+    }
+    if (Array.isArray(value)) {
+      return "array";
+    }
+    if (value instanceof Date) {
+      return "date";
+    }
+    if (value instanceof RegExp) {
+      return "regexp";
+    }
+    if (value instanceof Map) {
+      return "map";
+    }
+    if (value instanceof Set) {
+      return "set";
+    }
+    if (value instanceof Error) {
+      return "error";
+    }
+    if (value instanceof Function) {
+      return "function";
+    }
+    return "object";
+  }
+  return typeof value;
+}
+
+// lib/v4/errorMap/invalidUnion.ts
+function parseInvalidUnionIssue(issue) {
+  return {
+    type: issue.code,
+    path: issue.path,
+    message: issue.message ?? "Invalid input"
+  };
+}
+
+// lib/utils/stringify.ts
+function stringifySymbol(symbol) {
+  return symbol.description ?? "";
+}
+function stringify(value, options = {}) {
+  switch (typeof value) {
+    case "symbol":
+      return stringifySymbol(value);
+    case "bigint":
+    case "number": {
+      switch (options.localization) {
+        case true:
+          return value.toLocaleString();
+        case false:
+          return value.toString();
+        default:
+          return value.toLocaleString(options.localization);
+      }
+    }
+    case "string": {
+      if (options.wrapStringValueInQuote) {
+        return `"${value}"`;
+      }
+      return value;
+    }
+    default: {
+      if (value instanceof Date) {
+        switch (options.localization) {
+          case true:
+            return value.toLocaleString();
+          case false:
+            return value.toISOString();
+          default:
+            return value.toLocaleString(options.localization);
+        }
+      }
+      return String(value);
+    }
+  }
+}
+
+// lib/utils/joinValues.ts
+function joinValues(values, options) {
+  const valuesToDisplay = (options.maxValuesToDisplay ? values.slice(0, options.maxValuesToDisplay) : values).map((value) => {
+    return stringify(value, {
+      wrapStringValueInQuote: options.wrapStringValuesInQuote
+    });
+  });
+  if (valuesToDisplay.length < values.length) {
+    valuesToDisplay.push(
+      `${values.length - valuesToDisplay.length} more value(s)`
+    );
+  }
+  return valuesToDisplay.reduce((acc, value, index) => {
+    if (index > 0) {
+      if (index === valuesToDisplay.length - 1 && options.lastSeparator) {
+        acc += options.lastSeparator;
+      } else {
+        acc += options.separator;
+      }
+    }
+    acc += value;
+    return acc;
+  }, "");
+}
+
+// lib/v4/errorMap/invalidValue.ts
+function parseInvalidValueIssue(issue, options) {
+  let message;
+  if (issue.values.length === 0) {
+    message = "invalid value";
+  } else if (issue.values.length === 1) {
+    const valueStr = stringify(issue.values[0], {
+      wrapStringValueInQuote: true
+    });
+    message = `expected value to be ${valueStr}`;
+  } else {
+    const valuesStr = joinValues(issue.values, {
+      separator: options.allowedValuesSeparator,
+      lastSeparator: options.allowedValuesLastSeparator,
+      wrapStringValuesInQuote: options.wrapAllowedValuesInQuote,
+      maxValuesToDisplay: options.maxAllowedValuesToDisplay
+    });
+    message = `expected value to be one of ${valuesStr}`;
+  }
+  return {
+    type: issue.code,
+    path: issue.path,
+    message
+  };
+}
+
+// lib/v4/errorMap/notMultipleOf.ts
+function parseNotMultipleOfIssue(issue) {
+  return {
+    type: issue.code,
+    path: issue.path,
+    message: `expected multiple of ${issue.divisor}`
+  };
+}
+
+// lib/v4/errorMap/tooBig.ts
+function parseTooBigIssue(issue, options) {
+  const maxValueStr = issue.origin === "date" ? stringify(new Date(issue.maximum), {
+    localization: options.dateLocalization
+  }) : stringify(issue.maximum, {
+    localization: options.numberLocalization
+  });
+  switch (issue.origin) {
+    case "number":
+    case "int":
+    case "bigint": {
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `number must be less than${issue.inclusive ? " or equal to" : ""} ${maxValueStr}`
+      };
+    }
+    case "string": {
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `string must contain at most ${maxValueStr} character(s)`
+      };
+    }
+    case "date": {
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `date must be ${issue.inclusive ? "prior or equal to" : "prior to"} "${maxValueStr}"`
+      };
+    }
+    case "array": {
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `array must contain at most ${maxValueStr} item(s)`
+      };
+    }
+    case "set": {
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `set must contain at most ${maxValueStr} item(s)`
+      };
+    }
+    case "file": {
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `file must not exceed ${maxValueStr} byte(s) in size`
+      };
+    }
+    default:
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `value must be less than${issue.inclusive ? " or equal to" : ""} ${maxValueStr}`
+      };
+  }
+}
+
+// lib/v4/errorMap/tooSmall.ts
+function parseTooSmallIssue(issue, options) {
+  const minValueStr = issue.origin === "date" ? stringify(new Date(issue.minimum), {
+    localization: options.dateLocalization
+  }) : stringify(issue.minimum, {
+    localization: options.numberLocalization
+  });
+  switch (issue.origin) {
+    case "number":
+    case "int":
+    case "bigint": {
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `number must be greater than${issue.inclusive ? " or equal to" : ""} ${minValueStr}`
+      };
+    }
+    case "date": {
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `date must be ${issue.inclusive ? "later or equal to" : "later to"} "${minValueStr}"`
+      };
+    }
+    case "string": {
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `string must contain at least ${minValueStr} character(s)`
+      };
+    }
+    case "array": {
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `array must contain at least ${minValueStr} item(s)`
+      };
+    }
+    case "set": {
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `set must contain at least ${minValueStr} item(s)`
+      };
+    }
+    case "file": {
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `file must be at least ${minValueStr} byte(s) in size`
+      };
+    }
+    default:
+      return {
+        type: issue.code,
+        path: issue.path,
+        message: `value must be greater than${issue.inclusive ? " or equal to" : ""} ${minValueStr}`
+      };
+  }
+}
+
+// lib/v4/errorMap/unrecognizedKeys.ts
+function parseUnrecognizedKeysIssue(issue, options) {
+  const keysStr = joinValues(issue.keys, {
+    separator: options.unrecognizedKeysSeparator,
+    lastSeparator: options.unrecognizedKeysLastSeparator,
+    wrapStringValuesInQuote: options.wrapUnrecognizedKeysInQuote,
+    maxValuesToDisplay: options.maxUnrecognizedKeysToDisplay
+  });
+  return {
+    type: issue.code,
+    path: issue.path,
+    message: `unrecognized key(s) ${keysStr} in object`
+  };
+}
+
+// lib/v4/errorMap/errorMap.ts
+var issueParsers = {
+  invalid_type: parseInvalidTypeIssue,
+  too_big: parseTooBigIssue,
+  too_small: parseTooSmallIssue,
+  invalid_format: parseInvalidStringFormatIssue,
+  invalid_value: parseInvalidValueIssue,
+  invalid_element: parseInvalidElementIssue,
+  not_multiple_of: parseNotMultipleOfIssue,
+  unrecognized_keys: parseUnrecognizedKeysIssue,
+  invalid_key: parseInvalidKeyIssue,
+  custom: parseCustomIssue,
+  invalid_union: parseInvalidUnionIssue
+};
+var defaultErrorMapOptions = {
+  displayInvalidFormatDetails: false,
+  allowedValuesSeparator: ", ",
+  allowedValuesLastSeparator: " or ",
+  wrapAllowedValuesInQuote: true,
+  maxAllowedValuesToDisplay: 10,
+  unrecognizedKeysSeparator: ", ",
+  unrecognizedKeysLastSeparator: " and ",
+  wrapUnrecognizedKeysInQuote: true,
+  maxUnrecognizedKeysToDisplay: 5,
+  dateLocalization: true,
+  numberLocalization: true
+};
+function createErrorMap(partialOptions = {}) {
+  const options = {
+    ...defaultErrorMapOptions,
+    ...partialOptions
+  };
+  const errorMap = (issue) => {
+    if (issue.code === void 0) {
+      return "Not supported issue type";
+    }
+    const parseFunc = issueParsers[issue.code];
+    const ast = parseFunc(issue, options);
+    return ast.message;
+  };
+  return errorMap;
+}
+
+// lib/utils/NonEmptyArray.ts
+function isNonEmptyArray(value) {
+  return value.length !== 0;
+}
+
+// lib/utils/joinPath.ts
+var identifierRegex = /[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*/u;
+function joinPath(path) {
+  if (path.length === 1) {
+    let propertyKey = path[0];
+    if (typeof propertyKey === "symbol") {
+      propertyKey = stringifySymbol(propertyKey);
+    }
+    return propertyKey.toString() || '""';
+  }
+  return path.reduce((acc, propertyKey) => {
+    if (typeof propertyKey === "number") {
+      return acc + "[" + propertyKey.toString() + "]";
+    }
+    if (typeof propertyKey === "symbol") {
+      propertyKey = stringifySymbol(propertyKey);
+    }
+    if (propertyKey.includes('"')) {
+      return acc + '["' + escapeQuotes(propertyKey) + '"]';
+    }
+    if (!identifierRegex.test(propertyKey)) {
+      return acc + '["' + propertyKey + '"]';
+    }
+    const separator = acc.length === 0 ? "" : ".";
+    return acc + separator + propertyKey;
+  }, "");
+}
+function escapeQuotes(str) {
+  return str.replace(/"/g, '\\"');
+}
+
+// lib/utils/titleCase.ts
+function titleCase(value) {
+  if (value.length === 0) {
+    return value;
+  }
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+// lib/v4/MessageBuilder.ts
+var defaultMessageBuilderOptions = {
+  prefix: "Validation error",
+  prefixSeparator: ": ",
+  maxIssuesInMessage: 99,
+  // I've got 99 problems but the b$tch ain't one
+  unionSeparator: " or ",
+  issueSeparator: "; ",
+  includePath: true,
+  forceTitleCase: true
+};
+function createMessageBuilder(partialOptions = {}) {
+  const options = {
+    ...defaultMessageBuilderOptions,
+    ...partialOptions
+  };
+  return function messageBuilder(issues) {
+    const message = issues.slice(0, options.maxIssuesInMessage).map((issue) => mapIssue(issue, options)).join(options.issueSeparator);
+    return conditionallyPrefixMessage(message, options);
+  };
+}
+function mapIssue(issue, options) {
+  if (issue.code === "invalid_union" && isNonEmptyArray(issue.errors)) {
+    const individualMessages = issue.errors.map(
+      (issues) => issues.map(
+        (subIssue) => mapIssue(
+          {
+            ...subIssue,
+            path: issue.path.concat(subIssue.path)
+          },
+          options
+        )
+      ).join(options.issueSeparator)
+    );
+    return Array.from(new Set(individualMessages)).join(options.unionSeparator);
+  }
+  const buf = [];
+  if (options.forceTitleCase) {
+    buf.push(titleCase(issue.message));
+  } else {
+    buf.push(issue.message);
+  }
+  pathCondition: if (options.includePath && issue.path !== void 0 && isNonEmptyArray(issue.path)) {
+    if (issue.path.length === 1) {
+      const identifier = issue.path[0];
+      if (typeof identifier === "number") {
+        buf.push(` at index ${identifier}`);
+        break pathCondition;
+      }
+    }
+    buf.push(` at "${joinPath(issue.path)}"`);
+  }
+  return buf.join("");
+}
+function conditionallyPrefixMessage(message, options) {
+  if (options.prefix != null) {
+    if (message.length > 0) {
+      return [options.prefix, message].join(options.prefixSeparator);
+    }
+    return options.prefix;
+  }
+  if (message.length > 0) {
+    return message;
+  }
+  return defaultMessageBuilderOptions.prefix;
+}
+
+// lib/v4/fromZodError.ts
+function fromZodError(zodError, options = {}) {
+  if (!isZodErrorLike(zodError)) {
+    throw new TypeError(
+      `Invalid zodError param; expected instance of ZodError. Did you mean to use the "${fromError.name}" method instead?`
+    );
+  }
+  return fromZodErrorWithoutRuntimeCheck(zodError, options);
+}
+function fromZodErrorWithoutRuntimeCheck(zodError, options = {}) {
+  const zodIssues = zodError.issues;
+  let message;
+  if (isNonEmptyArray(zodIssues)) {
+    const messageBuilder = createMessageBuilderFromOptions(options);
+    message = messageBuilder(zodIssues);
+  } else {
+    message = zodError.message;
+  }
+  return new ValidationError(message, { cause: zodError });
+}
+function createMessageBuilderFromOptions(options) {
+  if ("messageBuilder" in options) {
+    return options.messageBuilder;
+  }
+  return createMessageBuilder(options);
+}
+
+// lib/v4/toValidationError.ts
+var toValidationError = (options = {}) => (err) => {
+  if (isZodErrorLike(err)) {
+    return fromZodErrorWithoutRuntimeCheck(err, options);
+  }
+  if (err instanceof Error) {
+    return new ValidationError(err.message, { cause: err });
+  }
+  return new ValidationError("Unknown error");
+};
+
+// lib/v4/fromError.ts
+function fromError(err, options = {}) {
+  return toValidationError(options)(err);
+}
+
+// lib/v4/fromZodIssue.ts
+import * as zod from "zod/v4/core";
+function fromZodIssue(issue, options = {}) {
+  const messageBuilder = createMessageBuilderFromOptions2(options);
+  const message = messageBuilder([issue]);
+  return new ValidationError(message, {
+    cause: new zod.$ZodRealError([issue])
+  });
+}
+function createMessageBuilderFromOptions2(options) {
+  if ("messageBuilder" in options) {
+    return options.messageBuilder;
+  }
+  return createMessageBuilder(options);
+}
+export {
+  ValidationError,
+  createErrorMap,
+  createMessageBuilder,
+  fromError,
+  fromZodError,
+  fromZodIssue,
+  isValidationError,
+  isValidationErrorLike,
+  isZodErrorLike,
+  toValidationError
+};
+//# sourceMappingURL=index.mjs.map

gui/frontend/node_modules/zod-validation-error/v4/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../lib/v4/isZodErrorLike.ts","../lib/v4/ValidationError.ts","../lib/v4/isValidationError.ts","../lib/v4/isValidationErrorLike.ts","../lib/v4/errorMap/custom.ts","../lib/v4/errorMap/invalidElement.ts","../lib/v4/errorMap/invalidKey.ts","../lib/v4/errorMap/invalidStringFormat.ts","../lib/v4/errorMap/invalidType.ts","../lib/v4/errorMap/invalidUnion.ts","../lib/utils/stringify.ts","../lib/utils/joinValues.ts","../lib/v4/errorMap/invalidValue.ts","../lib/v4/errorMap/notMultipleOf.ts","../lib/v4/errorMap/tooBig.ts","../lib/v4/errorMap/tooSmall.ts","../lib/v4/errorMap/unrecognizedKeys.ts","../lib/v4/errorMap/errorMap.ts","../lib/utils/NonEmptyArray.ts","../lib/utils/joinPath.ts","../lib/utils/titleCase.ts","../lib/v4/MessageBuilder.ts","../lib/v4/fromZodError.ts","../lib/v4/toValidationError.ts","../lib/v4/fromError.ts","../lib/v4/fromZodIssue.ts"],"sourcesContent":["import type * as zod from 'zod/v4/core';\n\nexport function isZodErrorLike(err: unknown): err is zod.$ZodError {\n  return (\n    err instanceof Object &&\n    'name' in err &&\n    (err.name === 'ZodError' || err.name === '$ZodError') &&\n    'issues' in err &&\n    Array.isArray(err.issues)\n  );\n}\n","import { isZodErrorLike } from './isZodErrorLike.ts';\nimport type * as zod from 'zod/v4/core';\n\nexport const ZOD_VALIDATION_ERROR_NAME = 'ZodValidationError';\n\n// make zod-validation-error compatible with\n// earlier to es2022 typescript configurations\n// @see https://github.com/causaly/zod-validation-error/issues/226\nexport interface ErrorOptions {\n  cause?: unknown;\n}\n\nexport class ValidationError extends Error {\n  name: typeof ZOD_VALIDATION_ERROR_NAME;\n  details: Array<zod.$ZodIssue>;\n\n  constructor(message?: string, options?: ErrorOptions) {\n    super(message, options);\n    this.name = ZOD_VALIDATION_ERROR_NAME;\n    this.details = getIssuesFromErrorOptions(options);\n  }\n\n  toString(): string {\n    return this.message;\n  }\n}\n\nfunction getIssuesFromErrorOptions(\n  options?: ErrorOptions\n): Array<zod.$ZodIssue> {\n  if (options) {\n    const cause = options.cause;\n    if (isZodErrorLike(cause)) {\n      return cause.issues;\n    }\n  }\n\n  return [];\n}\n","import { ValidationError } from './ValidationError.ts';\n\nexport function isValidationError(err: unknown): err is ValidationError {\n  return err instanceof ValidationError;\n}\n","import {\n  ZOD_VALIDATION_ERROR_NAME,\n  type ValidationError,\n} from './ValidationError.ts';\n\nexport function isValidationErrorLike(err: unknown): err is ValidationError {\n  return err instanceof Error && err.name === ZOD_VALIDATION_ERROR_NAME;\n}\n","import type * as zod from 'zod/v4/core';\nimport type { AbstractSyntaxTree } from './types.ts';\n\nexport function parseCustomIssue(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueCustom>\n): AbstractSyntaxTree {\n  return {\n    type: issue.code,\n    path: issue.path,\n    message: issue.message ?? 'Invalid input',\n  };\n}\n","import type * as zod from 'zod/v4/core';\nimport type { AbstractSyntaxTree } from './types.ts';\n\nexport function parseInvalidElementIssue(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueInvalidElement>\n): AbstractSyntaxTree {\n  return {\n    type: issue.code,\n    path: issue.path,\n    message: `unexpected element in ${issue.origin}`,\n  };\n}\n","import type * as zod from 'zod/v4/core';\nimport type { AbstractSyntaxTree } from './types.ts';\n\nexport function parseInvalidKeyIssue(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueInvalidKey>\n): AbstractSyntaxTree {\n  return {\n    type: issue.code,\n    path: issue.path,\n    message: `unexpected key in ${issue.origin}`,\n  };\n}\n","import type { AbstractSyntaxTree, ErrorMapOptions } from './types.ts';\nimport type * as zod from 'zod/v4/core';\n\nexport function parseInvalidStringFormatIssue(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueInvalidStringFormat>,\n  options: Pick<ErrorMapOptions, 'displayInvalidFormatDetails'> = {\n    displayInvalidFormatDetails: false,\n  }\n): AbstractSyntaxTree {\n  switch (issue.format) {\n    case 'lowercase':\n    case 'uppercase':\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `value must be in ${issue.format} format`,\n      };\n    default: {\n      if (isZodIssueStringStartsWith(issue)) {\n        return parseStringStartsWith(issue);\n      }\n      if (isZodIssueStringEndsWith(issue)) {\n        return parseStringEndsWith(issue);\n      }\n      if (isZodIssueStringIncludes(issue)) {\n        return parseStringIncludes(issue);\n      }\n      if (isZodIssueStringInvalidRegex(issue)) {\n        return parseStringInvalidRegex(issue, options);\n      }\n      if (isZodIssueStringInvalidJWT(issue)) {\n        return parseStringInvalidJWT(issue, options);\n      }\n\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `invalid ${issue.format}`,\n      };\n    }\n  }\n}\nfunction isZodIssueStringStartsWith(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueInvalidStringFormat>\n): issue is zod.$ZodRawIssue<zod.$ZodIssueStringStartsWith> {\n  return issue.format === 'starts_with';\n}\n\nfunction parseStringStartsWith(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueStringStartsWith>\n): AbstractSyntaxTree {\n  return {\n    type: issue.code,\n    path: issue.path,\n    message: `value must start with \"${issue.prefix}\"`,\n  };\n}\n\nfunction isZodIssueStringEndsWith(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueInvalidStringFormat>\n): issue is zod.$ZodRawIssue<zod.$ZodIssueStringEndsWith> {\n  return issue.format === 'ends_with';\n}\nfunction parseStringEndsWith(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueStringEndsWith>\n): AbstractSyntaxTree {\n  return {\n    type: issue.code,\n    path: issue.path,\n    message: `value must end with \"${issue.suffix}\"`,\n  };\n}\n\nfunction isZodIssueStringIncludes(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueInvalidStringFormat>\n): issue is zod.$ZodRawIssue<zod.$ZodIssueStringIncludes> {\n  return issue.format === 'includes';\n}\nfunction parseStringIncludes(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueStringIncludes>\n): AbstractSyntaxTree {\n  return {\n    type: issue.code,\n    path: issue.path,\n    message: `value must include \"${issue.includes}\"`,\n  };\n}\n\nfunction isZodIssueStringInvalidRegex(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueInvalidStringFormat>\n): issue is zod.$ZodRawIssue<zod.$ZodIssueStringInvalidRegex> {\n  return issue.format === 'regex';\n}\nfunction parseStringInvalidRegex(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueStringInvalidRegex>,\n  options: Pick<ErrorMapOptions, 'displayInvalidFormatDetails'> = {\n    displayInvalidFormatDetails: false,\n  }\n): AbstractSyntaxTree {\n  let message = 'value must match pattern';\n  if (options.displayInvalidFormatDetails) {\n    message += ` \"${issue.pattern}\"`;\n  }\n\n  return {\n    type: issue.code,\n    path: issue.path,\n    message,\n  };\n}\n\nfunction isZodIssueStringInvalidJWT(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueInvalidStringFormat>\n): issue is zod.$ZodRawIssue<zod.$ZodIssueStringInvalidJWT> {\n  return issue.format === 'jwt';\n}\nfunction parseStringInvalidJWT(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueStringInvalidJWT>,\n  options: Pick<ErrorMapOptions, 'displayInvalidFormatDetails'> = {\n    displayInvalidFormatDetails: false,\n  }\n): AbstractSyntaxTree {\n  return {\n    type: issue.code,\n    path: issue.path,\n    message:\n      options.displayInvalidFormatDetails && issue.algorithm\n        ? `invalid jwt/${issue.algorithm}`\n        : `invalid jwt`,\n  };\n}\n","import type { AbstractSyntaxTree } from './types.ts';\nimport type * as zod from 'zod/v4/core';\n\nexport function parseInvalidTypeIssue(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueInvalidType>\n): AbstractSyntaxTree {\n  let message = `expected ${issue.expected}`;\n\n  // note: it's possible that issue.input is not defined\n  if ('input' in issue) {\n    message += `, received ${getTypeName(issue.input)}`;\n  }\n\n  return {\n    type: issue.code,\n    path: issue.path,\n    message,\n  };\n}\n\nexport function getTypeName(value: unknown): string {\n  if (typeof value === 'object') {\n    if (value === null) {\n      return 'null';\n    }\n    if (value === undefined) {\n      return 'undefined';\n    }\n    if (Array.isArray(value)) {\n      return 'array';\n    }\n    if (value instanceof Date) {\n      return 'date';\n    }\n    if (value instanceof RegExp) {\n      return 'regexp';\n    }\n    if (value instanceof Map) {\n      return 'map';\n    }\n    if (value instanceof Set) {\n      return 'set';\n    }\n    if (value instanceof Error) {\n      return 'error';\n    }\n    if (value instanceof Function) {\n      return 'function';\n    }\n    return 'object';\n  }\n\n  return typeof value;\n}\n","import type * as zod from 'zod/v4/core';\nimport type { AbstractSyntaxTree } from './types.ts';\n\nexport function parseInvalidUnionIssue(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueInvalidUnion>\n): AbstractSyntaxTree {\n  return {\n    type: issue.code,\n    path: issue.path,\n    message: issue.message ?? 'Invalid input',\n  };\n}\n","import type { util } from 'zod/v4/core';\n\nexport function stringifySymbol(symbol: symbol): string {\n  return symbol.description ?? '';\n}\n\nexport type StringifyValueOptions = {\n  wrapStringValueInQuote?: boolean;\n  localization?: boolean | Intl.LocalesArgument;\n};\n\nexport function stringify(\n  value: util.Primitive | Date,\n  options: StringifyValueOptions = {}\n): string {\n  switch (typeof value) {\n    case 'symbol':\n      return stringifySymbol(value);\n    case 'bigint':\n    case 'number': {\n      switch (options.localization) {\n        case true:\n          return value.toLocaleString();\n        case false:\n          return value.toString();\n        default:\n          return value.toLocaleString(options.localization);\n      }\n    }\n    case 'string': {\n      if (options.wrapStringValueInQuote) {\n        return `\"${value}\"`;\n      }\n      return value;\n    }\n    default: {\n      if (value instanceof Date) {\n        switch (options.localization) {\n          case true:\n            return value.toLocaleString();\n          case false:\n            return value.toISOString();\n          default:\n            return value.toLocaleString(options.localization);\n        }\n      }\n      return String(value);\n    }\n  }\n}\n","import { stringify } from './stringify.ts';\nimport type { util } from 'zod/v4/core';\n\nexport type JoinValuesOptions = {\n  separator: string;\n  lastSeparator?: string;\n  wrapStringValuesInQuote?: boolean;\n  maxValuesToDisplay?: number;\n};\n\nexport function joinValues(\n  values: Array<util.Primitive>,\n  options: JoinValuesOptions\n): string {\n  const valuesToDisplay = (\n    options.maxValuesToDisplay\n      ? values.slice(0, options.maxValuesToDisplay)\n      : values\n  ).map((value) => {\n    return stringify(value, {\n      wrapStringValueInQuote: options.wrapStringValuesInQuote,\n    });\n  });\n\n  // add remaining values count (if any)\n  // this is to avoid displaying too many values in the error message\n  // and to keep the message concise\n  // e.g. `\"foo\", \"bar\", \"baz\" or 3 more value(s)`\n  if (valuesToDisplay.length < values.length) {\n    valuesToDisplay.push(\n      `${values.length - valuesToDisplay.length} more value(s)`\n    );\n  }\n\n  return valuesToDisplay.reduce<string>((acc, value, index) => {\n    if (index > 0) {\n      if (index === valuesToDisplay.length - 1 && options.lastSeparator) {\n        acc += options.lastSeparator;\n      } else {\n        acc += options.separator;\n      }\n    }\n\n    acc += value;\n\n    return acc;\n  }, '');\n}\n","import { joinValues } from '../../utils/joinValues.ts';\nimport { stringify } from '../../utils/stringify.ts';\nimport type { AbstractSyntaxTree, ErrorMapOptions } from './types.ts';\nimport type * as zod from 'zod/v4/core';\n\nexport function parseInvalidValueIssue(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueInvalidValue>,\n  options: Pick<\n    ErrorMapOptions,\n    | 'allowedValuesSeparator'\n    | 'maxAllowedValuesToDisplay'\n    | 'wrapAllowedValuesInQuote'\n    | 'allowedValuesLastSeparator'\n  >\n): AbstractSyntaxTree {\n  let message: string;\n\n  if (issue.values.length === 0) {\n    message = 'invalid value';\n  } else if (issue.values.length === 1) {\n    const valueStr = stringify(issue.values[0], {\n      wrapStringValueInQuote: true,\n    });\n    message = `expected value to be ${valueStr}`;\n  } else {\n    const valuesStr = joinValues(issue.values, {\n      separator: options.allowedValuesSeparator,\n      lastSeparator: options.allowedValuesLastSeparator,\n      wrapStringValuesInQuote: options.wrapAllowedValuesInQuote,\n      maxValuesToDisplay: options.maxAllowedValuesToDisplay,\n    });\n    message = `expected value to be one of ${valuesStr}`;\n  }\n\n  return {\n    type: issue.code,\n    path: issue.path,\n    message,\n  };\n}\n","import type * as zod from 'zod/v4/core';\nimport type { AbstractSyntaxTree } from './types.ts';\n\nexport function parseNotMultipleOfIssue(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueNotMultipleOf>\n): AbstractSyntaxTree {\n  return {\n    type: issue.code,\n    path: issue.path,\n    message: `expected multiple of ${issue.divisor}`,\n  };\n}\n","import { stringify } from '../../utils/stringify.ts';\nimport type { AbstractSyntaxTree, ErrorMapOptions } from './types.ts';\nimport type * as zod from 'zod/v4/core';\n\nexport function parseTooBigIssue(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueTooBig>,\n  options: Pick<ErrorMapOptions, 'dateLocalization' | 'numberLocalization'>\n): AbstractSyntaxTree {\n  const maxValueStr =\n    issue.origin === 'date'\n      ? stringify(new Date(issue.maximum as number), {\n          localization: options.dateLocalization,\n        })\n      : stringify(issue.maximum, {\n          localization: options.numberLocalization,\n        });\n\n  switch (issue.origin) {\n    case 'number':\n    case 'int':\n    case 'bigint': {\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `number must be less than${\n          issue.inclusive ? ' or equal to' : ''\n        } ${maxValueStr}`,\n      };\n    }\n    case 'string': {\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `string must contain at most ${maxValueStr} character(s)`,\n      };\n    }\n    case 'date': {\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `date must be ${\n          issue.inclusive ? 'prior or equal to' : 'prior to'\n        } \"${maxValueStr}\"`,\n      };\n    }\n    case 'array': {\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `array must contain at most ${maxValueStr} item(s)`,\n      };\n    }\n    case 'set': {\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `set must contain at most ${maxValueStr} item(s)`,\n      };\n    }\n    case 'file': {\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `file must not exceed ${maxValueStr} byte(s) in size`,\n      };\n    }\n    default:\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `value must be less than${\n          issue.inclusive ? ' or equal to' : ''\n        } ${maxValueStr}`,\n      };\n  }\n}\n","import { stringify } from '../../utils/stringify.ts';\nimport type * as zod from 'zod/v4/core';\nimport type { AbstractSyntaxTree, ErrorMapOptions } from './types.ts';\n\nexport function parseTooSmallIssue(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueTooSmall>,\n  options: Pick<ErrorMapOptions, 'dateLocalization' | 'numberLocalization'>\n): AbstractSyntaxTree {\n  const minValueStr =\n    issue.origin === 'date'\n      ? stringify(new Date(issue.minimum as number), {\n          localization: options.dateLocalization,\n        })\n      : stringify(issue.minimum, {\n          localization: options.numberLocalization,\n        });\n\n  switch (issue.origin) {\n    case 'number':\n    case 'int':\n    case 'bigint': {\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `number must be greater than${\n          issue.inclusive ? ' or equal to' : ''\n        } ${minValueStr}`,\n      };\n    }\n    case 'date': {\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `date must be ${\n          issue.inclusive ? 'later or equal to' : 'later to'\n        } \"${minValueStr}\"`,\n      };\n    }\n    case 'string': {\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `string must contain at least ${minValueStr} character(s)`,\n      };\n    }\n    case 'array': {\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `array must contain at least ${minValueStr} item(s)`,\n      };\n    }\n    case 'set': {\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `set must contain at least ${minValueStr} item(s)`,\n      };\n    }\n    case 'file': {\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `file must be at least ${minValueStr} byte(s) in size`,\n      };\n    }\n    default:\n      return {\n        type: issue.code,\n        path: issue.path,\n        message: `value must be greater than${\n          issue.inclusive ? ' or equal to' : ''\n        } ${minValueStr}`,\n      };\n  }\n}\n","import { joinValues } from '../../utils/joinValues.ts';\nimport type * as zod from 'zod/v4/core';\nimport type { AbstractSyntaxTree, ErrorMapOptions } from './types.ts';\n\nexport function parseUnrecognizedKeysIssue(\n  issue: zod.$ZodRawIssue<zod.$ZodIssueUnrecognizedKeys>,\n  options: Pick<\n    ErrorMapOptions,\n    | 'unrecognizedKeysSeparator'\n    | 'unrecognizedKeysLastSeparator'\n    | 'wrapUnrecognizedKeysInQuote'\n    | 'maxUnrecognizedKeysToDisplay'\n  >\n): AbstractSyntaxTree {\n  const keysStr = joinValues(issue.keys, {\n    separator: options.unrecognizedKeysSeparator,\n    lastSeparator: options.unrecognizedKeysLastSeparator,\n    wrapStringValuesInQuote: options.wrapUnrecognizedKeysInQuote,\n    maxValuesToDisplay: options.maxUnrecognizedKeysToDisplay,\n  });\n\n  return {\n    type: issue.code,\n    path: issue.path,\n    message: `unrecognized key(s) ${keysStr} in object`,\n  };\n}\n","import { parseCustomIssue } from './custom.ts';\nimport { parseInvalidElementIssue } from './invalidElement.ts';\nimport { parseInvalidKeyIssue } from './invalidKey.ts';\nimport { parseInvalidStringFormatIssue } from './invalidStringFormat.ts';\nimport { parseInvalidTypeIssue } from './invalidType.ts';\nimport { parseInvalidUnionIssue } from './invalidUnion.ts';\nimport { parseInvalidValueIssue } from './invalidValue.ts';\nimport { parseNotMultipleOfIssue } from './notMultipleOf.ts';\nimport { parseTooBigIssue } from './tooBig.ts';\nimport { parseTooSmallIssue } from './tooSmall.ts';\nimport { parseUnrecognizedKeysIssue } from './unrecognizedKeys.ts';\nimport type {\n  AbstractSyntaxTree,\n  ErrorMapOptions,\n  IssueType,\n} from './types.ts';\nimport type * as zod from 'zod/v4/core';\n\ntype IssueParsers = {\n  [IssueCode in IssueType]: (\n    issue: zod.$ZodRawIssue<Extract<zod.$ZodIssue, { code: IssueCode }>>,\n    options: ErrorMapOptions\n  ) => AbstractSyntaxTree;\n};\n\nconst issueParsers: IssueParsers = {\n  invalid_type: parseInvalidTypeIssue,\n  too_big: parseTooBigIssue,\n  too_small: parseTooSmallIssue,\n  invalid_format: parseInvalidStringFormatIssue,\n  invalid_value: parseInvalidValueIssue,\n  invalid_element: parseInvalidElementIssue,\n  not_multiple_of: parseNotMultipleOfIssue,\n  unrecognized_keys: parseUnrecognizedKeysIssue,\n  invalid_key: parseInvalidKeyIssue,\n  custom: parseCustomIssue,\n  invalid_union: parseInvalidUnionIssue,\n};\n\nexport const defaultErrorMapOptions = {\n  displayInvalidFormatDetails: false,\n  allowedValuesSeparator: ', ',\n  allowedValuesLastSeparator: ' or ',\n  wrapAllowedValuesInQuote: true,\n  maxAllowedValuesToDisplay: 10,\n  unrecognizedKeysSeparator: ', ',\n  unrecognizedKeysLastSeparator: ' and ',\n  wrapUnrecognizedKeysInQuote: true,\n  maxUnrecognizedKeysToDisplay: 5,\n  dateLocalization: true,\n  numberLocalization: true,\n} as const satisfies ErrorMapOptions;\n\nexport function createErrorMap(\n  partialOptions: Partial<ErrorMapOptions> = {}\n): zod.$ZodErrorMap<zod.$ZodIssue> {\n  // fill-in default options\n  const options = {\n    ...defaultErrorMapOptions,\n    ...partialOptions,\n  };\n\n  const errorMap: zod.$ZodErrorMap<zod.$ZodIssue> = (issue) => {\n    if (issue.code === undefined) {\n      // TODO: handle this case\n      return 'Not supported issue type';\n    }\n\n    const parseFunc = issueParsers[issue.code] as (\n      iss: typeof issue,\n      opts: ErrorMapOptions\n    ) => AbstractSyntaxTree;\n    const ast = parseFunc(issue, options);\n    return ast.message;\n  };\n\n  return errorMap;\n}\n","export type NonEmptyArray<T> = [T, ...T[]];\n\nexport function isNonEmptyArray<T>(value: T[]): value is NonEmptyArray<T> {\n  return value.length !== 0;\n}\n","import { stringifySymbol } from './stringify.ts';\nimport type { NonEmptyArray } from './NonEmptyArray.ts';\n\n/**\n * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#identifiers\n */\nconst identifierRegex = /[$_\\p{ID_Start}][$\\u200c\\u200d\\p{ID_Continue}]*/u;\n\nexport function joinPath(path: NonEmptyArray<PropertyKey>): string {\n  if (path.length === 1) {\n    let propertyKey = path[0];\n\n    if (typeof propertyKey === 'symbol') {\n      propertyKey = stringifySymbol(propertyKey);\n    }\n\n    return propertyKey.toString() || '\"\"';\n  }\n\n  return path.reduce<string>((acc, propertyKey) => {\n    // handle numeric indices\n    if (typeof propertyKey === 'number') {\n      return acc + '[' + propertyKey.toString() + ']';\n    }\n\n    // handle symbols\n    if (typeof propertyKey === 'symbol') {\n      propertyKey = stringifySymbol(propertyKey);\n    }\n\n    // handle quoted values\n    if (propertyKey.includes('\"')) {\n      return acc + '[\"' + escapeQuotes(propertyKey) + '\"]';\n    }\n\n    // handle special characters\n    if (!identifierRegex.test(propertyKey)) {\n      return acc + '[\"' + propertyKey + '\"]';\n    }\n\n    // handle normal values\n    const separator = acc.length === 0 ? '' : '.';\n    return acc + separator + propertyKey;\n  }, '');\n}\n\nfunction escapeQuotes(str: string): string {\n  return str.replace(/\"/g, '\\\\\"');\n}\n","export function titleCase(value: string): string {\n  if (value.length === 0) {\n    return value;\n  }\n  return value.charAt(0).toUpperCase() + value.slice(1);\n}\n","import { joinPath } from '../utils/joinPath.ts';\nimport { isNonEmptyArray, type NonEmptyArray } from '../utils/NonEmptyArray.ts';\nimport { titleCase } from '../utils/titleCase.ts';\nimport type * as zod from 'zod/v4/core';\n\nexport type ZodIssue = zod.$ZodIssue;\n\nexport type MessageBuilder = (issues: NonEmptyArray<ZodIssue>) => string;\n\nexport type MessageBuilderOptions = {\n  prefix: string | null | undefined;\n  prefixSeparator: string;\n  maxIssuesInMessage: number;\n  issueSeparator: string;\n  unionSeparator: string;\n  includePath: boolean;\n  forceTitleCase: boolean;\n};\n\nexport const defaultMessageBuilderOptions: MessageBuilderOptions & {\n  prefix: string;\n} = {\n  prefix: 'Validation error',\n  prefixSeparator: ': ',\n  maxIssuesInMessage: 99, // I've got 99 problems but the b$tch ain't one\n  unionSeparator: ' or ',\n  issueSeparator: '; ',\n  includePath: true,\n  forceTitleCase: true,\n};\n\nexport function createMessageBuilder(\n  partialOptions: Partial<MessageBuilderOptions> = {}\n): MessageBuilder {\n  const options = {\n    ...defaultMessageBuilderOptions,\n    ...partialOptions,\n  };\n\n  return function messageBuilder(issues) {\n    const message = issues\n      // limit max number of issues printed in the reason section\n      .slice(0, options.maxIssuesInMessage)\n      // format error message\n      .map((issue) => mapIssue(issue, options))\n      // concat as string\n      .join(options.issueSeparator);\n\n    return conditionallyPrefixMessage(message, options);\n  };\n}\n\nfunction mapIssue(\n  issue: zod.$ZodIssue,\n  options: MessageBuilderOptions\n): string {\n  if (issue.code === 'invalid_union' && isNonEmptyArray(issue.errors)) {\n    const individualMessages = issue.errors.map((issues) =>\n      issues\n        .map((subIssue) =>\n          mapIssue(\n            {\n              ...subIssue,\n              path: issue.path.concat(subIssue.path),\n            },\n            options\n          )\n        )\n        .join(options.issueSeparator)\n    );\n\n    // deduplicate messages\n    // and join them with the union separator\n    // to create a single message for the invalid union issue\n    return Array.from(new Set(individualMessages)).join(options.unionSeparator);\n  }\n\n  const buf = [];\n\n  if (options.forceTitleCase) {\n    buf.push(titleCase(issue.message));\n  } else {\n    buf.push(issue.message);\n  }\n\n  pathCondition: if (\n    options.includePath &&\n    issue.path !== undefined &&\n    isNonEmptyArray(issue.path)\n  ) {\n    // handle array indices\n    if (issue.path.length === 1) {\n      const identifier = issue.path[0];\n\n      if (typeof identifier === 'number') {\n        buf.push(` at index ${identifier}`);\n        break pathCondition;\n      }\n    }\n\n    buf.push(` at \"${joinPath(issue.path)}\"`);\n  }\n\n  return buf.join('');\n}\n\nfunction conditionallyPrefixMessage(\n  message: string,\n  options: Pick<MessageBuilderOptions, 'prefix' | 'prefixSeparator'>\n): string {\n  if (options.prefix != null) {\n    if (message.length > 0) {\n      return [options.prefix, message].join(options.prefixSeparator);\n    }\n\n    return options.prefix;\n  }\n\n  if (message.length > 0) {\n    return message;\n  }\n\n  // if both reason and prefix are empty, return default prefix\n  // to avoid having an empty error message\n  return defaultMessageBuilderOptions.prefix;\n}\n","import { isNonEmptyArray } from '../utils/NonEmptyArray.ts';\nimport { fromError } from './fromError.ts';\nimport { isZodErrorLike } from './isZodErrorLike.ts';\nimport {\n  createMessageBuilder,\n  type MessageBuilderOptions,\n  type MessageBuilder,\n} from './MessageBuilder.ts';\nimport { ValidationError } from './ValidationError.ts';\nimport type * as zod from 'zod/v4/core';\n\nexport type ZodError = zod.$ZodError;\n\nexport type FromZodErrorOptions =\n  | {\n      messageBuilder: MessageBuilder;\n    }\n  // maintain backwards compatibility\n  | Partial<MessageBuilderOptions>;\n\nexport function fromZodError(\n  zodError: ZodError,\n  options: FromZodErrorOptions = {}\n): ValidationError {\n  // perform runtime check to ensure the input is a ZodError\n  // why? because people have been historically using this function incorrectly\n  if (!isZodErrorLike(zodError)) {\n    throw new TypeError(\n      `Invalid zodError param; expected instance of ZodError. Did you mean to use the \"${fromError.name}\" method instead?`\n    );\n  }\n\n  return fromZodErrorWithoutRuntimeCheck(zodError, options);\n}\n\nexport function fromZodErrorWithoutRuntimeCheck(\n  zodError: ZodError,\n  options: FromZodErrorOptions = {}\n): ValidationError {\n  const zodIssues = zodError.issues;\n\n  let message: string;\n  if (isNonEmptyArray(zodIssues)) {\n    const messageBuilder = createMessageBuilderFromOptions(options);\n    message = messageBuilder(zodIssues);\n  } else {\n    message = zodError.message;\n  }\n\n  return new ValidationError(message, { cause: zodError });\n}\n\nfunction createMessageBuilderFromOptions(\n  options: FromZodErrorOptions\n): MessageBuilder {\n  if ('messageBuilder' in options) {\n    return options.messageBuilder;\n  }\n\n  return createMessageBuilder(options);\n}\n","import { ValidationError } from './ValidationError.ts';\nimport { isZodErrorLike } from './isZodErrorLike.ts';\nimport {\n  fromZodErrorWithoutRuntimeCheck,\n  type FromZodErrorOptions,\n} from './fromZodError.ts';\n\nexport const toValidationError =\n  (options: FromZodErrorOptions = {}) =>\n  (err: unknown): ValidationError => {\n    if (isZodErrorLike(err)) {\n      return fromZodErrorWithoutRuntimeCheck(err, options);\n    }\n\n    if (err instanceof Error) {\n      return new ValidationError(err.message, { cause: err });\n    }\n\n    return new ValidationError('Unknown error');\n  };\n","import { toValidationError } from './toValidationError.ts';\nimport type { FromZodErrorOptions } from './fromZodError.ts';\nimport type { ValidationError } from './ValidationError.ts';\n\n/**\n * This function is a non-curried version of `toValidationError`\n */\nexport function fromError(\n  err: unknown,\n  options: FromZodErrorOptions = {}\n): ValidationError {\n  return toValidationError(options)(err);\n}\n","import * as zod from 'zod/v4/core';\n\nimport {\n  type MessageBuilder,\n  type MessageBuilderOptions,\n  type ZodIssue,\n  createMessageBuilder,\n} from './MessageBuilder.ts';\nimport { ValidationError } from './ValidationError.ts';\n\nexport type FromZodIssueOptions =\n  | {\n      messageBuilder: MessageBuilder;\n    }\n  // maintain backwards compatibility\n  | Partial<Omit<MessageBuilderOptions, 'maxIssuesInMessage'>>;\n\nexport function fromZodIssue(\n  issue: ZodIssue,\n  options: FromZodIssueOptions = {}\n): ValidationError {\n  const messageBuilder = createMessageBuilderFromOptions(options);\n  const message = messageBuilder([issue]);\n\n  return new ValidationError(message, {\n    cause: new zod.$ZodRealError([issue]),\n  });\n}\n\nfunction createMessageBuilderFromOptions(\n  options: FromZodIssueOptions\n): MessageBuilder {\n  if ('messageBuilder' in options) {\n    return options.messageBuilder;\n  }\n\n  return createMessageBuilder(options);\n}\n"],"mappings":"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","names":["createMessageBuilderFromOptions"]}

gui/frontend/node_modules/zod/src/v4-mini/index.ts

@@ -0,0 +1,3 @@
+import * as z from "../v4/mini/external.js";
+export * from "../v4/mini/external.js";
+export { z };

gui/frontend/node_modules/zod/src/v4/core/tests/index.test.ts

@@ -0,0 +1,46 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/v3";
+
+test("test", () => {
+  expect(true).toBe(true);
+});
+
+test("test2", () => {
+  expect(() => z.string().parse(234)).toThrowErrorMatchingInlineSnapshot(`
+    [ZodError: [
+      {
+        "code": "invalid_type",
+        "expected": "string",
+        "received": "number",
+        "path": [],
+        "message": "Expected string, received number"
+      }
+    ]]
+  `);
+});
+
+test("async validation", async () => {
+  const testTuple = z
+    .tuple([z.string().refine(async () => true), z.number().refine(async () => true)])
+    .refine(async () => true);
+  expectTypeOf<typeof testTuple._output>().toEqualTypeOf<[string, number]>();
+
+  const val = await testTuple.parseAsync(["asdf", 1234]);
+  expect(val).toEqual(val);
+
+  const r1 = await testTuple.safeParseAsync(["asdf", "asdf"]);
+  expect(r1.success).toEqual(false);
+  expect(r1.error!).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "code": "invalid_type",
+        "expected": "number",
+        "received": "string",
+        "path": [
+          1
+        ],
+        "message": "Expected number, received string"
+      }
+    ]]
+  `);
+});

gui/frontend/node_modules/zod/src/v4/core/tests/locales/be.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, it } from "vitest";
+import be from "../../../locales/be.js";
+
+describe("Belarusian localization", () => {
+  const localeError = be().localeError;
+
+  describe("pluralization rules", () => {
+    for (const { type, cases } of TEST_CASES) {
+      describe(`${type} pluralization`, () => {
+        for (const { count, expected } of cases) {
+          it(`correctly pluralizes ${count} ${type}`, () => {
+            const error = localeError({
+              code: "too_small",
+              minimum: count,
+              type: "number",
+              inclusive: true,
+              path: [],
+              origin: type,
+              input: count - 1,
+            });
+            expect(error).toContain(expected);
+          });
+        }
+      });
+    }
+
+    it("handles negative numbers correctly", () => {
+      const error = localeError({
+        code: "too_small",
+        minimum: -2,
+        type: "number",
+        inclusive: true,
+        path: [],
+        origin: "array",
+        input: -3,
+      });
+      expect(error).toContain("-2 элементы");
+    });
+
+    it("handles zero correctly", () => {
+      const error = localeError({
+        code: "too_small",
+        minimum: 0,
+        type: "number",
+        inclusive: true,
+        path: [],
+        origin: "array",
+        input: -1,
+      });
+      expect(error).toContain("0 элементаў");
+    });
+
+    it("handles bigint values correctly", () => {
+      const error = localeError({
+        code: "too_small",
+        minimum: BigInt(21),
+        type: "number",
+        inclusive: true,
+        path: [],
+        origin: "array",
+        input: BigInt(20),
+      });
+      expect(error).toContain("21 элемент");
+    });
+  });
+});
+
+const TEST_CASES = [
+  {
+    type: "array",
+    cases: [
+      { count: 1, expected: "1 элемент" },
+      { count: 2, expected: "2 элементы" },
+      { count: 5, expected: "5 элементаў" },
+      { count: 11, expected: "11 элементаў" },
+      { count: 21, expected: "21 элемент" },
+      { count: 22, expected: "22 элементы" },
+      { count: 25, expected: "25 элементаў" },
+      { count: 101, expected: "101 элемент" },
+      { count: 111, expected: "111 элементаў" },
+    ],
+  },
+  {
+    type: "set",
+    cases: [
+      { count: 1, expected: "1 элемент" },
+      { count: 2, expected: "2 элементы" },
+      { count: 5, expected: "5 элементаў" },
+      { count: 11, expected: "11 элементаў" },
+      { count: 21, expected: "21 элемент" },
+      { count: 22, expected: "22 элементы" },
+      { count: 25, expected: "25 элементаў" },
+      { count: 101, expected: "101 элемент" },
+      { count: 111, expected: "111 элементаў" },
+    ],
+  },
+  {
+    type: "string",
+    cases: [
+      { count: 1, expected: "1 сімвал" },
+      { count: 2, expected: "2 сімвалы" },
+      { count: 5, expected: "5 сімвалаў" },
+      { count: 11, expected: "11 сімвалаў" },
+      { count: 21, expected: "21 сімвал" },
+      { count: 22, expected: "22 сімвалы" },
+      { count: 25, expected: "25 сімвалаў" },
+    ],
+  },
+  {
+    type: "file",
+    cases: [
+      { count: 0, expected: "0 байтаў" },
+      { count: 1, expected: "1 байт" },
+      { count: 2, expected: "2 байты" },
+      { count: 5, expected: "5 байтаў" },
+      { count: 11, expected: "11 байтаў" },
+      { count: 21, expected: "21 байт" },
+      { count: 22, expected: "22 байты" },
+      { count: 25, expected: "25 байтаў" },
+      { count: 101, expected: "101 байт" },
+      { count: 110, expected: "110 байтаў" },
+    ],
+  },
+] as const;

gui/frontend/node_modules/zod/src/v4/core/tests/locales/el.test.ts

@@ -0,0 +1,215 @@
+import { expect, test } from "vitest";
+import { z } from "../../../../index.js";
+import el from "../../../locales/el.js";
+
+test("Greek locale - too_small errors", () => {
+  z.config(el());
+
+  // Test string type translation
+  const stringSchema = z.string().min(5);
+  const stringResult = stringSchema.safeParse("abc");
+  expect(stringResult.success).toBe(false);
+  if (!stringResult.success) {
+    expect(stringResult.error.issues[0].message).toBe("Πολύ μικρό: αναμενόταν string να έχει >=5 χαρακτήρες");
+  }
+
+  // Test number type translation
+  const numberSchema = z.number().min(10);
+  const numberResult = numberSchema.safeParse(5);
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    expect(numberResult.error.issues[0].message).toBe("Πολύ μικρό: αναμενόταν number να είναι >=10");
+  }
+
+  // Test array type translation
+  const arraySchema = z.array(z.string()).min(3);
+  const arrayResult = arraySchema.safeParse(["a", "b"]);
+  expect(arrayResult.success).toBe(false);
+  if (!arrayResult.success) {
+    expect(arrayResult.error.issues[0].message).toBe("Πολύ μικρό: αναμενόταν array να έχει >=3 στοιχεία");
+  }
+
+  // Test set type translation
+  const setSchema = z.set(z.string()).min(2);
+  const setResult = setSchema.safeParse(new Set(["a"]));
+  expect(setResult.success).toBe(false);
+  if (!setResult.success) {
+    expect(setResult.error.issues[0].message).toBe("Πολύ μικρό: αναμενόταν set να έχει >=2 στοιχεία");
+  }
+});
+
+test("Greek locale - too_big errors", () => {
+  z.config(el());
+
+  // Test string type translation
+  const stringSchema = z.string().max(3);
+  const stringResult = stringSchema.safeParse("abcde");
+  expect(stringResult.success).toBe(false);
+  if (!stringResult.success) {
+    expect(stringResult.error.issues[0].message).toBe("Πολύ μεγάλο: αναμενόταν string να έχει <=3 χαρακτήρες");
+  }
+
+  // Test number type translation
+  const numberSchema = z.number().max(10);
+  const numberResult = numberSchema.safeParse(15);
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    expect(numberResult.error.issues[0].message).toBe("Πολύ μεγάλο: αναμενόταν number να είναι <=10");
+  }
+
+  // Test array type translation
+  const arraySchema = z.array(z.string()).max(2);
+  const arrayResult = arraySchema.safeParse(["a", "b", "c"]);
+  expect(arrayResult.success).toBe(false);
+  if (!arrayResult.success) {
+    expect(arrayResult.error.issues[0].message).toBe("Πολύ μεγάλο: αναμενόταν array να έχει <=2 στοιχεία");
+  }
+});
+
+test("Greek locale - invalid_type errors", () => {
+  z.config(el());
+
+  // Test string expected, number received
+  const stringSchema = z.string();
+  const stringResult = stringSchema.safeParse(123);
+  expect(stringResult.success).toBe(false);
+  if (!stringResult.success) {
+    expect(stringResult.error.issues[0].message).toBe("Μη έγκυρη είσοδος: αναμενόταν string, λήφθηκε number");
+  }
+
+  // Test number expected, string received
+  const numberSchema = z.number();
+  const numberResult = numberSchema.safeParse("abc");
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    expect(numberResult.error.issues[0].message).toBe("Μη έγκυρη είσοδος: αναμενόταν number, λήφθηκε string");
+  }
+
+  // Test boolean expected, null received
+  const booleanSchema = z.boolean();
+  const booleanResult = booleanSchema.safeParse(null);
+  expect(booleanResult.success).toBe(false);
+  if (!booleanResult.success) {
+    expect(booleanResult.error.issues[0].message).toBe("Μη έγκυρη είσοδος: αναμενόταν boolean, λήφθηκε null");
+  }
+
+  // Test array expected, object received
+  const arraySchema = z.array(z.string());
+  const arrayResult = arraySchema.safeParse({});
+  expect(arrayResult.success).toBe(false);
+  if (!arrayResult.success) {
+    expect(arrayResult.error.issues[0].message).toBe("Μη έγκυρη είσοδος: αναμενόταν array, λήφθηκε object");
+  }
+});
+
+test("Greek locale - other error cases", () => {
+  z.config(el());
+
+  // Test invalid_element with map (only "map" | "set" produce invalid_element)
+  const mapSchema = z.map(z.bigint(), z.number());
+  const mapResult = mapSchema.safeParse(new Map([[BigInt(123), BigInt(123)]]));
+  expect(mapResult.success).toBe(false);
+  if (!mapResult.success) {
+    expect(mapResult.error.issues[0].code).toBe("invalid_element");
+    expect(mapResult.error.issues[0].message).toBe("Μη έγκυρη τιμή στο map");
+  }
+
+  // Test invalid_key with record (only "map" | "record" produce invalid_key)
+  const recordSchema = z.record(z.number(), z.string());
+  const recordResult = recordSchema.safeParse({ notANumber: "value" });
+  expect(recordResult.success).toBe(false);
+  if (!recordResult.success) {
+    expect(recordResult.error.issues[0].code).toBe("invalid_key");
+    expect(recordResult.error.issues[0].message).toBe("Μη έγκυρο κλειδί στο record");
+  }
+
+  // Test invalid_value with enum
+  const enumSchema = z.enum(["a", "b"]);
+  const enumResult = enumSchema.safeParse("c");
+  expect(enumResult.success).toBe(false);
+  if (!enumResult.success) {
+    expect(enumResult.error.issues[0].message).toBe('Μη έγκυρη επιλογή: αναμενόταν ένα από "a"|"b"');
+  }
+
+  // Test not_multiple_of
+  const multipleSchema = z.number().multipleOf(3);
+  const multipleResult = multipleSchema.safeParse(10);
+  expect(multipleResult.success).toBe(false);
+  if (!multipleResult.success) {
+    expect(multipleResult.error.issues[0].message).toBe("Μη έγκυρος αριθμός: πρέπει να είναι πολλαπλάσιο του 3");
+  }
+
+  // Test unrecognized_keys (single key)
+  const strictSchema = z.object({ a: z.string() }).strict();
+  const strictResult = strictSchema.safeParse({ a: "test", b: "extra" });
+  expect(strictResult.success).toBe(false);
+  if (!strictResult.success) {
+    expect(strictResult.error.issues[0].message).toBe('Άγνωστο κλειδί: "b"');
+  }
+
+  // Test unrecognized_keys (multiple keys)
+  const strictMultipleResult = strictSchema.safeParse({
+    a: "test",
+    b: "extra",
+    c: "another",
+  });
+  expect(strictMultipleResult.success).toBe(false);
+  if (!strictMultipleResult.success) {
+    expect(strictMultipleResult.error.issues[0].message).toBe('Άγνωστα κλειδιά: "b", "c"');
+  }
+
+  // Test invalid_union
+  const unionSchema = z.union([z.string(), z.number()]);
+  const unionResult = unionSchema.safeParse(true);
+  expect(unionResult.success).toBe(false);
+  if (!unionResult.success) {
+    expect(unionResult.error.issues[0].message).toBe("Μη έγκυρη είσοδος");
+  }
+
+  // Test invalid_format with regex
+  const regexSchema = z.string().regex(/^[a-z]+$/);
+  const regexResult = regexSchema.safeParse("ABC123");
+  expect(regexResult.success).toBe(false);
+  if (!regexResult.success) {
+    expect(regexResult.error.issues[0].message).toBe(
+      "Μη έγκυρη συμβολοσειρά: πρέπει να ταιριάζει με το μοτίβο /^[a-z]+$/"
+    );
+  }
+
+  // Test invalid_format with startsWith
+  const startsWithSchema = z.string().startsWith("hello");
+  const startsWithResult = startsWithSchema.safeParse("world");
+  expect(startsWithResult.success).toBe(false);
+  if (!startsWithResult.success) {
+    expect(startsWithResult.error.issues[0].message).toBe('Μη έγκυρη συμβολοσειρά: πρέπει να ξεκινά με "hello"');
+  }
+
+  // Test invalid_format with endsWith
+  const endsWithSchema = z.string().endsWith("world");
+  const endsWithResult = endsWithSchema.safeParse("hello");
+  expect(endsWithResult.success).toBe(false);
+  if (!endsWithResult.success) {
+    expect(endsWithResult.error.issues[0].message).toBe('Μη έγκυρη συμβολοσειρά: πρέπει να τελειώνει με "world"');
+  }
+
+  // Test invalid_format with includes
+  const includesSchema = z.string().includes("test");
+  const includesResult = includesSchema.safeParse("hello");
+  expect(includesResult.success).toBe(false);
+  if (!includesResult.success) {
+    expect(includesResult.error.issues[0].message).toBe('Μη έγκυρη συμβολοσειρά: πρέπει να περιέχει "test"');
+  }
+});
+
+test("Greek locale - invalid_type with instanceof (class-name expected)", () => {
+  z.config(el());
+
+  // When `expected` starts with a capital letter, render an `instanceof` message,
+  // matching the convention used by most other locales (de, es, fr, it, etc.).
+  const dateSchema = z.instanceof(Date);
+  const dateResult = dateSchema.safeParse("not a date");
+  expect(dateResult.success).toBe(false);
+  if (!dateResult.success) {
+    expect(dateResult.error.issues[0].message).toBe("Μη έγκυρη είσοδος: αναμενόταν instanceof Date, λήφθηκε string");
+  }
+});

gui/frontend/node_modules/zod/src/v4/core/tests/locales/en.test.ts

@@ -0,0 +1,22 @@
+import { expect, test } from "vitest";
+import { parsedType } from "../../util.js";
+
+test("parsedType", () => {
+  expect(parsedType("string")).toBe("string");
+  expect(parsedType(1)).toBe("number");
+  expect(parsedType(true)).toBe("boolean");
+  expect(parsedType(null)).toBe("null");
+  expect(parsedType(undefined)).toBe("undefined");
+  expect(parsedType([])).toBe("array");
+  expect(parsedType({})).toBe("object");
+  expect(parsedType(new Date())).toBe("Date");
+  expect(parsedType(new Map())).toBe("Map");
+  expect(parsedType(new Set())).toBe("Set");
+  expect(parsedType(new Error())).toBe("Error");
+
+  const nullPrototype = Object.create(null);
+  expect(parsedType(nullPrototype)).toBe("object");
+
+  const doubleNullPrototype = Object.create(Object.create(null));
+  expect(parsedType(doubleNullPrototype)).toBe("object");
+});

gui/frontend/node_modules/zod/src/v4/core/tests/locales/es.test.ts

@@ -0,0 +1,181 @@
+import { expect, test } from "vitest";
+import { z } from "../../../../index.js";
+import es from "../../../locales/es.js";
+
+test("Spanish locale - type name translations in too_small errors", () => {
+  z.config(es());
+
+  // Test string type translation
+  const stringSchema = z.string().min(5);
+  const stringResult = stringSchema.safeParse("abc");
+  expect(stringResult.success).toBe(false);
+  if (!stringResult.success) {
+    expect(stringResult.error.issues[0].message).toBe(
+      "Demasiado pequeño: se esperaba que texto tuviera >=5 caracteres"
+    );
+  }
+
+  // Test number type translation
+  const numberSchema = z.number().min(10);
+  const numberResult = numberSchema.safeParse(5);
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    expect(numberResult.error.issues[0].message).toBe("Demasiado pequeño: se esperaba que número fuera >=10");
+  }
+
+  // Test array type translation
+  const arraySchema = z.array(z.string()).min(3);
+  const arrayResult = arraySchema.safeParse(["a", "b"]);
+  expect(arrayResult.success).toBe(false);
+  if (!arrayResult.success) {
+    expect(arrayResult.error.issues[0].message).toBe(
+      "Demasiado pequeño: se esperaba que arreglo tuviera >=3 elementos"
+    );
+  }
+
+  // Test set type translation
+  const setSchema = z.set(z.string()).min(2);
+  const setResult = setSchema.safeParse(new Set(["a"]));
+  expect(setResult.success).toBe(false);
+  if (!setResult.success) {
+    expect(setResult.error.issues[0].message).toBe("Demasiado pequeño: se esperaba que conjunto tuviera >=2 elementos");
+  }
+});
+
+test("Spanish locale - type name translations in too_big errors", () => {
+  z.config(es());
+
+  // Test string type translation
+  const stringSchema = z.string().max(3);
+  const stringResult = stringSchema.safeParse("abcde");
+  expect(stringResult.success).toBe(false);
+  if (!stringResult.success) {
+    expect(stringResult.error.issues[0].message).toBe("Demasiado grande: se esperaba que texto tuviera <=3 caracteres");
+  }
+
+  // Test number type translation
+  const numberSchema = z.number().max(10);
+  const numberResult = numberSchema.safeParse(15);
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    expect(numberResult.error.issues[0].message).toBe("Demasiado grande: se esperaba que número fuera <=10");
+  }
+
+  // Test array type translation
+  const arraySchema = z.array(z.string()).max(2);
+  const arrayResult = arraySchema.safeParse(["a", "b", "c"]);
+  expect(arrayResult.success).toBe(false);
+  if (!arrayResult.success) {
+    expect(arrayResult.error.issues[0].message).toBe("Demasiado grande: se esperaba que arreglo tuviera <=2 elementos");
+  }
+});
+
+test("Spanish locale - type name translations in invalid_type errors", () => {
+  z.config(es());
+
+  // Test string expected, number received
+  const stringSchema = z.string();
+  const stringResult = stringSchema.safeParse(123);
+  expect(stringResult.success).toBe(false);
+  if (!stringResult.success) {
+    expect(stringResult.error.issues[0].message).toBe("Entrada inválida: se esperaba texto, recibido número");
+  }
+
+  // Test number expected, string received
+  const numberSchema = z.number();
+  const numberResult = numberSchema.safeParse("abc");
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    expect(numberResult.error.issues[0].message).toBe("Entrada inválida: se esperaba número, recibido texto");
+  }
+
+  // Test boolean expected, null received
+  const booleanSchema = z.boolean();
+  const booleanResult = booleanSchema.safeParse(null);
+  expect(booleanResult.success).toBe(false);
+  if (!booleanResult.success) {
+    expect(booleanResult.error.issues[0].message).toBe("Entrada inválida: se esperaba booleano, recibido nulo");
+  }
+
+  // Test array expected, object received
+  const arraySchema = z.array(z.string());
+  const arrayResult = arraySchema.safeParse({});
+  expect(arrayResult.success).toBe(false);
+  if (!arrayResult.success) {
+    expect(arrayResult.error.issues[0].message).toBe("Entrada inválida: se esperaba arreglo, recibido objeto");
+  }
+});
+
+test("Spanish locale - fallback for unknown type names", () => {
+  z.config(es());
+
+  // Test with a type that's not in the TypeNames dictionary
+  // This will test the fallback behavior
+  const dateSchema = z.date().min(new Date("2025-01-01"));
+  const dateResult = dateSchema.safeParse(new Date("2024-01-01"));
+  expect(dateResult.success).toBe(false);
+  if (!dateResult.success) {
+    // Should use "fecha" since we included it in TypeNames
+    expect(dateResult.error.issues[0].message).toContain("fecha");
+  }
+});
+
+test("Spanish locale - other error cases", () => {
+  z.config(es());
+
+  // Test invalid_element with tuple
+  const tupleSchema = z.tuple([z.string(), z.number()]);
+  const tupleResult = tupleSchema.safeParse(["abc", "not a number"]);
+  expect(tupleResult.success).toBe(false);
+  if (!tupleResult.success) {
+    expect(tupleResult.error.issues[0].message).toContain("Entrada inválida");
+  }
+
+  // Test invalid_value with enum
+  const enumSchema = z.enum(["a", "b"]);
+  const enumResult = enumSchema.safeParse("c");
+  expect(enumResult.success).toBe(false);
+  if (!enumResult.success) {
+    expect(enumResult.error.issues[0].message).toBe('Opción inválida: se esperaba una de "a"|"b"');
+  }
+
+  // Test not_multiple_of
+  const multipleSchema = z.number().multipleOf(3);
+  const multipleResult = multipleSchema.safeParse(10);
+  expect(multipleResult.success).toBe(false);
+  if (!multipleResult.success) {
+    expect(multipleResult.error.issues[0].message).toBe("Número inválido: debe ser múltiplo de 3");
+  }
+
+  // Test unrecognized_keys
+  const strictSchema = z.object({ a: z.string() }).strict();
+  const strictResult = strictSchema.safeParse({ a: "test", b: "extra" });
+  expect(strictResult.success).toBe(false);
+  if (!strictResult.success) {
+    expect(strictResult.error.issues[0].message).toBe('Llave desconocida: "b"');
+  }
+
+  // Test invalid_union
+  const unionSchema = z.union([z.string(), z.number()]);
+  const unionResult = unionSchema.safeParse(true);
+  expect(unionResult.success).toBe(false);
+  if (!unionResult.success) {
+    expect(unionResult.error.issues[0].message).toBe("Entrada inválida");
+  }
+
+  // Test invalid_format with regex
+  const regexSchema = z.string().regex(/^[a-z]+$/);
+  const regexResult = regexSchema.safeParse("ABC123");
+  expect(regexResult.success).toBe(false);
+  if (!regexResult.success) {
+    expect(regexResult.error.issues[0].message).toBe("Cadena inválida: debe coincidir con el patrón /^[a-z]+$/");
+  }
+
+  // Test invalid_format with startsWith
+  const startsWithSchema = z.string().startsWith("hello");
+  const startsWithResult = startsWithSchema.safeParse("world");
+  expect(startsWithResult.success).toBe(false);
+  if (!startsWithResult.success) {
+    expect(startsWithResult.error.issues[0].message).toBe('Cadena inválida: debe comenzar con "hello"');
+  }
+});

gui/frontend/node_modules/zod/src/v4/core/tests/locales/fr.test.ts

@@ -0,0 +1,72 @@
+import { expect, test } from "vitest";
+import { z } from "../../../../index.js";
+import fr from "../../../locales/fr.js";
+
+test("French locale - type name translations in too_small errors", () => {
+  z.config(fr());
+
+  const stringResult = z.string().min(5).safeParse("abc");
+  expect(stringResult.success).toBe(false);
+  if (!stringResult.success) {
+    expect(stringResult.error.issues[0].message).toBe("Trop petit : chaîne doit avoir >=5 caractères");
+  }
+
+  const numberResult = z.number().min(10).safeParse(5);
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    expect(numberResult.error.issues[0].message).toBe("Trop petit : nombre doit être >=10");
+  }
+
+  const arrayResult = z.array(z.string()).min(3).safeParse(["a", "b"]);
+  expect(arrayResult.success).toBe(false);
+  if (!arrayResult.success) {
+    expect(arrayResult.error.issues[0].message).toBe("Trop petit : tableau doit avoir >=3 éléments");
+  }
+
+  const setResult = z
+    .set(z.string())
+    .min(2)
+    .safeParse(new Set(["a"]));
+  expect(setResult.success).toBe(false);
+  if (!setResult.success) {
+    expect(setResult.error.issues[0].message).toBe("Trop petit : ensemble doit avoir >=2 éléments");
+  }
+});
+
+test("French locale - type name translations in too_big errors", () => {
+  z.config(fr());
+
+  const stringResult = z.string().max(3).safeParse("abcde");
+  expect(stringResult.success).toBe(false);
+  if (!stringResult.success) {
+    expect(stringResult.error.issues[0].message).toBe("Trop grand : chaîne doit avoir <=3 caractères");
+  }
+
+  const numberResult = z.number().max(10).safeParse(15);
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    expect(numberResult.error.issues[0].message).toBe("Trop grand : nombre doit être <=10");
+  }
+
+  const arrayResult = z.array(z.string()).max(2).safeParse(["a", "b", "c"]);
+  expect(arrayResult.success).toBe(false);
+  if (!arrayResult.success) {
+    expect(arrayResult.error.issues[0].message).toBe("Trop grand : tableau doit avoir <=2 éléments");
+  }
+});
+
+test("French locale - type name translations in invalid_type errors", () => {
+  z.config(fr());
+
+  const stringResult = z.string().safeParse(123);
+  expect(stringResult.success).toBe(false);
+  if (!stringResult.success) {
+    expect(stringResult.error.issues[0].message).toBe("Entrée invalide : chaîne attendu, nombre reçu");
+  }
+
+  const arrayResult = z.array(z.string()).safeParse({});
+  expect(arrayResult.success).toBe(false);
+  if (!arrayResult.success) {
+    expect(arrayResult.error.issues[0].message).toBe("Entrée invalide : tableau attendu, objet reçu");
+  }
+});

gui/frontend/node_modules/zod/src/v4/core/tests/locales/he.test.ts

@@ -0,0 +1,379 @@
+import { beforeEach, describe, expect, test } from "vitest";
+import { z } from "../../../../index.js";
+import he from "../../../locales/he.js";
+
+describe("Hebrew localization", () => {
+  beforeEach(() => {
+    z.config(he());
+  });
+
+  describe("too_small errors with definite article and gendered verbs", () => {
+    test("string type (feminine - צריכה)", () => {
+      const schema = z.string().min(3);
+      const result = schema.safeParse("ab");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קצר מדי: המחרוזת צריכה להכיל 3 תווים או יותר");
+      }
+    });
+
+    test("number type (masculine - צריך)", () => {
+      const schema = z.number().min(10);
+      const result = schema.safeParse(5);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קטן מדי: המספר צריך להיות גדול או שווה ל-10");
+      }
+    });
+
+    test("array type (masculine - צריך)", () => {
+      const schema = z.array(z.string()).min(1);
+      const result = schema.safeParse([]);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קטן מדי: המערך צריך להכיל לפחות פריט אחד");
+      }
+    });
+
+    test("set type (feminine - צריכה)", () => {
+      const schema = z.set(z.string()).min(2);
+      const result = schema.safeParse(new Set(["a"]));
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קטן מדי: הקבוצה (Set) צריכה להכיל 2 פריטים או יותר");
+      }
+    });
+  });
+
+  describe("too_big errors with definite article and gendered verbs", () => {
+    test("string type (feminine - צריכה)", () => {
+      const schema = z.string().max(3);
+      const result = schema.safeParse("abcde");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("ארוך מדי: המחרוזת צריכה להכיל 3 תווים או פחות");
+      }
+    });
+
+    test("number type (masculine - צריך)", () => {
+      const schema = z.number().max(365);
+      const result = schema.safeParse(400);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("גדול מדי: המספר צריך להיות קטן או שווה ל-365");
+      }
+    });
+
+    test("array max", () => {
+      const schema = z.array(z.string()).max(2);
+      const result = schema.safeParse(["a", "b", "c"]);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("גדול מדי: המערך צריך להכיל 2 פריטים או פחות");
+      }
+    });
+  });
+
+  describe("invalid_type errors with definite article and gendered verbs", () => {
+    test("string expected (feminine), number received", () => {
+      const schema = z.string();
+      const result = schema.safeParse(123);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קלט לא תקין: צריך להיות מחרוזת, התקבל מספר");
+      }
+    });
+
+    test("number expected (masculine), string received", () => {
+      const schema = z.number();
+      const result = schema.safeParse("abc");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קלט לא תקין: צריך להיות מספר, התקבל מחרוזת");
+      }
+    });
+
+    test("boolean expected (masculine), null received", () => {
+      const schema = z.boolean();
+      const result = schema.safeParse(null);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קלט לא תקין: צריך להיות ערך בוליאני, התקבל ערך ריק (null)");
+      }
+    });
+
+    test("array expected (masculine), object received", () => {
+      const schema = z.array(z.string());
+      const result = schema.safeParse({});
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קלט לא תקין: צריך להיות מערך, התקבל אובייקט");
+      }
+    });
+
+    test("object expected (masculine), array received", () => {
+      const schema = z.object({ a: z.string() });
+      const result = schema.safeParse([]);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קלט לא תקין: צריך להיות אובייקט, התקבל מערך");
+      }
+    });
+
+    test("function expected (feminine), string received", () => {
+      const schema = z.function();
+      const result = schema.safeParse("not a function");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קלט לא תקין: צריך להיות פונקציה, התקבל מחרוזת");
+      }
+    });
+  });
+
+  describe("gendered verbs consistency", () => {
+    test("feminine types use צריכה", () => {
+      const feminineTypes = [
+        { schema: z.string().min(5), input: "abc" },
+        { schema: z.set(z.string()).min(2), input: new Set(["a"]) },
+      ];
+
+      for (const { schema, input } of feminineTypes) {
+        const result = schema.safeParse(input);
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          expect(result.error.issues[0].message).toContain("צריכה");
+        }
+      }
+    });
+
+    test("masculine types use צריך", () => {
+      const masculineTypes = [
+        { schema: z.number().min(10), input: 5 },
+        { schema: z.array(z.string()).min(2), input: ["a"] },
+      ];
+
+      for (const { schema, input } of masculineTypes) {
+        const result = schema.safeParse(input);
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          expect(result.error.issues[0].message).toContain("צריך");
+        }
+      }
+    });
+  });
+
+  describe("invalid_value with enum", () => {
+    test("single value", () => {
+      const schema = z.enum(["a"]);
+      const result = schema.safeParse("b");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe('ערך לא תקין: הערך חייב להיות "a"');
+      }
+    });
+
+    test("two values", () => {
+      const schema = z.enum(["a", "b"]);
+      const result = schema.safeParse("c");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe('ערך לא תקין: האפשרויות המתאימות הן "a" או "b"');
+      }
+    });
+
+    test("multiple values", () => {
+      const schema = z.enum(["a", "b", "c"]);
+      const result = schema.safeParse("d");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe('ערך לא תקין: האפשרויות המתאימות הן "a", "b" או "c"');
+      }
+    });
+  });
+
+  describe("other error types", () => {
+    test("not_multiple_of", () => {
+      const schema = z.number().multipleOf(3);
+      const result = schema.safeParse(10);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("מספר לא תקין: חייב להיות מכפלה של 3");
+      }
+    });
+
+    test("unrecognized_keys - single key", () => {
+      const schema = z.object({ a: z.string() }).strict();
+      const result = schema.safeParse({ a: "test", b: "extra" });
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe('מפתח לא מזוהה: "b"');
+      }
+    });
+
+    test("unrecognized_keys - multiple keys", () => {
+      const schema = z.object({ a: z.string() }).strict();
+      const result = schema.safeParse({ a: "test", b: "extra", c: "more" });
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe('מפתחות לא מזוהים: "b", "c"');
+      }
+    });
+
+    test("invalid_union", () => {
+      const schema = z.union([z.string(), z.number()]);
+      const result = schema.safeParse(true);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קלט לא תקין");
+      }
+    });
+
+    test("invalid_key in object", () => {
+      const schema = z.record(z.number(), z.string());
+      const result = schema.safeParse({ notANumber: "value" });
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("שדה לא תקין באובייקט");
+      }
+    });
+  });
+
+  describe("invalid_format with string checks", () => {
+    test("startsWith", () => {
+      const schema = z.string().startsWith("hello");
+      const result = schema.safeParse("world");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe('המחרוזת חייבת להתחיל ב "hello"');
+      }
+    });
+
+    test("endsWith", () => {
+      const schema = z.string().endsWith("world");
+      const result = schema.safeParse("hello");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe('המחרוזת חייבת להסתיים ב "world"');
+      }
+    });
+
+    test("includes", () => {
+      const schema = z.string().includes("test");
+      const result = schema.safeParse("hello world");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe('המחרוזת חייבת לכלול "test"');
+      }
+    });
+
+    test("regex", () => {
+      const schema = z.string().regex(/^[a-z]+$/);
+      const result = schema.safeParse("ABC123");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("המחרוזת חייבת להתאים לתבנית /^[a-z]+$/");
+      }
+    });
+  });
+
+  describe("invalid_format with common formats", () => {
+    test("email", () => {
+      const schema = z.string().email();
+      const result = schema.safeParse("not-an-email");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("כתובת אימייל לא תקינה");
+      }
+    });
+
+    test("url", () => {
+      const schema = z.string().url();
+      const result = schema.safeParse("not-a-url");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("כתובת רשת לא תקינה");
+      }
+    });
+
+    test("uuid", () => {
+      const schema = z.string().uuid();
+      const result = schema.safeParse("not-a-uuid");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("UUID לא תקין");
+      }
+    });
+  });
+
+  describe("tuple validation", () => {
+    test("invalid element type in tuple shows full error message", () => {
+      const schema = z.tuple([z.string(), z.number()]);
+      const result = schema.safeParse(["abc", "not a number"]);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קלט לא תקין: צריך להיות מספר, התקבל מחרוזת");
+      }
+    });
+  });
+
+  describe("inclusive vs exclusive bounds", () => {
+    test("inclusive minimum (>=)", () => {
+      const schema = z.number().min(10);
+      const result = schema.safeParse(5);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קטן מדי: המספר צריך להיות גדול או שווה ל-10");
+      }
+    });
+
+    test("exclusive minimum (>)", () => {
+      const schema = z.number().gt(10);
+      const result = schema.safeParse(10);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קטן מדי: המספר צריך להיות גדול מ-10");
+      }
+    });
+
+    test("inclusive maximum (<=)", () => {
+      const schema = z.number().max(10);
+      const result = schema.safeParse(15);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("גדול מדי: המספר צריך להיות קטן או שווה ל-10");
+      }
+    });
+
+    test("exclusive maximum (<)", () => {
+      const schema = z.number().lt(10);
+      const result = schema.safeParse(10);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("גדול מדי: המספר צריך להיות קטן מ-10");
+      }
+    });
+  });
+
+  describe("all type names with definite article", () => {
+    test("verifies all type translations are correct", () => {
+      const types = [
+        { schema: z.string(), expected: "מחרוזת", input: 123 },
+        { schema: z.number(), expected: "מספר", input: "abc" },
+        { schema: z.boolean(), expected: "ערך בוליאני", input: "abc" },
+        { schema: z.bigint(), expected: "BigInt", input: "abc" },
+        { schema: z.date(), expected: "תאריך", input: "abc" },
+        { schema: z.array(z.any()), expected: "מערך", input: "abc" },
+        { schema: z.object({}), expected: "אובייקט", input: "abc" },
+        { schema: z.function(), expected: "פונקציה", input: "abc" },
+      ];
+
+      for (const { schema, expected, input } of types) {
+        const result = schema.safeParse(input);
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          expect(result.error.issues[0].message).toContain(expected);
+        }
+      }
+    });
+  });
+});

gui/frontend/node_modules/zod/src/v4/core/tests/locales/hr.test.ts

@@ -0,0 +1,163 @@
+import { expect, test } from "vitest";
+import { z } from "../../../../index.js";
+import hr from "../../../locales/hr.js";
+
+test("Croatian locale - type name translations in too_small errors", () => {
+  z.config(hr());
+
+  // Test string type translation
+  const stringSchema = z.string().min(5);
+  const stringResult = stringSchema.safeParse("abc");
+  expect(stringResult.success).toBe(false);
+  if (!stringResult.success) {
+    expect(stringResult.error.issues[0].message).toBe("Premalo: očekivano da tekst ima >=5 znakova");
+  }
+
+  // Test number type translation
+  const numberSchema = z.number().min(10);
+  const numberResult = numberSchema.safeParse(5);
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    expect(numberResult.error.issues[0].message).toBe("Premalo: očekivano da broj bude >=10");
+  }
+
+  // Test array type translation
+  const arraySchema = z.array(z.string()).min(3);
+  const arrayResult = arraySchema.safeParse(["a", "b"]);
+  expect(arrayResult.success).toBe(false);
+  if (!arrayResult.success) {
+    expect(arrayResult.error.issues[0].message).toBe("Premalo: očekivano da niz ima >=3 stavki");
+  }
+
+  // Test set type translation
+  const setSchema = z.set(z.string()).min(2);
+  const setResult = setSchema.safeParse(new Set(["a"]));
+  expect(setResult.success).toBe(false);
+  if (!setResult.success) {
+    expect(setResult.error.issues[0].message).toBe("Premalo: očekivano da skup ima >=2 stavki");
+  }
+});
+
+test("Croatian locale - type name translations in too_big errors", () => {
+  z.config(hr());
+
+  // Test string type translation
+  const stringSchema = z.string().max(3);
+  const stringResult = stringSchema.safeParse("abcde");
+  expect(stringResult.success).toBe(false);
+  if (!stringResult.success) {
+    expect(stringResult.error.issues[0].message).toBe("Preveliko: očekivano da tekst ima <=3 znakova");
+  }
+
+  // Test number type translation
+  const numberSchema = z.number().max(10);
+  const numberResult = numberSchema.safeParse(15);
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    expect(numberResult.error.issues[0].message).toBe("Preveliko: očekivano da broj bude <=10");
+  }
+
+  // Test array type translation
+  const arraySchema = z.array(z.string()).max(2);
+  const arrayResult = arraySchema.safeParse(["a", "b", "c"]);
+  expect(arrayResult.success).toBe(false);
+  if (!arrayResult.success) {
+    expect(arrayResult.error.issues[0].message).toBe("Preveliko: očekivano da niz ima <=2 stavki");
+  }
+});
+
+test("Croatian locale - type name translations in invalid_type errors", () => {
+  z.config(hr());
+
+  // Test string expected, number received
+  const stringSchema = z.string();
+  const stringResult = stringSchema.safeParse(123);
+  expect(stringResult.success).toBe(false);
+  if (!stringResult.success) {
+    expect(stringResult.error.issues[0].message).toBe("Neispravan unos: očekuje se tekst, a primljeno je broj");
+  }
+
+  // Test number expected, string received
+  const numberSchema = z.number();
+  const numberResult = numberSchema.safeParse("abc");
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    expect(numberResult.error.issues[0].message).toBe("Neispravan unos: očekuje se broj, a primljeno je tekst");
+  }
+
+  // Test boolean expected, null received
+  const booleanSchema = z.boolean();
+  const booleanResult = booleanSchema.safeParse(null);
+  expect(booleanResult.success).toBe(false);
+  if (!booleanResult.success) {
+    expect(booleanResult.error.issues[0].message).toBe("Neispravan unos: očekuje se boolean, a primljeno je null");
+  }
+
+  // Test array expected, object received
+  const arraySchema = z.array(z.string());
+  const arrayResult = arraySchema.safeParse({});
+  expect(arrayResult.success).toBe(false);
+  if (!arrayResult.success) {
+    expect(arrayResult.error.issues[0].message).toBe("Neispravan unos: očekuje se niz, a primljeno je objekt");
+  }
+});
+
+test("Croatian locale - other error cases", () => {
+  z.config(hr());
+
+  // Test invalid_element with tuple
+  const tupleSchema = z.tuple([z.string(), z.number()]);
+  const tupleResult = tupleSchema.safeParse(["abc", "not a number"]);
+  expect(tupleResult.success).toBe(false);
+  if (!tupleResult.success) {
+    expect(tupleResult.error.issues[0].message).toContain("Neispravan unos");
+  }
+
+  // Test invalid_value with enum
+  const enumSchema = z.enum(["a", "b"]);
+  const enumResult = enumSchema.safeParse("c");
+  expect(enumResult.success).toBe(false);
+  if (!enumResult.success) {
+    expect(enumResult.error.issues[0].message).toBe('Neispravna opcija: očekivano jedno od "a"|"b"');
+  }
+
+  // Test not_multiple_of
+  const multipleSchema = z.number().multipleOf(3);
+  const multipleResult = multipleSchema.safeParse(10);
+  expect(multipleResult.success).toBe(false);
+  if (!multipleResult.success) {
+    expect(multipleResult.error.issues[0].message).toBe("Neispravan broj: mora biti višekratnik od 3");
+  }
+
+  // Test unrecognized_keys
+  const strictSchema = z.object({ a: z.string() }).strict();
+  const strictResult = strictSchema.safeParse({ a: "test", b: "extra" });
+  expect(strictResult.success).toBe(false);
+  if (!strictResult.success) {
+    expect(strictResult.error.issues[0].message).toBe('Neprepoznat ključ: "b"');
+  }
+
+  // Test invalid_union
+  const unionSchema = z.union([z.string(), z.number()]);
+  const unionResult = unionSchema.safeParse(true);
+  expect(unionResult.success).toBe(false);
+  if (!unionResult.success) {
+    expect(unionResult.error.issues[0].message).toBe("Neispravan unos");
+  }
+
+  // Test invalid_format with regex
+  const regexSchema = z.string().regex(/^[a-z]+$/);
+  const regexResult = regexSchema.safeParse("ABC123");
+  expect(regexResult.success).toBe(false);
+  if (!regexResult.success) {
+    expect(regexResult.error.issues[0].message).toBe("Neispravan tekst: mora odgovarati uzorku /^[a-z]+$/");
+  }
+
+  // Test invalid_format with startsWith
+  const startsWithSchema = z.string().startsWith("hello");
+  const startsWithResult = startsWithSchema.safeParse("world");
+  expect(startsWithResult.success).toBe(false);
+  if (!startsWithResult.success) {
+    expect(startsWithResult.error.issues[0].message).toBe('Neispravan tekst: mora započinjati s "hello"');
+  }
+});

gui/frontend/node_modules/zod/src/v4/core/tests/locales/nl.test.ts

@@ -0,0 +1,46 @@
+import { expect, test } from "vitest";
+import nl from "../../../locales/nl.js";
+
+test("Dutch locale error messages", () => {
+  const { localeError } = nl();
+
+  // Test invalid_type
+  expect(
+    localeError({
+      code: "invalid_type",
+      expected: "string",
+      input: 123,
+    })
+  ).toBe("Ongeldige invoer: verwacht string, ontving getal");
+
+  // Test too_big with sizing
+  expect(
+    localeError({
+      code: "too_big",
+      origin: "string",
+      maximum: 10,
+      inclusive: true,
+      input: "test string that is too long",
+    })
+  ).toBe("Te lang: verwacht dat string <=10 tekens heeft");
+
+  // Test too_small with sizing
+  expect(
+    localeError({
+      code: "too_small",
+      origin: "array",
+      minimum: 5,
+      inclusive: false,
+      input: [1, 2],
+    })
+  ).toBe("Te klein: verwacht dat array >5 elementen heeft");
+
+  // Test invalid_format
+  expect(
+    localeError({
+      code: "invalid_format",
+      format: "email",
+      input: "invalid-email",
+    })
+  ).toBe("Ongeldig: emailadres");
+});

gui/frontend/node_modules/zod/src/v4/core/tests/locales/ru.test.ts

@@ -0,0 +1,128 @@
+import { describe, expect, it } from "vitest";
+import ru from "../../../locales/ru.js";
+
+describe("Russian localization", () => {
+  const localeError = ru().localeError;
+
+  describe("pluralization rules", () => {
+    for (const { type, cases } of TEST_CASES) {
+      describe(`${type} pluralization`, () => {
+        for (const { count, expected } of cases) {
+          it(`correctly pluralizes ${count} ${type}`, () => {
+            const error = localeError({
+              code: "too_small",
+              minimum: count,
+              type: "number",
+              inclusive: true,
+              path: [],
+              origin: type,
+              input: count - 1,
+            });
+
+            expect(error).toContain(expected);
+          });
+        }
+      });
+    }
+
+    it("handles negative numbers correctly", () => {
+      const error = localeError({
+        code: "too_small",
+        minimum: -2,
+        type: "number",
+        inclusive: true,
+        path: [],
+        origin: "array",
+        input: -3,
+      });
+
+      expect(error).toContain("-2 элемента");
+    });
+
+    it("handles zero correctly", () => {
+      const error = localeError({
+        code: "too_small",
+        minimum: 0,
+        type: "number",
+        inclusive: true,
+        path: [],
+        origin: "array",
+        input: -1,
+      });
+
+      expect(error).toContain("0 элементов");
+    });
+
+    it("handles bigint values correctly", () => {
+      const error = localeError({
+        code: "too_small",
+        minimum: BigInt(21),
+        type: "number",
+        inclusive: true,
+        path: [],
+        origin: "array",
+        input: BigInt(20),
+      });
+
+      expect(error).toContain("21 элемент");
+    });
+  });
+});
+
+const TEST_CASES = [
+  {
+    type: "array",
+    cases: [
+      { count: 1, expected: "1 элемент" },
+      { count: 2, expected: "2 элемента" },
+      { count: 5, expected: "5 элементов" },
+      { count: 11, expected: "11 элементов" },
+      { count: 21, expected: "21 элемент" },
+      { count: 22, expected: "22 элемента" },
+      { count: 25, expected: "25 элементов" },
+      { count: 101, expected: "101 элемент" },
+      { count: 111, expected: "111 элементов" },
+    ],
+  },
+  {
+    type: "set",
+    cases: [
+      { count: 1, expected: "1 элемент" },
+      { count: 2, expected: "2 элемента" },
+      { count: 5, expected: "5 элементов" },
+      { count: 11, expected: "11 элементов" },
+      { count: 21, expected: "21 элемент" },
+      { count: 22, expected: "22 элемента" },
+      { count: 25, expected: "25 элементов" },
+      { count: 101, expected: "101 элемент" },
+      { count: 111, expected: "111 элементов" },
+    ],
+  },
+  {
+    type: "string",
+    cases: [
+      { count: 1, expected: "1 символ" },
+      { count: 2, expected: "2 символа" },
+      { count: 5, expected: "5 символов" },
+      { count: 11, expected: "11 символов" },
+      { count: 21, expected: "21 символ" },
+      { count: 22, expected: "22 символа" },
+      { count: 25, expected: "25 символов" },
+    ],
+  },
+  {
+    type: "file",
+    cases: [
+      { count: 0, expected: "0 байт" },
+      { count: 1, expected: "1 байт" },
+      { count: 2, expected: "2 байта" },
+      { count: 5, expected: "5 байт" },
+      { count: 11, expected: "11 байт" },
+      { count: 21, expected: "21 байт" },
+      { count: 22, expected: "22 байта" },
+      { count: 25, expected: "25 байт" },
+      { count: 101, expected: "101 байт" },
+      { count: 110, expected: "110 байт" },
+    ],
+  },
+] as const;

gui/frontend/node_modules/zod/src/v4/core/tests/locales/tr.test.ts

@@ -0,0 +1,69 @@
+import { expect, test } from "vitest";
+import * as z from "zod/v4";
+import { parsedType } from "../../util.js";
+
+test("parsedType", () => {
+  expect(parsedType("string")).toBe("string");
+  expect(parsedType(1)).toBe("number");
+  expect(parsedType(true)).toBe("boolean");
+  expect(parsedType(null)).toBe("null");
+  expect(parsedType(undefined)).toBe("undefined");
+  expect(parsedType([])).toBe("array");
+  expect(parsedType({})).toBe("object");
+  expect(parsedType(new Date())).toBe("Date");
+  expect(parsedType(new Map())).toBe("Map");
+  expect(parsedType(new Set())).toBe("Set");
+  expect(parsedType(new Error())).toBe("Error");
+
+  const nullPrototype = Object.create(null);
+  expect(parsedType(nullPrototype)).toBe("object");
+
+  const doubleNullPrototype = Object.create(Object.create(null));
+  expect(parsedType(doubleNullPrototype)).toBe("object");
+
+  expect(parsedType(Number.NaN)).toBe("nan");
+});
+
+test("locales - tr", () => {
+  z.config(z.locales.tr());
+
+  const invalidType = z.number().safeParse("a");
+  expect(invalidType.error!.issues[0].code).toBe("invalid_type");
+  expect(invalidType.error!.issues[0].message).toBe("Geçersiz değer: beklenen number, alınan string");
+
+  const invalidType2 = z.string().safeParse(1);
+  expect(invalidType2.error!.issues[0].code).toBe("invalid_type");
+  expect(invalidType2.error!.issues[0].message).toBe("Geçersiz değer: beklenen string, alınan number");
+
+  const invalidValue = z.enum(["a", "b"]).safeParse(1);
+  expect(invalidValue.error!.issues[0].code).toBe("invalid_value");
+  expect(invalidValue.error!.issues[0].message).toBe('Geçersiz seçenek: aşağıdakilerden biri olmalı: "a"|"b"');
+
+  const tooBig = z.number().max(10).safeParse(15);
+  expect(tooBig.error!.issues[0].code).toBe("too_big");
+  expect(tooBig.error!.issues[0].message).toBe("Çok büyük: beklenen number <=10");
+
+  const tooSmall = z.number().min(10).safeParse(5);
+  expect(tooSmall.error!.issues[0].code).toBe("too_small");
+  expect(tooSmall.error!.issues[0].message).toBe("Çok küçük: beklenen number >=10");
+
+  const invalidFormatRegex = z.string().regex(/abcd/).safeParse("invalid-string");
+  expect(invalidFormatRegex.error!.issues[0].code).toBe("invalid_format");
+  expect(invalidFormatRegex.error!.issues[0].message).toBe("Geçersiz metin: /abcd/ desenine uymalı");
+
+  const invalidFormatStartsWith = z.string().startsWith("abcd").safeParse("invalid-string");
+  expect(invalidFormatStartsWith.error!.issues[0].code).toBe("invalid_format");
+  expect(invalidFormatStartsWith.error!.issues[0].message).toBe('Geçersiz metin: "abcd" ile başlamalı');
+
+  const notMultipleOf = z.number().multipleOf(3).safeParse(10);
+  expect(notMultipleOf.error!.issues[0].code).toBe("not_multiple_of");
+  expect(notMultipleOf.error!.issues[0].message).toBe("Geçersiz sayı: 3 ile tam bölünebilmeli");
+
+  const unrecognizedKeys = z.object({ a: z.string(), b: z.number() }).strict().safeParse({ a: "a", b: 1, c: 2 });
+  expect(unrecognizedKeys.error!.issues[0].code).toBe("unrecognized_keys");
+  expect(unrecognizedKeys.error!.issues[0].message).toBe('Tanınmayan anahtar: "c"');
+
+  const invalidUnion = z.union([z.string(), z.number()]).safeParse(true);
+  expect(invalidUnion.error!.issues[0].code).toBe("invalid_union");
+  expect(invalidUnion.error!.issues[0].message).toBe("Geçersiz değer");
+});

gui/frontend/node_modules/zod/src/v4/core/tests/locales/uz.test.ts

@@ -0,0 +1,105 @@
+import { expect, test } from "vitest";
+import * as z from "zod/v4";
+
+test("locales - uz", () => {
+  z.config(z.locales.uz());
+
+  const invalidType = z.number().safeParse("a");
+  expect(invalidType.error!.issues[0].code).toBe("invalid_type");
+  expect(invalidType.error!.issues[0].message).toBe("Noto‘g‘ri kirish: kutilgan raqam, qabul qilingan string");
+
+  const invalidType2 = z.string().safeParse(1);
+  expect(invalidType2.error!.issues[0].code).toBe("invalid_type");
+  expect(invalidType2.error!.issues[0].message).toBe("Noto‘g‘ri kirish: kutilgan string, qabul qilingan raqam");
+
+  const invalidValue = z.enum(["a", "b"]).safeParse(1);
+  expect(invalidValue.error!.issues[0].code).toBe("invalid_value");
+  expect(invalidValue.error!.issues[0].message).toBe('Noto‘g‘ri variant: quyidagilardan biri kutilgan "a"|"b"');
+
+  const tooBig = z.number().max(10).safeParse(15);
+  expect(tooBig.error!.issues[0].code).toBe("too_big");
+  expect(tooBig.error!.issues[0].message).toBe("Juda katta: kutilgan number <=10");
+
+  const tooSmall = z.number().min(10).safeParse(5);
+  expect(tooSmall.error!.issues[0].code).toBe("too_small");
+  expect(tooSmall.error!.issues[0].message).toBe("Juda kichik: kutilgan number >=10");
+
+  const invalidFormatRegex = z.string().regex(/abcd/).safeParse("invalid-string");
+  expect(invalidFormatRegex.error!.issues[0].code).toBe("invalid_format");
+  expect(invalidFormatRegex.error!.issues[0].message).toContain("shabloniga mos kelishi kerak");
+
+  const invalidFormatStartsWith = z.string().startsWith("abcd").safeParse("invalid-string");
+  expect(invalidFormatStartsWith.error!.issues[0].code).toBe("invalid_format");
+  expect(invalidFormatStartsWith.error!.issues[0].message).toContain('"abcd" bilan boshlanishi kerak');
+
+  const notMultipleOf = z.number().multipleOf(3).safeParse(10);
+  expect(notMultipleOf.error!.issues[0].code).toBe("not_multiple_of");
+  expect(notMultipleOf.error!.issues[0].message).toContain("3 ning karralisi bo‘lishi kerak");
+
+  const unrecognizedKeys = z.object({ a: z.string(), b: z.number() }).strict().safeParse({ a: "a", b: 1, c: 2 });
+  expect(unrecognizedKeys.error!.issues[0].code).toBe("unrecognized_keys");
+  expect(unrecognizedKeys.error!.issues[0].message).toContain('Noma’lum kalit: "c"');
+
+  const invalidUnion = z.union([z.string(), z.number()]).safeParse(true);
+  expect(invalidUnion.error!.issues[0].code).toBe("invalid_union");
+  expect(invalidUnion.error!.issues[0].message).toBe("Noto‘g‘ri kirish");
+
+  const tooBigString = z.string().max(5).safeParse("too long string");
+  expect(tooBigString.error!.issues[0].code).toBe("too_big");
+  expect(tooBigString.error!.issues[0].message).toContain("belgi");
+  expect(tooBigString.error!.issues[0].message).toContain("bo‘lishi kerak");
+
+  const tooSmallArray = z.array(z.string()).min(3).safeParse(["a", "b"]);
+  expect(tooSmallArray.error!.issues[0].code).toBe("too_small");
+  expect(tooSmallArray.error!.issues[0].message).toContain("element");
+  expect(tooSmallArray.error!.issues[0].message).toContain("bo‘lishi kerak");
+
+  const invalidFormatEndsWith = z.string().endsWith("xyz").safeParse("invalid-string");
+  expect(invalidFormatEndsWith.error!.issues[0].code).toBe("invalid_format");
+  expect(invalidFormatEndsWith.error!.issues[0].message).toContain('"xyz" bilan tugashi kerak');
+
+  const invalidFormatIncludes = z.string().includes("test").safeParse("invalid-string");
+  expect(invalidFormatIncludes.error!.issues[0].code).toBe("invalid_format");
+  expect(invalidFormatIncludes.error!.issues[0].message).toContain('"test" ni o‘z ichiga olishi kerak');
+
+  const invalidFormatEmail = z.string().email().safeParse("invalid-email");
+  expect(invalidFormatEmail.error!.issues[0].code).toBe("invalid_format");
+  expect(invalidFormatEmail.error!.issues[0].message).toContain("elektron pochta manzili");
+
+  const invalidFormatUrl = z.string().url().safeParse("invalid-url");
+  expect(invalidFormatUrl.error!.issues[0].code).toBe("invalid_format");
+  expect(invalidFormatUrl.error!.issues[0].message).toContain("URL");
+
+  const unrecognizedKeysMultiple = z
+    .object({ a: z.string(), b: z.number() })
+    .strict()
+    .safeParse({ a: "a", b: 1, c: 2, d: 3 });
+  expect(unrecognizedKeysMultiple.error!.issues[0].code).toBe("unrecognized_keys");
+  expect(unrecognizedKeysMultiple.error!.issues[0].message).toContain("Noma’lum kalitlar");
+
+  const invalidElement = z.array(z.string()).safeParse([1, 2, 3]);
+  expect(invalidElement.error!.issues[0].code).toBe("invalid_type");
+  expect(invalidElement.error!.issues[0].message).toContain("raqam");
+
+  const tooSmallMap = z
+    .map(z.string(), z.string())
+    .min(3)
+    .safeParse(new Map([["a", "b"]]));
+  expect(tooSmallMap.error!.issues[0].code).toBe("too_small");
+  expect(tooSmallMap.error!.issues[0].message).toContain("yozuv");
+  expect(tooSmallMap.error!.issues[0].message).toContain("bo‘lishi kerak");
+
+  const tooBigMap = z
+    .map(z.string(), z.string())
+    .max(2)
+    .safeParse(
+      new Map([
+        ["a", "b"],
+        ["c", "d"],
+        ["e", "f"],
+      ])
+    );
+  expect(tooBigMap.error!.issues[0].code).toBe("too_big");
+  expect(tooBigMap.error!.issues[0].message).toContain("yozuv");
+  expect(tooBigMap.error!.issues[0].message).toContain("bo‘lishi kerak");
+});

gui/frontend/node_modules/zod/src/v4/core/tests/record-constructor.test.ts

@@ -0,0 +1,125 @@
+import { expect, test } from "vitest";
+import * as z from "zod/v4";
+
+test("record should parse objects with non-function constructor field", () => {
+  const schema = z.record(z.string(), z.any());
+
+  expect(() => schema.parse({ constructor: "string", key: "value" })).not.toThrow();
+
+  const result1 = schema.parse({ constructor: "string", key: "value" });
+  expect(result1).toEqual({ constructor: "string", key: "value" });
+
+  expect(() => schema.parse({ constructor: 123, key: "value" })).not.toThrow();
+
+  const result2 = schema.parse({ constructor: 123, key: "value" });
+  expect(result2).toEqual({ constructor: 123, key: "value" });
+
+  expect(() => schema.parse({ constructor: null, key: "value" })).not.toThrow();
+
+  const result3 = schema.parse({ constructor: null, key: "value" });
+  expect(result3).toEqual({ constructor: null, key: "value" });
+
+  expect(() => schema.parse({ constructor: {}, key: "value" })).not.toThrow();
+
+  const result4 = schema.parse({ constructor: {}, key: "value" });
+  expect(result4).toEqual({ constructor: {}, key: "value" });
+
+  expect(() => schema.parse({ constructor: [], key: "value" })).not.toThrow();
+
+  const result5 = schema.parse({ constructor: [], key: "value" });
+  expect(result5).toEqual({ constructor: [], key: "value" });
+
+  expect(() => schema.parse({ constructor: true, key: "value" })).not.toThrow();
+
+  const result6 = schema.parse({ constructor: true, key: "value" });
+  expect(result6).toEqual({ constructor: true, key: "value" });
+});
+
+test("record should still work with normal objects", () => {
+  const schema = z.record(z.string(), z.string());
+
+  expect(() => schema.parse({ normalKey: "value" })).not.toThrow();
+
+  const result1 = schema.parse({ normalKey: "value" });
+  expect(result1).toEqual({ normalKey: "value" });
+
+  expect(() => schema.parse({ key1: "value1", key2: "value2" })).not.toThrow();
+
+  const result2 = schema.parse({ key1: "value1", key2: "value2" });
+  expect(result2).toEqual({ key1: "value1", key2: "value2" });
+});
+
+test("record should validate values according to schema even with constructor field", () => {
+  const stringSchema = z.record(z.string(), z.string());
+
+  expect(() => stringSchema.parse({ constructor: "string", key: "value" })).not.toThrow();
+
+  expect(() => stringSchema.parse({ constructor: 123, key: "value" })).toThrow();
+});
+
+test("record should work with different key types and constructor field", () => {
+  const enumSchema = z.record(z.enum(["constructor", "key"]), z.string());
+
+  expect(() => enumSchema.parse({ constructor: "value1", key: "value2" })).not.toThrow();
+
+  const result = enumSchema.parse({ constructor: "value1", key: "value2" });
+  expect(result).toEqual({ constructor: "value1", key: "value2" });
+});
+
+test("record should skip non-enumerable own properties", () => {
+  const schema = z.record(z.string(), z.string());
+
+  const input = { key: "value" };
+  Object.defineProperty(input, "~standard", {
+    value: { validate: () => {}, vendor: "zod", version: 1 },
+    enumerable: false,
+    writable: false,
+    configurable: false,
+  });
+
+  const result = schema.safeParse(input);
+  expect(result.success).toBe(true);
+  if (result.success) {
+    expect(result.data).toEqual({ key: "value" });
+    expect("~standard" in result.data).toBe(false);
+  }
+});
+
+test("record fails on enumerable invalid values even when non-enumerable properties are present", () => {
+  const schema = z.record(z.string(), z.string());
+
+  const input = { key: "value", bad: 123 };
+  Object.defineProperty(input, "hidden", {
+    value: "should be ignored",
+    enumerable: false,
+  });
+
+  const result = schema.safeParse(input);
+  expect(result.success).toBe(false);
+});
+
+test("record validates enumerable Symbol keys and skips non-enumerable Symbol keys", () => {
+  const enumerableSym = Symbol.for("included");
+  const nonEnumerableSym = Symbol.for("hidden");
+  const schema = z.record(z.symbol(), z.string());
+
+  const input: Record<symbol, unknown> = { [enumerableSym]: "value" };
+  Object.defineProperty(input, nonEnumerableSym, {
+    value: 123,
+    enumerable: false,
+  });
+
+  const result = schema.safeParse(input);
+  expect(result.success).toBe(true);
+  if (result.success) {
+    expect(result.data[enumerableSym]).toBe("value");
+    expect(Object.prototype.hasOwnProperty.call(result.data, nonEnumerableSym)).toBe(false);
+  }
+});
+
+test("z.json() accepts z.toJSONSchema() output (issue #5714)", () => {
+  const schema = z.object({ name: z.string() });
+  const jsonSchema = z.toJSONSchema(schema);
+
+  expect(z.json().safeParse(jsonSchema).success).toBe(true);
+});

gui/frontend/node_modules/zod/src/v4/core/tests/recursive-tuples.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+import * as z from "zod/v4";
+
+describe("Recursive Tuples Regression #5089", () => {
+  it("creates recursive tuple without crash", () => {
+    expect(() => {
+      const y = z.lazy((): any => z.tuple([y, y]).or(z.string()));
+    }).not.toThrow();
+  });
+
+  it("parses recursive tuple data correctly", () => {
+    const y = z.lazy((): any => z.tuple([y, y]).or(z.string()));
+
+    // Base case
+    expect(y.parse("hello")).toBe("hello");
+
+    // Recursive cases
+    expect(() => y.parse(["a", "b"])).not.toThrow();
+    expect(() => y.parse(["a", ["b", "c"]])).not.toThrow();
+  });
+
+  it("matches #5089 expected behavior", () => {
+    // Exact code from the issue
+    expect(() => {
+      const y = z.lazy((): any => z.tuple([y, y]).or(z.string()));
+      y.parse(["a", ["b", "c"]]);
+    }).not.toThrow();
+  });
+
+  it("handles workaround pattern", () => {
+    // Alternative pattern from issue discussion
+    expect(() => {
+      const y = z.lazy((): any => z.string().or(z.lazy(() => z.tuple([y, y]))));
+      y.parse(["a", ["b", "c"]]);
+    }).not.toThrow();
+  });
+
+  it("recursive arrays still work (comparison)", () => {
+    const y = z.lazy((): any => z.array(y).or(z.string()));
+
+    expect(y.parse("hello")).toBe("hello");
+    expect(y.parse(["hello", "world"])).toEqual(["hello", "world"]);
+    expect(y.parse(["a", ["b", "c"]])).toEqual(["a", ["b", "c"]]);
+  });
+});

gui/frontend/node_modules/zod/src/v4/core/to-json-schema.ts

@@ -0,0 +1,622 @@
+import type * as core from "../core/index.js";
+import type * as JSONSchema from "./json-schema.js";
+import { type $ZodRegistry, globalRegistry } from "./registries.js";
+import type * as schemas from "./schemas.js";
+import type { StandardJSONSchemaV1, StandardSchemaWithJSONProps } from "./standard-schema.js";
+
+export type Processor<T extends schemas.$ZodType = schemas.$ZodType> = (
+  schema: T,
+  ctx: ToJSONSchemaContext,
+  json: JSONSchema.BaseSchema,
+  params: ProcessParams
+) => void;
+
+export interface JSONSchemaGeneratorParams {
+  processors: Record<string, Processor>;
+  /** A registry used to look up metadata for each schema. Any schema with an `id` property will be extracted as a $def.
+   *  @default globalRegistry */
+  metadata?: $ZodRegistry<Record<string, any>>;
+  /** The JSON Schema version to target.
+   * - `"draft-2020-12"` — Default. JSON Schema Draft 2020-12
+   * - `"draft-07"` — JSON Schema Draft 7
+   * - `"draft-04"` — JSON Schema Draft 4
+   * - `"openapi-3.0"` — OpenAPI 3.0 Schema Object */
+  target?: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string) | undefined;
+  /** How to handle unrepresentable types.
+   * - `"throw"` — Default. Unrepresentable types throw an error
+   * - `"any"` — Unrepresentable types become `{}` */
+  unrepresentable?: "throw" | "any";
+  /** Arbitrary custom logic that can be used to modify the generated JSON Schema. */
+  override?: (ctx: {
+    zodSchema: schemas.$ZodTypes;
+    jsonSchema: JSONSchema.BaseSchema;
+    path: (string | number)[];
+  }) => void;
+  /** Whether to extract the `"input"` or `"output"` type. Relevant to transforms, defaults, coerced primitives, etc.
+   * - `"output"` — Default. Convert the output schema.
+   * - `"input"` — Convert the input schema. */
+  io?: "input" | "output";
+  cycles?: "ref" | "throw";
+  reused?: "ref" | "inline";
+  external?:
+    | {
+        registry: $ZodRegistry<{ id?: string | undefined }>;
+        uri?: ((id: string) => string) | undefined;
+        defs: Record<string, JSONSchema.BaseSchema>;
+      }
+    | undefined;
+}
+
+/**
+ * Parameters for the toJSONSchema function.
+ */
+export type ToJSONSchemaParams = Omit<JSONSchemaGeneratorParams, "processors" | "external">;
+
+/**
+ * Parameters for the toJSONSchema function when passing a registry.
+ */
+export interface RegistryToJSONSchemaParams extends ToJSONSchemaParams {
+  uri?: (id: string) => string;
+}
+
+export interface ProcessParams {
+  schemaPath: schemas.$ZodType[];
+  path: (string | number)[];
+}
+
+export interface Seen {
+  /** JSON Schema result for this Zod schema */
+  schema: JSONSchema.BaseSchema;
+  /** A cached version of the schema that doesn't get overwritten during ref resolution */
+  def?: JSONSchema.BaseSchema;
+  defId?: string | undefined;
+  /** Number of times this schema was encountered during traversal */
+  count: number;
+  /** Cycle path */
+  cycle?: (string | number)[] | undefined;
+  isParent?: boolean | undefined;
+  /** Schema to inherit JSON Schema properties from (set by processor for wrappers) */
+  ref?: schemas.$ZodType | null;
+  /** JSON Schema property path for this schema */
+  path?: (string | number)[] | undefined;
+}
+
+export interface ToJSONSchemaContext {
+  processors: Record<string, Processor>;
+  metadataRegistry: $ZodRegistry<Record<string, any>>;
+  target: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string);
+  unrepresentable: "throw" | "any";
+  override: (ctx: {
+    // must be schemas.$ZodType to prevent recursive type resolution error
+    zodSchema: schemas.$ZodType;
+    jsonSchema: JSONSchema.BaseSchema;
+    path: (string | number)[];
+  }) => void;
+  io: "input" | "output";
+  counter: number;
+  seen: Map<schemas.$ZodType, Seen>;
+  cycles: "ref" | "throw";
+  reused: "ref" | "inline";
+  external?:
+    | {
+        registry: $ZodRegistry<{ id?: string | undefined }>;
+        uri?: ((id: string) => string) | undefined;
+        defs: Record<string, JSONSchema.BaseSchema>;
+      }
+    | undefined;
+}
+
+// function initializeContext<T extends schemas.$ZodType>(inputs: JSONSchemaGeneratorParams<T>): ToJSONSchemaContext<T> {
+//   return {
+//     processor: inputs.processor,
+//     metadataRegistry: inputs.metadata ?? globalRegistry,
+//     target: inputs.target ?? "draft-2020-12",
+//     unrepresentable: inputs.unrepresentable ?? "throw",
+//   };
+// }
+
+export function initializeContext(params: JSONSchemaGeneratorParams): ToJSONSchemaContext {
+  // Normalize target: convert old non-hyphenated versions to hyphenated versions
+  let target: ToJSONSchemaContext["target"] = params?.target ?? "draft-2020-12";
+  if (target === "draft-4") target = "draft-04";
+  if (target === "draft-7") target = "draft-07";
+
+  return {
+    processors: params.processors ?? {},
+    metadataRegistry: params?.metadata ?? globalRegistry,
+    target,
+    unrepresentable: params?.unrepresentable ?? "throw",
+    override: (params?.override as any) ?? (() => {}),
+    io: params?.io ?? "output",
+    counter: 0,
+    seen: new Map(),
+    cycles: params?.cycles ?? "ref",
+    reused: params?.reused ?? "inline",
+    external: params?.external ?? undefined,
+  };
+}
+
+export function process<T extends schemas.$ZodType>(
+  schema: T,
+  ctx: ToJSONSchemaContext,
+  _params: ProcessParams = { path: [], schemaPath: [] }
+): JSONSchema.BaseSchema {
+  const def = schema._zod.def as schemas.$ZodTypes["_zod"]["def"];
+
+  // check for schema in seens
+  const seen = ctx.seen.get(schema);
+
+  if (seen) {
+    seen.count++;
+
+    // check if cycle
+    const isCycle = _params.schemaPath.includes(schema);
+    if (isCycle) {
+      seen.cycle = _params.path;
+    }
+
+    return seen.schema;
+  }
+
+  // initialize
+  const result: Seen = { schema: {}, count: 1, cycle: undefined, path: _params.path };
+  ctx.seen.set(schema, result);
+
+  // custom method overrides default behavior
+  const overrideSchema = schema._zod.toJSONSchema?.();
+  if (overrideSchema) {
+    result.schema = overrideSchema as any;
+  } else {
+    const params = {
+      ..._params,
+      schemaPath: [..._params.schemaPath, schema],
+      path: _params.path,
+    };
+
+    if (schema._zod.processJSONSchema) {
+      schema._zod.processJSONSchema(ctx, result.schema, params);
+    } else {
+      const _json = result.schema;
+      const processor = ctx.processors[def.type];
+      if (!processor) {
+        throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
+      }
+      processor(schema, ctx, _json, params);
+    }
+
+    const parent = schema._zod.parent as T;
+
+    if (parent) {
+      // Also set ref if processor didn't (for inheritance)
+      if (!result.ref) result.ref = parent;
+      process(parent, ctx, params);
+      ctx.seen.get(parent)!.isParent = true;
+    }
+  }
+
+  // metadata
+  const meta = ctx.metadataRegistry.get(schema);
+  if (meta) Object.assign(result.schema, meta);
+
+  if (ctx.io === "input" && isTransforming(schema)) {
+    // examples/defaults only apply to output type of pipe
+    delete result.schema.examples;
+    delete result.schema.default;
+  }
+
+  // set prefault as default
+  if (ctx.io === "input" && "_prefault" in result.schema) result.schema.default ??= result.schema._prefault;
+  delete result.schema._prefault;
+
+  // pulling fresh from ctx.seen in case it was overwritten
+  const _result = ctx.seen.get(schema)!;
+
+  return _result.schema;
+}
+
+export function extractDefs<T extends schemas.$ZodType>(
+  ctx: ToJSONSchemaContext,
+  schema: T
+  // params: EmitParams
+): void {
+  // iterate over seen map;
+  const root = ctx.seen.get(schema);
+
+  if (!root) throw new Error("Unprocessed schema. This is a bug in Zod.");
+
+  // Track ids to detect duplicates across different schemas
+  const idToSchema = new Map<string, schemas.$ZodType>();
+  for (const entry of ctx.seen.entries()) {
+    const id = ctx.metadataRegistry.get(entry[0])?.id;
+    if (id) {
+      const existing = idToSchema.get(id);
+      if (existing && existing !== entry[0]) {
+        throw new Error(
+          `Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`
+        );
+      }
+      idToSchema.set(id, entry[0]);
+    }
+  }
+
+  // returns a ref to the schema
+  // defId will be empty if the ref points to an external schema (or #)
+  const makeURI = (entry: [schemas.$ZodType<unknown, unknown>, Seen]): { ref: string; defId?: string } => {
+    // comparing the seen objects because sometimes
+    // multiple schemas map to the same seen object.
+    // e.g. lazy
+
+    // external is configured
+    const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
+    if (ctx.external) {
+      const externalId = ctx.external.registry.get(entry[0])?.id; // ?? "__shared";// `__schema${ctx.counter++}`;
+
+      // check if schema is in the external registry
+      const uriGenerator = ctx.external.uri ?? ((id: string) => id);
+      if (externalId) {
+        return { ref: uriGenerator(externalId) };
+      }
+
+      // otherwise, add to __shared
+      const id: string = entry[1].defId ?? (entry[1].schema.id as string) ?? `schema${ctx.counter++}`;
+      entry[1].defId = id; // set defId so it will be reused if needed
+      return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
+    }
+
+    if (entry[1] === root) {
+      return { ref: "#" };
+    }
+
+    // self-contained schema
+    const uriPrefix = `#`;
+    const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
+    const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
+    return { defId, ref: defUriPrefix + defId };
+  };
+
+  // stored cached version in `def` property
+  // remove all properties, set $ref
+  const extractToDef = (entry: [schemas.$ZodType<unknown, unknown>, Seen]): void => {
+    // if the schema is already a reference, do not extract it
+    if (entry[1].schema.$ref) {
+      return;
+    }
+    const seen = entry[1];
+    const { ref, defId } = makeURI(entry);
+
+    seen.def = { ...seen.schema };
+    // defId won't be set if the schema is a reference to an external schema
+    // or if the schema is the root schema
+    if (defId) seen.defId = defId;
+    // wipe away all properties except $ref
+    const schema = seen.schema;
+    for (const key in schema) {
+      delete schema[key];
+    }
+    schema.$ref = ref;
+  };
+
+  // throw on cycles
+
+  // break cycles
+  if (ctx.cycles === "throw") {
+    for (const entry of ctx.seen.entries()) {
+      const seen = entry[1];
+      if (seen.cycle) {
+        throw new Error(
+          "Cycle detected: " +
+            `#/${seen.cycle?.join("/")}/<root>` +
+            '\n\nSet the `cycles` parameter to `"ref"` to resolve cyclical schemas with defs.'
+        );
+      }
+    }
+  }
+
+  // extract schemas into $defs
+  for (const entry of ctx.seen.entries()) {
+    const seen = entry[1];
+
+    // convert root schema to # $ref
+    if (schema === entry[0]) {
+      extractToDef(entry); // this has special handling for the root schema
+      continue;
+    }
+
+    // extract schemas that are in the external registry
+    if (ctx.external) {
+      const ext = ctx.external.registry.get(entry[0])?.id;
+      if (schema !== entry[0] && ext) {
+        extractToDef(entry);
+        continue;
+      }
+    }
+
+    // extract schemas with `id` meta
+    const id = ctx.metadataRegistry.get(entry[0])?.id;
+    if (id) {
+      extractToDef(entry);
+      continue;
+    }
+
+    // break cycles
+    if (seen.cycle) {
+      // any
+      extractToDef(entry);
+      continue;
+    }
+
+    // extract reused schemas
+    if (seen.count > 1) {
+      if (ctx.reused === "ref") {
+        extractToDef(entry);
+        // biome-ignore lint:
+        continue;
+      }
+    }
+  }
+}
+
+export function finalize<T extends schemas.$ZodType>(
+  ctx: ToJSONSchemaContext,
+  schema: T
+): ZodStandardJSONSchemaPayload<T> {
+  const root = ctx.seen.get(schema);
+  if (!root) throw new Error("Unprocessed schema. This is a bug in Zod.");
+
+  // flatten refs - inherit properties from parent schemas
+  const flattenRef = (zodSchema: schemas.$ZodType) => {
+    const seen = ctx.seen.get(zodSchema)!;
+
+    // already processed
+    if (seen.ref === null) return;
+
+    const schema = seen.def ?? seen.schema;
+    const _cached = { ...schema };
+
+    const ref = seen.ref;
+    seen.ref = null; // prevent infinite recursion
+
+    if (ref) {
+      flattenRef(ref);
+
+      const refSeen = ctx.seen.get(ref)!;
+      const refSchema = refSeen.schema;
+
+      // merge referenced schema into current
+      if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
+        // older drafts can't combine $ref with other properties
+        schema.allOf = schema.allOf ?? [];
+        schema.allOf.push(refSchema);
+      } else {
+        Object.assign(schema, refSchema);
+      }
+      // restore child's own properties (child wins)
+      Object.assign(schema, _cached);
+
+      const isParentRef = zodSchema._zod.parent === ref;
+
+      // For parent chain, child is a refinement - remove parent-only properties
+      if (isParentRef) {
+        for (const key in schema) {
+          if (key === "$ref" || key === "allOf") continue;
+          if (!(key in _cached)) {
+            delete schema[key];
+          }
+        }
+      }
+
+      // When ref was extracted to $defs, remove properties that match the definition
+      if (refSchema.$ref && refSeen.def) {
+        for (const key in schema) {
+          if (key === "$ref" || key === "allOf") continue;
+          if (key in refSeen.def && JSON.stringify(schema[key]) === JSON.stringify(refSeen.def[key])) {
+            delete schema[key];
+          }
+        }
+      }
+    }
+
+    // If parent was extracted (has $ref), propagate $ref to this schema
+    // This handles cases like: readonly().meta({id}).describe()
+    // where processor sets ref to innerType but parent should be referenced
+    const parent = zodSchema._zod.parent;
+    if (parent && parent !== ref) {
+      // Ensure parent is processed first so its def has inherited properties
+      flattenRef(parent);
+      const parentSeen = ctx.seen.get(parent);
+      if (parentSeen?.schema.$ref) {
+        schema.$ref = parentSeen.schema.$ref;
+        // De-duplicate with parent's definition
+        if (parentSeen.def) {
+          for (const key in schema) {
+            if (key === "$ref" || key === "allOf") continue;
+            if (key in parentSeen.def && JSON.stringify(schema[key]) === JSON.stringify(parentSeen.def[key])) {
+              delete schema[key];
+            }
+          }
+        }
+      }
+    }
+
+    // execute overrides
+    ctx.override({
+      zodSchema: zodSchema as schemas.$ZodTypes,
+      jsonSchema: schema,
+      path: seen.path ?? [],
+    });
+  };
+
+  for (const entry of [...ctx.seen.entries()].reverse()) {
+    flattenRef(entry[0]);
+  }
+
+  const result: JSONSchema.BaseSchema = {};
+  if (ctx.target === "draft-2020-12") {
+    result.$schema = "https://json-schema.org/draft/2020-12/schema";
+  } else if (ctx.target === "draft-07") {
+    result.$schema = "http://json-schema.org/draft-07/schema#";
+  } else if (ctx.target === "draft-04") {
+    result.$schema = "http://json-schema.org/draft-04/schema#";
+  } else if (ctx.target === "openapi-3.0") {
+    // OpenAPI 3.0 schema objects should not include a $schema property
+  } else {
+    // Arbitrary string values are allowed but won't have a $schema property set
+  }
+
+  if (ctx.external?.uri) {
+    const id = ctx.external.registry.get(schema)?.id;
+    if (!id) throw new Error("Schema is missing an `id` property");
+    result.$id = ctx.external.uri(id);
+  }
+
+  Object.assign(result, root.def ?? root.schema);
+
+  // The `id` in `.meta()` is a Zod-specific registration tag used to extract
+  // schemas into $defs — it is not user-facing JSON Schema metadata. Strip it
+  // from the output body where it would otherwise leak. The id is preserved
+  // implicitly via the $defs key (and via $ref paths).
+  const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
+  if (rootMetaId !== undefined && result.id === rootMetaId) delete result.id;
+
+  // build defs object
+  const defs: JSONSchema.BaseSchema["$defs"] = ctx.external?.defs ?? {};
+  for (const entry of ctx.seen.entries()) {
+    const seen = entry[1];
+    if (seen.def && seen.defId) {
+      if (seen.def.id === seen.defId) delete seen.def.id;
+      defs[seen.defId] = seen.def;
+    }
+  }
+
+  // set definitions in result
+  if (ctx.external) {
+  } else {
+    if (Object.keys(defs).length > 0) {
+      if (ctx.target === "draft-2020-12") {
+        result.$defs = defs;
+      } else {
+        result.definitions = defs;
+      }
+    }
+  }
+
+  try {
+    // this "finalizes" this schema and ensures all cycles are removed
+    // each call to finalize() is functionally independent
+    // though the seen map is shared
+    const finalized = JSON.parse(JSON.stringify(result));
+    Object.defineProperty(finalized, "~standard", {
+      value: {
+        ...schema["~standard"],
+        jsonSchema: {
+          input: createStandardJSONSchemaMethod(schema, "input", ctx.processors),
+          output: createStandardJSONSchemaMethod(schema, "output", ctx.processors),
+        },
+      },
+      enumerable: false,
+      writable: false,
+    });
+
+    return finalized;
+  } catch (_err) {
+    throw new Error("Error converting schema to JSON.");
+  }
+}
+
+function isTransforming(
+  _schema: schemas.$ZodType,
+  _ctx?: {
+    seen: Set<schemas.$ZodType>;
+  }
+): boolean {
+  const ctx = _ctx ?? { seen: new Set() };
+
+  if (ctx.seen.has(_schema)) return false;
+  ctx.seen.add(_schema);
+
+  const def = (_schema as schemas.$ZodTypes)._zod.def;
+
+  if (def.type === "transform") return true;
+
+  if (def.type === "array") return isTransforming(def.element, ctx);
+  if (def.type === "set") return isTransforming(def.valueType, ctx);
+  if (def.type === "lazy") return isTransforming(def.getter(), ctx);
+
+  if (
+    def.type === "promise" ||
+    def.type === "optional" ||
+    def.type === "nonoptional" ||
+    def.type === "nullable" ||
+    def.type === "readonly" ||
+    def.type === "default" ||
+    def.type === "prefault"
+  ) {
+    return isTransforming(def.innerType, ctx);
+  }
+
+  if (def.type === "intersection") {
+    return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
+  }
+  if (def.type === "record" || def.type === "map") {
+    return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
+  }
+  if (def.type === "pipe") {
+    if (_schema._zod.traits.has("$ZodCodec")) return true;
+    return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
+  }
+
+  if (def.type === "object") {
+    for (const key in def.shape) {
+      if (isTransforming(def.shape[key]!, ctx)) return true;
+    }
+    return false;
+  }
+  if (def.type === "union") {
+    for (const option of def.options) {
+      if (isTransforming(option, ctx)) return true;
+    }
+    return false;
+  }
+  if (def.type === "tuple") {
+    for (const item of def.items) {
+      if (isTransforming(item, ctx)) return true;
+    }
+    if (def.rest && isTransforming(def.rest, ctx)) return true;
+    return false;
+  }
+
+  return false;
+}
+
+export type ZodStandardSchemaWithJSON<T> = StandardSchemaWithJSONProps<core.input<T>, core.output<T>>;
+export interface ZodStandardJSONSchemaPayload<T> extends JSONSchema.BaseSchema {
+  "~standard": ZodStandardSchemaWithJSON<T>;
+}
+
+/**
+ * Creates a toJSONSchema method for a schema instance.
+ * This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
+ */
+export const createToJSONSchemaMethod =
+  <T extends schemas.$ZodType>(schema: T, processors: Record<string, Processor> = {}) =>
+  (params?: ToJSONSchemaParams): ZodStandardJSONSchemaPayload<T> => {
+    const ctx = initializeContext({ ...params, processors });
+    process(schema, ctx);
+    extractDefs(ctx, schema);
+    return finalize(ctx, schema);
+  };
+
+/**
+ * Creates a toJSONSchema method for a schema instance.
+ * This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
+ */
+type StandardJSONSchemaMethodParams = Parameters<StandardJSONSchemaV1["~standard"]["jsonSchema"]["input"]>[0];
+export const createStandardJSONSchemaMethod =
+  <T extends schemas.$ZodType>(schema: T, io: "input" | "output", processors: Record<string, Processor> = {}) =>
+  (params?: StandardJSONSchemaMethodParams): JSONSchema.BaseSchema => {
+    const { libraryOptions, target } = params ?? {};
+    const ctx = initializeContext({ ...(libraryOptions ?? {}), target, io, processors });
+    process(schema, ctx);
+    extractDefs(ctx, schema);
+    return finalize(ctx, schema);
+  };

gui/frontend/node_modules/zod/src/v4/core/util.ts

@@ -0,0 +1,983 @@
+import type * as checks from "./checks.js";
+import { globalConfig } from "./core.js";
+import type { $ZodConfig } from "./core.js";
+import type * as errors from "./errors.js";
+import type * as schemas from "./schemas.js";
+
+// json
+export type JSONType = string | number | boolean | null | JSONType[] | { [key: string]: JSONType };
+export type JWTAlgorithm =
+  | "HS256"
+  | "HS384"
+  | "HS512"
+  | "RS256"
+  | "RS384"
+  | "RS512"
+  | "ES256"
+  | "ES384"
+  | "ES512"
+  | "PS256"
+  | "PS384"
+  | "PS512"
+  | "EdDSA"
+  | (string & {});
+
+export type HashAlgorithm = "md5" | "sha1" | "sha256" | "sha384" | "sha512";
+export type HashEncoding = "hex" | "base64" | "base64url";
+export type HashFormat = `${HashAlgorithm}_${HashEncoding}`;
+export type IPVersion = "v4" | "v6";
+export type MimeTypes =
+  | "application/json"
+  | "application/xml"
+  | "application/x-www-form-urlencoded"
+  | "application/javascript"
+  | "application/pdf"
+  | "application/zip"
+  | "application/vnd.ms-excel"
+  | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+  | "application/msword"
+  | "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+  | "application/vnd.ms-powerpoint"
+  | "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+  | "application/octet-stream"
+  | "application/graphql"
+  | "text/html"
+  | "text/plain"
+  | "text/css"
+  | "text/javascript"
+  | "text/csv"
+  | "image/png"
+  | "image/jpeg"
+  | "image/gif"
+  | "image/svg+xml"
+  | "image/webp"
+  | "audio/mpeg"
+  | "audio/ogg"
+  | "audio/wav"
+  | "audio/webm"
+  | "video/mp4"
+  | "video/webm"
+  | "video/ogg"
+  | "font/woff"
+  | "font/woff2"
+  | "font/ttf"
+  | "font/otf"
+  | "multipart/form-data"
+  | (string & {});
+export type ParsedTypes =
+  | "string"
+  | "number"
+  | "bigint"
+  | "boolean"
+  | "symbol"
+  | "undefined"
+  | "object"
+  | "function"
+  | "file"
+  | "date"
+  | "array"
+  | "map"
+  | "set"
+  | "nan"
+  | "null"
+  | "promise";
+
+// utils
+export type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
+export type AssertNotEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? false : true;
+export type AssertExtends<T, U> = T extends U ? T : never;
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
+export type MakePartial<T, K extends keyof T> = Omit<T, K> & InexactPartial<Pick<T, K>>;
+export type MakeRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+
+export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
+export type NoUndefined<T> = T extends undefined ? never : T;
+export type Whatever = {} | undefined | null;
+export type LoosePartial<T extends object> = InexactPartial<T> & {
+  [k: string]: unknown;
+};
+export type Mask<Keys extends PropertyKey> = { [K in Keys]?: true };
+export type Writeable<T> = { -readonly [P in keyof T]: T[P] } & {};
+export type InexactPartial<T> = {
+  [P in keyof T]?: T[P] | undefined;
+};
+export type EmptyObject = Record<string, never>;
+export type BuiltIn =
+  | (((...args: any[]) => any) | (new (...args: any[]) => any))
+  | { readonly [Symbol.toStringTag]: string }
+  | Date
+  | Error
+  | Generator
+  | Promise<unknown>
+  | RegExp;
+export type MakeReadonly<T> = T extends Map<infer K, infer V>
+  ? ReadonlyMap<K, V>
+  : T extends Set<infer V>
+    ? ReadonlySet<V>
+    : T extends [infer Head, ...infer Tail]
+      ? readonly [Head, ...Tail]
+      : T extends Array<infer V>
+        ? ReadonlyArray<V>
+        : T extends BuiltIn
+          ? T
+          : Readonly<T>;
+export type SomeObject = Record<PropertyKey, any>;
+export type Identity<T> = T;
+export type Flatten<T> = Identity<{ [k in keyof T]: T[k] }>;
+export type Mapped<T> = { [k in keyof T]: T[k] };
+export type Prettify<T> = {
+  // @ts-ignore
+  [K in keyof T]: T[K];
+} & {};
+
+export type NoNeverKeys<T> = {
+  [k in keyof T]: [T[k]] extends [never] ? never : k;
+}[keyof T];
+export type NoNever<T> = Identity<{
+  [k in NoNeverKeys<T>]: k extends keyof T ? T[k] : never;
+}>;
+export type Extend<A extends SomeObject, B extends SomeObject> = Flatten<
+  // fast path when there is no keys overlap
+  keyof A & keyof B extends never
+    ? A & B
+    : {
+        [K in keyof A as K extends keyof B ? never : K]: A[K];
+      } & {
+        [K in keyof B]: B[K];
+      }
+>;
+
+export type TupleItems = ReadonlyArray<schemas.SomeType>;
+export type AnyFunc = (...args: any[]) => any;
+export type IsProp<T, K extends keyof T> = T[K] extends AnyFunc ? never : K;
+export type MaybeAsync<T> = T | Promise<T>;
+export type KeyOf<T> = keyof OmitIndexSignature<T>;
+export type OmitIndexSignature<T> = {
+  [K in keyof T as string extends K ? never : K extends string ? K : never]: T[K];
+};
+export type ExtractIndexSignature<T> = {
+  [K in keyof T as string extends K ? K : K extends string ? never : K]: T[K];
+};
+export type Keys<T extends object> = keyof OmitIndexSignature<T>;
+
+export type SchemaClass<T extends schemas.SomeType> = {
+  new (def: T["_zod"]["def"]): T;
+};
+export type EnumValue = string | number; // | bigint | boolean | symbol;
+export type EnumLike = Readonly<Record<string, EnumValue>>;
+export type ToEnum<T extends EnumValue> = Flatten<{ [k in T]: k }>;
+export type KeysEnum<T extends object> = ToEnum<Exclude<keyof T, symbol>>;
+export type KeysArray<T extends object> = Flatten<(keyof T & string)[]>;
+export type Literal = string | number | bigint | boolean | null | undefined;
+export type LiteralArray = Array<Literal>;
+export type Primitive = string | number | symbol | bigint | boolean | null | undefined;
+export type PrimitiveArray = Array<Primitive>;
+export type HasSize = { size: number };
+export type HasLength = { length: number }; // string | Array<unknown> | Set<unknown> | File;
+export type Numeric = number | bigint | Date;
+export type SafeParseResult<T> = SafeParseSuccess<T> | SafeParseError<T>;
+export type SafeParseSuccess<T> = { success: true; data: T; error?: never };
+export type SafeParseError<T> = {
+  success: false;
+  data?: never;
+  error: errors.$ZodError<T>;
+};
+
+export type PropValues = Record<string, Set<Primitive>>;
+export type PrimitiveSet = Set<Primitive>;
+
+// functions
+export function assertEqual<A, B>(val: AssertEqual<A, B>): AssertEqual<A, B> {
+  return val;
+}
+
+export function assertNotEqual<A, B>(val: AssertNotEqual<A, B>): AssertNotEqual<A, B> {
+  return val;
+}
+
+export function assertIs<T>(_arg: T): void {}
+
+export function assertNever(_x: never): never {
+  throw new Error("Unexpected value in exhaustive check");
+}
+export function assert<T>(_: any): asserts _ is T {}
+
+export function getEnumValues(entries: EnumLike): EnumValue[] {
+  const numericValues = Object.values(entries).filter((v) => typeof v === "number");
+  const values = Object.entries(entries)
+    .filter(([k, _]) => numericValues.indexOf(+k) === -1)
+    .map(([_, v]) => v);
+  return values;
+}
+
+export function joinValues<T extends Primitive[]>(array: T, separator = "|"): string {
+  return array.map((val) => stringifyPrimitive(val)).join(separator);
+}
+
+export function jsonStringifyReplacer(_: string, value: any): any {
+  if (typeof value === "bigint") return value.toString();
+  return value;
+}
+
+export function cached<T>(getter: () => T): { value: T } {
+  const set = false;
+  return {
+    get value() {
+      if (!set) {
+        const value = getter();
+        Object.defineProperty(this, "value", { value });
+        return value;
+      }
+      throw new Error("cached value already set");
+    },
+  };
+}
+
+export function nullish(input: any): boolean {
+  return input === null || input === undefined;
+}
+
+export function cleanRegex(source: string): string {
+  const start = source.startsWith("^") ? 1 : 0;
+  const end = source.endsWith("$") ? source.length - 1 : source.length;
+  return source.slice(start, end);
+}
+
+export function floatSafeRemainder(val: number, step: number): number {
+  const ratio = val / step;
+  const roundedRatio = Math.round(ratio);
+  // Use a relative epsilon scaled to the magnitude of the result
+  const tolerance = Number.EPSILON * Math.max(Math.abs(ratio), 1);
+  if (Math.abs(ratio - roundedRatio) < tolerance) return 0;
+  return ratio - roundedRatio;
+}
+
+const EVALUATING = /* @__PURE__*/ Symbol("evaluating");
+
+export function defineLazy<T, K extends keyof T>(object: T, key: K, getter: () => T[K]): void {
+  let value: T[K] | typeof EVALUATING | undefined = undefined;
+  Object.defineProperty(object, key, {
+    get() {
+      if (value === EVALUATING) {
+        // Circular reference detected, return undefined to break the cycle
+        return undefined as T[K];
+      }
+      if (value === undefined) {
+        value = EVALUATING;
+        value = getter();
+      }
+      return value;
+    },
+    set(v) {
+      Object.defineProperty(object, key, {
+        value: v,
+        // configurable: true,
+      });
+      // object[key] = v;
+    },
+    configurable: true,
+  });
+}
+
+export function objectClone(obj: object) {
+  return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
+}
+
+export function assignProp<T extends object, K extends PropertyKey>(
+  target: T,
+  prop: K,
+  value: K extends keyof T ? T[K] : any
+): void {
+  Object.defineProperty(target, prop, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true,
+  });
+}
+
+export function mergeDefs(...defs: Record<string, any>[]): any {
+  const mergedDescriptors: Record<string, PropertyDescriptor> = {};
+
+  for (const def of defs) {
+    const descriptors = Object.getOwnPropertyDescriptors(def);
+    Object.assign(mergedDescriptors, descriptors);
+  }
+
+  return Object.defineProperties({}, mergedDescriptors);
+}
+
+export function cloneDef(schema: schemas.$ZodType): any {
+  return mergeDefs(schema._zod.def);
+}
+
+export function getElementAtPath(obj: any, path: (string | number)[] | null | undefined): any {
+  if (!path) return obj;
+  return path.reduce((acc, key) => acc?.[key], obj);
+}
+
+export function promiseAllObject<T extends object>(promisesObj: T): Promise<{ [k in keyof T]: Awaited<T[k]> }> {
+  const keys = Object.keys(promisesObj);
+  const promises = keys.map((key) => (promisesObj as any)[key]);
+
+  return Promise.all(promises).then((results) => {
+    const resolvedObj: any = {};
+    for (let i = 0; i < keys.length; i++) {
+      resolvedObj[keys[i]!] = results[i];
+    }
+    return resolvedObj;
+  });
+}
+
+export function randomString(length = 10): string {
+  const chars = "abcdefghijklmnopqrstuvwxyz";
+  let str = "";
+  for (let i = 0; i < length; i++) {
+    str += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return str;
+}
+
+export function esc(str: string): string {
+  return JSON.stringify(str);
+}
+
+export function slugify(input: string): string {
+  return input
+    .toLowerCase()
+    .trim()
+    .replace(/[^\w\s-]/g, "")
+    .replace(/[\s_-]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+export const captureStackTrace: (targetObject: object, constructorOpt?: Function) => void = (
+  "captureStackTrace" in Error ? Error.captureStackTrace : (..._args: any[]) => {}
+) as any;
+
+export function isObject(data: any): data is Record<PropertyKey, unknown> {
+  return typeof data === "object" && data !== null && !Array.isArray(data);
+}
+
+export const allowsEval: { value: boolean } = /* @__PURE__*/ cached(() => {
+  // Skip the probe under `jitless`: strict CSPs report the caught `new Function`
+  // as a `securitypolicyviolation` even though the throw is swallowed.
+  if (globalConfig.jitless) {
+    return false;
+  }
+
+  // @ts-ignore
+  if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
+    return false;
+  }
+
+  try {
+    const F = Function;
+    new F("");
+    return true;
+  } catch (_) {
+    return false;
+  }
+});
+
+export function isPlainObject(o: any): o is Record<PropertyKey, unknown> {
+  if (isObject(o) === false) return false;
+
+  // modified constructor
+  const ctor = o.constructor;
+  if (ctor === undefined) return true;
+
+  if (typeof ctor !== "function") return true;
+
+  // modified prototype
+  const prot = ctor.prototype;
+  if (isObject(prot) === false) return false;
+
+  // ctor doesn't have static `isPrototypeOf`
+  if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
+    return false;
+  }
+
+  return true;
+}
+
+export function shallowClone(o: any): any {
+  if (isPlainObject(o)) return { ...o };
+  if (Array.isArray(o)) return [...o];
+  if (o instanceof Map) return new Map(o);
+  if (o instanceof Set) return new Set(o);
+  return o;
+}
+
+export function numKeys(data: any): number {
+  let keyCount = 0;
+  for (const key in data) {
+    if (Object.prototype.hasOwnProperty.call(data, key)) {
+      keyCount++;
+    }
+  }
+  return keyCount;
+}
+
+export const getParsedType = (data: any): ParsedTypes => {
+  const t = typeof data;
+
+  switch (t) {
+    case "undefined":
+      return "undefined";
+
+    case "string":
+      return "string";
+
+    case "number":
+      return Number.isNaN(data) ? "nan" : "number";
+
+    case "boolean":
+      return "boolean";
+
+    case "function":
+      return "function";
+
+    case "bigint":
+      return "bigint";
+
+    case "symbol":
+      return "symbol";
+
+    case "object":
+      if (Array.isArray(data)) {
+        return "array";
+      }
+      if (data === null) {
+        return "null";
+      }
+      if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
+        return "promise";
+      }
+      if (typeof Map !== "undefined" && data instanceof Map) {
+        return "map";
+      }
+      if (typeof Set !== "undefined" && data instanceof Set) {
+        return "set";
+      }
+      if (typeof Date !== "undefined" && data instanceof Date) {
+        return "date";
+      }
+      // @ts-ignore
+      if (typeof File !== "undefined" && data instanceof File) {
+        return "file";
+      }
+      return "object";
+
+    default:
+      throw new Error(`Unknown data type: ${t}`);
+  }
+};
+
+export const propertyKeyTypes: Set<string> = /* @__PURE__*/ new Set(["string", "number", "symbol"]);
+export const primitiveTypes: Set<string> = /* @__PURE__*/ new Set([
+  "string",
+  "number",
+  "bigint",
+  "boolean",
+  "symbol",
+  "undefined",
+]);
+export function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// zod-specific utils
+export function clone<T extends schemas.$ZodType>(inst: T, def?: T["_zod"]["def"], params?: { parent: boolean }): T {
+  const cl = new inst._zod.constr(def ?? inst._zod.def);
+  if (!def || params?.parent) cl._zod.parent = inst;
+  return cl as any;
+}
+
+export type EmptyToNever<T> = keyof T extends never ? never : T;
+
+export type Normalize<T> = T extends undefined
+  ? never
+  : T extends Record<any, any>
+    ? Flatten<
+        {
+          [k in keyof Omit<T, "error" | "message">]: T[k];
+        } & ("error" extends keyof T
+          ? {
+              error?: Exclude<T["error"], string>;
+              // path?: PropertyKey[] | undefined;
+              // message?: string | undefined;
+            }
+          : unknown)
+      >
+    : never;
+
+export function normalizeParams<T>(_params: T): Normalize<T> {
+  const params: any = _params;
+
+  if (!params) return {} as any;
+  if (typeof params === "string") return { error: () => params } as any;
+  if (params?.message !== undefined) {
+    if (params?.error !== undefined) throw new Error("Cannot specify both `message` and `error` params");
+    params.error = params.message;
+  }
+  delete params.message;
+  if (typeof params.error === "string") return { ...params, error: () => params.error } as any;
+  return params;
+}
+
+export function createTransparentProxy<T extends object>(getter: () => T): T {
+  let target: T;
+  return new Proxy(
+    {},
+    {
+      get(_, prop, receiver) {
+        target ??= getter();
+        return Reflect.get(target, prop, receiver);
+      },
+      set(_, prop, value, receiver) {
+        target ??= getter();
+        return Reflect.set(target, prop, value, receiver);
+      },
+      has(_, prop) {
+        target ??= getter();
+        return Reflect.has(target, prop);
+      },
+      deleteProperty(_, prop) {
+        target ??= getter();
+        return Reflect.deleteProperty(target, prop);
+      },
+      ownKeys(_) {
+        target ??= getter();
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(_, prop) {
+        target ??= getter();
+        return Reflect.getOwnPropertyDescriptor(target, prop);
+      },
+      defineProperty(_, prop, descriptor) {
+        target ??= getter();
+        return Reflect.defineProperty(target, prop, descriptor);
+      },
+    }
+  ) as T;
+}
+
+export function stringifyPrimitive(value: any): string {
+  if (typeof value === "bigint") return value.toString() + "n";
+  if (typeof value === "string") return `"${value}"`;
+  return `${value}`;
+}
+
+export function optionalKeys(shape: schemas.$ZodShape): string[] {
+  return Object.keys(shape).filter((k) => {
+    return shape[k]!._zod.optin === "optional" && shape[k]!._zod.optout === "optional";
+  });
+}
+
+export type CleanKey<T extends PropertyKey> = T extends `?${infer K}` ? K : T extends `${infer K}?` ? K : T;
+export type ToCleanMap<T extends schemas.$ZodLooseShape> = {
+  [k in keyof T]: k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k;
+};
+export type FromCleanMap<T extends schemas.$ZodLooseShape> = {
+  [k in keyof T as k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k]: k;
+};
+
+export const NUMBER_FORMAT_RANGES: Record<checks.$ZodNumberFormats, [number, number]> = {
+  safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+  int32: [-2147483648, 2147483647],
+  uint32: [0, 4294967295],
+  float32: [-3.4028234663852886e38, 3.4028234663852886e38],
+  float64: [-Number.MAX_VALUE, Number.MAX_VALUE],
+};
+
+export const BIGINT_FORMAT_RANGES: Record<checks.$ZodBigIntFormats, [bigint, bigint]> = {
+  int64: [/* @__PURE__*/ BigInt("-9223372036854775808"), /* @__PURE__*/ BigInt("9223372036854775807")],
+  uint64: [/* @__PURE__*/ BigInt(0), /* @__PURE__*/ BigInt("18446744073709551615")],
+};
+
+export function pick(schema: schemas.$ZodObject, mask: Record<string, unknown>): any {
+  const currDef = schema._zod.def;
+
+  const checks = currDef.checks;
+  const hasChecks = checks && checks.length > 0;
+  if (hasChecks) {
+    throw new Error(".pick() cannot be used on object schemas containing refinements");
+  }
+
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const newShape: Writeable<schemas.$ZodShape> = {};
+      for (const key in mask) {
+        if (!(key in currDef.shape)) {
+          throw new Error(`Unrecognized key: "${key}"`);
+        }
+        if (!mask[key]) continue;
+        newShape[key] = currDef.shape[key]!;
+      }
+
+      assignProp(this, "shape", newShape); // self-caching
+      return newShape;
+    },
+    checks: [],
+  });
+
+  return clone(schema, def) as any;
+}
+
+export function omit(schema: schemas.$ZodObject, mask: object): any {
+  const currDef = schema._zod.def;
+
+  const checks = currDef.checks;
+  const hasChecks = checks && checks.length > 0;
+  if (hasChecks) {
+    throw new Error(".omit() cannot be used on object schemas containing refinements");
+  }
+
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const newShape: Writeable<schemas.$ZodShape> = { ...schema._zod.def.shape };
+      for (const key in mask) {
+        if (!(key in currDef.shape)) {
+          throw new Error(`Unrecognized key: "${key}"`);
+        }
+        if (!(mask as any)[key]) continue;
+
+        delete newShape[key];
+      }
+      assignProp(this, "shape", newShape); // self-caching
+      return newShape;
+    },
+    checks: [],
+  });
+
+  return clone(schema, def);
+}
+
+export function extend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): any {
+  if (!isPlainObject(shape)) {
+    throw new Error("Invalid input to extend: expected a plain object");
+  }
+
+  const checks = schema._zod.def.checks;
+  const hasChecks = checks && checks.length > 0;
+  if (hasChecks) {
+    // Only throw if new shape overlaps with existing shape
+    // Use getOwnPropertyDescriptor to check key existence without accessing values
+    const existingShape = schema._zod.def.shape;
+    for (const key in shape) {
+      if (Object.getOwnPropertyDescriptor(existingShape, key) !== undefined) {
+        throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
+      }
+    }
+  }
+
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const _shape = { ...schema._zod.def.shape, ...shape };
+      assignProp(this, "shape", _shape); // self-caching
+      return _shape;
+    },
+  });
+  return clone(schema, def) as any;
+}
+
+export function safeExtend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): any {
+  if (!isPlainObject(shape)) {
+    throw new Error("Invalid input to safeExtend: expected a plain object");
+  }
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const _shape = { ...schema._zod.def.shape, ...shape };
+      assignProp(this, "shape", _shape); // self-caching
+      return _shape;
+    },
+  });
+  return clone(schema, def) as any;
+}
+
+export function merge(a: schemas.$ZodObject, b: schemas.$ZodObject): any {
+  if (a._zod.def.checks?.length) {
+    throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.");
+  }
+  const def = mergeDefs(a._zod.def, {
+    get shape() {
+      const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
+      assignProp(this, "shape", _shape); // self-caching
+      return _shape;
+    },
+    get catchall() {
+      return b._zod.def.catchall;
+    },
+    checks: b._zod.def.checks ?? [],
+  });
+
+  return clone(a, def) as any;
+}
+
+export function partial(
+  Class: SchemaClass<schemas.$ZodOptional> | null,
+  schema: schemas.$ZodObject,
+  mask: object | undefined
+): any {
+  const currDef = schema._zod.def;
+  const checks = currDef.checks;
+  const hasChecks = checks && checks.length > 0;
+  if (hasChecks) {
+    throw new Error(".partial() cannot be used on object schemas containing refinements");
+  }
+
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const oldShape = schema._zod.def.shape;
+      const shape: Writeable<schemas.$ZodShape> = { ...oldShape };
+
+      if (mask) {
+        for (const key in mask) {
+          if (!(key in oldShape)) {
+            throw new Error(`Unrecognized key: "${key}"`);
+          }
+          if (!(mask as any)[key]) continue;
+          // if (oldShape[key]!._zod.optin === "optional") continue;
+          shape[key] = Class
+            ? new Class({
+                type: "optional",
+                innerType: oldShape[key]!,
+              })
+            : oldShape[key]!;
+        }
+      } else {
+        for (const key in oldShape) {
+          // if (oldShape[key]!._zod.optin === "optional") continue;
+          shape[key] = Class
+            ? new Class({
+                type: "optional",
+                innerType: oldShape[key]!,
+              })
+            : oldShape[key]!;
+        }
+      }
+
+      assignProp(this, "shape", shape); // self-caching
+      return shape;
+    },
+    checks: [],
+  });
+
+  return clone(schema, def) as any;
+}
+
+export function required(
+  Class: SchemaClass<schemas.$ZodNonOptional>,
+  schema: schemas.$ZodObject,
+  mask: object | undefined
+): any {
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const oldShape = schema._zod.def.shape;
+      const shape: Writeable<schemas.$ZodShape> = { ...oldShape };
+
+      if (mask) {
+        for (const key in mask) {
+          if (!(key in shape)) {
+            throw new Error(`Unrecognized key: "${key}"`);
+          }
+          if (!(mask as any)[key]) continue;
+          // overwrite with non-optional
+          shape[key] = new Class({
+            type: "nonoptional",
+            innerType: oldShape[key]!,
+          });
+        }
+      } else {
+        for (const key in oldShape) {
+          // overwrite with non-optional
+          shape[key] = new Class({
+            type: "nonoptional",
+            innerType: oldShape[key]!,
+          });
+        }
+      }
+
+      assignProp(this, "shape", shape); // self-caching
+      return shape;
+    },
+  });
+
+  return clone(schema, def) as any;
+}
+
+export type Constructor<T, Def extends any[] = any[]> = new (...args: Def) => T;
+
+// invalid_type | too_big | too_small | invalid_format | not_multiple_of | unrecognized_keys | invalid_union | invalid_key | invalid_element | invalid_value | custom
+export function aborted(x: schemas.ParsePayload, startIndex = 0): boolean {
+  if (x.aborted === true) return true;
+  for (let i = startIndex; i < x.issues.length; i++) {
+    if (x.issues[i]?.continue !== true) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Checks for explicit abort (continue === false), as opposed to implicit abort (continue === undefined).
+// Used to respect `abort: true` in .refine() even for checks that have a `when` function.
+export function explicitlyAborted(x: schemas.ParsePayload, startIndex = 0): boolean {
+  if (x.aborted === true) return true;
+  for (let i = startIndex; i < x.issues.length; i++) {
+    if (x.issues[i]?.continue === false) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export function prefixIssues(path: PropertyKey, issues: errors.$ZodRawIssue[]): errors.$ZodRawIssue[] {
+  return issues.map((iss) => {
+    (iss as any).path ??= [];
+    (iss as any).path.unshift(path);
+    return iss;
+  });
+}
+
+export function unwrapMessage(message: string | { message: string } | undefined | null): string | undefined {
+  return typeof message === "string" ? message : message?.message;
+}
+
+export function finalizeIssue(
+  iss: errors.$ZodRawIssue,
+  ctx: schemas.ParseContextInternal | undefined,
+  config: $ZodConfig
+): errors.$ZodIssue {
+  const message = iss.message
+    ? iss.message
+    : (unwrapMessage(iss.inst?._zod.def?.error?.(iss as never)) ??
+      unwrapMessage(ctx?.error?.(iss as never)) ??
+      unwrapMessage(config.customError?.(iss)) ??
+      unwrapMessage(config.localeError?.(iss)) ??
+      "Invalid input");
+
+  const { inst: _inst, continue: _continue, input: _input, ...rest } = iss as any;
+  rest.path ??= [];
+  rest.message = message;
+  if (ctx?.reportInput) {
+    rest.input = _input;
+  }
+  return rest;
+}
+
+export function getSizableOrigin(input: any): "set" | "map" | "file" | "unknown" {
+  if (input instanceof Set) return "set";
+  if (input instanceof Map) return "map";
+  // @ts-ignore
+  if (input instanceof File) return "file";
+  return "unknown";
+}
+
+export function getLengthableOrigin(input: any): "array" | "string" | "unknown" {
+  if (Array.isArray(input)) return "array";
+  if (typeof input === "string") return "string";
+  return "unknown";
+}
+
+export function parsedType(data: unknown): errors.$ZodInvalidTypeExpected {
+  const t = typeof data;
+  switch (t) {
+    case "number": {
+      return Number.isNaN(data) ? "nan" : "number";
+    }
+    case "object": {
+      if (data === null) {
+        return "null";
+      }
+      if (Array.isArray(data)) {
+        return "array";
+      }
+
+      const obj = data as object;
+      if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) {
+        return (obj.constructor as { name: string }).name;
+      }
+    }
+  }
+  return t;
+}
+
+//////////    REFINES     //////////
+export function issue(_iss: string, input: any, inst: any): errors.$ZodRawIssue;
+export function issue(_iss: errors.$ZodRawIssue): errors.$ZodRawIssue;
+export function issue(...args: [string | errors.$ZodRawIssue, any?, any?]): errors.$ZodRawIssue {
+  const [iss, input, inst] = args;
+  if (typeof iss === "string") {
+    return {
+      message: iss,
+      code: "custom",
+      input,
+      inst,
+    };
+  }
+
+  return { ...iss };
+}
+
+export function cleanEnum(obj: Record<string, EnumValue>): EnumValue[] {
+  return Object.entries(obj)
+    .filter(([k, _]) => {
+      // return true if NaN, meaning it's not a number, thus a string key
+      return Number.isNaN(Number.parseInt(k, 10));
+    })
+    .map((el) => el[1]);
+}
+
+// Codec utility functions
+export function base64ToUint8Array(base64: string): InstanceType<typeof Uint8Array> {
+  const binaryString = atob(base64);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes;
+}
+
+export function uint8ArrayToBase64(bytes: Uint8Array): string {
+  let binaryString = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binaryString += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binaryString);
+}
+
+export function base64urlToUint8Array(base64url: string): InstanceType<typeof Uint8Array> {
+  const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
+  const padding = "=".repeat((4 - (base64.length % 4)) % 4);
+  return base64ToUint8Array(base64 + padding);
+}
+
+export function uint8ArrayToBase64url(bytes: Uint8Array): string {
+  return uint8ArrayToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+
+export function hexToUint8Array(hex: string): InstanceType<typeof Uint8Array> {
+  const cleanHex = hex.replace(/^0x/, "");
+  if (cleanHex.length % 2 !== 0) {
+    throw new Error("Invalid hex string length");
+  }
+  const bytes = new Uint8Array(cleanHex.length / 2);
+  for (let i = 0; i < cleanHex.length; i += 2) {
+    bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16);
+  }
+  return bytes;
+}
+
+export function uint8ArrayToHex(bytes: Uint8Array): string {
+  return Array.from(bytes)
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+}
+
+// instanceof
+export abstract class Class {
+  constructor(..._args: any[]) {}
+}

gui/frontend/node_modules/zod/src/v4/core/versions.ts

@@ -0,0 +1,5 @@
+export const version = {
+  major: 4,
+  minor: 4,
+  patch: 3 as number,
+} as const;

gui/frontend/node_modules/zod/src/v4/core/zsf.ts

@@ -0,0 +1,323 @@
+///////////////////////////////////////////////////
+////////////////      TYPES     ///////////////////
+///////////////////////////////////////////////////
+
+export interface $ZSF {
+  $zsf: { version: number };
+  type: string;
+  // default value if not defined
+  default: unknown;
+  // fallback value if validation fails
+  fallback: unknown;
+}
+
+export interface $ZSFString extends $ZSF {
+  type: "string";
+  min_length?: number;
+  max_length?: number;
+  pattern?: string;
+}
+
+export type NumberTypes = "float32" | "int32" | "uint32" | "float64" | "int64" | "uint64" | "bigint" | "bigdecimal";
+
+export interface $ZSFNumber extends $ZSF {
+  type: "number";
+  format?: NumberTypes;
+  minimum?: number;
+  maximum?: number;
+  multiple_of?: number;
+}
+
+export interface $ZSFBoolean extends $ZSF {
+  type: "boolean";
+}
+
+export interface $ZSFNull extends $ZSF {
+  type: "null";
+}
+
+export interface $ZSFUndefined extends $ZSF {
+  type: "undefined";
+}
+
+export interface $ZSFOptional<T extends $ZSF = $ZSF> extends $ZSF {
+  type: "optional";
+  inner: T;
+}
+
+export interface $ZSFNever extends $ZSF {
+  type: "never";
+}
+
+export interface $ZSFAny extends $ZSF {
+  type: "any";
+}
+
+/** Supports */
+export interface $ZSFEnum<Elements extends { [k: string]: $ZSFLiteral } = { [k: string]: $ZSFLiteral }> extends $ZSF {
+  type: "enum";
+  elements: Elements;
+}
+
+export interface $ZSFArray<PrefixItems extends $ZSF[] = $ZSF[], Items extends $ZSF = $ZSF> extends $ZSF {
+  type: "array";
+  prefixItems: PrefixItems;
+  items: Items;
+}
+
+// type $ZSFObjectProperties = { [k: string]: $ZSF };
+type $ZSFObjectProperties = Array<{
+  key: string;
+  value: $ZSF;
+  format?: "literal" | "pattern";
+  ordering?: number;
+}>;
+export interface $ZSFObject<Properties extends $ZSFObjectProperties = $ZSFObjectProperties> extends $ZSF {
+  type: "object";
+  properties: Properties;
+}
+
+// export interface $ZSFTuple<
+//   Items extends $ZSF[] = $ZSF[],
+//   Rest extends $ZSF = $ZSF,
+// > extends $ZSF {
+//   type: "array";
+//   items: Items;
+//   rest: Rest;
+// }
+
+/** Supports arbitrary literal values */
+export interface $ZSFLiteral<T extends $ZSF = $ZSF> extends $ZSF {
+  type: "literal";
+  schema: T;
+  value: unknown;
+}
+
+export interface $ZSFUnion<Elements extends $ZSF[] = $ZSF[]> extends $ZSF {
+  type: "union";
+  elements: Elements;
+}
+
+export interface $ZSFIntersection extends $ZSF {
+  type: "intersection";
+  elements: $ZSF[];
+}
+
+export interface $ZSFMap<K extends $ZSF = $ZSF, V extends $ZSF = $ZSF> extends $ZSF {
+  type: "map";
+  keys: K;
+  values: V;
+}
+
+export interface $ZSFConditional<If extends $ZSF, Then extends $ZSF, Else extends $ZSF> extends $ZSF {
+  type: "conditional";
+  if: If;
+  then: Then;
+  else: Else;
+}
+
+/////////////////////////////////////////////////
+////////////////      CHECKS     ////////////////
+/////////////////////////////////////////////////
+
+// export interface $ZSFCheckRegex {
+//   check: "regex";
+//   pattern: string;
+// }
+
+// export interface $ZSFCheckEmail {
+//   check: "email";
+// }
+
+// export interface $ZSFCheckURL {
+//   check: "url";
+// }
+
+// export interface $ZSFCheckEmoji {
+//   check: "emoji";
+// }
+
+// export interface $ZSFCheckUUID {
+//   check: "uuid";
+// }
+
+// export interface $ZSFCheckUUIDv4 {
+//   check: "uuidv4";
+// }
+
+// export interface $ZSFCheckUUIDv6 {
+//   check: "uuidv6";
+// }
+
+// export interface $ZSFCheckNanoid {
+//   check: "nanoid";
+// }
+
+// export interface $ZSFCheckGUID {
+//   check: "guid";
+// }
+
+// export interface $ZSFCheckCUID {
+//   check: "cuid";
+// }
+
+// export interface $ZSFCheckCUID2 {
+//   check: "cuid2";
+// }
+
+// export interface $ZSFCheckULID {
+//   check: "ulid";
+// }
+
+// export interface $ZSFCheckXID {
+//   check: "xid";
+// }
+
+// export interface $ZSFCheckKSUID {
+//   check: "ksuid";
+// }
+
+// export interface $ZSFCheckISODateTime {
+//   check: "datetime";
+//   precision?: number;
+//   local?: boolean;
+// }
+
+// export interface $ZSFCheckISODate {
+//   check: "date";
+// }
+
+// export interface $ZSFCheckISOTime {
+//   check: "time";
+//   precision?: number;
+//   local?: boolean;
+// }
+
+// export interface $ZSFCheckDuration {
+//   check: "duration";
+// }
+
+// export interface $ZSFCheckIP {
+//   check: "ip";
+// }
+
+// export interface $ZSFCheckIPv4 {
+//   check: "ipv4";
+// }
+
+// export interface $ZSFCheckIPv6 {
+//   check: "ipv6";
+// }
+
+// export interface $ZSFCheckBase64 {
+//   check: "base64";
+// }
+
+// export interface $ZSFCheckJWT {
+//   check: "jwt";
+// }
+
+// export interface $ZSFCheckJSONString {
+//   check: "json_string";
+// }
+
+// export interface $ZSFCheckPrefix {
+//   check: "prefix";
+//   prefix: string;
+// }
+
+// export interface $ZSFCheckSuffix {
+//   check: "suffix";
+//   suffix: string;
+// }
+
+// export interface $ZSFCheckIncludes {
+//   check: "includes";
+//   includes: string;
+// }
+
+// export interface $ZSFCheckMinSize {
+//   check: "min_size";
+//   minimum: number;
+// }
+
+// export interface $ZSFCheckMaxSize {
+//   check: "max_size";
+//   maximum: number;
+// }
+
+// export interface $ZSFCheckSizeEquals {
+//   check: "size_equals";
+//   size: number;
+// }
+
+// export interface $ZSFCheckLessThan {
+//   check: "less_than";
+//   maximum: number | bigint | Date;
+// }
+
+// export interface $ZSFCheckLessThanOrEqual {
+//   check: "less_than_or_equal";
+//   maximum: number | bigint | Date;
+// }
+
+// export interface $ZSFCheckGreaterThan {
+//   check: "greater_than";
+//   minimum: number | bigint | Date;
+// }
+
+// export interface $ZSFCheckGreaterThanOrEqual {
+//   check: "greater_than_or_equal";
+//   minimum: number | bigint | Date;
+// }
+
+// export interface $ZSFCheckEquals {
+//   check: "equals";
+//   value: number | bigint | Date;
+// }
+
+// export interface $ZSFCheckMultipleOf {
+//   check: "multiple_of";
+//   multipleOf: number;
+// }
+
+// export type $ZSFStringFormatChecks =
+//   | $ZSFCheckRegex
+//   | $ZSFCheckEmail
+//   | $ZSFCheckURL
+//   | $ZSFCheckEmoji
+//   | $ZSFCheckUUID
+//   | $ZSFCheckUUIDv4
+//   | $ZSFCheckUUIDv6
+//   | $ZSFCheckNanoid
+//   | $ZSFCheckGUID
+//   | $ZSFCheckCUID
+//   | $ZSFCheckCUID2
+//   | $ZSFCheckULID
+//   | $ZSFCheckXID
+//   | $ZSFCheckKSUID
+//   | $ZSFCheckISODateTime
+//   | $ZSFCheckISODate
+//   | $ZSFCheckISOTime
+//   | $ZSFCheckDuration
+//   | $ZSFCheckIP
+//   | $ZSFCheckIPv4
+//   | $ZSFCheckIPv6
+//   | $ZSFCheckBase64
+//   | $ZSFCheckJWT
+//   | $ZSFCheckJSONString
+//   | $ZSFCheckPrefix
+//   | $ZSFCheckSuffix
+//   | $ZSFCheckIncludes;
+
+// export type $ZSFCheck =
+//   | $ZSFStringFormatChecks
+//   | $ZSFCheckMinSize
+//   | $ZSFCheckMaxSize
+//   | $ZSFCheckSizeEquals
+//   | $ZSFCheckLessThan
+//   | $ZSFCheckLessThanOrEqual
+//   | $ZSFCheckGreaterThan
+//   | $ZSFCheckGreaterThanOrEqual
+//   | $ZSFCheckEquals
+//   | $ZSFCheckMultipleOf;

gui/frontend/node_modules/zod/src/v4/index.ts

@@ -0,0 +1,4 @@
+import z4 from "./classic/index.js";
+export * from "./classic/index.js";
+
+export default z4;

gui/frontend/node_modules/zod/src/v4/locales/ar.ts

@@ -0,0 +1,115 @@
+import type { $ZodStringFormats } from "../core/checks.js";
+import type * as errors from "../core/errors.js";
+import * as util from "../core/util.js";
+
+const error: () => errors.$ZodErrorMap = () => {
+  const Sizable: Record<string, { unit: string; verb: string }> = {
+    string: { unit: "حرف", verb: "أن يحوي" },
+    file: { unit: "بايت", verb: "أن يحوي" },
+    array: { unit: "عنصر", verb: "أن يحوي" },
+    set: { unit: "عنصر", verb: "أن يحوي" },
+  };
+
+  function getSizing(origin: string): { unit: string; verb: string } | null {
+    return Sizable[origin] ?? null;
+  }
+
+  const FormatDictionary: {
+    [k in $ZodStringFormats | (string & {})]?: string;
+  } = {
+    regex: "مدخل",
+    email: "بريد إلكتروني",
+    url: "رابط",
+    emoji: "إيموجي",
+    uuid: "UUID",
+    uuidv4: "UUIDv4",
+    uuidv6: "UUIDv6",
+    nanoid: "nanoid",
+    guid: "GUID",
+    cuid: "cuid",
+    cuid2: "cuid2",
+    ulid: "ULID",
+    xid: "XID",
+    ksuid: "KSUID",
+    datetime: "تاريخ ووقت بمعيار ISO",
+    date: "تاريخ بمعيار ISO",
+    time: "وقت بمعيار ISO",
+    duration: "مدة بمعيار ISO",
+    ipv4: "عنوان IPv4",
+    ipv6: "عنوان IPv6",
+    cidrv4: "مدى عناوين بصيغة IPv4",
+    cidrv6: "مدى عناوين بصيغة IPv6",
+    base64: "نَص بترميز base64-encoded",
+    base64url: "نَص بترميز base64url-encoded",
+    json_string: "نَص على هيئة JSON",
+    e164: "رقم هاتف بمعيار E.164",
+    jwt: "JWT",
+    template_literal: "مدخل",
+  };
+
+  const TypeDictionary: {
+    [k in errors.$ZodInvalidTypeExpected | (string & {})]?: string;
+  } = {
+    nan: "NaN",
+  };
+
+  return (issue) => {
+    switch (issue.code) {
+      case "invalid_type": {
+        const expected = TypeDictionary[issue.expected] ?? issue.expected;
+        const receivedType = util.parsedType(issue.input);
+        const received = TypeDictionary[receivedType] ?? receivedType;
+        if (/^[A-Z]/.test(issue.expected)) {
+          return `مدخلات غير مقبولة: يفترض إدخال instanceof ${issue.expected}، ولكن تم إدخال ${received}`;
+        }
+        return `مدخلات غير مقبولة: يفترض إدخال ${expected}، ولكن تم إدخال ${received}`;
+      }
+      case "invalid_value":
+        if (issue.values.length === 1)
+          return `مدخلات غير مقبولة: يفترض إدخال ${util.stringifyPrimitive(issue.values[0])}`;
+        return `اختيار غير مقبول: يتوقع انتقاء أحد هذه الخيارات: ${util.joinValues(issue.values, "|")}`;
+      case "too_big": {
+        const adj = issue.inclusive ? "<=" : "<";
+        const sizing = getSizing(issue.origin);
+        if (sizing)
+          return ` أكبر من اللازم: يفترض أن تكون ${issue.origin ?? "القيمة"} ${adj} ${issue.maximum.toString()} ${sizing.unit ?? "عنصر"}`;
+        return `أكبر من اللازم: يفترض أن تكون ${issue.origin ?? "القيمة"} ${adj} ${issue.maximum.toString()}`;
+      }
+      case "too_small": {
+        const adj = issue.inclusive ? ">=" : ">";
+        const sizing = getSizing(issue.origin);
+        if (sizing) {
+          return `أصغر من اللازم: يفترض لـ ${issue.origin} أن يكون ${adj} ${issue.minimum.toString()} ${sizing.unit}`;
+        }
+
+        return `أصغر من اللازم: يفترض لـ ${issue.origin} أن يكون ${adj} ${issue.minimum.toString()}`;
+      }
+      case "invalid_format": {
+        const _issue = issue as errors.$ZodStringFormatIssues;
+        if (_issue.format === "starts_with") return `نَص غير مقبول: يجب أن يبدأ بـ "${issue.prefix}"`;
+        if (_issue.format === "ends_with") return `نَص غير مقبول: يجب أن ينتهي بـ "${_issue.suffix}"`;
+        if (_issue.format === "includes") return `نَص غير مقبول: يجب أن يتضمَّن "${_issue.includes}"`;
+        if (_issue.format === "regex") return `نَص غير مقبول: يجب أن يطابق النمط ${_issue.pattern}`;
+        return `${FormatDictionary[_issue.format] ?? issue.format} غير مقبول`;
+      }
+      case "not_multiple_of":
+        return `رقم غير مقبول: يجب أن يكون من مضاعفات ${issue.divisor}`;
+      case "unrecognized_keys":
+        return `معرف${issue.keys.length > 1 ? "ات" : ""} غريب${issue.keys.length > 1 ? "ة" : ""}: ${util.joinValues(issue.keys, "، ")}`;
+      case "invalid_key":
+        return `معرف غير مقبول في ${issue.origin}`;
+      case "invalid_union":
+        return "مدخل غير مقبول";
+      case "invalid_element":
+        return `مدخل غير مقبول في ${issue.origin}`;
+      default:
+        return "مدخل غير مقبول";
+    }
+  };
+};
+
+export default function (): { localeError: errors.$ZodErrorMap } {
+  return {
+    localeError: error(),
+  };
+}

gui/frontend/node_modules/zod/src/v4/locales/az.ts

@@ -0,0 +1,111 @@
+import type { $ZodStringFormats } from "../core/checks.js";
+import type * as errors from "../core/errors.js";
+import * as util from "../core/util.js";
+
+const error: () => errors.$ZodErrorMap = () => {
+  const Sizable: Record<string, { unit: string; verb: string }> = {
+    string: { unit: "simvol", verb: "olmalıdır" },
+    file: { unit: "bayt", verb: "olmalıdır" },
+    array: { unit: "element", verb: "olmalıdır" },
+    set: { unit: "element", verb: "olmalıdır" },
+  };
+
+  function getSizing(origin: string): { unit: string; verb: string } | null {
+    return Sizable[origin] ?? null;
+  }
+
+  const FormatDictionary: {
+    [k in $ZodStringFormats | (string & {})]?: string;
+  } = {
+    regex: "input",
+    email: "email address",
+    url: "URL",
+    emoji: "emoji",
+    uuid: "UUID",
+    uuidv4: "UUIDv4",
+    uuidv6: "UUIDv6",
+    nanoid: "nanoid",
+    guid: "GUID",
+    cuid: "cuid",
+    cuid2: "cuid2",
+    ulid: "ULID",
+    xid: "XID",
+    ksuid: "KSUID",
+    datetime: "ISO datetime",
+    date: "ISO date",
+    time: "ISO time",
+    duration: "ISO duration",
+    ipv4: "IPv4 address",
+    ipv6: "IPv6 address",
+    cidrv4: "IPv4 range",
+    cidrv6: "IPv6 range",
+    base64: "base64-encoded string",
+    base64url: "base64url-encoded string",
+    json_string: "JSON string",
+    e164: "E.164 number",
+    jwt: "JWT",
+    template_literal: "input",
+  };
+
+  const TypeDictionary: {
+    [k in errors.$ZodInvalidTypeExpected | (string & {})]?: string;
+  } = {
+    nan: "NaN",
+  };
+
+  return (issue) => {
+    switch (issue.code) {
+      case "invalid_type": {
+        const expected = TypeDictionary[issue.expected] ?? issue.expected;
+        const receivedType = util.parsedType(issue.input);
+        const received = TypeDictionary[receivedType] ?? receivedType;
+        if (/^[A-Z]/.test(issue.expected)) {
+          return `Yanlış dəyər: gözlənilən instanceof ${issue.expected}, daxil olan ${received}`;
+        }
+        return `Yanlış dəyər: gözlənilən ${expected}, daxil olan ${received}`;
+      }
+      case "invalid_value":
+        if (issue.values.length === 1) return `Yanlış dəyər: gözlənilən ${util.stringifyPrimitive(issue.values[0])}`;
+        return `Yanlış seçim: aşağıdakılardan biri olmalıdır: ${util.joinValues(issue.values, "|")}`;
+      case "too_big": {
+        const adj = issue.inclusive ? "<=" : "<";
+        const sizing = getSizing(issue.origin);
+        if (sizing)
+          return `Çox böyük: gözlənilən ${issue.origin ?? "dəyər"} ${adj}${issue.maximum.toString()} ${sizing.unit ?? "element"}`;
+        return `Çox böyük: gözlənilən ${issue.origin ?? "dəyər"} ${adj}${issue.maximum.toString()}`;
+      }
+      case "too_small": {
+        const adj = issue.inclusive ? ">=" : ">";
+        const sizing = getSizing(issue.origin);
+        if (sizing) return `Çox kiçik: gözlənilən ${issue.origin} ${adj}${issue.minimum.toString()} ${sizing.unit}`;
+        return `Çox kiçik: gözlənilən ${issue.origin} ${adj}${issue.minimum.toString()}`;
+      }
+      case "invalid_format": {
+        const _issue = issue as errors.$ZodStringFormatIssues;
+        if (_issue.format === "starts_with") return `Yanlış mətn: "${_issue.prefix}" ilə başlamalıdır`;
+        if (_issue.format === "ends_with") return `Yanlış mətn: "${_issue.suffix}" ilə bitməlidir`;
+        if (_issue.format === "includes") return `Yanlış mətn: "${_issue.includes}" daxil olmalıdır`;
+        if (_issue.format === "regex") return `Yanlış mətn: ${_issue.pattern} şablonuna uyğun olmalıdır`;
+        return `Yanlış ${FormatDictionary[_issue.format] ?? issue.format}`;
+      }
+      case "not_multiple_of":
+        return `Yanlış ədəd: ${issue.divisor} ilə bölünə bilən olmalıdır`;
+      case "unrecognized_keys":
+        return `Tanınmayan açar${issue.keys.length > 1 ? "lar" : ""}: ${util.joinValues(issue.keys, ", ")}`;
+      case "invalid_key":
+        return `${issue.origin} daxilində yanlış açar`;
+      case "invalid_union":
+        return "Yanlış dəyər";
+      case "invalid_element":
+        return `${issue.origin} daxilində yanlış dəyər`;
+      default:
+        return `Yanlış dəyər`;
+    }
+  };
+};
+
+export default function (): { localeError: errors.$ZodErrorMap } {
+  return {
+    localeError: error(),
+  };
+}

gui/frontend/node_modules/zod/src/v4/locales/be.ts

@@ -0,0 +1,176 @@
+import type { $ZodStringFormats } from "../core/checks.js";
+import type * as errors from "../core/errors.js";
+import * as util from "../core/util.js";
+
+function getBelarusianPlural(count: number, one: string, few: string, many: string): string {
+  const absCount = Math.abs(count);
+  const lastDigit = absCount % 10;
+  const lastTwoDigits = absCount % 100;
+
+  if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
+    return many;
+  }
+
+  if (lastDigit === 1) {
+    return one;
+  }
+
+  if (lastDigit >= 2 && lastDigit <= 4) {
+    return few;
+  }
+
+  return many;
+}
+
+interface BelarusianSizable {
+  unit: {
+    one: string;
+    few: string;
+    many: string;
+  };
+  verb: string;
+}
+const error: () => errors.$ZodErrorMap = () => {
+  const Sizable: Record<string, BelarusianSizable> = {
+    string: {
+      unit: {
+        one: "сімвал",
+        few: "сімвалы",
+        many: "сімвалаў",
+      },
+      verb: "мець",
+    },
+    array: {
+      unit: {
+        one: "элемент",
+        few: "элементы",
+        many: "элементаў",
+      },
+      verb: "мець",
+    },
+    set: {
+      unit: {
+        one: "элемент",
+        few: "элементы",
+        many: "элементаў",
+      },
+      verb: "мець",
+    },
+    file: {
+      unit: {
+        one: "байт",
+        few: "байты",
+        many: "байтаў",
+      },
+      verb: "мець",
+    },
+  };
+
+  function getSizing(origin: string): BelarusianSizable | null {
+    return Sizable[origin] ?? null;
+  }
+
+  const FormatDictionary: {
+    [k in $ZodStringFormats | (string & {})]?: string;
+  } = {
+    regex: "увод",
+    email: "email адрас",
+    url: "URL",
+    emoji: "эмодзі",
+    uuid: "UUID",
+    uuidv4: "UUIDv4",
+    uuidv6: "UUIDv6",
+    nanoid: "nanoid",
+    guid: "GUID",
+    cuid: "cuid",
+    cuid2: "cuid2",
+    ulid: "ULID",
+    xid: "XID",
+    ksuid: "KSUID",
+    datetime: "ISO дата і час",
+    date: "ISO дата",
+    time: "ISO час",
+    duration: "ISO працягласць",
+    ipv4: "IPv4 адрас",
+    ipv6: "IPv6 адрас",
+    cidrv4: "IPv4 дыяпазон",
+    cidrv6: "IPv6 дыяпазон",
+    base64: "радок у фармаце base64",
+    base64url: "радок у фармаце base64url",
+    json_string: "JSON радок",
+    e164: "нумар E.164",
+    jwt: "JWT",
+    template_literal: "увод",
+  };
+
+  const TypeDictionary: {
+    [k in errors.$ZodInvalidTypeExpected | (string & {})]?: string;
+  } = {
+    nan: "NaN",
+    number: "лік",
+    array: "масіў",
+  };
+
+  return (issue) => {
+    switch (issue.code) {
+      case "invalid_type": {
+        const expected = TypeDictionary[issue.expected] ?? issue.expected;
+        const receivedType = util.parsedType(issue.input);
+        const received = TypeDictionary[receivedType] ?? receivedType;
+        if (/^[A-Z]/.test(issue.expected)) {
+          return `Няправільны ўвод: чакаўся instanceof ${issue.expected}, атрымана ${received}`;
+        }
+        return `Няправільны ўвод: чакаўся ${expected}, атрымана ${received}`;
+      }
+      case "invalid_value":
+        if (issue.values.length === 1) return `Няправільны ўвод: чакалася ${util.stringifyPrimitive(issue.values[0])}`;
+        return `Няправільны варыянт: чакаўся адзін з ${util.joinValues(issue.values, "|")}`;
+      case "too_big": {
+        const adj = issue.inclusive ? "<=" : "<";
+        const sizing = getSizing(issue.origin);
+        if (sizing) {
+          const maxValue = Number(issue.maximum);
+          const unit = getBelarusianPlural(maxValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
+          return `Занадта вялікі: чакалася, што ${issue.origin ?? "значэнне"} павінна ${sizing.verb} ${adj}${issue.maximum.toString()} ${unit}`;
+        }
+        return `Занадта вялікі: чакалася, што ${issue.origin ?? "значэнне"} павінна быць ${adj}${issue.maximum.toString()}`;
+      }
+      case "too_small": {
+        const adj = issue.inclusive ? ">=" : ">";
+        const sizing = getSizing(issue.origin);
+        if (sizing) {
+          const minValue = Number(issue.minimum);
+          const unit = getBelarusianPlural(minValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
+          return `Занадта малы: чакалася, што ${issue.origin} павінна ${sizing.verb} ${adj}${issue.minimum.toString()} ${unit}`;
+        }
+        return `Занадта малы: чакалася, што ${issue.origin} павінна быць ${adj}${issue.minimum.toString()}`;
+      }
+      case "invalid_format": {
+        const _issue = issue as errors.$ZodStringFormatIssues;
+        if (_issue.format === "starts_with") return `Няправільны радок: павінен пачы��ацца з "${_issue.prefix}"`;
+        if (_issue.format === "ends_with") return `Няправільны радок: павінен заканчвацца на "${_issue.suffix}"`;
+        if (_issue.format === "includes") return `Няправільны радок: павінен змяшчаць "${_issue.includes}"`;
+        if (_issue.format === "regex") return `Няправільны радок: павінен адпавядаць шаблону ${_issue.pattern}`;
+        return `Няправільны ${FormatDictionary[_issue.format] ?? issue.format}`;
+      }
+      case "not_multiple_of":
+        return `Няправільны лік: павінен быць кратным ${issue.divisor}`;
+      case "unrecognized_keys":
+        return `Нераспазнаны ${issue.keys.length > 1 ? "ключы" : "ключ"}: ${util.joinValues(issue.keys, ", ")}`;
+      case "invalid_key":
+        return `Няправільны ключ у ${issue.origin}`;
+      case "invalid_union":
+        return "Няправільны ўвод";
+      case "invalid_element":
+        return `Няправільнае значэнне ў ${issue.origin}`;
+      default:
+        return `Няправільны ўвод`;
+    }
+  };
+};
+
+export default function (): { localeError: errors.$ZodErrorMap } {
+  return {
+    localeError: error(),
+  };
+}

gui/frontend/node_modules/zod/src/v4/locales/bg.ts

@@ -0,0 +1,128 @@
+import type { $ZodStringFormats } from "../core/checks.js";
+import type * as errors from "../core/errors.js";
+import * as util from "../core/util.js";
+
+const error: () => errors.$ZodErrorMap = () => {
+  const Sizable: Record<string, { unit: string; verb: string }> = {
+    string: { unit: "символа", verb: "да съдържа" },
+    file: { unit: "байта", verb: "да съдържа" },
+    array: { unit: "елемента", verb: "да съдържа" },
+    set: { unit: "елемента", verb: "да съдържа" },
+  };
+
+  function getSizing(origin: string): { unit: string; verb: string } | null {
+    return Sizable[origin] ?? null;
+  }
+
+  const FormatDictionary: {
+    [k in $ZodStringFormats | (string & {})]?: string;
+  } = {
+    regex: "вход",
+    email: "имейл адрес",
+    url: "URL",
+    emoji: "емоджи",
+    uuid: "UUID",
+    uuidv4: "UUIDv4",
+    uuidv6: "UUIDv6",
+    nanoid: "nanoid",
+    guid: "GUID",
+    cuid: "cuid",
+    cuid2: "cuid2",
+    ulid: "ULID",
+    xid: "XID",
+    ksuid: "KSUID",
+    datetime: "ISO време",
+    date: "ISO дата",
+    time: "ISO време",
+    duration: "ISO продължителност",
+    ipv4: "IPv4 адрес",
+    ipv6: "IPv6 адрес",
+    cidrv4: "IPv4 диапазон",
+    cidrv6: "IPv6 диапазон",
+    base64: "base64-кодиран низ",
+    base64url: "base64url-кодиран низ",
+    json_string: "JSON низ",
+    e164: "E.164 номер",
+    jwt: "JWT",
+    template_literal: "вход",
+  };
+
+  const TypeDictionary: {
+    [k in errors.$ZodInvalidTypeExpected | (string & {})]?: string;
+  } = {
+    nan: "NaN",
+    number: "число",
+    array: "масив",
+  };
+
+  return (issue) => {
+    switch (issue.code) {
+      case "invalid_type": {
+        const expected = TypeDictionary[issue.expected] ?? issue.expected;
+        const receivedType = util.parsedType(issue.input);
+        const received = TypeDictionary[receivedType] ?? receivedType;
+        if (/^[A-Z]/.test(issue.expected)) {
+          return `Невалиден вход: очакван instanceof ${issue.expected}, получен ${received}`;
+        }
+        return `Невалиден вход: очакван ${expected}, получен ${received}`;
+      }
+
+      case "invalid_value":
+        if (issue.values.length === 1) return `Невалиден вход: очакван ${util.stringifyPrimitive(issue.values[0])}`;
+        return `Невалидна опция: очаквано едно от ${util.joinValues(issue.values, "|")}`;
+      case "too_big": {
+        const adj = issue.inclusive ? "<=" : "<";
+        const sizing = getSizing(issue.origin);
+        if (sizing)
+          return `Твърде голямо: очаква се ${issue.origin ?? "стойност"} да съдържа ${adj}${issue.maximum.toString()} ${sizing.unit ?? "елемента"}`;
+        return `Твърде голямо: очаква се ${issue.origin ?? "стойност"} да бъде ${adj}${issue.maximum.toString()}`;
+      }
+      case "too_small": {
+        const adj = issue.inclusive ? ">=" : ">";
+        const sizing = getSizing(issue.origin);
+        if (sizing) {
+          return `Твърде малко: очаква се ${issue.origin} да съдържа ${adj}${issue.minimum.toString()} ${sizing.unit}`;
+        }
+
+        return `Твърде малко: очаква се ${issue.origin} да бъде ${adj}${issue.minimum.toString()}`;
+      }
+      case "invalid_format": {
+        const _issue = issue as errors.$ZodStringFormatIssues;
+        if (_issue.format === "starts_with") {
+          return `Невалиден низ: трябва да започва с "${_issue.prefix}"`;
+        }
+        if (_issue.format === "ends_with") return `Невалиден низ: трябва да завършва с "${_issue.suffix}"`;
+        if (_issue.format === "includes") return `Невалиден низ: трябва да включва "${_issue.includes}"`;
+        if (_issue.format === "regex") return `Невалиден низ: трябва да съвпада с ${_issue.pattern}`;
+
+        let invalid_adj = "Невалиден";
+
+        if (_issue.format === "emoji") invalid_adj = "Невалидно";
+        if (_issue.format === "datetime") invalid_adj = "Невалидно";
+        if (_issue.format === "date") invalid_adj = "Невалидна";
+        if (_issue.format === "time") invalid_adj = "Невалидно";
+        if (_issue.format === "duration") invalid_adj = "Невалидна";
+
+        return `${invalid_adj} ${FormatDictionary[_issue.format] ?? issue.format}`;
+      }
+      case "not_multiple_of":
+        return `Невалидно число: трябва да бъде кратно на ${issue.divisor}`;
+      case "unrecognized_keys":
+        return `Неразпознат${issue.keys.length > 1 ? "и" : ""} ключ${issue.keys.length > 1 ? "ове" : ""}: ${util.joinValues(issue.keys, ", ")}`;
+      case "invalid_key":
+        return `Невалиден ключ в ${issue.origin}`;
+      case "invalid_union":
+        return "Невалиден вход";
+      case "invalid_element":
+        return `Невалидна стойност в ${issue.origin}`;
+      default:
+        return `Невалиден вход`;
+    }
+  };
+};
+
+export default function (): { localeError: errors.$ZodErrorMap } {
+  return {
+    localeError: error(),
+  };
+}

gui/frontend/node_modules/zod/src/v4/locales/ca.ts

@@ -0,0 +1,116 @@
+import type { $ZodStringFormats } from "../core/checks.js";
+import type * as errors from "../core/errors.js";
+import * as util from "../core/util.js";
+
+const error: () => errors.$ZodErrorMap = () => {
+  const Sizable: Record<string, { unit: string; verb: string }> = {
+    string: { unit: "caràcters", verb: "contenir" },
+    file: { unit: "bytes", verb: "contenir" },
+    array: { unit: "elements", verb: "contenir" },
+    set: { unit: "elements", verb: "contenir" },
+  };
+
+  function getSizing(origin: string): { unit: string; verb: string } | null {
+    return Sizable[origin] ?? null;
+  }
+
+  const FormatDictionary: {
+    [k in $ZodStringFormats | (string & {})]?: string;
+  } = {
+    regex: "entrada",
+    email: "adreça electrònica",
+    url: "URL",
+    emoji: "emoji",
+    uuid: "UUID",
+    uuidv4: "UUIDv4",
+    uuidv6: "UUIDv6",
+    nanoid: "nanoid",
+    guid: "GUID",
+    cuid: "cuid",
+    cuid2: "cuid2",
+    ulid: "ULID",
+    xid: "XID",
+    ksuid: "KSUID",
+    datetime: "data i hora ISO",
+    date: "data ISO",
+    time: "hora ISO",
+    duration: "durada ISO",
+    ipv4: "adreça IPv4",
+    ipv6: "adreça IPv6",
+    cidrv4: "rang IPv4",
+    cidrv6: "rang IPv6",
+    base64: "cadena codificada en base64",
+    base64url: "cadena codificada en base64url",
+    json_string: "cadena JSON",
+    e164: "número E.164",
+    jwt: "JWT",
+    template_literal: "entrada",
+  };
+
+  const TypeDictionary: {
+    [k in errors.$ZodInvalidTypeExpected | (string & {})]?: string;
+  } = {
+    nan: "NaN",
+  };
+
+  return (issue) => {
+    switch (issue.code) {
+      case "invalid_type": {
+        const expected = TypeDictionary[issue.expected] ?? issue.expected;
+        const receivedType = util.parsedType(issue.input);
+        const received = TypeDictionary[receivedType] ?? receivedType;
+        if (/^[A-Z]/.test(issue.expected)) {
+          return `Tipus invàlid: s'esperava instanceof ${issue.expected}, s'ha rebut ${received}`;
+        }
+        return `Tipus invàlid: s'esperava ${expected}, s'ha rebut ${received}`;
+      }
+      case "invalid_value":
+        if (issue.values.length === 1) return `Valor invàlid: s'esperava ${util.stringifyPrimitive(issue.values[0])}`;
+        return `Opció invàlida: s'esperava una de ${util.joinValues(issue.values, " o ")}`;
+      case "too_big": {
+        const adj = issue.inclusive ? "com a màxim" : "menys de";
+        const sizing = getSizing(issue.origin);
+        if (sizing)
+          return `Massa gran: s'esperava que ${issue.origin ?? "el valor"} contingués ${adj} ${issue.maximum.toString()} ${sizing.unit ?? "elements"}`;
+        return `Massa gran: s'esperava que ${issue.origin ?? "el valor"} fos ${adj} ${issue.maximum.toString()}`;
+      }
+      case "too_small": {
+        const adj = issue.inclusive ? "com a mínim" : "més de";
+        const sizing = getSizing(issue.origin);
+        if (sizing) {
+          return `Massa petit: s'esperava que ${issue.origin} contingués ${adj} ${issue.minimum.toString()} ${sizing.unit}`;
+        }
+
+        return `Massa petit: s'esperava que ${issue.origin} fos ${adj} ${issue.minimum.toString()}`;
+      }
+      case "invalid_format": {
+        const _issue = issue as errors.$ZodStringFormatIssues;
+        if (_issue.format === "starts_with") {
+          return `Format invàlid: ha de començar amb "${_issue.prefix}"`;
+        }
+        if (_issue.format === "ends_with") return `Format invàlid: ha d'acabar amb "${_issue.suffix}"`;
+        if (_issue.format === "includes") return `Format invàlid: ha d'incloure "${_issue.includes}"`;
+        if (_issue.format === "regex") return `Format invàlid: ha de coincidir amb el patró ${_issue.pattern}`;
+        return `Format invàlid per a ${FormatDictionary[_issue.format] ?? issue.format}`;
+      }
+      case "not_multiple_of":
+        return `Número invàlid: ha de ser múltiple de ${issue.divisor}`;
+      case "unrecognized_keys":
+        return `Clau${issue.keys.length > 1 ? "s" : ""} no reconeguda${issue.keys.length > 1 ? "s" : ""}: ${util.joinValues(issue.keys, ", ")}`;
+      case "invalid_key":
+        return `Clau invàlida a ${issue.origin}`;
+      case "invalid_union":
+        return "Entrada invàlida"; // Could also be "Tipus d'unió invàlid" but "Entrada invàlida" is more general
+      case "invalid_element":
+        return `Element invàlid a ${issue.origin}`;
+      default:
+        return `Entrada invàlida`;
+    }
+  };
+};
+
+export default function (): { localeError: errors.$ZodErrorMap } {
+  return {
+    localeError: error(),
+  };
+}

gui/frontend/node_modules/zod/src/v4/locales/cs.ts

@@ -0,0 +1,118 @@
+import type { $ZodStringFormats } from "../core/checks.js";
+import type * as errors from "../core/errors.js";
+import * as util from "../core/util.js";
+
+const error: () => errors.$ZodErrorMap = () => {
+  const Sizable: Record<string, { unit: string; verb: string }> = {
+    string: { unit: "znaků", verb: "mít" },
+    file: { unit: "bajtů", verb: "mít" },
+    array: { unit: "prvků", verb: "mít" },
+    set: { unit: "prvků", verb: "mít" },
+  };
+
+  function getSizing(origin: string): { unit: string; verb: string } | null {
+    return Sizable[origin] ?? null;
+  }
+
+  const FormatDictionary: {
+    [k in $ZodStringFormats | (string & {})]?: string;
+  } = {
+    regex: "regulární výraz",
+    email: "e-mailová adresa",
+    url: "URL",
+    emoji: "emoji",
+    uuid: "UUID",
+    uuidv4: "UUIDv4",
+    uuidv6: "UUIDv6",
+    nanoid: "nanoid",
+    guid: "GUID",
+    cuid: "cuid",
+    cuid2: "cuid2",
+    ulid: "ULID",
+    xid: "XID",
+    ksuid: "KSUID",
+    datetime: "datum a čas ve formátu ISO",
+    date: "datum ve formátu ISO",
+    time: "čas ve formátu ISO",
+    duration: "doba trvání ISO",
+    ipv4: "IPv4 adresa",
+    ipv6: "IPv6 adresa",
+    cidrv4: "rozsah IPv4",
+    cidrv6: "rozsah IPv6",
+    base64: "řetězec zakódovaný ve formátu base64",
+    base64url: "řetězec zakódovaný ve formátu base64url",
+    json_string: "řetězec ve formátu JSON",
+    e164: "číslo E.164",
+    jwt: "JWT",
+    template_literal: "vstup",
+  };
+
+  const TypeDictionary: {
+    [k in errors.$ZodInvalidTypeExpected | (string & {})]?: string;
+  } = {
+    nan: "NaN",
+    number: "číslo",
+    string: "řetězec",
+    function: "funkce",
+    array: "pole",
+  };
+
+  return (issue) => {
+    switch (issue.code) {
+      case "invalid_type": {
+        const expected = TypeDictionary[issue.expected] ?? issue.expected;
+        const receivedType = util.parsedType(issue.input);
+        const received = TypeDictionary[receivedType] ?? receivedType;
+        if (/^[A-Z]/.test(issue.expected)) {
+          return `Neplatný vstup: očekáváno instanceof ${issue.expected}, obdrženo ${received}`;
+        }
+        return `Neplatný vstup: očekáváno ${expected}, obdrženo ${received}`;
+      }
+      case "invalid_value":
+        if (issue.values.length === 1) return `Neplatný vstup: očekáváno ${util.stringifyPrimitive(issue.values[0])}`;
+        return `Neplatná možnost: očekávána jedna z hodnot ${util.joinValues(issue.values, "|")}`;
+      case "too_big": {
+        const adj = issue.inclusive ? "<=" : "<";
+        const sizing = getSizing(issue.origin);
+        if (sizing) {
+          return `Hodnota je příliš velká: ${issue.origin ?? "hodnota"} musí mít ${adj}${issue.maximum.toString()} ${sizing.unit ?? "prvků"}`;
+        }
+        return `Hodnota je příliš velká: ${issue.origin ?? "hodnota"} musí být ${adj}${issue.maximum.toString()}`;
+      }
+      case "too_small": {
+        const adj = issue.inclusive ? ">=" : ">";
+        const sizing = getSizing(issue.origin);
+        if (sizing) {
+          return `Hodnota je příliš malá: ${issue.origin ?? "hodnota"} musí mít ${adj}${issue.minimum.toString()} ${sizing.unit ?? "prvků"}`;
+        }
+        return `Hodnota je příliš malá: ${issue.origin ?? "hodnota"} musí být ${adj}${issue.minimum.toString()}`;
+      }
+      case "invalid_format": {
+        const _issue = issue as errors.$ZodStringFormatIssues;
+        if (_issue.format === "starts_with") return `Neplatný řetězec: musí začínat na "${_issue.prefix}"`;
+        if (_issue.format === "ends_with") return `Neplatný řetězec: musí končit na "${_issue.suffix}"`;
+        if (_issue.format === "includes") return `Neplatný řetězec: musí obsahovat "${_issue.includes}"`;
+        if (_issue.format === "regex") return `Neplatný řetězec: musí odpovídat vzoru ${_issue.pattern}`;
+        return `Neplatný formát ${FormatDictionary[_issue.format] ?? issue.format}`;
+      }
+      case "not_multiple_of":
+        return `Neplatné číslo: musí být násobkem ${issue.divisor}`;
+      case "unrecognized_keys":
+        return `Neznámé klíče: ${util.joinValues(issue.keys, ", ")}`;
+      case "invalid_key":
+        return `Neplatný klíč v ${issue.origin}`;
+      case "invalid_union":
+        return "Neplatný vstup";
+      case "invalid_element":
+        return `Neplatná hodnota v ${issue.origin}`;
+      default:
+        return `Neplatný vstup`;
+    }
+  };
+};
+
+export default function (): { localeError: errors.$ZodErrorMap } {
+  return {
+    localeError: error(),
+  };
+}

gui/frontend/node_modules/zod/src/v4/locales/da.ts

@@ -0,0 +1,123 @@
+import type { $ZodStringFormats } from "../core/checks.js";
+import type * as errors from "../core/errors.js";
+import * as util from "../core/util.js";
+
+const error: () => errors.$ZodErrorMap = () => {
+  const Sizable: Record<string, { unit: string; verb: string }> = {
+    string: { unit: "tegn", verb: "havde" },
+    file: { unit: "bytes", verb: "havde" },
+    array: { unit: "elementer", verb: "indeholdt" },
+    set: { unit: "elementer", verb: "indeholdt" },
+  };
+
+  function getSizing(origin: string): { unit: string; verb: string } | null {
+    return Sizable[origin] ?? null;
+  }
+
+  const FormatDictionary: {
+    [k in $ZodStringFormats | (string & {})]?: string;
+  } = {
+    regex: "input",
+    email: "e-mailadresse",
+    url: "URL",
+    emoji: "emoji",
+    uuid: "UUID",
+    uuidv4: "UUIDv4",
+    uuidv6: "UUIDv6",
+    nanoid: "nanoid",
+    guid: "GUID",
+    cuid: "cuid",
+    cuid2: "cuid2",
+    ulid: "ULID",
+    xid: "XID",
+    ksuid: "KSUID",
+    datetime: "ISO dato- og klokkeslæt",
+    date: "ISO-dato",
+    time: "ISO-klokkeslæt",
+    duration: "ISO-varighed",
+    ipv4: "IPv4-område",
+    ipv6: "IPv6-område",
+    cidrv4: "IPv4-spektrum",
+    cidrv6: "IPv6-spektrum",
+    base64: "base64-kodet streng",
+    base64url: "base64url-kodet streng",
+    json_string: "JSON-streng",
+    e164: "E.164-nummer",
+    jwt: "JWT",
+    template_literal: "input",
+  };
+
+  const TypeDictionary: {
+    [k in errors.$ZodInvalidTypeExpected | (string & {})]?: string;
+  } = {
+    nan: "NaN",
+    string: "streng",
+    number: "tal",
+    boolean: "boolean",
+    array: "liste",
+    object: "objekt",
+    set: "sæt",
+    file: "fil",
+  };
+
+  return (issue) => {
+    switch (issue.code) {
+      case "invalid_type": {
+        const expected = TypeDictionary[issue.expected] ?? issue.expected;
+        const receivedType = util.parsedType(issue.input);
+        const received = TypeDictionary[receivedType] ?? receivedType;
+        if (/^[A-Z]/.test(issue.expected)) {
+          return `Ugyldigt input: forventede instanceof ${issue.expected}, fik ${received}`;
+        }
+        return `Ugyldigt input: forventede ${expected}, fik ${received}`;
+      }
+      case "invalid_value":
+        if (issue.values.length === 1) return `Ugyldig værdi: forventede ${util.stringifyPrimitive(issue.values[0])}`;
+        return `Ugyldigt valg: forventede en af følgende ${util.joinValues(issue.values, "|")}`;
+      case "too_big": {
+        const adj = issue.inclusive ? "<=" : "<";
+        const sizing = getSizing(issue.origin);
+        const origin = TypeDictionary[issue.origin] ?? issue.origin;
+        if (sizing)
+          return `For stor: forventede ${origin ?? "value"} ${sizing.verb} ${adj} ${issue.maximum.toString()} ${sizing.unit ?? "elementer"}`;
+        return `For stor: forventede ${origin ?? "value"} havde ${adj} ${issue.maximum.toString()}`;
+      }
+      case "too_small": {
+        const adj = issue.inclusive ? ">=" : ">";
+        const sizing = getSizing(issue.origin);
+        const origin = TypeDictionary[issue.origin] ?? issue.origin;
+        if (sizing) {
+          return `For lille: forventede ${origin} ${sizing.verb} ${adj} ${issue.minimum.toString()} ${sizing.unit}`;
+        }
+
+        return `For lille: forventede ${origin} havde ${adj} ${issue.minimum.toString()}`;
+      }
+      case "invalid_format": {
+        const _issue = issue as errors.$ZodStringFormatIssues;
+        if (_issue.format === "starts_with") return `Ugyldig streng: skal starte med "${_issue.prefix}"`;
+        if (_issue.format === "ends_with") return `Ugyldig streng: skal ende med "${_issue.suffix}"`;
+        if (_issue.format === "includes") return `Ugyldig streng: skal indeholde "${_issue.includes}"`;
+        if (_issue.format === "regex") return `Ugyldig streng: skal matche mønsteret ${_issue.pattern}`;
+        return `Ugyldig ${FormatDictionary[_issue.format] ?? issue.format}`;
+      }
+      case "not_multiple_of":
+        return `Ugyldigt tal: skal være deleligt med ${issue.divisor}`;
+      case "unrecognized_keys":
+        return `${issue.keys.length > 1 ? "Ukendte nøgler" : "Ukendt nøgle"}: ${util.joinValues(issue.keys, ", ")}`;
+      case "invalid_key":
+        return `Ugyldig nøgle i ${issue.origin}`;
+      case "invalid_union":
+        return "Ugyldigt input: matcher ingen af de tilladte typer";
+      case "invalid_element":
+        return `Ugyldig værdi i ${issue.origin}`;
+      default:
+        return `Ugyldigt input`;
+    }
+  };
+};
+
+export default function (): { localeError: errors.$ZodErrorMap } {
+  return {
+    localeError: error(),
+  };
+}

gui/frontend/node_modules/zod/src/v4/locales/de.ts

@@ -0,0 +1,116 @@
+import type { $ZodStringFormats } from "../core/checks.js";
+import type * as errors from "../core/errors.js";
+import * as util from "../core/util.js";
+
+const error: () => errors.$ZodErrorMap = () => {
+  const Sizable: Record<string, { unit: string; verb: string }> = {
+    string: { unit: "Zeichen", verb: "zu haben" },
+    file: { unit: "Bytes", verb: "zu haben" },
+    array: { unit: "Elemente", verb: "zu haben" },
+    set: { unit: "Elemente", verb: "zu haben" },
+  };
+
+  function getSizing(origin: string): { unit: string; verb: string } | null {
+    return Sizable[origin] ?? null;
+  }
+
+  const FormatDictionary: {
+    [k in $ZodStringFormats | (string & {})]?: string;
+  } = {
+    regex: "Eingabe",
+    email: "E-Mail-Adresse",
+    url: "URL",
+    emoji: "Emoji",
+    uuid: "UUID",
+    uuidv4: "UUIDv4",
+    uuidv6: "UUIDv6",
+    nanoid: "nanoid",
+    guid: "GUID",
+    cuid: "cuid",
+    cuid2: "cuid2",
+    ulid: "ULID",
+    xid: "XID",
+    ksuid: "KSUID",
+    datetime: "ISO-Datum und -Uhrzeit",
+    date: "ISO-Datum",
+    time: "ISO-Uhrzeit",
+    duration: "ISO-Dauer",
+    ipv4: "IPv4-Adresse",
+    ipv6: "IPv6-Adresse",
+    cidrv4: "IPv4-Bereich",
+    cidrv6: "IPv6-Bereich",
+    base64: "Base64-codierter String",
+    base64url: "Base64-URL-codierter String",
+    json_string: "JSON-String",
+    e164: "E.164-Nummer",
+    jwt: "JWT",
+    template_literal: "Eingabe",
+  };
+
+  const TypeDictionary: {
+    [k in errors.$ZodInvalidTypeExpected | (string & {})]?: string;
+  } = {
+    nan: "NaN",
+    number: "Zahl",
+    array: "Array",
+  };
+
+  return (issue) => {
+    switch (issue.code) {
+      case "invalid_type": {
+        const expected = TypeDictionary[issue.expected] ?? issue.expected;
+        const receivedType = util.parsedType(issue.input);
+        const received = TypeDictionary[receivedType] ?? receivedType;
+        if (/^[A-Z]/.test(issue.expected)) {
+          return `Ungültige Eingabe: erwartet instanceof ${issue.expected}, erhalten ${received}`;
+        }
+        return `Ungültige Eingabe: erwartet ${expected}, erhalten ${received}`;
+      }
+      case "invalid_value":
+        if (issue.values.length === 1) return `Ungültige Eingabe: erwartet ${util.stringifyPrimitive(issue.values[0])}`;
+        return `Ungültige Option: erwartet eine von ${util.joinValues(issue.values, "|")}`;
+      case "too_big": {
+        const adj = issue.inclusive ? "<=" : "<";
+        const sizing = getSizing(issue.origin);
+        if (sizing)
+          return `Zu groß: erwartet, dass ${issue.origin ?? "Wert"} ${adj}${issue.maximum.toString()} ${sizing.unit ?? "Elemente"} hat`;
+        return `Zu groß: erwartet, dass ${issue.origin ?? "Wert"} ${adj}${issue.maximum.toString()} ist`;
+      }
+      case "too_small": {
+        const adj = issue.inclusive ? ">=" : ">";
+        const sizing = getSizing(issue.origin);
+        if (sizing) {
+          return `Zu klein: erwartet, dass ${issue.origin} ${adj}${issue.minimum.toString()} ${sizing.unit} hat`;
+        }
+
+        return `Zu klein: erwartet, dass ${issue.origin} ${adj}${issue.minimum.toString()} ist`;
+      }
+      case "invalid_format": {
+        const _issue = issue as errors.$ZodStringFormatIssues;
+        if (_issue.format === "starts_with") return `Ungültiger String: muss mit "${_issue.prefix}" beginnen`;
+        if (_issue.format === "ends_with") return `Ungültiger String: muss mit "${_issue.suffix}" enden`;
+        if (_issue.format === "includes") return `Ungültiger String: muss "${_issue.includes}" enthalten`;
+        if (_issue.format === "regex") return `Ungültiger String: muss dem Muster ${_issue.pattern} entsprechen`;
+        return `Ungültig: ${FormatDictionary[_issue.format] ?? issue.format}`;
+      }
+      case "not_multiple_of":
+        return `Ungültige Zahl: muss ein Vielfaches von ${issue.divisor} sein`;
+      case "unrecognized_keys":
+        return `${issue.keys.length > 1 ? "Unbekannte Schlüssel" : "Unbekannter Schlüssel"}: ${util.joinValues(issue.keys, ", ")}`;
+      case "invalid_key":
+        return `Ungültiger Schlüssel in ${issue.origin}`;
+      case "invalid_union":
+        return "Ungültige Eingabe";
+      case "invalid_element":
+        return `Ungültiger Wert in ${issue.origin}`;
+      default:
+        return `Ungültige Eingabe`;
+    }
+  };
+};
+
+export default function (): { localeError: errors.$ZodErrorMap } {
+  return {
+    localeError: error(),
+  };
+}

gui/frontend/node_modules/zod/src/v4/locales/el.ts

@@ -0,0 +1,121 @@
+import type { $ZodStringFormats } from "../core/checks.js";
+import type * as errors from "../core/errors.js";
+import * as util from "../core/util.js";
+
+const error: () => errors.$ZodErrorMap = () => {
+  const Sizable: Record<string, { unit: string; verb: string }> = {
+    string: { unit: "χαρακτήρες", verb: "να έχει" },
+    file: { unit: "bytes", verb: "να έχει" },
+    array: { unit: "στοιχεία", verb: "να έχει" },
+    set: { unit: "στοιχεία", verb: "να έχει" },
+    map: { unit: "καταχωρήσεις", verb: "να έχει" },
+  };
+
+  function getSizing(origin: string): { unit: string; verb: string } | null {
+    return Sizable[origin] ?? null;
+  }
+
+  const FormatDictionary: {
+    [k in $ZodStringFormats | (string & {})]?: string;
+  } = {
+    regex: "είσοδος",
+    email: "διεύθυνση email",
+    url: "URL",
+    emoji: "emoji",
+    uuid: "UUID",
+    uuidv4: "UUIDv4",
+    uuidv6: "UUIDv6",
+    nanoid: "nanoid",
+    guid: "GUID",
+    cuid: "cuid",
+    cuid2: "cuid2",
+    ulid: "ULID",
+    xid: "XID",
+    ksuid: "KSUID",
+    datetime: "ISO ημερομηνία και ώρα",
+    date: "ISO ημερομηνία",
+    time: "ISO ώρα",
+    duration: "ISO διάρκεια",
+    ipv4: "διεύθυνση IPv4",
+    ipv6: "διεύθυνση IPv6",
+    mac: "διεύθυνση MAC",
+    cidrv4: "εύρος IPv4",
+    cidrv6: "εύρος IPv6",
+    base64: "συμβολοσειρά κωδικοποιημένη σε base64",
+    base64url: "συμβολοσειρά κωδικοποιημένη σε base64url",
+    json_string: "συμβολοσειρά JSON",
+    e164: "αριθμός E.164",
+    jwt: "JWT",
+    template_literal: "είσοδος",
+  };
+
+  const TypeDictionary: {
+    [k in errors.$ZodInvalidTypeExpected | (string & {})]?: string;
+  } = {
+    nan: "NaN",
+  };
+
+  return (issue) => {
+    switch (issue.code) {
+      case "invalid_type": {
+        const expected = TypeDictionary[issue.expected] ?? issue.expected;
+        const receivedType = util.parsedType(issue.input);
+        const received = TypeDictionary[receivedType] ?? receivedType;
+        if (typeof issue.expected === "string" && /^[A-Z]/.test(issue.expected)) {
+          return `Μη έγκυρη είσοδος: αναμενόταν instanceof ${issue.expected}, λήφθηκε ${received}`;
+        }
+        return `Μη έγκυρη είσοδος: αναμενόταν ${expected}, λήφθηκε ${received}`;
+      }
+
+      case "invalid_value":
+        if (issue.values.length === 1)
+          return `Μη έγκυρη είσοδος: αναμενόταν ${util.stringifyPrimitive(issue.values[0])}`;
+        return `Μη έγκυρη επιλογή: αναμενόταν ένα από ${util.joinValues(issue.values, "|")}`;
+      case "too_big": {
+        const adj = issue.inclusive ? "<=" : "<";
+        const sizing = getSizing(issue.origin);
+        if (sizing)
+          return `Πολύ μεγάλο: αναμενόταν ${issue.origin ?? "τιμή"} να έχει ${adj}${issue.maximum.toString()} ${sizing.unit ?? "στοιχεία"}`;
+        return `Πολύ μεγάλο: αναμενόταν ${issue.origin ?? "τιμή"} να είναι ${adj}${issue.maximum.toString()}`;
+      }
+      case "too_small": {
+        const adj = issue.inclusive ? ">=" : ">";
+        const sizing = getSizing(issue.origin);
+        if (sizing) {
+          return `Πολύ μικρό: αναμενόταν ${issue.origin} να έχει ${adj}${issue.minimum.toString()} ${sizing.unit}`;
+        }
+
+        return `Πολύ μικρό: αναμενόταν ${issue.origin} να είναι ${adj}${issue.minimum.toString()}`;
+      }
+      case "invalid_format": {
+        const _issue = issue as errors.$ZodStringFormatIssues;
+        if (_issue.format === "starts_with") {
+          return `Μη έγκυρη συμβολοσειρά: πρέπει να ξεκινά με "${_issue.prefix}"`;
+        }
+        if (_issue.format === "ends_with") return `Μη έγκυρη συμβολοσειρά: πρέπει να τελειώνει με "${_issue.suffix}"`;
+        if (_issue.format === "includes") return `Μη έγκυρη συμβολοσειρά: πρέπει να περιέχει "${_issue.includes}"`;
+        if (_issue.format === "regex")
+          return `Μη έγκυρη συμβολοσειρά: πρέπει να ταιριάζει με το μοτίβο ${_issue.pattern}`;
+        return `Μη έγκυρο: ${FormatDictionary[_issue.format] ?? issue.format}`;
+      }
+      case "not_multiple_of":
+        return `Μη έγκυρος αριθμός: πρέπει να είναι πολλαπλάσιο του ${issue.divisor}`;
+      case "unrecognized_keys":
+        return `Άγνωστ${issue.keys.length > 1 ? "α" : "ο"} κλειδ${issue.keys.length > 1 ? "ιά" : "ί"}: ${util.joinValues(issue.keys, ", ")}`;
+      case "invalid_key":
+        return `Μη έγκυρο κλειδί στο ${issue.origin}`;
+      case "invalid_union":
+        return "Μη έγκυρη είσοδος";
+      case "invalid_element":
+        return `Μη έγκυρη τιμή στο ${issue.origin}`;
+      default:
+        return `Μη έγκυρη είσοδος`;
+    }
+  };
+};
+
+export default function (): { localeError: errors.$ZodErrorMap } {
+  return {
+    localeError: error(),
+  };
+}

gui/frontend/node_modules/zod/src/v4/locales/en.ts

@@ -0,0 +1,123 @@
+import type { $ZodStringFormats } from "../core/checks.js";
+import type * as errors from "../core/errors.js";
+import * as util from "../core/util.js";
+
+const error: () => errors.$ZodErrorMap = () => {
+  const Sizable: Record<string, { unit: string; verb: string }> = {
+    string: { unit: "characters", verb: "to have" },
+    file: { unit: "bytes", verb: "to have" },
+    array: { unit: "items", verb: "to have" },
+    set: { unit: "items", verb: "to have" },
+    map: { unit: "entries", verb: "to have" },
+  };
+
+  function getSizing(origin: string): { unit: string; verb: string } | null {
+    return Sizable[origin] ?? null;
+  }
+
+  const FormatDictionary: {
+    [k in $ZodStringFormats | (string & {})]?: string;
+  } = {
+    regex: "input",
+    email: "email address",
+    url: "URL",
+    emoji: "emoji",
+    uuid: "UUID",
+    uuidv4: "UUIDv4",
+    uuidv6: "UUIDv6",
+    nanoid: "nanoid",
+    guid: "GUID",
+    cuid: "cuid",
+    cuid2: "cuid2",
+    ulid: "ULID",
+    xid: "XID",
+    ksuid: "KSUID",
+    datetime: "ISO datetime",
+    date: "ISO date",
+    time: "ISO time",
+    duration: "ISO duration",
+    ipv4: "IPv4 address",
+    ipv6: "IPv6 address",
+    mac: "MAC address",
+    cidrv4: "IPv4 range",
+    cidrv6: "IPv6 range",
+    base64: "base64-encoded string",
+    base64url: "base64url-encoded string",
+    json_string: "JSON string",
+    e164: "E.164 number",
+    jwt: "JWT",
+    template_literal: "input",
+  };
+
+  // type names: missing keys = do not translate (use raw value via ?? fallback)
+  const TypeDictionary: {
+    [k in errors.$ZodInvalidTypeExpected | (string & {})]?: string;
+  } = {
+    // Compatibility: "nan" -> "NaN" for display
+    nan: "NaN",
+    // All other type names omitted - they fall back to raw values via ?? operator
+  };
+
+  return (issue) => {
+    switch (issue.code) {
+      case "invalid_type": {
+        const expected = TypeDictionary[issue.expected] ?? issue.expected;
+        const receivedType = util.parsedType(issue.input);
+        const received = TypeDictionary[receivedType] ?? receivedType;
+        return `Invalid input: expected ${expected}, received ${received}`;
+      }
+
+      case "invalid_value":
+        if (issue.values.length === 1) return `Invalid input: expected ${util.stringifyPrimitive(issue.values[0])}`;
+        return `Invalid option: expected one of ${util.joinValues(issue.values, "|")}`;
+      case "too_big": {
+        const adj = issue.inclusive ? "<=" : "<";
+        const sizing = getSizing(issue.origin);
+        if (sizing)
+          return `Too big: expected ${issue.origin ?? "value"} to have ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elements"}`;
+        return `Too big: expected ${issue.origin ?? "value"} to be ${adj}${issue.maximum.toString()}`;
+      }
+      case "too_small": {
+        const adj = issue.inclusive ? ">=" : ">";
+        const sizing = getSizing(issue.origin);
+        if (sizing) {
+          return `Too small: expected ${issue.origin} to have ${adj}${issue.minimum.toString()} ${sizing.unit}`;
+        }
+
+        return `Too small: expected ${issue.origin} to be ${adj}${issue.minimum.toString()}`;
+      }
+      case "invalid_format": {
+        const _issue = issue as errors.$ZodStringFormatIssues;
+        if (_issue.format === "starts_with") {
+          return `Invalid string: must start with "${_issue.prefix}"`;
+        }
+        if (_issue.format === "ends_with") return `Invalid string: must end with "${_issue.suffix}"`;
+        if (_issue.format === "includes") return `Invalid string: must include "${_issue.includes}"`;
+        if (_issue.format === "regex") return `Invalid string: must match pattern ${_issue.pattern}`;
+        return `Invalid ${FormatDictionary[_issue.format] ?? issue.format}`;
+      }
+      case "not_multiple_of":
+        return `Invalid number: must be a multiple of ${issue.divisor}`;
+      case "unrecognized_keys":
+        return `Unrecognized key${issue.keys.length > 1 ? "s" : ""}: ${util.joinValues(issue.keys, ", ")}`;
+      case "invalid_key":
+        return `Invalid key in ${issue.origin}`;
+      case "invalid_union":
+        if (issue.options && Array.isArray(issue.options) && issue.options.length > 0) {
+          const opts = issue.options.map((o) => `'${o}'`).join(" | ");
+          return `Invalid discriminator value. Expected ${opts}`;
+        }
+        return "Invalid input";
+      case "invalid_element":
+        return `Invalid value in ${issue.origin}`;
+      default:
+        return `Invalid input`;
+    }
+  };
+};
+
+export default function (): { localeError: errors.$ZodErrorMap } {
+  return {
+    localeError: error(),
+  };
+}

gui/frontend/node_modules/zod/src/v4/locales/eo.ts

@@ -0,0 +1,118 @@
+import type { $ZodStringFormats } from "../core/checks.js";
+import type * as errors from "../core/errors.js";
+import * as util from "../core/util.js";
+
+const error: () => errors.$ZodErrorMap = () => {
+  const Sizable: Record<string, { unit: string; verb: string }> = {
+    string: { unit: "karaktrojn", verb: "havi" },
+    file: { unit: "bajtojn", verb: "havi" },
+    array: { unit: "elementojn", verb: "havi" },
+    set: { unit: "elementojn", verb: "havi" },
+  };
+
+  function getSizing(origin: string): { unit: string; verb: string } | null {
+    return Sizable[origin] ?? null;
+  }
+
+  const FormatDictionary: {
+    [k in $ZodStringFormats | (string & {})]?: string;
+  } = {
+    regex: "enigo",
+    email: "retadreso",
+    url: "URL",
+    emoji: "emoĝio",
+    uuid: "UUID",
+    uuidv4: "UUIDv4",
+    uuidv6: "UUIDv6",
+    nanoid: "nanoid",
+    guid: "GUID",
+    cuid: "cuid",
+    cuid2: "cuid2",
+    ulid: "ULID",
+    xid: "XID",
+    ksuid: "KSUID",
+    datetime: "ISO-datotempo",
+    date: "ISO-dato",
+    time: "ISO-tempo",
+    duration: "ISO-daŭro",
+    ipv4: "IPv4-adreso",
+    ipv6: "IPv6-adreso",
+    cidrv4: "IPv4-rango",
+    cidrv6: "IPv6-rango",
+    base64: "64-ume kodita karaktraro",
+    base64url: "URL-64-ume kodita karaktraro",
+    json_string: "JSON-karaktraro",
+    e164: "E.164-nombro",
+    jwt: "JWT",
+    template_literal: "enigo",
+  };
+
+  const TypeDictionary: {
+    [k in errors.$ZodInvalidTypeExpected | (string & {})]?: string;
+  } = {
+    nan: "NaN",
+    number: "nombro",
+    array: "tabelo",
+    null: "senvalora",
+  };
+
+  return (issue) => {
+    switch (issue.code) {
+      case "invalid_type": {
+        const expected = TypeDictionary[issue.expected] ?? issue.expected;
+        const receivedType = util.parsedType(issue.input);
+        const received = TypeDictionary[receivedType] ?? receivedType;
+        if (/^[A-Z]/.test(issue.expected)) {
+          return `Nevalida enigo: atendiĝis instanceof ${issue.expected}, riceviĝis ${received}`;
+        }
+        return `Nevalida enigo: atendiĝis ${expected}, riceviĝis ${received}`;
+      }
+
+      case "invalid_value":
+        if (issue.values.length === 1) return `Nevalida enigo: atendiĝis ${util.stringifyPrimitive(issue.values[0])}`;
+        return `Nevalida opcio: atendiĝis unu el ${util.joinValues(issue.values, "|")}`;
+      case "too_big": {
+        const adj = issue.inclusive ? "<=" : "<";
+        const sizing = getSizing(issue.origin);
+        if (sizing)
+          return `Tro granda: atendiĝis ke ${issue.origin ?? "valoro"} havu ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elementojn"}`;
+        return `Tro granda: atendiĝis ke ${issue.origin ?? "valoro"} havu ${adj}${issue.maximum.toString()}`;
+      }
+      case "too_small": {
+        const adj = issue.inclusive ? ">=" : ">";
+        const sizing = getSizing(issue.origin);
+        if (sizing) {
+          return `Tro malgranda: atendiĝis ke ${issue.origin} havu ${adj}${issue.minimum.toString()} ${sizing.unit}`;
+        }
+
+        return `Tro malgranda: atendiĝis ke ${issue.origin} estu ${adj}${issue.minimum.toString()}`;
+      }
+      case "invalid_format": {
+        const _issue = issue as errors.$ZodStringFormatIssues;
+        if (_issue.format === "starts_with") return `Nevalida karaktraro: devas komenciĝi per "${_issue.prefix}"`;
+        if (_issue.format === "ends_with") return `Nevalida karaktraro: devas finiĝi per "${_issue.suffix}"`;
+        if (_issue.format === "includes") return `Nevalida karaktraro: devas inkluzivi "${_issue.includes}"`;
+        if (_issue.format === "regex") return `Nevalida karaktraro: devas kongrui kun la modelo ${_issue.pattern}`;
+        return `Nevalida ${FormatDictionary[_issue.format] ?? issue.format}`;
+      }
+      case "not_multiple_of":
+        return `Nevalida nombro: devas esti oblo de ${issue.divisor}`;
+      case "unrecognized_keys":
+        return `Nekonata${issue.keys.length > 1 ? "j" : ""} ŝlosilo${issue.keys.length > 1 ? "j" : ""}: ${util.joinValues(issue.keys, ", ")}`;
+      case "invalid_key":
+        return `Nevalida ŝlosilo en ${issue.origin}`;
+      case "invalid_union":
+        return "Nevalida enigo";
+      case "invalid_element":
+        return `Nevalida valoro en ${issue.origin}`;
+      default:
+        return `Nevalida enigo`;
+    }
+  };
+};
+
+export default function (): { localeError: errors.$ZodErrorMap } {
+  return {
+    localeError: error(),
+  };
+}